转载自: https://www.cnblogs.com/denny402/tag/caffe/
(1) 生成配置文件
# -*- coding: utf-8 -*-
"""
Spyder Editor
"""
from caffe import layers as L,params as P,to_proto
path='/home/xxx/data/' #保存数据和配置文件的路径
train_lmdb=path+'train_db' #训练数据LMDB文件的位置
val_lmdb=path+'val_db' #验证数据LMDB文件的位置
mean_file=path+'mean.binaryproto' #均值文件的位置
train_proto=path+'train.prototxt' #生成的训练配置文件保存的位置
val_proto=path+'val.prototxt' #生成的验证配置文件保存的位置
#编写一个函数,用于生成网络
def create_net(lmdb,batch_size,include_acc=False):
#创建第一层:数据层。向上传递两类数据:图片数据和对应的标签
data, label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2,
transform_param=dict(crop_size=40,mean_file=mean_file,mirror=True))
#创建第二屋:卷积层
conv1=L.Convolution(data, kernel_size=5, stride=1,num_output=16, pad=2,weight_filler=dict(type='xavier'))
#创建激活函数层
relu1=L.ReLU(conv1, in_place=True)
#创建池化层
pool1=L.Pooling(relu1, pool=P.Pooling.MAX, kernel_size=3, stride=2)
conv2=L.Convolution(pool1, kernel_size=3, stride=1,num_output=32, pad=1,weight_filler=dict(type='xavier'))
relu2=L.ReLU(conv2, in_place=True)
pool2=L.Pooling(relu2, pool=P.Pooling.MAX, kernel_size=3, stride=2)
#创建一个全连接层
fc3=L.InnerProduct(pool2, num_output=1024,weight_filler=dict(type='xavier'))
relu3=L.ReLU(fc3, in_place=True)
#创建一个dropout层
drop3 = L.Dropout(relu3, in_place=True)
fc4 = L.InnerProduct(drop3, num_output=10,weight_filler=dict(type='xavier'))
#创建一个softmax层
loss = L.SoftmaxWithLoss(fc4, label)
if include_acc: #在训练阶段,不需要accuracy层,但是在验证阶段,是需要的
acc = L.Accuracy(fc4, label)
return to_proto(loss, acc)
else:
return to_proto(loss)
def write_net():
#将以上的设置写入到prototxt文件
with open(train_proto, 'w') as f:
f.write(str(create_net(train_lmdb,batch_size=64)))
#写入配置文件
with open(val_proto, 'w') as f:
f.write(str(create_net(val_lmdb,batch_size=32, include_acc=True)))
if __name__ == '__main__':
write_net()
通过上面这个文件的执行,我们就会得到两个配置文件:train.prototxt和val.prototxt,分别用于训练阶段和验证阶段。
这种方式生成配置文件,必须有个前提,就是要先把原始图片转换成LMDB文件才行。如果我们已经把原始图片做成了一个列表清单(txt文件,一行一张图片),则可以不用LMDB格式作为输入数据,可以用ImageData作为数据源输入,代码如下:
# -*- coding: utf-8 -*-
from caffe import layers as L,params as P,to_proto
path='/home/xxx/data/'
train_list=path+'train.txt'
val_list=path+'val.txt'
train_proto=path+'train.prototxt'
val_proto=path+'val.prototxt'
def create_net(img_list,batch_size,include_acc=False):
data,label=L.ImageData(source=img_list,batch_size=batch_size,new_width=48,new_height=48,ntop=2,
transform_param=dict(crop_size=40,mirror=True))
conv1=L.Convolution(data, kernel_size=5, stride=1,num_output=16, pad=2,weight_filler=dict(type='xavier'))
relu1=L.ReLU(conv1, in_place=True)
pool1=L.Pooling(relu1, pool=P.Pooling.MAX, kernel_size=3, stride=2)
conv2=L.Convolution(pool1, kernel_size=53, stride=1,num_output=32, pad=1,weight_filler=dict(type='xavier'))
relu2=L.ReLU(conv2, in_place=True)
pool2=L.Pooling(relu2, pool=P.Pooling.MAX, kernel_size=3, stride=2)
conv3=L.Convolution(pool2, kernel_size=53, stride=1,num_output=32, pad=1,weight_filler=dict(type='xavier'))
relu3=L.ReLU(conv3, in_place=True)
pool3=L.Pooling(relu3, pool=P.Pooling.MAX, kernel_size=3, stride=2)
fc4=L.InnerProduct(pool3, num_output=1024,weight_filler=dict(type='xavier'))
relu4=L.ReLU(fc4, in_place=True)
drop4 = L.Dropout(relu4, in_place=True)
fc5 = L.InnerProduct(drop4, num_output=7,weight_filler=dict(type='xavier'))
loss = L.SoftmaxWithLoss(fc5, label)
if include_acc:
acc = L.Accuracy(fc5, label)
return to_proto(loss, acc)
else:
return to_proto(loss)
def write_net():
#
with open(train_proto, 'w') as f:
f.write(str(create_net(train_list,batch_size=64)))
#
with open(val_proto, 'w') as f:
f.write(str(create_net(val_list,batch_size=32, include_acc=True)))
if __name__ == '__main__':
write_net()
即第一层由原来的Data类型,变成了ImageData类型,不需要LMDB文件和均值文件,但需要一个txt文件。
(2) 生成solver文件
caffe在训练的时候,需要一些参数设置,我们一般将这些参数设置在一个叫solver.prototxt的文件里面,如下:
base_lr: 0.001
display: 782
gamma: 0.1
lr_policy: “step”
max_iter: 78200
momentum: 0.9
snapshot: 7820
snapshot_prefix: “snapshot”
solver_mode: GPU
solver_type: SGD
stepsize: 26067
test_interval: 782
test_iter: 313
test_net: “/home/xxx/data/val.prototxt”
train_net: “/home/xxx/data/proto/train.prototxt”
weight_decay: 0.0005
有一些参数需要计算的,也不是乱设置。
假设我们有50000个训练样本,batch_size为64,即每批次处理64个样本,那么需要迭代50000/64=782次才处理完一次全部的样本。我们把处理完一次所有的样本,称之为一代,即epoch。所以,这里的test_interval设置为782,即处理完一次所有的训练数据后,才去进行测试。如果我们想训练100代,则需要设置max_iter为78200.
同理,如果有10000个测试样本,batch_size设为32,那么需要迭代10000/32=313次才完整地测试完一次,所以设置test_iter为313.
学习率变化规律我们设置为随着迭代次数的增加,慢慢变低。总共迭代78200次,我们将变化lr_rate三次,所以stepsize设置为78200/3=26067,即每迭代26067次,我们就降低一次学习率。
下面是生成solver文件的python代码,比较简单:
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 17 18:20:57 2016
@author: root
"""
path='/home/xxx/data/'
solver_file=path+'solver.prototxt' #solver文件保存位置
sp={}
sp['train_net']=‘“’+path+'train.prototxt”' # 训练配置文件
sp['test_net']=‘“’+path+'val.prototxt”' # 测试配置文件
sp['test_iter']='313' # 测试迭代次数
sp['test_interval']='782' # 测试间隔
sp['base_lr']='0.001' # 基础学习率
sp['display']='782' # 屏幕日志显示间隔
sp['max_iter']='78200' # 最大迭代次数
sp['lr_policy']='“step”' # 学习率变化规律
sp['gamma']='0.1' # 学习率变化指数
sp['momentum']='0.9' # 动量
sp['weight_decay']='0.0005' # 权值衰减
sp['stepsize']='26067' # 学习率变化频率
sp['snapshot']='7820' # 保存model间隔
sp['snapshot_prefix']=‘"snapshot"’ # 保存的model前缀
sp['solver_mode']='GPU' # 是否使用gpu
sp['solver_type']='SGD' # 优化算法
def write_solver():
#写入文件
with open(solver_file, 'w') as f:
for key, value in sorted(sp.items()):
if not(type(value) is str):
raise TypeError('All solver parameters must be strings')
f.write('%s: %s\n' % (key, value))
if __name__ == '__main__':
write_solver()
执行上面的文件,我们就会得到一个solver.prototxt文件,有了这个文件,我们下一步就可以进行训练了。
当然,如果你觉得上面这种键值对的字典方式,写起来容易出错,我们也可以使用另外一种比较简便的方法,没有引号,不太容易出错,如下:
# -*- coding: utf-8 -*-
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)
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))
(3) 训练模型
caffe.set_mode_cpu()
# 若用GPU训练
# caffe.set_device(0)
# caffe.set_mode_gpu()
solver = caffe.SGDSolver(solver_proto)
solver.solve()
(4) 生成deploy文件
如果要把训练好的模型拿来测试新的图片,那必须得要一个deploy.prototxt文件,这个文件实际上和test.prototxt文件差不多,只是头尾不相同而也。deploy文件没有第一层数据输入层,也没有最后的Accuracy层,但最后多了一个Softmax概率层。
这里我们采用代码的方式来自动生成该文件,以mnist为例。
# -*- coding: utf-8 -*-
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()
运行该文件后,生成一个deploy.prototxt文件。 这个文件不推荐用代码来生成,反而麻烦。大家熟悉以后可以将test.prototxt复制一份,修改相应的地方就可以了,更加方便。
(5) 训练好的模型测试新图片
从mnist数据集的test集中随便找一张图片,用来进行实验。
#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] #将该序号转换成对应的类别名称,并打印
最后输出 the class is : 5
分类正确。
如果是预测多张图片,可把上面这个文件写成一个函数,然后进行循环预测就可以了。