In [ ]:

    

require 'torch'
require 'nn'
require 'image'
require 'optim'


    

In [ ]:

    

-- reload the array
file = torch.DiskFile('ex1data1.txt', 'r')
data = file:readObject()


    

In [ ]:

    

model = nn.Sequential()
ninputs = 1; noutputs = 1
model:add(nn.Linear(ninputs, noutputs))


    

In [ ]:

    

criterion = nn.MSECriterion()


    

In [ ]:

    

x, dl_dx = model:getParameters()


    

In [ ]:

    

feval = function(x_new)
   -- set x to x_new, if differnt
   -- (in this simple example, x_new will typically always point to x,
   -- so the copy is really useless)
   if x ~= x_new then
      x:copy(x_new)
   end

   -- select a new training sample
   _nidx_ = (_nidx_ or 0) + 1
   if _nidx_ > (#data)[1] then _nidx_ = 1 end

   local sample = data[_nidx_]
   local target = sample[{ {2} }]      -- this funny looking syntax allows
   local inputs = sample[{ {1} }]    -- slicing of arrays.

   -- reset gradients (gradients are always accumulated, to accommodate 
   -- batch methods)
   dl_dx:zero()

   -- evaluate the loss function and its derivative wrt x, for that sample
   local loss_x = criterion:forward(model:forward(inputs), target)
   model:backward(inputs, criterion:backward(model.output, target))

   -- return loss(x) and dloss/dx
   return loss_x, dl_dx
end


    

In [ ]:

    

sgd_params = {
   learningRate = 1e-4,
   learningRateDecay = 1e-5,
   weightDecay = 0,
   momentum = 0
}


    

In [ ]:

    

for i = 1,1e4 do

   -- this variable is used to estimate the average loss
   current_loss = 0

   -- an epoch is a full loop over our training data
   for i = 1,(#data)[1] do

      -- optim contains several optimization algorithms. 
      -- All of these algorithms assume the same parameters:
      --   + a closure that computes the loss, and its gradient wrt to x, 
      --     given a point x
      --   + a point x
      --   + some parameters, which are algorithm-specific
      
      _,fs = optim.sgd(feval,x,sgd_params)

      -- Functions in optim all return two things:
      --   + the new x, found by the optimization method (here SGD)
      --   + the value of the loss functions at all points that were used by
      --     the algorithm. SGD only estimates the function once, so
      --     that list just contains one value.

      current_loss = current_loss + fs[1]
   end

   -- report average error on epoch
   current_loss = current_loss / (#data)[1]
   if i %100 == 0 then
        print('current loss = ' .. current_loss)
    end

end


    

In [ ]:

    

-- reload the array
file = torch.DiskFile('ex1data2.txt', 'r')
test = file:readObject()


    

In [ ]:

    

print('id  approx   text')
current_loss = 0
for i = 1,(#test)[1] do
   local myPrediction = model:forward(test[i][1])
   print(string.format("%2d  %6.2f %6.2f", i, myPrediction[1], test[i][2]))
    current_loss = current_loss + (myPrediction[1] - test[i][2])*(myPrediction[1] - test[i][2])
end
current_loss = current_loss / (#test)[1]
print('evaluation = ' .. current_loss)