Caffe-python interface 学习-网络训练、部署、测试

继续python接口的学习。剩下还有solver、deploy文件的生成和模型的测试。

网络训练

solver文件生成

其实我觉得用python生成solver并不如直接写个配置文件,它不像net配置一样有很多重复的东西。
对于一下的solver配置文件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
base_lr: 0.001
display: 782
gamma: 0.1
lr_policy: “step”
max_iter: 78200 #训练样本迭代次数=max_iter/782(训练完一次全部样本的迭代数)
momentum: 0.9
snapshot: 7820
snapshot_prefix: "snapshot"
solver_mode: GPU
solver_type: SGD
stepsize: 26067
test_interval: 782 #test_interval=训练样本数(50000)/batch_size(train:64)
test_iter: 313 #test_iter=测试样本数(10000)/batch_size(test:32)
test_net: "/home/xxx/data/val.prototxt"
train_net: "/home/xxx/data/proto/train.prototxt"
weight_decay: 0.0005

可以用以下方式实现生成:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from caffe.proto import caffe_pb2
s = caffe_pb2.SolverParameter()
path='/home/xxx/data/'
solver_file=path+'solver1.prototxt'
s.train_net = path+'train.prototxt'
s.test_net.append(path+'val.prototxt')
s.test_interval = 782
s.test_iter.append(313) #这里用的是append,码风不太一样
s.max_iter = 78200
s.base_lr = 0.001
s.momentum = 0.9
s.weight_decay = 5e-4
s.lr_policy = 'step'
s.stepsize=26067
s.gamma = 0.1
s.display = 782
s.snapshot = 7820
s.snapshot_prefix = 'shapshot'
s.type = “SGD”
s.solver_mode = caffe_pb2.SolverParameter.GPU
with open(solver_file, 'w') as f:
f.write(str(s))

并没有简单多少。
需要注意的是有些参数需要计算得到:

  • test_interval:
    假设我们有50000个训练样本,batch_size为64,即每批次处理64个样本,那么需要迭代50000/64=782次才处理完一次全部的样本。我们把处理完一次所有的样本,称之为一代,即epoch。所以,这里的test_interval设置为782,即处理完一次所有的训练数据后,才去进行测试。如果我们想训练100代,则需要设置max_iter为78200.
  • test_iter:
    同理,如果有10000个测试样本,batch_size设为32,那么需要迭代10000/32=313次才完整地测试完一次,所以设置test_iter为313.
  • lr_rate:
    学习率变化规律我们设置为随着迭代次数的增加,慢慢变低。总共迭代78200次,我们将变化lr_rate三次,所以stepsize设置为78200/3=26067,即每迭代26067次,我们就降低一次学习率。

模型训练

完整按照定义的网络和solver去训练,就像命令行一样:

1
2
solver = caffe.SGDSolver('/home/xxx/solver.prototxt')
solver.solve()

不过也可以分得更细一些,比如先加载模型:

1
solver = caffe.get_solver('models/bvlc_reference_caffenet/solver.prototxt')

这里用的是.get_solver,默认按照SGD方法求解。
向前传播一次网络,即从输入层到loss层,计算net.blobs[k].data

1
solver.net.forward() # train net

反向传播一次网络,即从loss层到输入层,计算net.blobs[k].diff and net.params[k][j].diff

1
solver.net.backward()

如果需要一次完整的计算,正向、反向、更新权重(net.params[k][j].data),可以使用

1
solver.step(1)

改变数字进行多次计算。

网络部署

部署即生成一个deploy文件,用于下面的模型测试。这里既可以用python,也可以直接修改net文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from caffe import layers as L,params as P,to_proto
root='/home/xxx/'
deploy=root+'mnist/deploy.prototxt' #文件保存路径
def create_deploy():
#少了第一层,data层
conv1=L.Convolution(bottom='data', kernel_size=5, stride=1,num_output=20, pad=0,weight_filler=dict(type='xavier'))
pool1=L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=2, stride=2)
conv2=L.Convolution(pool1, kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type='xavier'))
pool2=L.Pooling(conv2, pool=P.Pooling.MAX, kernel_size=2, stride=2)
fc3=L.InnerProduct(pool2, num_output=500,weight_filler=dict(type='xavier'))
relu3=L.ReLU(fc3, in_place=True)
fc4 = L.InnerProduct(relu3, num_output=10,weight_filler=dict(type='xavier'))
#最后没有accuracy层,但有一个Softmax层
prob=L.Softmax(fc4)
return to_proto(prob)
def write_deploy():
with open(deploy, 'w') as f:
f.write('name:"Lenet"\n')
f.write('input:"data"\n')
f.write('input_dim:1\n')
f.write('input_dim:3\n')
f.write('input_dim:28\n')
f.write('input_dim:28\n')
f.write(str(create_deploy()))
if __name__ == '__main__':
write_deploy()

如果自己修改net,需要修改数据输入:

1
2
3
4
5
6
layer {
name: "data"
type: "Input"
top: "data"
input_param { shape: { dim: 1 dim: 3 dim: 100 dim: 100 } }
}

并且增加一个softmax,对于原来的softmaxwithloss直接换掉就行。

网络测试

训练好之后得到模型,实际使用是需要用模型进行预测。这时需要用到deploy文件和caffemodel。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#coding=utf-8
import caffe
import numpy as np
root='/home/xxx/' #根目录
deploy=root + 'mnist/deploy.prototxt' #deploy文件
caffe_model=root + 'mnist/lenet_iter_9380.caffemodel' #训练好的 caffemodel
img=root+'mnist/test/5/00008.png' #随机找的一张待测图片
labels_filename = root + 'mnist/test/labels.txt' #类别名称文件,将数字标签转换回类别名称
net = caffe.Net(deploy,caffe_model,caffe.TEST) #加载model和network
#图片预处理设置
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape}) #设定图片的shape格式(1,3,28,28)
transformer.set_transpose('data', (2,0,1)) #改变维度的顺序,由原始图片(28,28,3)变为(3,28,28)
#transformer.set_mean('data', np.load(mean_file).mean(1).mean(1)) #减去均值,前面训练模型时没有减均值,这儿就不用
transformer.set_raw_scale('data', 255) # 缩放到【0,255】之间
transformer.set_channel_swap('data', (2,1,0)) #交换通道,将图片由RGB变为BGR
im=caffe.io.load_image(img) #加载图片
net.blobs['data'].data[...] = transformer.preprocess('data',im) #执行上面设置的图片预处理操作,并将图片载入到blob中
#执行测试
out = net.forward()
labels = np.loadtxt(labels_filename, str, delimiter='\t') #读取类别名称文件
prob= net.blobs['Softmax1'].data[0].flatten() #取出最后一层(Softmax)属于某个类别的概率值,并打印
print prob
order=prob.argsort()[-1] #将概率值排序,取出最大值所在的序号
print 'the class is:',labels[order] #将该序号转换成对应的类别名称,并打印

总结

利用python接口,对网络的具体参数能够有更全面的认识和理解。不过也有几点需要注意:

  1. 数据格式的转换
    caffe的数据blob shape是NCHW,通道数在前。而python图像处理时shape是HW*C,通道数在后。因此需要转换一下。
  2. 图片显示与保存
    由于没有图形界面,很方便的jupyter notebook不能使用,只好保存图片查看。

caffe的python接口学习(2):生成solver文件
caffe的python接口学习(5):生成deploy文件
caffe的python接口学习(6):用训练好的模型(caffemodel)来分类新的图片
Deep learning tutorial on Caffe technology : basic commands, Python and C++ code.
Multilabel classification on PASCAL using python data-layers