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

Posted 2020-10-23 llguanli

继续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