proc val 命令行 nim 慢慢 mnist backward word .org

繼續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 學習|網絡訓練、部署、測試