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

Posted Yan_Joy

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Caffe-python interface 学习|网络训练部署测试相关的知识,希望对你有一定的参考价值。

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

网络训练

solver文件生成

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

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

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

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去训练,就像命令行一样:

solver = caffe.SGDSolver(‘/home/xxx/solver.prototxt‘)
solver.solve()

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

solver = caffe.get_solver(‘models/bvlc_reference_caffenet/solver.prototxt‘)

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

solver.net.forward()  # train net

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

solver.net.backward()

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

solver.step(1)

改变数字进行多次计算。

网络部署

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

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,需要修改数据输入:

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

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

网络测试

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

#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是N*C*H*W,通道数在前。而python图像处理时shape是H*W*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













以上是关于Caffe-python interface 学习|网络训练部署测试的主要内容,如果未能解决你的问题,请参考以下文章

golang 关于 interface 的学习整理

JavaSE入门学习20:Java面向对象之接口(interface)

JavaSE入门学习21:Java面向对象之接口(interface)

golang中interface接口的深度解析

Thinking in java学习笔记之interface

Avalon总线学习 ---Avalon Interface Specifications