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

时间：2023-03-08 17:42:10

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

相关文章