Caffe-python interface 学习|网络定义详解

之前用的都是caffe的命令行接口，单独训练还行，不过看里面层的参数、数据还是很麻烦的。特别是这周实验遇到了比较大的问题，命令行无能为力，还是要好好看看python接口。

python 接口编译

这个一般在编译caffe时都会顺带完成，如果遇到ImportError: No module named caffe，可能是没有编译或者没有添加到路径。
编译可以在根目录下make pycaffe，目录是/caffe/python。将caffe/python的路径添加到用户环境变量~/.bashrc中：

export PYTHONPATH=/home/xxx/caffe/python

然后输入sudo ldconfig确认。当然我的服务器没有管理员权限，这时可以每次手动添加目录，见下文。
编译时要在Makefile.config中修改有关路径，除此之外，

WITH_PYTHON_LAYER := 1

也是需要注意的一点，这在f-rcnn中也提到过。

python 接口调用

import sys
sys.path.append('/home/xxx/caffe/python')#手动添加路径
import caffe
import numpy as np
from skimage import io
import matplotlib.pyplot as plt

以上可以直接复制好，每次都加上。

运行模式小设置

caffe.set_mode_cpu()#设置为cpu模式
caffe.set_device(0)#gpu号
caffe.set_mode_gpu()#gpu模式

定义网络

下面是一个例子：

# -*- 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()

上面的代码，我们一开始就import了两个包，一个是layers，另一个是params。layers里面包含了Caffe所以内置的层（比如卷积，ReLU等），而params则包含了各种枚举值。
网上很少找到函数详解，自己凭着理解总结一下吧：

数据层

data,label=L.Data(
        source=lmdb,                             #数据源，训练数据LMDB文件的位置
        backend=P.Data.LMDB,                     #数据类型，本文是lmdb
        batch_size=batch_size,                   #batch大小
        ntop=2,                                  #输出数量，本文是data和label，所以是2
        transform_param=dict(crop_size=40,       #crop大小
                            mean_file=mean_file, #均值文件
                            mirror=True          #镜像操作
                            )
        )

卷积层

conv1=L.Convolution(
        data,                             #数据流入（即从数据层得到的data）
        kernel_size=5,                    #卷积核大小
        stride=1,                         #步长
        num_output=16,                    #输出
        pad=2,                            #填零
        weight_filler=dict(type='xavier') #权重初始化方式'xavier'
        )

激活层、dropout层

relu1=L.ReLU(
            conv1,         #数据流入（即从卷积层得到的conv1）
            in_place=True  #in_place ，就地运算，节省存储开销
            )
drop3=L.Dropout(
            relu3,         #数据流入（即从激活层得到的relu3）
            in_place=True  #in_place ，就地运算，节省存储开销
            )

池化层

pool1=L.Pooling(
            relu1,               #数据流入（即从激活层得到的relu1）
            pool=P.Pooling.MAX,  #池化方式：最大池化
            kernel_size=3,       #池化核大小
            stride=2             #步长
            )

全连接层

fc3=L.InnerProduct(
            pool2,                            #数据流入（即从池化层得到的pool2）
            num_output=1024,                  #全连接输出数目
            weight_filler=dict(type='xavier') #权重初始化方式'xavier'
            )

SoftmaxWithLoss层

loss = L.SoftmaxWithLoss(
            fc4,    #数据流入（即从全连接层得到的fc4）
            label   #数据流入（即从数据层得到的label）
            )

Accuracy层

if include_acc:                  #在训练阶段，不需要accuracy层，但是在验证阶段，是需要的
    acc = L.Accuracy(
                fc4,  
                label 
                ) 
    return to_proto(loss, acc)
else:
    return to_proto(loss)

总结

上面那种是一层一层往上累加的，最后返回了最后一层。
当然如果直接建一个caffe.NetSpec()，会有一个整体的把握：

def mynet(lmdb, batch_size):
    n = caffe.NetSpec()
    ###################
    n.data, n.label = L.Data(batch_size=batch_size, backend=P.Data.LMDB, source=lmdb, transform_param=dict(scale=1./255), ntop=2)
    ###################
    return n.to_proto()

方法的参数中的lmdb是指Caffe支持的数据库的一种，叫lmdb，我们传入数据库的路径即可。而n=caffe.NetSpec()是获取Caffe的一个Net，我们只需不断的填充这个n，最后面把n输出到文件。
在填充的时候要记得加上n.。
各层的具体参数可以参考caffe.proto。

caffe的python接口学习（1）：生成配置文件
Deep learning tutorial on Caffe technology : basic commands, Python and C++ code.
Caffe学习4-利用caffe.proto自定义自己的网络