1 最近一直在学习caffe深度学习模型，便于日后的复习，就开始随笔记些东西。有错误的话，欢迎朋友们的批评指正，一起学习。
日后准备深入学习下算法知识，补一些自己的短板。如果大家配置中遇到问题，欢迎私信交流。
2 win条件下具体的配置见下文。【扣扣：1396750111】
3.1 构建数据集
数据集的下载如下图：
3.2 windows下进行环境搭建
3.2.1 Caffe下载及安装
1. 微软提供window工具包https://github.com/Microsoft/caffe，右下角Download
ZIP，解压后文件夹是caffe-master。
2．复制caffe-master/windows下CommonSettings.props.example，改为CommonSettings.props，把它拖到Nootepad+++打开，更改这三项（因为没有GPU），保存。CommonSettings.props简单配置如下图：
3. 双击caffe-master/windows下的Caffe.sln，用VS2013（下面3.2.3会介绍具体方法）打开，生成解决方案；官网自带的有16个项目。
Caffe的16个项目生成解决方案如下图：
4. Nuget所需要的第三方库安装，在线下载的。第三方库Nuget下载下来如下，放到与caffe-master并列的文件夹即可。
5. 编译成功后会在caffe-master\Build\x64\Release中出现各种编译后的文件。
编译成功后如下图：
3.2.2 Python的Anaconda配置及安装
1.Windows下Anaconda2和Anaconda3共存，我先安装Anaconda3，安装在I:\Anaconda3。
2. 然后我再安装Anaconda2，需要安装在F:\Anaconda3\envs\py2。
3. Anaconda2环境测试成功。
环境方面就介绍到这里呢，具体得操作才行，期待和你的交流~
第4章 算法设计与实现
4.1卷积神经网络
卷积神经网络中，一般卷积层后都会跟着池化层。在通过卷积获得了特征之后，就可以利用这些特征去做分类。虽然在理论上，可以用所有提取得到的特征去训练分类器，例如用Softmax来进行分类，但是这样会面临着计算量的巨大挑战。假设对于一个256 x
256像素的图像，在一个8x8的输入上，已经通过实验预先学习获得了100个特征，然后将特征和图像进行卷积，每做一次运算，都会得到一个249 x 249维的卷积特征，由于有100个特征，那对于一个样本，将会得到一个62001x100维的卷积特征向量。超过六百万的特征输入，任何分类器都难以处理，并且可能出现过拟合的情况。
为了解决这个问题，则需要降低特征的维数，而图像具有一种“静态性”的属性，这也是采用卷积后的特征表示图像的原因，正因为这个属性，从一个图像区域提取到的特征，很有可能也可以用来表示图像的另一个区域。于是为了描述一些很大的图像，对于图像的不同位置的特征，可以进行合并统计，比较常用的是用图像区域上的某个特定特征的最大值(或平均值)来对图像进行描述。与使用全部的特征相比，这些概要统计特征不仅具有较低的维度，同时还会改善结果，可以有效降低过拟合。这种操作方法就被称作池化，根据池化方法可以分为平均池化、最大值池化和随机池化。从以上可以看出，局部感受野、权值共享和空间亚采样是卷积神经网络的三个特性，通过这三者的结合可以得到某种程度上的尺度、位移和形变不变性。
4.2 Googlenet算法模型
4.21 Googlenet算法简介
GoogleNet和VGG是2014年imagenet竞赛的双雄，这两类模型结构有一个共同特点是go deeper。跟VGG不同的是，GoogleNet做了更大胆的网络上的尝试而不是像VGG继承了Lenet以及AlexNet的一些框架，该模型虽然有22层，但大小却比AlexNet和VGG都小很多，性能优越。
深度学习以及神经网络快速发展，人们容易通过更高性能的硬件，更庞大的带标签数据和更深更宽的网络模型等手段来获得更好的预测识别效果，但是这一策略带来了两个重要的缺陷。
（1）更深更宽的网络模型会产生巨量参数，从而容易出现过拟合现象。
（2）网络规模加大会极大增加计算量，消耗更多的计算资源。
解决这两个缺陷的根本方法就是将全连接甚至一般的卷积都转化为稀疏连接。一方面现实生物神经系统的连接也是稀疏的，另一方面有文献表明：对于大规模稀疏的神经网络，可以通过分析激活值的统计特性和对高度相关的输出进行聚类来逐层构建出一个最优网络。这点表明臃肿的稀疏网络可能被不失性能地简化。虽然数学证明有着严格的条件限制，但Hebbian定理有力地支持了这一结论。
由于计算机软硬件对非均匀稀疏数据的计算效率很差，所以在AlexNet模型重新启用了全连接层，其目的是为了更好地优化并行运算。具体方法是采用将多个稀疏矩阵合并成相关的稠密子矩阵的方法来提高计算性能，Google团队沿着这个思路提出了名为Inception 结构来实现此目的。
4.22 Googlenet算法模型
1.Inception模型
Inception结构的主要思想是找出如何让已有的稠密组件接近与覆盖卷积视觉网络中的最佳局部稀疏结构。有文献提出一个层与层的结构，在结构的最后一层进行相关性统计，将高相关性的聚集到一起。这些聚类构成下一层的单元，且与上一层单元连接。假设前面层的每个单元对应于输入图像的某些区域，这些单元被分为滤波器组。Google团队首先提出来的是Inception模型，如下图所示：
Googlenet模型如下：
2.选择GoogLeNet的原因
（1）GoogLeNet采用了模块化的结构，方便增添和修改；
（2）网络最后采用了average pooling来代替全连接层，但是，实际在最后还是加了一个全连接层，主要是为了方便以后大家finetune；虽然移除了全连接，但是网络中依然使用了Dropout ；为了避免梯度消失，网络额外增加了2个辅助的softmax用于向前传导梯度。
（3）本文的主要想法其实是想通过构建密集的块结构来近似最优的稀疏结构，从而达到提高性能而又不大量增加计算量的目的，上面的这些模型特点很好的实现了这个想法。GoogleNet的caffemodel大小约50M，性能很优异。
第5章 系统测试
5.1 模型程序书写
5.11 训练数据转换程序
制作标签：
生成train.txt test.txt标签文档
生成lmdb训练数据程序：
G:\caffe-master\Build\x64\Release\convert_imageset.exe ^
--resize_height=256 --resize_width=256 ^
--shuffle ^
--backend="lmdb" ^
G:\caffe-master\models\my_models_recognition\data\train\^
G:\caffe-master\models\my_models_recognition\labels\train.txt^
G:\caffe-master\models\my_models_recognition\lmdb\train\
pause
%执行数据转换的可执行文件%
%重新设定图片的大小%
%打乱图片%
%转换格式%
%图片路径%
%图片标签%
%lmdb转换后的数据存放在此目录%
运行lmdb训练数据程序
生成lmdb训练数据
5.12 测试数据转换程序
生成lmdb训测试数据程序：
G:\caffe-master\Build\x64\Release\convert_imageset.exe ^
--resize_height=256 --resize_width=256 ^
--shuffle ^
--backend="lmdb" ^
G:\caffe-master\models\my_models_recognition\data\test\ ^
G:\caffe-master\models\my_models_recognition\labels\test.txt^
G:\caffe-master\models\my_models_recognition\lmdb\test\
pause
%执行数据转换的可执行文件%
%重新设定图片的大小%
%打乱图片%
%转换格式%
%图片路径%
%图片标签%
%lmdb转换后的数据存放在此目录%
5.13 训练模型程序
训练模型程序：
name: "CaffeNet"
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
phase: TRAIN
}
# transform_param {
# mirror: true
# crop_size: 227
# mean_file: "data/ilsvrc12/imagenet_mean.binaryproto"
# }
# mean pixel / channel-wise meaninstead of mean image
transform_param {
crop_size: 227
mean_value: 104
mean_value: 117
mean_value: 123
mirror: true
}
data_param {
source:"G:/caffe-master/models/my_models_recognition/lmdb/train"
batch_size: 100
backend: LMDB
}
}
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
phase: TEST
}
# transform_param {
# mirror: false
# crop_size: 227
# mean_file: "data/ilsvrc12/imagenet_mean.binaryproto"
# }
# mean pixel / channel-wise meaninstead of mean image
transform_param {
crop_size: 227
mean_value: 104
mean_value: 117
mean_value: 123
mirror: false
}
data_param {
source:"G:/caffe-master/models/my_models_recognition/lmdb/test"
batch_size: 50
backend: LMDB
}
}
layer {
name: "conv1"
type: "Convolution"
bottom: "data"
top: "conv1"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 96
kernel_size: 11
stride: 4
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
layer {
name: "relu1"
type: "ReLU"
bottom: "conv1"
top: "conv1"
}
layer {
name: "pool1"
type: "Pooling"
bottom: "conv1"
top: "pool1"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "norm1"
type: "LRN"
bottom: "pool1"
top: "norm1"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "conv2"
type: "Convolution"
bottom: "norm1"
top: "conv2"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 2
kernel_size: 5
group: 2
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 1
}
}
}
layer {
name: "relu2"
type: "ReLU"
bottom: "conv2"
top: "conv2"
}
layer {
name: "pool2"
type: "Pooling"
bottom: "conv2"
top: "pool2"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "norm2"
type: "LRN"
bottom: "pool2"
top: "norm2"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "conv3"
type: "Convolution"
bottom: "norm2"
top: "conv3"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 384
pad: 1
kernel_size: 3
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
layer {
name: "relu3"
type: "ReLU"
bottom: "conv3"
top: "conv3"
}
layer {
name: "conv4"
type: "Convolution"
bottom: "conv3"
top: "conv4"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 384
pad: 1
kernel_size: 3
group: 2
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 1
}
}
}
layer {
name: "relu4"
type: "ReLU"
bottom: "conv4"
top: "conv4"
}
layer {
name: "conv5"
type: "Convolution"
bottom: "conv4"
top: "conv5"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 1
kernel_size: 3
group: 2
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 1
}
}
}
layer {
name: "relu5"
type: "ReLU"
bottom: "conv5"
top: "conv5"
}
layer {
name: "pool5"
type: "Pooling"
bottom: "conv5"
top: "pool5"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "fc6"
type: "InnerProduct"
bottom: "pool5"
top: "fc6"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 512
weight_filler {
type: "gaussian"
std: 0.005
}
bias_filler {
type: "constant"
value: 1
}
}
}
layer {
name: "relu6"
type: "ReLU"
bottom: "fc6"
top: "fc6"
}
layer {
name: "drop6"
type: "Dropout"
bottom: "fc6"
top: "fc6"
dropout_param {
dropout_ratio: 0.5
}
}
layer {
name: "fc7"
type: "InnerProduct"
bottom: "fc6"
top: "fc7"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 512
weight_filler {
type: "gaussian"
std: 0.005
}
bias_filler {
type: "constant"
value: 1
}
}
}
layer {
name: "relu7"
type: "ReLU"
bottom: "fc7"
top: "fc7"
}
layer {
name: "drop7"
type: "Dropout"
bottom: "fc7"
top: "fc7"
dropout_param {
dropout_ratio: 0.5
}
}
layer {
name: "fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 5
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
layer {
name: "accuracy"
type: "Accuracy"
bottom: "fc8"
bottom: "label"
top: "accuracy"
include {
phase: TEST
}
}
layer {
name: "loss"
type: "SoftmaxWithLoss"
bottom: "fc8"
bottom: "label"
top: "loss"
}
5.2 模型迭代训练
运行训练程序（此处心里苦啊，没有gpu，怼了十几个小时啊）
运行训练模型程序完成（13小时）
1000次模型迭代，生成Image训练模型（多少次，大家可以定哒）
5.3 模型测试
1.测试程序
import caffe
import numpy as np
import matplotlib.pyplot as plt
import os
import PIL
from PIL import Image
import sys
#定义Caffe根目录
caffe_root = 'G:/caffe-master/'
#网络结构描述文件
deploy_file = caffe_root+'models/my_models_recognition/deploy.prototxt'
#训练好的模型
model_file =caffe_root+'models/my_models_recognition/model/caffenet_train_iter_5000.caffemodel'
#gpu模式
#caffe.set_device(0)
caffe.set_mode_gpu()
#定义网络模型
net = caffe.Classifier(deploy_file, #调用deploy文件
model_file, #调用模型文件
channel_swap=(2,1,0), #caffe中图片是BGR格式，而原始格式是RGB，所以要转化
raw_scale=255, #python中将图片存储为[0, 1]，而caffe中将图片存储为[0,
255]，所以需要一个转换
image_dims=(227, 227)) #输入模型的图片要是227*227的图片
#分类标签文件
imagenet_labels_filename = caffe_root+'models/my_models_recognition/labels/label.txt'
#载入分类标签文件
labels = np.loadtxt(imagenet_labels_filename, str)
#对目标路径中的图像，遍历并分类
for root,dirs,files inos.walk(caffe_root+'models/my_models_recognition/image/'):
for file infiles:
#加载要分类的图片
image_file= os.path.join(root,file)
input_image = caffe.io.load_image(image_file)
#打印图片路径及名称
image_path= os.path.join(root,file)
print(image_path)
#显示图片
img=Image.open(image_path)
plt.imshow(img)
plt.axis('off')
plt.show()
#预测图片类别
prediction= net.predict([input_image])
print 'predictedclass:',prediction[0].argmax()
#输出概率最大的前5个预测结果
top_k =prediction[0].argsort()[::-1]
fornode_id in top_k:
#获取分类名称
human_string = labels[node_id]
#获取该分类的置信度
score= prediction[0][node_id]
print('%s (score = %.5f)' % (human_string, score))
2．测试结果
测试代码运行
测试代码运行结果图（准确率还是可以的，开森，撒花~）
起飞啦~ 下次再补充啦
