Torch7 Convolutional Demo

demo.lua

require 'nn'

-- Uncomment if you do have not yet downloaded this dataset
-- os.execute('wget -c https://s3.amazonaws.com/torch7/data/cifar10torchsmall.zip')
-- os.execute('unzip cifar10torchsmall.zip')

trainset  = torch.load('cifar10-train.t7')
trainset.data = trainset.data:double()
testset   = torch.load('cifar10-test.t7')
classes   = {'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'}

setmetatable(trainset, {
                __index = function(t,i)
                            return {t.data[i], t.label[i]}
                        end
                });

function trainset:size()
    return self.data:size(1)
end

mean = {}                                                -- store the mean, to normalize the test set in the future
stdv  = {}                                               -- store the standard-deviation for the future
for i=1,3 do                                             -- over each image channel
    mean[i] = trainset.data[{ {}, {i}, {}, {}  }]:mean() -- mean estimation
    print('Channel ' .. i .. ', Mean: ' .. mean[i])
    trainset.data[{ {}, {i}, {}, {}  }]:add(-mean[i])    -- mean subtraction

    stdv[i] = trainset.data[{ {}, {i}, {}, {}  }]:std()  -- std estimation
    print('Channel ' .. i .. ', Standard Deviation: ' .. stdv[i])
    trainset.data[{ {}, {i}, {}, {}  }]:div(stdv[i])     -- std scaling
end
testset.data = testset.data:double()                     -- convert from Byte tensor to Double tensor
for i=1,3 do                                             -- over each image channel
    testset.data[{ {}, {i}, {}, {}  }]:add(-mean[i])     -- mean subtraction    
    testset.data[{ {}, {i}, {}, {}  }]:div(stdv[i])      -- std scaling
end

net = nn.Sequential()
net:add(nn.SpatialConvolution(3, 6, 5, 5))  -- 3 input image channels, 6 output channels, 5x5 convolution kernel
net:add(nn.ReLU())                          -- non-linearity 
net:add(nn.SpatialMaxPooling(2,2,2,2))      -- A max-pooling operation that looks at 2x2 windows and finds the max.
net:add(nn.SpatialConvolution(6, 16, 5, 5))
net:add(nn.ReLU())                          -- non-linearity 
net:add(nn.SpatialMaxPooling(2,2,2,2))
net:add(nn.View(16*5*5))                    -- reshapes from a 3D tensor of 16x5x5 into 1D tensor of 16*5*5
net:add(nn.Linear(16*5*5, 120))             -- fully connected layer (matrix multiplication between input and weights)
net:add(nn.ReLU())                          -- non-linearity 
net:add(nn.Linear(120, 84))
net:add(nn.ReLU())                          -- non-linearity 
net:add(nn.Linear(84, 10))                  -- 10 is the number of outputs of the network (in this case, 10 digits)
net:add(nn.LogSoftMax())                    -- converts the output to a log-probability. Useful for classification problems
print(net:__tostring())

criterion = nn.ClassNLLCriterion()         -- define a loss function
trainer = nn.StochasticGradient(net, criterion)
trainer.learningRate = 0.001
trainer.maxIteration = 5
trainer:train(trainset)
predicted = net:forward(testset.data[100])
predicted:exp()
print("GROUND TRUTH: " .. classes[testset.label[100]])
print("PREDICTED:\n")
for i=1,predicted:size(1) do
    print(classes[i], predicted[i])
end