Caffe学习——Imagenet分类

Caffe学习——Imagenet分类

1. Caffe安装

参考Alten Li的Caffe安装[1]。

2. Imagenet分类

代码来自Caffe的Notebook Examples[2]。在导入Caffe前，先在sys.path中插入Caffe的路径：examples文件夹下有子文件夹pycaffe（猜是安装Caffe时执行“make pycaffe”生成的文件夹），并没有python文件夹；python文件夹属于caffe文件夹的子文件夹。所以，如果把根文件夹设为'/home/parallel/caffe/'，导入caffe也是有效的。

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# Make sure that caffe is on the python path:
caffe_root = '/home/parallel/caffe/examples/'  # this file is expected to be in {caffe_root}/examples
import sys
sys.path.insert(0, caffe_root + 'python')

import caffe

figure.figsize为图像的大小（分别为宽和高，单位为英寸）；image.interpolation为'nearest'表示当屏幕像素和图像像素不一致时，并没有在像素间计算插入值（可以理解为过渡值），所以如果屏幕像素过高，只是复制距这个像素点最近的像素值，所以每个像素值看起来像是个小方块。默认imshow显示采用的cmap为'jet'，这里用'gray'，所以显示的图像都是灰度图像。

plt.rcParams['figure.figsize'] = (10, 10)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

set_mode_cpu设置Caffe跑CPU模式。deploy.prototxt里定义了网络架构，后缀为.caffemodel为Caffe训练后得到的模型，最后定义网络的类型为'TEST'，这时网络只有前向计算得到输出结果，没有反向计算调整caffe模型的参数。

caffe.set_mode_cpu()
net = caffe.Net(caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt',
                caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel',
                caffe.TEST)

io为Caffe的数据输入模块，Transformer初始化时将输入数据的索引设为'data'，同时设置了输入数据（这里为图像）的大小。set_transpose负责将索引为'data'的输入数据做维度上的交换：如果原始图像为RGB图像，那么0对应R通道，1对应G通道，2对应B通道，(2,0,1)transpose后'data'变为BGR。mean.npy为像素的平均值，这个文件caffe可以自己生成（？：以后用到再说）。set_raw_scale将输入数据缩放为原来的255倍。(2,1,0)转置又将BGR图像转换为RGB图像。

# input preprocessing: 'data' is the name of the input blob == net.inputs[0]
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
transformer.set_transpose('data', (2,0,1))
transformer.set_mean('data', np.load('/home/parallel/caffe/python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel
transformer.set_raw_scale('data', 255)  # the reference model operates on images in [0,255] range instead of [0,1]
transformer.set_channel_swap('data', (2,1,0))  # the reference model has channels in BGR order instead of RGB

设置块大小为50，通道数为3，图像大小为227*227。然后用上面设置的transformer对加载的图像'cat.jpg'做预处理。

# set net to batch size of 50
net.blobs['data'].reshape(50,3,227,227)
net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image(caffe_root + 'images/cat.jpg'))

前向计算输出结果给out。打印out中概率（'prob'）最大的索引，输入为50个图像为一组，这里应该是把'cat.jpg'复制了50张（从data[0]到data[49]）。所以'prob'标签后面的[0]可以修改为49及以内的任何正整数。

out = net.forward()
print("Predicted class is #{}.".format(out['prob'][0].argmax()))

显示图像。imshow设置的'cmap'应该为'gray'，不清楚为什么这里会显示彩色图像。

plt.imshow(transformer.deprocess('data', net.blobs['data'].data[0]))

加载groundtruch标签，存放在synset_words.txt里面。如果没有这个文件加载给labels，会执行get_ilsvrc_aux.sh批处理文件获取该文件。

# load labels
imagenet_labels_filename = '/home/parallel/caffe/data/ilsvrc12/synset_words.txt'
try:
    labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
except:
    !../data/ilsvrc12/get_ilsvrc_aux.sh
    labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')

获取'prob'最大的6个预测索引，这里最大的概率对应的索引应该为281，对应的标签为'n02123045 tabby, tabby cat'。

# sort top k predictions from softmax output
top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]
print labels[top_k]

设置为CPU模式，输出结果为最好的3次，每次都是1个前向计算（感觉3次输入1样，所以基本上没什么差异）。CPU每次前向计算花费的时间为6.45秒；

# CPU mode
net.forward()  # call once for allocation
%timeit net.forward()

1 loops, best of 3: 6.45 s per loop

设置为GPU模式，同理得到每次前向计算花费的时间为0.233秒。

# GPU mode
caffe.set_device(0)
caffe.set_mode_gpu()
net.forward()  # call once for allocation
%timeit net.forward()

1 loops, best of 3: 223 ms per loop

网络架构的绘制使用graphviz[3]。

net.blobs里包含网络每块特征地图的字典索引k和对应内容v的大小，net.params训练后的网络参数[4]。

net.params为事先设置的参数尺寸(output channels, input channels, filter height filter width)。

根据net.params中的filter size来计算net.blobs的(batch size, output channels, height, width)。

data: 50张图片为1组输入，通道数为3（RGB），图像宽度和高度为227。

conv1:(227-11)/4+1=55

pool1 :(55-3)/2+1=27

conv2:(27-5+4)/1+1=27

pool2 :(27-3)/2+1=13

conv3:(13-3+2)/1+1=13

conv4:(13-3+2)/1+1=13

conv5:13

pool5 :(13-3)/2+1=6 

[(k, v.data.shape) for k, v in net.blobs.items()]

[('data', (50, 3, 227, 227)),
 ('conv1', (50, 96, 55, 55)),
 ('pool1', (50, 96, 27, 27)),
 ('norm1', (50, 96, 27, 27)),
 ('conv2', (50, 256, 27, 27)),
 ('pool2', (50, 256, 13, 13)),
 ('norm2', (50, 256, 13, 13)),
 ('conv3', (50, 384, 13, 13)),
 ('conv4', (50, 384, 13, 13)),
 ('conv5', (50, 256, 13, 13)),
 ('pool5', (50, 256, 6, 6)),
 ('fc6', (50, 4096)),
 ('fc7', (50, 4096)),
 ('fc8', (50, 1000)),
 ('prob', (50, 1000))]

[(k, v[0].data.shape) for k, v in net.params.items()]

[('conv1', (96, 3, 11, 11)),
 ('conv2', (256, 48, 5, 5)),
 ('conv3', (384, 256, 3, 3)),
 ('conv4', (384, 192, 3, 3)),
 ('conv5', (256, 192, 3, 3)),
 ('fc6', (4096, 9216)),
 ('fc7', (4096, 4096)),
 ('fc8', (1000, 4096))]

vis_square是把data归一化，然后把n个data放在同一张图片里显示出来。

params存储网络中间层的网络参数，conv1层的参数尺寸为(96, 3, 11, 11)，params['conv1'][0].data为conv1的权重参数，filters转置后的尺寸为(96, 11, 11, 3)，符合vis_square函数中data的定义(n, height, width, channels)。

filters = net.params['conv1'][0].data
vis_square(filters.transpose(0, 2, 3, 1))

conv2层的参数尺寸为(256,48,5,5)，params['conv2'][0].data为conv2的权重参数，这里只显示其中的48个。注意到conv1的output channels为96，conv2的input channels为48，说明剩下的48个output channels都被丢弃了。

filters = net.params['conv2'][0].data
vis_square(filters[:48].reshape(48**2, 5, 5))

blobs存储网络中间层的输出数据，显示conv1层前36个特征图。根据blobs的定义，data[0, :36]应该是第1张图片的前36个output channels。

feat = net.blobs['conv1'].data[0, :36]
vis_square(feat, padval=1)

显示conv2层前36个特征图。

feat = net.blobs['conv2'].data[0, :36]
vis_square(feat, padval=1)

显示conv3层所有的特征图。

feat = net.blobs['conv3'].data[0]
vis_square(feat, padval=0.5)

显示conv4层所有的特征图。

feat = net.blobs['conv4'].data[0]
vis_square(feat, padval=0.5)

显示conv5层所有的特征图。

feat = net.blobs['conv5'].data[0]
vis_square(feat, padval=0.5)

显示pool5层所有的特征图。

feat = net.blobs['pool5'].data[0]
vis_square(feat, padval=1)

全连接层的params的结构为(output channels, input channels)，所以fc6和fc7的直方图横轴都为4096。上面的图为全连接层4096个神经元的输出值，下面的图为对这些神经元的响应值的强度为直方图的输入，可知fc6大多数神经元的响应值都在40以下，和fc7相比，直方图的斜率的绝对值应该是偏小。也就是说全连接层前后相连，越往后神经元的响应值越不会均匀分布化，而通过神经元间的竞争所以最后一层全连接层'prob'产生的尖峰即为优胜的神经元，这个神经元对应的索引决定了对象属于哪一类。

feat = net.blobs['fc6'].data[0]
plt.subplot(2, 1, 1)
plt.plot(feat.flat)
plt.subplot(2, 1, 2)
_ = plt.hist(feat.flat[feat.flat > 0], bins=100)

feat = net.blobs['fc7'].data[0]
plt.subplot(2, 1, 1)
plt.plot(feat.flat)
plt.subplot(2, 1, 2)
_ = plt.hist(feat.flat[feat.flat > 0], bins=100)

feat = net.blobs['prob'].data[0]
plt.plot(feat.flat)

3. 参考链接

[1] http://blog.csdn.net/altenli/article/details/44199539

[2] http://nbviewer.ipython.org/github/BVLC/caffe/blob/master/examples/00-classification.ipynb

[3] http://blog.csdn.net/honyniu/article/details/46391569

[4] http://blog.csdn.net/guoyilin/article/details/42873747