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

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

python 接口编译

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

1
export PYTHONPATH=/home/xxx/caffe/python

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

1
WITH_PYTHON_LAYER := 1

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

python 接口调用

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

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

运行模式小设置

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

定义网络

下面是一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# -*- 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则包含了各种枚举值。
网上很少找到函数详解,自己凭着理解总结一下吧:

数据层

1
2
3
4
5
6
7
8
9
10
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 #镜像操作
)
)

卷积层

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

激活层、dropout层

1
2
3
4
5
6
7
8
relu1=L.ReLU(
conv1, #数据流入(即从卷积层得到的conv1)
in_place=True #in_place ,就地运算,节省存储开销
)
drop3=L.Dropout(
relu3, #数据流入(即从激活层得到的relu3)
in_place=True #in_place ,就地运算,节省存储开销
)

池化层

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

全连接层

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

SoftmaxWithLoss层

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

Accuracy层

1
2
3
4
5
6
7
8
if include_acc: #在训练阶段,不需要accuracy层,但是在验证阶段,是需要的
acc = L.Accuracy(
fc4,
label
)
return to_proto(loss, acc)
else:
return to_proto(loss)

总结

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

1
2
3
4
5
6
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
总的来说,这种方式生成prototxt要简单一些,代码量比直接写要小,而且层的输入输出清晰:输入是第一个参数,输出是返回值。不过也要注意不同参数的数据格式,如dict(type='xavier')

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