torch 深度学习(5)
这篇文章主要是想使用torch学习并理解如何构建siamese network。
siamese network的结构如下：
1486455020988.jpg
使用的数据集：mnist 手写数据集
实验目的：通过孪生网络使得同一类的尽可能的靠近，不同类的尽可能不同。
命令行：
sudo luarocks install mnist
主要涉及的torch/nn中Container包括Sequential和ParallelTable，具体参见Docs » Modules » Containers
OK,现在来看代码
1_data 数据预处理
主要在于数据的加载和中心化以及归一化处理
require 'torch'
mnist = require('mnist')
-- the size of mnist is 28*28
-- initialize the dataset
train={
data = mnist.traindataset().data:type('torch.FloatTensor'), -- traindata
label = mnist.traindataset().label, -- train label
size=function()
return mnist.traindataset().data:size(1) end
}
test={
data = mnist.testdataset().data:type('torch.FloatTensor'),
label = mnist.testdataset().label,
size=function()
return mnist.testdataset().data:size(1) end
}
local meanV = train.data:mean()
local stdV = train.data:std()
train.data = train.data:csub(meanV)
train.data = train.data:div(stdV)
test.data = test.data:add(-meanV)
test.data = test.data:mul(1.0/stdV)
mnist数据集中图像的大小是$28 imes 28$的，训练样本有60000张，测试样本有10000张
2_model 构建模型
首先孪生网络包括两个子网络，这两个子网络包含在ParallelTable中，而每一个单独的子网络又是在一个Sequential容器内，所以
require 'nn'
cnn=nn.Sequential()
-- stage 1
cnn:add(nn.SpatialConvolution(1,8,3,3,1,1,1)) -- 28*28
-- nn.SpationConvolution(nInputPlane,nOutputPlane,kW,kH,dW,dH,padW,padH)
cnn:add(nn.ReLU())
cnn:add(nn.SpatialMaxPooling(2,2)) -- 14*14
-- stage 2
cnn:add(nn.SpatialConvolution(8,16,3,3,1,1,1)) -- 14*14
cnn:add(nn.ReLU())
cnn:add(nn.SpatialMaxPooling(2,2)) -- 7*7
-- stage 3
cnn:add(nn.SpatialConvolution(16,32,3,3,1,1,1))
cnn:add(nn.ReLU())
cnn:add(nn.SpatialMaxPooling(2,2)) -- 3*3
-- stage 4
cnn:add(nn.Reshape(32*3*3))
cnn:add(nn.Linear(32*3*3,256))
cnn:add(nn.ReLU())
-- stage 5
cnn:add(nn.Linear(256,2))
parallel_model = nn.ParallelTable()
parallel_model:add(cnn)
parallel_model:add(cnn:clone('weight','bias','gradWeight','gradBias'))
--这里，孪生网络要求两个子网络共享参数，所以要分享权重和梯度变化
model = nn.Sequential()
model:add(nn.SplitTable(1))
model:add(parallel_model)
model:add(nn.PairwiseDistance(2)) -- L2距离
--print(model)
构造的模型如下：
1486455042581.jpg
为什么最终每一个子网络输出维度为2？这是因为我们希望之后能够在二维上显示的观察结果
nn.SplitTable(ndim): 将该层输入在第ndim上划分成table，在代码中就是将model的输入样本沿着第1维保存成table，table每一个元素对应这ParallelTable中的一个子网络，
所以model的输入应该是$2 imes 1 imes 28 imes 28$的torch.Tensor
3_loss 损失函数
这里使用的损失函数为 HingeEmbeddingCriterion,具体定义参见HingeEmbeddingCriterion
其形式：loss(x,y) = forward(x,y) = x, if y=1 = max(0,margin - x), if y=-1
$$
loss(x,y)=egin{cases}
x, ext{ if}quad y=1\
max(0,margin-x), if y=-1
end{cases}
$$
criterion=nn.HingeEmbeddingCriterion()
4_train 模型训练
在所有的步骤中，我觉得训练这一步相对来说是比较复杂的。
首先要定义数据的batch处理方式，然后定义优化方法调用的函数feval，这个函数使用BP算法更新了模型的参数，所以在整个文件之前要通过model.getPatameters()获得模型参数的引用。
最后就是调用optim中的优化方法对模型进行不断的优化了。
require 'nn'
require 'optim'
require 'xlua'
if model then
parameters,gradParameters=model:getParameters()
end
batchSize = 100
learningRate = 0.01
function training()
epoch=epoch or 1
time = sys.clock()
shuffer = torch.randperm(train:size())
print ">>>>>>>>>>>>>>>>>>>>>> doing epoch on training data: >>>>>>>>>>>>>>>>>>>>>"
print("=======> online epoch # " .. epoch .. '[batchSize = ' .. batchSize .. ']')
for t=1,train:size(),batchSize do
xlua.progress(t,train:size())
batchData = {}
batchLabel = {}
for i=t,math.min(t+batchSize-1,train:size()) do
local input=torch.Tensor(2,1,28,28) --注意这里，每个样本是28*28的tensor，但是模型中cnn的输入要求是1*28*28的所以应该存成2*1*28*28的tensor
input[1]=train.data[i]
input[2]=train.data[shuffer[i]]
if train.label[i] == train.label[shuffer[i]] then
target = 1
else
target = -1
end
table.insert(batchData,input)
table.insert(batchLabel,target)
end
local feval = function(x)
if x~= parameters then
parameters:copy(x)
end
model:zeroGradParameters()
local f=0
for i=1,#batchData do
--print(#batchData[i])
local output = model:forward(batchData[i])
local err = criterion:forward(output,batchLabel[i])
f=f+err
local df_do = criterion:backward(output,batchLabel[i])
model:backward(batchData[i],df_do)
end
gradParameters:div(#batchData)
f=f/#batchData
return f, gradParameters
end
optimState = {leraningRate=learningRate}
optim.adam(feval,parameters,optimState)
end
time = sys.clock()-time
time=time/train:size()
print('=================> time to learn one smaple = ' .. (time*1000) .. 'ms')
epoch =epoch+1
end
5_Test 模型测试
这里我只是测试了模型了输出误差，其实评价该模型可以通过confusion矩阵实现，偷了个懒，后面可视化的时候也可以看到分类结果
require 'xlua'
function testing()
print '======> testing:'
local time=sys.clock()
local shuffer = torch.randperm(test:size())
err=0
for t=1,test:size() do
xlua.progress(t,test:size())
local input=torch.Tensor(2,1,28,28)
input[1]=test.data[t]
input[2]=test.data[shuffer[t]]
if test.label[t]==test.label[shuffer[t]] then
target = 1
else
target = -1
end
output=model:forward(input)
f=criterion(output,target)
err=err+f
end
time=sys.clock()-time
time = time/test:size()
print('=======> time to test each sample = ' .. (time*1000) .. 'ms')
print('=======> average error is ' .. err/test:size())
end
6_visualization 结果可视化
这里我使用了itorch:Plot()的功能，折腾了很久ipython-notebook还是没装好，只是装好的itorch，参见官网
results={}
for i=1,10 do
table.insert(results,{x={},y={}})
end
for t=1,5000 do -- 这里我们验证了5000个样本，如果绘制10000个样本的话实在太密集了
local idx=test.label[t]
local data=torch.Tensor(1,28,28)
data[1]=test.data[t]
local pos = cnn:forward(data)
if idx==0 then
idx=10
end
table.insert(results[idx].x,pos[1])
table.insert(results[idx].y,pos[2])
end
Plot =require'itorch.Plot'
plot=Plot():circle(results[1].x,results[1].y,'red','1'):draw()
plot:circle(results[2].x,results[2].y,'green','2'):redraw()
plot:circle(results[3].x,results[3].y,'blue','3'):redraw()
plot:circle(results[4].x,results[4].y,'black','4'):redraw()
plot:circle(results[5].x,results[5].y,'orange','5'):redraw()
plot:triangle(results[6].x,results[6].y,'red','6'):redraw()
plot:triangle(results[7].x,results[7].y,'green','7'):redraw()
plot:triangle(results[8].x,results[8].y,'blue','8'):redraw()
plot:triangle(results[9].x,results[9].y,'black','9'):redraw()
plot:triangle(results[10].x,results[10].y,'orange','10'):redraw()
plot:title('样本降维到2维时的分布'):redraw()
plot:xaxis('x1'):yaxis('x2'):redraw()
plot:legend(true)
plot:redraw()
plot:save('out.html') --只能保存成html之后再人工保存成png图像
这个模型有点类似于使用FDA找到两个主方向
7_doall 统一执行文件
dofile '1_data.lua'
dofile '2_model.lua'
dofile '3_loss.lua'
dofile '4_train.lua'
dofile '5_test.lua'
k=1
while k<30 do
training()
k=k+1
end
testing()
dofile '6_visualization.lua'
结果
idx.png
参考资料：
Teaonly/easylearning.io/siamese_network
深度学习实验: Siamese network
facebook/iTorch