title: How to get a prediction using Torch7
body: <p>I'm still familiarizing myself with Torch and so far so good. I have however hit a dead end that I'm not sure how to get around: how can I get Torch7 (or more specifically the dp library) to evaluate a single input and return the predicted output?</p>
  
  <p>Here's my setup (basically the dp demo):</p>
  
  <pre><code>  require 'dp'
  --[[hyperparameters]]--
  opt = {
      nHidden = 100, --number of hidden units
      learningRate = 0.1, --training learning rate
      momentum = 0.9, --momentum factor to use for training
      maxOutNorm = 1, --maximum norm allowed for output neuron weights
      batchSize = 128, --number of examples per mini-batch
      maxTries = 100, --maximum number of epochs without reduction in validation error.
      maxEpoch = 1000 --maximum number of epochs of training
  }
  --[[data]]--
  datasource = dp.Mnist{input_preprocess = dp.Standardize()}
  print("feature size: ", datasource:featureSize())
  
  --[[Model]]--
  model = dp.Sequential{
      models = {
          dp.Neural{
              input_size = datasource:featureSize(),
              output_size = opt.nHidden,
              transfer = nn.Tanh(),
              sparse_init = true
          },
          dp.Neural{
              input_size = opt.nHidden,
              output_size = #(datasource:classes()),
              transfer = nn.LogSoftMax(),
              sparse_init = true
          }
      }
  }
  
  --[[Propagators]]--
  train = dp.Optimizer{
      loss = dp.NLL(),
      visitor = { -- the ordering here is important:
          dp.Momentum{momentum_factor = opt.momentum},
          dp.Learn{learning_rate = opt.learningRate},
          dp.MaxNorm{max_out_norm = opt.maxOutNorm}
      },
      feedback = dp.Confusion(),
      sampler = dp.ShuffleSampler{batch_size = opt.batchSize},
      progress = true
  }
  valid = dp.Evaluator{
      loss = dp.NLL(),
      feedback = dp.Confusion(),
      sampler = dp.Sampler{}
  }
  test = dp.Evaluator{
      loss = dp.NLL(),
      feedback = dp.Confusion(),
      sampler = dp.Sampler{}
  }
  
  --[[Experiment]]--
  xp = dp.Experiment{
      model = model,
      optimizer = train,
      validator = valid,
      tester = test,
      observer = {
          dp.FileLogger(),
          dp.EarlyStopper{
              error_report = {'validator','feedback','confusion','accuracy'},
              maximize = true,
              max_epochs = opt.maxTries
          }
      },
      random_seed = os.time(),
      max_epoch = opt.maxEpoch
  }
  
  xp:run(datasource)
  </code></pre>