深度学习- 用Torch实现MNIST手写数字识别

本节代码地址：

https://github.com/vic-w/torch-practice/tree/master/mnist

MNIST是手写数字识别的数据库。在深度学习流行的今天，MNIST数据库已经被大家玩坏了。但是用它来学习卷积神经网络是再好不过的了。这一次，我们就用Torch来实现MNIST数据库的识别。

这一次的代码用到了mnist库，如果之前没有安装，可以在命令行键入：

[plain]
view plain
copy

luarocks install mnist  

和往常一样，我们要先包含必要的库

[plain]
view plain
copy

require 'torch'  
require 'nn'  
require 'optim'  
mnist = require 'mnist'  

其中require ’mnist'一句返回了一个mnist的对象。可以用下面两句来获得mnist的图像数据。

[plain]
view plain
copy

fullset = mnist.traindataset()  
testset = mnist.testdataset() 

将这个模型用Torch的代码实现也非常简单。首先仍然是建立一个容器用来存放各种模块。

[plain]
view plain
copy

model = nn.Sequential()  

放入一个reshape模块。因为mnist库的原始图片是储存为1列728个像素的。我们需要把它们变成1通道28*28的一个方形图片。

[plain]
view plain
copy

model:add(nn.Reshape(1, 28, 28))  

接下来要把图片的每个像素除以256再乘以3.2，也就是把像素的取值归一化到0至3.2之间。这相当于Caffe中的Scale模块。

[plain]
view plain
copy

model:add(nn.MulConstant(1/256.0*3.2))  

然后是第一个卷积层，它的参数按顺序分别代表：输入图像是1通道，卷积核数量20，卷积核大小5*5，卷积步长1*1，图像留边0*0

[plain]
view plain
copy

model:add(nn.SpatialConvolutionMM(1, 20, 5, 5, 1, 1, 0, 0))  

一个池化层，它的参数按顺序分别代表：池化大小2*2，步长2*2，图像留边0*0

[plain]
view plain
copy

model:add(nn.SpatialMaxPooling(2, 2 , 2, 2, 0, 0))  

再接一个卷积层和一个池化层，由于上一个卷积层的核的数量是20，所以这时输入图像的通道个数为20

[plain]
view plain
copy

model:add(nn.SpatialConvolutionMM(20, 50, 5, 5, 1, 1, 0, 0))  
model:add(nn.SpatialMaxPooling(2, 2 , 2, 2, 0, 0))  

在接入全连接层之前，我们需要把数据重新排成一列，所以有需要一个reshape模块

[plain]
view plain
copy

model:add(nn.Reshape(4*4*50))  

这个参数为什么是4*4*50即800呢？其实是这样算出来的：我们的输入是1通道28*28的图像，经过第一个卷积层之后变成了20通道24*24的图像。又经过池化层，图像尺寸缩小一半，变为20通道12*12。通过第二个卷积层，变为50通道8*8的图像，又经过池化层缩小一半，变为50通道4*4的图像。所以这其中的像素一共有4*4*50=800个。
接下来是第一个全连接层。输入为4*4*50=800，输出为500

[plain]
view plain
copy

model:add(nn.Linear(4*4*50, 500))  

两个全连接层之间有一个ReLU激活层

[plain]
view plain
copy

model:add(nn.ReLU())  

然后是第二个全连接层，输入是500，输出是10，也就代表了10个数字的输出结果，哪个节点的响应高，结果就定为对应的数字。

[plain]
view plain
copy

model:add(nn.Linear(500, 10))  

最后是一个LogSoftMax层，用来把上一层的响应归一化到0至1之间。

[plain]
view plain
copy

model:add(nn.LogSoftMax())  

模型的建立就完成了。我们还需要一个判定标准。由于我们这一次是要解决分类问题，一般使用nn.ClassNLLCriterion这种类型的标准（Negative Log Likelihood）

[plain]
view plain
copy

criterion = nn.ClassNLLCriterion()  

为了要达到更好的优化效果，这里需要对model内部参数的初始化做一下特殊的处理。还记得torch会帮我们随机初始化参数吗？我们现在不使用torch的初始化参数，而使用一种更高级的初始化方法，称之为xavier方法。概括来讲，就是根据每层的输入个数和输出个数来决定参数随机初始化的分布范围。在代码里只需要一句：

[plain]
view plain
copy

model = require('weight-init')(model, 'xavier')  

其中的‘weight-init’指向了与主文件同一文件夹里的weight-init.lua这个文件。xavier方法就在这个文件里面。它是由https://github.com/e-lab/torch-toolbox所实现的。

到这里，网络模型的部分就都已经完成了。我们现在就需要建立评估函数，然后循环迭代就可以了。这些都是例行公事，可以参照前面的代码来写，这里就不在赘述了。

完整的代码在这里，大家可以运行试一试。

[plain]
view plain
copy

require 'torch'  
require 'nn'  
require 'optim'  
--require 'cunn'  
--require 'cutorch'  
mnist = require 'mnist'  
  
fullset = mnist.traindataset()  
testset = mnist.testdataset()  
  
trainset = {  
    size = 50000,  
    data = fullset.data[{{1,50000}}]:double(),  
    label = fullset.label[{{1,50000}}]  
}  
  
validationset = {  
    size = 10000,  
    data = fullset.data[{{50001,60000}}]:double(),  
    label = fullset.label[{{50001,60000}}]  
}  
  
trainset.data = trainset.data - trainset.data:mean()  
validationset.data = validationset.data - validationset.data:mean()  
  
  
model = nn.Sequential()  
model:add(nn.Reshape(1, 28, 28))  
model:ad
b7cd
d(nn.MulConstant(1/256.0*3.2))  
model:add(nn.SpatialConvolutionMM(1, 20, 5, 5, 1, 1, 0, 0))  
model:add(nn.SpatialMaxPooling(2, 2 , 2, 2, 0, 0))  
model:add(nn.SpatialConvolutionMM(20, 50, 5, 5, 1, 1, 0, 0))  
model:add(nn.SpatialMaxPooling(2, 2 , 2, 2, 0, 0))  
model:add(nn.Reshape(4*4*50))  
model:add(nn.Linear(4*4*50, 500))  
model:add(nn.ReLU())  
model:add(nn.Linear(500, 10))  
model:add(nn.LogSoftMax())  
  
model = require('weight-init')(model, 'xavier')  
  
criterion = nn.ClassNLLCriterion()  
  
--model = model:cuda()  
--criterion = criterion:cuda()  
--trainset.data = trainset.data:cuda()  
--trainset.label = trainset.label:cuda()  
--validationset.data = validationset.data:cuda()  
--validationset.label = validationset.label:cuda()  
  
sgd_params = {  
   learningRate = 1e-2,  
   learningRateDecay = 1e-4,  
   weightDecay = 1e-3,  
   momentum = 1e-4  
}  
  
x, dl_dx = model:getParameters()  
  
step = function(batch_size)  
    local current_loss = 0  
    local count = 0  
    local shuffle = torch.randperm(trainset.size)  
    batch_size = batch_size or 200  
    for t = 1,trainset.size,batch_size do  
        -- setup inputs and targets for this mini-batch  
        local size = math.min(t + batch_size - 1, trainset.size) - t  
        local inputs = torch.Tensor(size, 28, 28)--:cuda()  
        local targets = torch.Tensor(size)--:cuda()  
        for i = 1,size do  
            local input = trainset.data[shuffle[i+t]]  
            local target = trainset.label[shuffle[i+t]]  
            -- if target == 0 then target = 10 end  
            inputs[i] = input  
            targets[i] = target  
        end  
        targets:add(1)  
        local feval = function(x_new)  
            -- reset data  
            if x ~= x_new then x:copy(x_new) end  
            dl_dx:zero()  
  
            -- perform mini-batch gradient descent  
            local loss = criterion:forward(model:forward(inputs), targets)  
            model:backward(inputs, criterion:backward(model.output, targets))  
  
            return loss, dl_dx  
        end  
  
        _, fs = optim.sgd(feval, x, sgd_params)  
  
        -- fs is a table containing value of the loss function  
        -- (just 1 value for the SGD optimization)  
        count = count + 1  
        current_loss = current_loss + fs[1]  
    end  
  
    -- normalize loss  
    return current_loss / count  
end  
  
eval = function(dataset, batch_size)  
    local count = 0  
    batch_size = batch_size or 200  
      
    for i = 1,dataset.size,batch_size do  
        local size = math.min(i + batch_size - 1, dataset.size) - i  
        local inputs = dataset.data[{{i,i+size-1}}]--:cuda()  
        local targets = dataset.label[{{i,i+size-1}}]:long()--:cuda()  
        local outputs = model:forward(inputs)  
        local _, indices = torch.max(outputs, 2)  
        indices:add(-1)  
        local guessed_right = indices:eq(targets):sum()  
        count = count + guessed_right  
    end  
  
    return count / dataset.size  
end  
  
max_iters = 30  
  
do  
    local last_accuracy = 0  
    local decreasing = 0  
    local threshold = 1 -- how many deacreasing epochs we allow  
    for i = 1,max_iters do  
        local loss = step()  
        print(string.format('Epoch: %d Current loss: %4f', i, loss))  
        local accuracy = eval(validationset)  
        print(string.format('Accuracy on the validation set: %4f', accuracy))  
        if accuracy < last_accuracy then  
            if decreasing > threshold then break end  
            decreasing = decreasing + 1  
        else  
            decreasing = 0  
        end  
        last_accuracy = accuracy  
    end  
end  
  
testset.data = testset.data:double()  
eval(testset)