使用NER训练自己的model
使用NER训练自己的model：是斯坦福大学提供开源命名实体识别库，使用语言实现， 可以用来识别文本中的人名、地名、组织名称等实体。采用的是CRF分类器进行实体识别。
使用Standford NER进行命名实体识别
该过程参考
1. 下载源代码
2. 将stanford-ner-.zip解压到某个目录下，比如stanford-ner
3. 进入stanford-ner目录cd stanford-ner
4. 在linux/mac中可以使用运行一下命令，使用sample.txt文件进行命名实体测试，采用的是Stanford NER库自带的英文模型，该模型可以识别人名、地名和组织关系名称
java -mx600m -cp &*:lib/*& edu.stanford.nlp.ie.crf.CRFClassifier -loadClassifier classifiers/english.all.3class.distsim.crf.ser.gz -textFile sample.txt
5 . 运行以上命令后得到以下结果,其中每个单词后面都有标定结果， 0表示未识别，PERSON/ORGANIZATION分别表示人名和组织名称
The/O fate/O of/O Lehman/ORGANIZATION Brothers/ORGANIZATION ,/O the/O beleaguered/O investment/O bank/O ,/O hung/O in/O the/O balance/O on/O Sunday/O as/O Federal/ORGANIZATION Reserve/ORGANIZATION officials/O and/O the/O leaders/O of/O major/O financial/O institutions/O continued/O to/O gather/O in/O emergency/O meetings/O trying/O to/O complete/O a/O plan/O to/O rescue/O the/O stricken/O bank/O ./O
Several/O possible/O plans/O emerged/O from/O the/O talks/O ,/O held/O at/O the/O Federal/ORGANIZATION Reserve/ORGANIZATION Bank/ORGANIZATION of/ORGANIZATION New/ORGANIZATION York/ORGANIZATION and/O led/O by/O Timothy/PERSON R./PERSON Geithner/PERSON ,/O the/O president/O of/O the/O New/ORGANIZATION York/ORGANIZATION Fed/ORGANIZATION ,/O and/O Treasury/ORGANIZATION Secretary/O Henry/PERSON M./PERSON Paulson/PERSON Jr./PERSON ./O
使用Standford NER 训练自己语言模型
该过程参考
1. 准备训练数据，训练数据中，每行有两列，用tab分隔，第一列为单词，第二列为该单词的标记。以印度尼西亚语为例。将以下句子转换成训练数据
Pengamat politik dari Universitas Gadjah Mada, Arie Sudjito, menilai, keinginan Ketua Umum Partai Golkar Aburizal Bakrie untuk maju kembali sebagai ketua umum merupakan pemaksaan kehendak.
训练数据存储到jane-austen-emma-ch1.tsv
Universitas ORGANIZATION
ORGANIZATION
ORGANIZATION
Sudjito PERSON
ORGANIZATION
ORGANIZATION
2 . 配置属性文件，存储到austen.prop
# location of the training file
trainFile = jane-austen-emma-ch1.tsv
# location where you would like to save (serialize) your
# adding .gz at the end automatically gzips the file,
# making it smaller, and faster to load
serializeTo = ner-model.ser.gz
# structure o this tells the classifier that
# the word is in column 0 and the correct answer is in column 1
map = word=0,answer=1
# This specifies the order of the CRF: order 1 means that features
# apply at most to a class pair of previous class and current class
# or current class and next class.
# these are the features we'd like to train with
# some are discussed below, the rest can be
# understood by looking at NERFeatureFactory
useClassFeature=true
useWord=true
# word character ngrams will be included up to length 6 as prefixes
# and suffixes only
useNGrams=true
noMidNGrams=true
maxNGramLeng=6
usePrev=true
useNext=true
useDisjunctive=true
useSequences=true
usePrevSequences=true
# the last 4 properties deal with word shape features
useTypeSeqs=true
useTypeSeqs2=true
useTypeySequences=true
wordShape=chris2useLC
3 . 运行以下命令进行模型训练，生成NER模型ner-model.ser.gz
java -mx600m -cp &*:lib/*& edu.stanford.nlp.ie.crf.CRFClassifier -prop austen.prop
4 . 创建测试数据,生成测试文件test.txt
Hal ini, kata Arie, berpotensi menimbukan perpecahan di kalangan kader Golkar di daerah.
5 . 运行以下命令进行测试
java -mx600m -cp &*:lib/*& edu.stanford.nlp.ie.crf.CRFClassifier -loadClassifier ner-model.ser.gz
-textFile test.txt
6 . 运行结果
Hal/0 ini/0 ,/0 kata/0 Arie/PERSON ,/0 berpotensi/0 menimbukan/0 perpecahan/0 di/0 kalangan/0 kader/0 Golkar/ORGANIZATION di/0 daerah/0 ./0caffe框架（56）
caffe团队用imagenet图片进行训练，迭代30多万次，训练出来一个model。这个model将图片分为1000类，应该是目前为止最好的图片分类model了。
假设我现在有一些自己的图片想进行分类，但样本量太小，可能只有几百张，而一般深度学习都要求样本量在1万以上，因此训练出来的model精度太低，根本用不上，那怎么办呢？
那就用caffe团队提供给我们的model吧。
因为训练好的model里面存放的就是一些参数，因此我们实际上就是把别人预先训练好的参数，拿来作为我们的初始化参数，而不需要再去随机初始化了。图片的整个训练过程，说白了就是将初始化参数不断更新到最优的参数的一个过程，既然这个过程别人已经帮我们做了，而且比我们做得更好，那为什么不用他们的成果呢？
使用别人训练好的参数，必须有一个前提，那就是必须和别人用同一个network，因为参数是根据network而来的。当然，最后一层，我们是可以修改的，因为我们的数据可能并没有1000类，而只有几类。我们把最后一层的输出类别改一下，然后把层的名称改一下就可以了。最后用别人的参数、修改后的network和我们自己的数据，再进行训练，使得参数适应我们的数据，这样一个过程，通常称之为微调（fine tuning).
既然前两篇文章我们已经讲过使用digits来进行训练和可视化，这样一个神器怎么能不使用呢？因此本文以此工具为例，讲解整个微调训练过程。
一、下载model参数
可以直接在浏览器里输入地址下载，也可以运行脚本文件下载。下载地址为：
文件名称为：bvlc_reference_caffenet.caffemodel，文件大小为230M左右，为了代码的统一，将这个caffemodel文件下载到caffe根目录下的&models/bvlc_reference_caffenet/ 文件夹下面。也可以运行脚本文件进行下载：
# sudo ./scripts/download_model_binary.py models/bvlc_reference_caffenet
&二、准备数据
如果有自己的数据最好，如果没有，可以下载我的练习数据：
这些数据共有500张图片，分为大巴车、恐龙、大象、鲜花和马五个类，每个类100张。编号分别以3，4，5，6，7开头，各为一类。我从其中每类选出20张作为测试，其余80张作为训练。因此最终训练图片400张（放在train文件夹内，每个类一个子文件夹），测试图片100张（放在test文件夹内，每个类一个子文件夹）。
将图片下载下来后解压，放在一个文件夹内。比如我在当前用户根目录下创建了一个data文件夹，专门用来存放数据，因此我的训练图片路径为：/home/xxx/data/re/train
打开浏览器，运行digits，如果没有这个工具的，推荐安装，真的是学习caffe的神器。安装及使用可参见我的前两篇文章：
新建一个classification dataset,设置如下图：
下面图片格式选为jpg, 为dataset取一个名字，就开始转换吧。结果如图：
三、设置model
回到digits根目录，新建一个classification model， 选中你的dataset, 开始设置最重要的network.
caffenet的网络配置文件，放在 caffe/models/bvlc_reference_caffenet/ 这个文件夹里面，名字叫train_val.prototxt。打开这个文件，将里面的内容复制到上图的Custom Network文本框里，然后进行修改，主要修改这几个地方：
1、修改train阶段的data层为：
name: &data&
type: &Data&
top: &data&
top: &label&
phase: TRAIN
transform_param {
mirror: true
crop_size: 227
即把均值文件（mean_file)、数据源文件(source)、批次大小(batch_size)和数据源格式（backend)这四项都删除了。因为这四项系统会根据dataset和页面左边“solver options&的设置自动生成。
2、修改test阶段的data层：
name: &data&
type: &Data&
top: &data&
top: &label&
phase: TEST
transform_param {
mirror: false
crop_size: 227
和上面一样，也是删除那些项。
3、修改最后一个全连接层（fc8)：
name: &fc8-re&
#原来为&fc8&
type: &InnerProduct&
bottom: &fc7&
top: &fc8&
lr_mult: 1.0
decay_mult: 1.0
lr_mult: 2.0
decay_mult: 0.0
inner_product_param {
num_output: 5
#原来为&1000&
weight_filler {
type: &gaussian&
bias_filler {
type: &constant&
value: 0.0
看注释的地方，就只有两个地方修改，其它不变。
设置好后，就可以开始微调了(fine tuning).
训练结果就是一个新的model，可以用来单张图片和多张图片测试。具体测试方法前一篇文章已讲过，在此就不重复了。
在此，将别人训练好的model用到我们自己的图片分类上，整个微调过程就是这样了。如果你不用digits，而直接用命令操作，那就更简单，只需要修改一个train_val.prototxt的配置文件就可以了，其它都是一样的操作。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：197766次
积分：3212
积分：3212
排名：第9954名
原创：74篇
转载：259篇
评论：124条
研二在读，关注：深度学习，计算机视觉，机器学习，图像处理。博文主要是自己的一些总结。转载文章供资料学习（转载一些最新文章），如有侵权望告知。注：有些评论没有回复，最近比较忙不好意思。
(1)(14)(43)(57)(22)(16)(46)(24)(43)(42)(40)如何将别人训练好的model用到自己的数据上 - Caffe 深度学习入门教程_Linux教程_Linux公社-Linux系统门户网站
你好，游客
Caffe 深度学习入门教程
如何将别人训练好的model用到自己的数据上
来源：Linux社区&
作者：denny402
如何将别人训练好的model用到自己的数据上
caffe团队用imagenet图片进行训练，迭代30多万次，训练出来一个model。这个model将图片分为1000类，应该是目前为止最好的图片分类model了。
假设我现在有一些自己的图片想进行分类，但样本量太小，可能只有几百张，而一般深度学习都要求样本量在1万以上，因此训练出来的model精度太低，根本用不上，那怎么办呢？
那就用caffe团队提供给我们的model吧。
因为训练好的model里面存放的就是一些参数，因此我们实际上就是把别人预先训练好的参数，拿来作为我们的初始化参数，而不需要再去随机初始化了。图片的整个训练过程，说白了就是将初始化参数不断更新到最优的参数的一个过程，既然这个过程别人已经帮我们做了，而且比我们做得更好，那为什么不用他们的成果呢？
使用别人训练好的参数，必须有一个前提，那就是必须和别人用同一个network，因为参数是根据network而来的。当然，最后一层，我们是可以修改的，因为我们的数据可能并没有1000类，而只有几类。我们把最后一层的输出类别改一下，然后把层的名称改一下就可以了。最后用别人的参数、修改后的network和我们自己的数据，再进行训练，使得参数适应我们的数据，这样一个过程，通常称之为微调（fine tuning).
既然前两篇文章我们已经讲过使用digits来进行训练和可视化，这样一个神器怎么能不使用呢？因此本文以此工具为例，讲解整个微调训练过程。
一、下载model参数
可以直接在浏览器里输入地址下载，也可以运行脚本文件下载。下载地址为：
文件名称为：bvlc_reference_caffenet.caffemodel，文件大小为230M左右，为了代码的统一，将这个caffemodel文件下载到caffe根目录下的&models/bvlc_reference_caffenet/ 文件夹下面。也可以运行脚本文件进行下载：
# sudo ./scripts/download_model_binary.py models/bvlc_reference_caffenet
&二、准备数据
如果有自己的数据最好，如果没有，可以下载我的练习数据：
到Linux公社1号FTP服务器下载
------------------------------------------分割线------------------------------------------
在 2016年\11月\Caffe 深度学习入门教程\
下载方法见
------------------------------------------分割线------------------------------------------&
这些数据共有500张图片，分为大巴车、恐龙、大象、鲜花和马五个类，每个类100张。编号分别以3，4，5，6，7开头，各为一类。我从其中每类选出20张作为测试，其余80张作为训练。因此最终训练图片400张（放在train文件夹内，每个类一个子文件夹），测试图片100张（放在test文件夹内，每个类一个子文件夹）。
将图片下载下来后解压，放在一个文件夹内。比如我在当前用户根目录下创建了一个data文件夹，专门用来存放数据，因此我的训练图片路径为：/home/xxx/data/re/train
打开浏览器，运行digits，如果没有这个工具的，推荐安装，真的是学习caffe的神器。安装及使用可参见我的前两篇文章：&
新建一个classification dataset,设置如下图：
下面图片格式选为jpg, 为dataset取一个名字，就开始转换吧。结果如图：
三、设置model
回到digits根目录，新建一个classification model， 选中你的dataset, 开始设置最重要的network.
caffenet的网络配置文件，放在 caffe/models/bvlc_reference_caffenet/ 这个文件夹里面，名字叫train_val.prototxt。打开这个文件，将里面的内容复制到上图的Custom Network文本框里，然后进行修改，主要修改这几个地方：
1、修改train阶段的data层为：
name: "data"
type: "Data"
top: "data"
top: "label"
phase: TRAIN
transform_param {
mirror: true
crop_size: 227
即把均值文件（mean_file)、数据源文件(source)、批次大小(batch_size)和数据源格式（backend)这四项都删除了。因为这四项系统会根据dataset和页面左边&solver options"的设置自动生成。
2、修改test阶段的data层：
name: "data"
type: "Data"
top: "data"
top: "label"
phase: TEST
transform_param {
mirror: false
crop_size: 227
和上面一样，也是删除那些项。
3、修改最后一个全连接层（fc8)：
name: "fc8-re"
#原来为"fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
lr_mult: 1.0
decay_mult: 1.0
lr_mult: 2.0
decay_mult: 0.0
inner_product_param {
num_output: 5
#原来为"1000"
weight_filler {
type: "gaussian"
bias_filler {
type: "constant"
value: 0.0
看注释的地方，就只有两个地方修改，其它不变。
设置好后，就可以开始微调了(fine tuning).
训练结果就是一个新的model，可以用来单张图片和多张图片测试。具体测试方法前一篇文章已讲过，在此就不重复了。
在此，将别人训练好的model用到我们自己的图片分类上，整个微调过程就是这样了。如果你不用digits，而直接用命令操作，那就更简单，只需要修改一个train_val.prototxt的配置文件就可以了，其它都是一样的操作。
本文永久更新链接地址：23
【内容导??】
相关资讯 & & &
& (03月07日)
& (03月07日)
& (01月12日)fine-tuning:利用已有模型训练其他数据集 - 知乎专栏
你正在使用一个过时的浏览器。请以查看此页面。
{"debug":false,"apiRoot":"","paySDK":"/api/js","wechatConfigAPI":"/api/wechat/jssdkconfig","name":"production","instance":"column","tokens":{"X-XSRF-TOKEN":null,"X-UDID":null,"Authorization":"oauth c3cef7c66aa9e6a1e3160e20"}}
{"database":{"Post":{"":{"title":"fine-tuning:利用已有模型训练其他数据集","author":"fishjunyu","content":"谢@提醒，尝试了将前面层的lr调成0，只训练全连接层，结果放在了每个微调网络的最后；另外添加了50层的ResNet进行fine-tuning，结果得到了进一步的提高，超越了SVM在这一数据集上的最佳performance(87%)---------------------------------------------------------------------------------------------------------------------------Deep Learning或者说CNN在图像识别这一领域取得了巨大的进步，那么自然我们就想将CNN应用到我们自己的数据集上，但这时通常就会面临一个问题：通常我们的dataset都不会特别大，一般不会超过1万张，甚至更少，每一类图片只有几十或者十几张。这时候，直接应用这些数据训练一个网络的想法就不可行了，因为深度学习成功的一个关键性因素就是大量带标签数据组成的训练集。如果只利用手头上这点数据，即使我们利用非常好的网络结构，也达不到很高的performance。这时候，fine-tuning的思想就可以很好解决我们的问题：我们通过对ImageNet上训练出来的模型（如CaffeNet,VGGNet,ResNet)进行微调，然后应用到我们自己的数据集上。由于ImageNet数以百万计带标签的训练集数据，使得如CaffeNet之类的预训练的模型具有非常强大的泛化能力，这些预训练的模型的中间层包含非常多一般性的视觉元素，我们只需要对他的后几层进行微调，在应用到我们的数据上，通常就可以得到非常好的结果。最重要的是，在目标任务上达到很高performance所需要的数据的量相对很少这是Caffe官方提供的fine-tuing示例：下面我们看另外一个有趣的例子：Oxford flowers分类我修改了他们的一些代码，使用了VGG_16而不是VGG_S模型，得到了更好的结果。这是一个给花分类的例子,我们首先git clone /fish145/fine-tuning\ncd Oxford102\n克隆整个项目到本地，然后使用python bootstrap.py\n准备图片，并下载CaffeNet和VGG-16这两个预训练模型运行结束之后我们就可以看到这些美丽的图片了运行结束之后我们就可以看到这些美丽的图片了可以看到，总共8189张图片被划分为训练集(1020张）,验证集(1020张）和测试集(6149张)可以看到，总共8189张图片被划分为训练集(1020张）,验证集(1020张）和测试集(6149张)1.微调CaffeNet我们首先微调CaffeNet：1).CaffeNet包含五层卷积层和三层全连接层，我们保留前面七层的参数，修改最后一层fc8为fc8_oxford_102,将最后预测种类设置为102，相当于我们只需要着重训练这一层的参数，而微调前面的七层看一下配置文件中值得注意的地方：这是输入部分，我们这里使用ImageData的形式作为Input，train.txt和valid.txt就是上面程序生成的数据列表，没有使用以往常用的lmdb格式。因为作为微调，数据量相对很少，所以使用这种比较慢的形式也是可以接受的这是输入部分，我们这里使用ImageData的形式作为Input，train.txt和valid.txt就是上面程序生成的数据列表，没有使用以往常用的lmdb格式。因为作为微调，数据量相对很少，所以使用这种比较慢的形式也是可以接受的2).然后设置base_lr为0.001（原始模型中为0.01），因为我们只需要微调前面几层的结构，而将最后一层的learning_rate设置为0.01,来加快这一层的学习;如果你想完全停止除fc8_flickr外其他层的微调，你可以设置那些层的lr_mult为0看一下solver.prototxt:可以看到除了base_lr和stepsize被修改外，其余参数都基本一致可以看到除了base_lr和stepsize被修改外，其余参数都基本一致新加入的fc8_oxford_102层的learning_rate是前七层的十倍新加入的fc8_oxford_102层的learning_rate是前七层的十倍3).stepsize也需要设置的小一点接下来开始训练，采用标准的训练过程，用验证集来调整参数，用测试集来测试最终的模型caffe train -solver=solver.prototxt -weights=pretrained-weights.caffemodel -gpu 0\n用以上命令进行训练:单GPU上训练50000次用了单GPU上训练50000次用了六个小时左右，但其实三万次的模型在测试集上的performance最高，后面应该出现了点过拟合，我们看一下训练过程中的accuracy曲线图loss下降的非常快，大致30000次迭代之后，已经达到最佳loss下降的非常快，大致30000次迭代之后，已经达到最佳接下来我们在测试集(6149张)图片上测试我们的模型：caffe test -model=test.prototxt -weights=snapshot.caffemodel -iterations=123 -gpu 0\n最后的accuracy为最后的accuracy为81.43%，在验证集上的accuracy为84%左右，可以看出模型泛化能力还是非常好的最后我们用训练出来的模型对自己的图片进行预测：python predict.py test1.jpg deploy.prototxt pretrained.caffemodel ilsvrc_2012_mean.npy 227\n参数依次是测试的图片,配置文件,model,均值文件以及crop之后的图片sizetitle为花的种类以及为该种类的概率。title为花的种类以及为该种类的概率。如果有数量庞大的花的数据以及一些额外工作，我们就可以得到一个识花的工具了！--------------------------------------------------------------------------------------------------------------------尝试将前五层的卷积层的lr调成0，只训练全连接层，在验证集上的结果如下图：82.85%，和之前的结果(83.95%)相比只下降了1%,再看一下测试集上：82.85%，和之前的结果(83.95%)相比只下降了1%,再看一下测试集上：也只下降了1%左右，也只下降了1%左右，但是训练时间并没有差多少，也是6个小时左右，所以用CaffeNet进行fine-tuning的话，这种策略并没有什么收益！2.微调VGGNet(16 layers)VGG_16包含13个卷积层和3个全连接层，和上面一样，我们只修改最后一层，具体的结构大家参考项目下的配置文件即可由于这个结构比较庞大，单GPU(Tesla K80)训练大概需要两天时间~30000次迭代后，accuracy达到了30000次迭代后，accuracy达到了89.1%，比CaffeNet结构提高了接近6%！如果使用现在最好的ResNet结构，应该可以达到90%以上的accuracy下面比较一下二者的训练曲线：然后看一下在测试集上的表现：在测试集上的accuracy为在测试集上的accuracy为86.3%，同样是一个飞跃！这一结果已经无限逼近这个数据集上目前的最佳结果了(87%,使用SVM方法)最后测试自己的图片就不进行了，感兴趣的可以自行尝试，这个model比前一个的识别能力要更好---------------------------------------------------------------------------------------------------------------------------尝试将前十三层的卷积层的lr调成0，只训练后三层全连接层，结果如下：accuracy降到81.56%了，在测试集上更是连80%也没有：accuracy降到81.56%了，在测试集上更是连80%也没有：但是训练时间降低到了16个小时，整整快了两倍左右，但是对performance影响太大，所以也不推荐使用；在层数较深的情况下，由于DL本身的特性，在越高层形成的特征越抽象，而前面的卷积层则是颜色和边缘这些比较泛化的特征，所以在fine-tuning时，可以将前几层conv层的lr置为0，但是后面的conv不建议这么做，否则对performance影响太大，得不偿失！---------------------------------------------------------------------------------------------------------------------------3.微调ResNet(50 layers)最近使用fine-tuning完成了一个task,为达到最好的performance，使用了50层的ResNet结构。中间也遇到一些坑，一起写在这里，给大家一个借鉴。1)数据转换由于50层的结构太深了，所以我们需要将数据转换成lmdb格式，否则训练起来太慢了，这里使用caffe提供的convert_imageset.ex。convert_imageset.exe --shuffle --resize_height=256 --resize_width=256 &root&/ train.txt oxford102_train_lmdb\n--shuffle代表打乱数据顺序，--resize代表将图片resize至指定尺寸，&root&/为图片所在的根目录，然后是文件集和生成的lmdb数据库名，我们将train,test和valid均转换成lmdb文件2)生成配置文件Kaiming大神给我们提供了他们训练出来的模型:也有deploy.prototxt,可以参考deploy用一个script来生成。关于model，值得一提的是，官方的model只有conv1有bias_term,后面的那些卷积层均没有偏置项，所以在生成prototxt时，需要把那些层的bias_term禁用。(这个地方，当时被坑了很久，后来找了很长时间，终于找到了这个bug)3)训练使用了两块K80的GPU来进行训练，一是为了缩短训练时间，二则一块GPU没有那么大的显存。最终只花了16个小时就迭代了5万次，也可以看出LMDB数据库的高效性！再验证集上达到了再验证集上达到了91.37%的Accuracy.再来看一下测试集上的表现:再来看一下测试集上的表现:达到了达到了88.08%的准确率，超过了目前在这一数据集上表现最好的SVM方法(87%)ResNet果然没有让人失望！总结通过Caffe官方提供的fine-tuning和本文中给出的示例，可以看出，对于很多CV任务，我们不需要重新建模并训练，可以在ILSVRC大赛中寻找类似的比较好的结果，然后下载预训练的模型，根据我们的任务来微调模型即可。尤其是当我们的数据相对较少时，就更适合选择这种办法。既可以有效利用深度神经网络强大的泛化能力，又可以免去设计复杂的模型以及耗时良久的训练。目前最强大的模型是ResNet，很多视觉任务都可以通过fine-tuning ResNet得到非常好的performance!这里推广一个好用的工具：,是身边一个非常厉害的小伙伴做的，基于260万张花的鉴定照片，得到的可以一键识别400种花卉的工具，国庆出行游玩必备！不过目前只支持ios","updated":"T10:02:04.000Z","canComment":false,"commentPermission":"anyone","commentCount":50,"collapsedCount":0,"likeCount":82,"state":"published","isLiked":false,"slug":"","lastestTipjarors":[{"isFollowed":false,"name":"两片","headline":"","avatarUrl":"/v2-ebcc4e5c1a448_s.jpg","isFollowing":false,"type":"people","slug":"twopie","profileUrl":"/people/twopie","bio":"","hash":"0bb7dc50f4d350a945ce09fe96d02716","uid":08,"isOrg":false,"description":"","isOrgWhiteList":false,"avatar":{"id":"v2-ebcc4e5c1a448","template":"/{id}_{size}.jpg"}}],"isTitleImageFullScreen":false,"rating":"none","titleImage":"/v2-fecfdeeef43fcdee31ab2_r.jpg","links":{"comments":"/api/posts//comments"},"reviewers":[],"topics":[{"url":"/topic/","id":"","name":"深度学习（Deep Learning）"},{"url":"/topic/","id":"","name":"机器学习"},{"url":"/topic/","id":"","name":"Caffe（深度学习框架）"}],"adminClosedComment":false,"titleImageSize":{"width":1024,"height":768},"href":"/api/posts/","excerptTitle":"","column":{"slug":"startdl","name":"深度学习:从入门到放弃"},"tipjarState":"activated","tipjarTagLine":"真诚赞赏，手留余香","sourceUrl":"","pageCommentsCount":50,"tipjarorCount":1,"snapshotUrl":"","publishedTime":"T18:02:04+08:00","url":"/p/","lastestLikers":[{"profileUrl":"/people/sun-bin-bin-89","bio":"","hash":"828949dcdafa0f7fe864c","uid":32,"isOrg":false,"description":"","isOrgWhiteList":false,"slug":"sun-bin-bin-89","avatar":{"id":"cb58cbf76","template":"/{id}_{size}.jpg"},"name":"孙彬彬"},{"profileUrl":"/people/xiaice","bio":"","hash":"d3d09e6d297bf60c86d9b3","uid":80,"isOrg":false,"description":"","isOrgWhiteList":false,"slug":"xiaice","avatar":{"id":"da8e974dc","template":"/{id}_{size}.jpg"},"name":"韩夏"},{"profileUrl":"/people/he-he-27-83-11","bio":"","hash":"e04dc00f00061adec783f331eb41fbb8","uid":819800,"isOrg":false,"description":"","isOrgWhiteList":false,"slug":"he-he-27-83-11","avatar":{"id":"da8e974dc","template":"/{id}_{size}.jpg"},"name":"呵呵"},{"profileUrl":"/people/liu-qiao-yuan-41","bio":"为自己负责的女博士","hash":"cdebc7c5d596b8fe6bd0bec","uid":838100,"isOrg":false,"description":"努力顺其自然","isOrgWhiteList":false,"slug":"liu-qiao-yuan-41","avatar":{"id":"v2-0a36dbfbc811d51a0dcd77cd","template":"/{id}_{size}.jpg"},"name":"candy666"},{"profileUrl":"/people/muzi618","bio":"勿忘初心 方得始终","hash":"e5f037d0e608cfea736ef8c","uid":36,"isOrg":false,"description":"热爱生活的磕盐狗","isOrgWhiteList":false,"slug":"muzi618","avatar":{"id":"76f4b47a109e94bacf85e","template":"/{id}_{size}.jpg"},"name":"李军"}],"summary":"谢@提醒，尝试了将前面层的lr调成0，只训练全连接层，结果放在了每个微调网络的最后；另外添加了50层的ResNet进行fine-tuning，结果得到了进一步的提高，超越了SVM在这一数据集上的最佳performance(87%) ------------------------------------------…","reviewingCommentsCount":0,"meta":{"previous":{"isTitleImageFullScreen":false,"rating":"none","titleImage":"/4a8f787975bae0b14cf7a_r.png","links":{"comments":"/api/posts//comments"},"topics":[{"url":"/topic/","id":"","name":"深度学习（Deep Learning）"},{"url":"/topic/","id":"","name":"卷积神经网络（CNN）"},{"url":"/topic/","id":"","name":"机器学习"}],"adminClosedComment":false,"href":"/api/posts/","excerptTitle":"","author":{"profileUrl":"/people/fishjunyu","bio":"入门CV,初学deep learning","hash":"1e83d7f42dffb8ba714c0e08307b47db","uid":651600,"isOrg":false,"description":"程序猿,入门CV,初学DL","isOrgWhiteList":false,"slug":"fishjunyu","avatar":{"id":"504fcc4057efb1e1c4b08d4cde2c96a5","template":"/{id}_{size}.jpg"},"name":"余俊"},"column":{"slug":"startdl","name":"深度学习:从入门到放弃"},"content":"通过上次在Cifar10上复现ResNet的结果，我们得到了上表，最后一栏是论文中的结果，可以看到已经最好的初始化方法(MSRA)已经和论文中的结果非常接近了！今天我们完全按照论文中的实验环境，复现一下ResNet论文中的结果。上次的论文复现主要和原文中有两点不同：1.Data AugmentationCifar10中的图像都是32X32的，论文中对测试集中的每张图在每边都扩展了4个像素，得到40X40的图像，在训练时随机crop出32X32的图像进行训练，而对测试集不做任何操作import lmdb\nimport cv2\nimport caffe\nfrom caffe.proto import caffe_pb2\n\nenv1=lmdb.open('cifar10_train_lmdb')\ntxn1=env1.begin()\ncursor=txn1.cursor()\ndatum=caffe_pb2.Datum()\n\nenv2=lmdb.open('cifar10_pad4_train_lmdb',map_size=50000*1000*10)\ntxn2=env2.begin(write=True)\n\ncount=0\nfor key,value in cursor:\n
datum.ParseFromString(value)\n
label=datum.label\n\n
data=caffe.io.datum_to_array(datum)\n
img=data.transpose(1,2,0)\n
pad=cv2.copyMakeBorder(img,4,4,4,4,cv2.BORDER_REFLECT)\n\n
array=pad.transpose(2,0,1)\n
datum1=caffe.io.array_to_datum(array,label)\n\n
str_id='{:08}'.format(count)\n
txn2.put(str_id,datum1.SerializeToString())\n\n
count+=1\n
if count%1000 ==0:\n
print('already handled with {} pictures'.format(count))\n
txn2.commit()\n
txn2=env2.begin(write=True)\n\ntxn2.commit()\nenv2.close()\nenv1.close()\n程序很容易理解，最关键的是这句:pad=cv2.copyMakeBorder(img,4,4,4,4,cv2.BORDER_REFLECT)\n使用cv2的makeBorder函数扩展4个像素，运行后本地就会得到cifar10_pad4_train_lmdb了，注意，均值文件也需要重新生成，用于训练集数据2.Different Shortcut Structure这是将网络结构借助ethereon绘制出来的部分截图，上面的红字代表这一层的卷积过滤器的数量，可以看到在filter数量加倍之后，shortcut结构没法直接相加了，所以原文中采用了PadChannel的结构，将多余的Channel全部补零，主要结构就是上图所示，先用一个average pooling层将feature map的size减半，再使用PadChannel增加16层的零filter层，我们将这种方法称为zero-padding法（亦即论文中的option A),这种方法的优点是接近于恒等层，不会引入新的参数。但是caffe目前不支持这种zero-padding的方法,所以我们需要向caffe中添加PadChannel层:看一下官方关于添加新层的说明，主要是以下四个文件:1.pad_channel_layer.hpp添加到include/caffe/layers:#ifndef CAFFE_PAD_CHANNEL_LAYER_HPP_\n#define CAFFE_PAD_CHANNEL_LAYER_HPP_\n\n#include \"caffe/blob.hpp\"\n#include \"caffe/layer.hpp\"\n#include \"caffe/proto/caffe.pb.h\"\n\nnamespace caffe {\n\n\t/*\n\t* @brief zero-padding channel to extend number of channels\n\t*\n\t* Note: Back-propagate just drop the pad derivatives\n\t*/\n\ttemplate &typename Dtype&\n\tclass PadChannelLayer : public Layer&Dtype& {\n\tpublic:\n\t\texplicit PadChannelLayer(const LayerParameter& param)\n\t\t\t: Layer&Dtype&(param) {}\n\t\tvirtual void LayerSetUp(const vector&Blob&Dtype&*&& bottom,\n\t\t\tconst vector&Blob&Dtype&*&& top);\n\t\tvirtual void Reshape(const vector&Blob&Dtype&*&& bottom,\n\t\t\tconst vector&Blob&Dtype&*&& top);\n\n\t\tvirtual inline const char* type() const { return \"PadChannel\"; }\n\t\tvirtual inline int ExactNumBottomBlobs() const { return 1; }\n\t\tvirtual inline int ExactNumTopBlobs() const { return 1; }\n\n\tprotected:\n\t\tvirtual void Forward_cpu(const vector&Blob&Dtype&*&& bottom,\n\t\t\tconst vector&Blob&Dtype&*&& top);\n\t\tvirtual void Backward_cpu(const vector&Blob&Dtype&*&& top,\n\t\t\tconst vector&bool&& propagate_down, const vector&Blob&Dtype&*&& bottom);\n\t\tvirtual void Forward_gpu(const vector&Blob&Dtype&*&& bottom,\n\t\t\tconst vector&Blob&Dtype&*&& top);\n\t\tvirtual void Backward_gpu(const vector&Blob&Dtype&*&& top,\n\t\t\tconst vector&bool&& propagate_down, const vector&Blob&Dtype&*&& bottom);\n\t\tint num_channels_to_pad_;\n\t};\n\n}
// namespace caffe\n\n#endif
// CAFFE_PAD_CHANNEL_LAYER_HPP_\n2.pad_channel_layer.cpp添加到src/caffe/layers#include \"caffe/layers/pad_channel_layer.hpp\"\n\nnamespace caffe {\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::LayerSetUp(const vector&Blob&Dtype&*&& bottom,\n\t\tconst vector&Blob&Dtype&*&& top) {\n\t\tCHECK_NE(top[0], bottom[0]) && this-&type() && \" Layer does not \"\n\t\t\t\"allow in-place computation.\";\n\t\tnum_channels_to_pad_ = this-&layer_param_.pad_channel_param().num_channels_to_pad();\n\t\tCHECK_GT(num_channels_to_pad_, 0) && \"num channels to pad must greater than 0!\";\n\t}\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::Reshape(const vector&Blob&Dtype&*&& bottom,\n\t\tconst vector&Blob&Dtype&*&& top) {\n\n\t\tvector&int& top_shape = bottom[0]-&shape();\n\t\ttop_shape[1] += num_channels_to_pad_;\n\t\ttop[0]-&Reshape(top_shape);\n\t}\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::Forward_cpu(const vector&Blob&Dtype&*&& bottom,\n\t\tconst vector&Blob&Dtype&*&& top) {\n\t\tconst Dtype* bottom_data = bottom[0]-&cpu_data();\n\t\tDtype* top_data = top[0]-&mutable_cpu_data();\n\t\tint num = bottom[0]-&num();\n\t\tint channels = bottom[0]-&channels();\n\t\tint dim = bottom[0]-&height() * bottom[0]-&width();\n\t\tint channel_by_dim = channels * dim;\n\t\tfor (int n = 0; n & num; n++){\n\t\t\tcaffe_copy(channel_by_dim, bottom_data, top_data);\n\t\t\tbottom_data += channel_by_dim;\n\t\t\ttop_data += channel_by_dim;\n\t\t\tcaffe_set(num_channels_to_pad_ * dim, Dtype(0), top_data);\n\t\t\ttop_data += num_channels_to_pad_ * dim;\n\t\t}\n\t}\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::Backward_cpu(const vector&Blob&Dtype&*&& bottom,\n\t\tconst vector&bool&& propagate_down, const vector&Blob&Dtype&*&& top) {\n\t\tconst Dtype* top_diff = top[0]-&cpu_diff();\n\t\tDtype* bottom_diff = bottom[0]-&mutable_cpu_diff();\n\t\tint num = bottom[0]-&num();\n\t\tint channels = bottom[0]-&channels();\n\t\tint dim = bottom[0]-&height() * bottom[0]-&width();\n\t\tint channel_by_dim = channels * dim;\n\t\tfor (int n = 0; n & num; n++){ // just drop the padding derivatives part.\n\t\t\tcaffe_copy(channel_by_dim, top_diff, bottom_diff);\n\t\t\ttop_diff += (channels + num_channels_to_pad_) * dim;\n\t\t\tbottom_diff += channel_by_dim;\n\t\t}\n\t}\n\tINSTANTIATE_CLASS(PadChannelLayer);\n\tREGISTER_LAYER_CLASS(PadChannel);\n\n}
// namespace caffe\n3.pad_channel_layer.cu添加到src/caffe/layers:#include \"caffe/layers/pad_channel_layer.hpp\"\n\nnamespace caffe {\n\n\t// Copy (one line per thread) from one array to another, with arbitrary\n\t// strides in the last two dimensions.\n\ttemplate &typename Dtype&\n\t__global__ void pad_forward_kernel(const int dst_count, const int src_channels, const int dst_channels,\n\t\tconst int dim, const Dtype* src, Dtype* dst){\n\t\tCUDA_KERNEL_LOOP(index, dst_count)\n\t\t{\n\t\t\tint num = index / (dim * dst_channels);\n\t\t\tint dst_c = index / dim % dst_channels;\n\t\t\tint pixel_pos = index % dim;\n\t\t\tif (dst_c & src_channels)\n\t\t\t\tdst[index] = src[num * src_channels * dim + dst_c * dim + pixel_pos];\n\t\t\telse\n\t\t\t\tdst[index] = Dtype(0);\n\t\t}\n\t}\n\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::Forward_gpu(const vector&Blob&Dtype&*&& bottom,\n\t\tconst vector&Blob&Dtype&*&& top){\n\t\tconst Dtype* bottom_data = bottom[0]-&gpu_data();\n\t\tDtype* top_data = top[0]-&mutable_gpu_data();\n\n\t\tint src_channels = bottom[0]-&channels();\n\t\tint dim = bottom[0]-&height() * bottom[0]-&width();\n\t\tint dst_channels = src_channels + num_channels_to_pad_;\n\t\tconst int dst_count = top[0]-&count();\n\t\tpad_forward_kernel&Dtype& && &CAFFE_GET_BLOCKS(dst_count), CAFFE_CUDA_NUM_THREADS && &(\n\t\t\tdst_count, src_channels, dst_channels, dim, bottom_data, top_data);\n\t\tCUDA_POST_KERNEL_CHECK;\n\t}\n\n\ttemplate &typename Dtype&\n\t__global__ void pad_backward_kernel(const int bottom_count, const int bottom_channels, const int top_channels,\n\t\tconst int dim, const Dtype* top, Dtype* bottom)\n\t{\n\t\tCUDA_KERNEL_LOOP(index, bottom_count)\n\t\t{\n\t\t\tint num = index / (dim * bottom_channels);\n\t\t\tint bottom_c = index / dim % bottom_channels;\n\t\t\tint pixel_pos = index % dim;\n\t\t\tbottom[index] = top[num * top_channels * dim + bottom_c * dim + pixel_pos];\n\t\t}\n\t}\n\n\ttemplate &typename Dtype&\n\tvoid PadChannelLayer&Dtype&::Backward_gpu(const vector&Blob&Dtype&*&& top,\n\t\tconst vector&bool&& propagate_down, const vector&Blob&Dtype&*&& bottom) {\n\t\tconst Dtype* top_diff = top[0]-&gpu_diff();\n\t\tDtype* bottom_diff = bottom[0]-&mutable_gpu_diff();\n\t\tint bottom_count = bottom[0]-&count();\n\t\tint bottom_channels = bottom[0]-&channels();\n\t\tint dim = bottom[0]-&height() * bottom[0]-&width();\n\t\tint top_channels = bottom_channels + num_channels_to_pad_;\n\t\tpad_backward_kernel&Dtype& && &CAFFE_GET_BLOCKS(bottom_count), CAFFE_CUDA_NUM_THREADS && &(\n\t\t\tbottom_count, bottom_channels, top_channels, dim, top_diff, bottom_diff);\n\t\tCUDA_POST_KERNEL_CHECK;\n\t}\n\n\tINSTANTIATE_LAYER_GPU_FUNCS(PadChannelLayer);\n\n}
// namespace caffe\n4.向caffe.proto中添加对应的message：好的，重新编译一次caffe之后，我们就可以使用PadChannel层了！下面我们看一下另外一种shortcut结构:论文中将这种结构称为projection（亦即option B),使用1x1的卷积核来增加维度，这种方法会引入额外的参数！3.复现实验好的，现在一切准备就绪，我们开始完整复现ResNet在Cifar10上的实验结果：以下是一些参数设置:weight_decay=0.0001 momentum=0.9 batch_size=128learning_rate=0.1，0.01/32k，0.001/48k max_iter=64k当层数达到110层时，为加快收敛，我们先将learning_rate设置为0.01，迭代400次之后，再将learning_rate设置回0.1，正常进行训练A代表zero-padding,B代表projection,可以看出，Option A得到的结果和论文中基本一致，因为论文中采用的就是这种方法，而Option B却是所有结果中最好的，可以看出projection的方法是要优于zero_padding的方法的！接下来放几张训练的结果图:首先是zero_padding:接下来是projection:（这里暂时先忽略164的结果)4.总结至此，ResNet在cifar10的复现实验已经全部完成，我们完美复现了论文中的结果，甚至还得到了比论文中更好的结果！","state":"published","sourceUrl":"","pageCommentsCount":0,"canComment":false,"snapshotUrl":"","slug":,"publishedTime":"T19:18:36+08:00","url":"/p/","title":"Deep Residual Networks学习(二)","summary":"通过上次在Cifar10上复现ResNet的结果，我们得到了上表，最后一栏是论文中的结果，可以看到已经最好的初始化方法(MSRA)已经和论文中的结果非常接近了！今天我们完全按照论文中的实验环境，复现一下ResNet论文中的结果。上次的论文复现主要和原文中有两点不…","reviewingCommentsCount":0,"meta":{"previous":null,"next":null},"commentPermission":"anyone","commentsCount":0,"likesCount":0},"next":{"isTitleImageFullScreen":false,"rating":"none","titleImage":"/v2-3c934c7dc8_r.png","links":{"comments":"/api/posts//comments"},"topics":[{"url":"/topic/","id":"","name":"深度学习（Deep Learning）"},{"url":"/topic/","id":"","name":"物体识别"},{"url":"/topic/","id":"","name":"Caffe（深度学习框架）"}],"adminClosedComment":false,"href":"/api/posts/","excerptTitle":"","author":{"profileUrl":"/people/fishjunyu","bio":"入门CV,初学deep learning","hash":"1e83d7f42dffb8ba714c0e08307b47db","uid":651600,"isOrg":false,"description":"程序猿,入门CV,初学DL","isOrgWhiteList":false,"slug":"fishjunyu","avatar":{"id":"504fcc4057efb1e1c4b08d4cde2c96a5","template":"/{id}_{size}.jpg"},"name":"余俊"},"column":{"slug":"startdl","name":"深度学习:从入门到放弃"},"content":"这篇承接上一篇，FRCN是rbgirshick在R-CNN基础上提出的改进，提出了一些创新式的做法，不仅提升了训练和测试时的速度，而且提升了精度。SPPnet是Kaiming He提出的一种结构，论文链接在这：可以看出，FRCN不仅在精度上得到了提升，更重要的是，它在测试时比RCNN快了213倍，这让实时处理成为可能(当然faster RCNN基本已经达到了实时的要求)。接下来我们首先分析一下这篇论文：写在解读之前:通篇阅读下来，实在敬服rbgirshick大神。有理有据，对比实验，实现，思路都十分清晰。尤其是第五部分，对那几个问题的探讨和对比实验，更是让人茅塞顿开。RBG大神的学术态度真是高山仰止！一.论文解读1.Introductiondetection有两方面的挑战。第一，大量的候选区域需要被处理;第二，候选区域只能提供大致的定位，所以必须被细调来达到精确的定位。这两个挑战让众多解决方案只能牺牲速度和精度。RCNN是一个多级的过程，首先提取约2k个候选区域，然后使用log loss微调一个卷积网络，最后，训练SVMs作为检测器。RCNN在测试时很慢（在GPU上大约47s/image），因为每一个候选区域都需要在卷积网络中做一遍前向传播,没有共享计算。SPPnet改进了这一点，它将整张图片作为输入得到一张特征图，然后再用特征图中提取到的特征向量分类每一个候选区域，但SPPnet同样是一个多级过程。rbgirshick认为FRCN有以下几个贡献:1.更高的检测质量(mAP)相比于RCNN和SPPnet2.使用一个多任务的loss,训练时单级的3.训练可以更新所有网络层4.不需要为特征缓存提供磁盘存储2.Architecture和training这张图就是FRCN的架构图。一个FRCN网络使用整张图片和候选区域集做为输入，网络首先处理整张图片得到一个卷积特征图，然后，为每个候选区域的ROI(region of interest)池化层从特征图中提取一个固定长度的特征向量，每个特征向量被送入全连接层，最终分成两个兄弟输出层：一个产生softmax概率评估K个物体类别外加一个\"背景\"类，另一个为每一个物体类输出4个实数值，每个4个值的集合都是K个类别的位置细调的结果。2.1 ROI pooling layerROI池化层是SPP(spatial pyramid pooling)层的特殊情况，这里等看完SPPnet那篇文章再来详细解释2.2 Initializing from pre-trained networks一个预训练的网络初始化一个FRCN网络，需要三个转换：1.最后一层最大池化层被一个ROI层替代来和网络的第一个全连接层相容2.最后一个全连接层和softmax层被前文所述的兄弟层替代3.网络需要被修改成采用两个输入：一个图像列表和这些图像中的ROIs列表2.3 Fine-tuning for detection使用反向传播方法来训练所有网络层的参数是FRCN的一个重要能力。首先，文中阐释了为什么SPPnet不能更新SPP层以下的层的参数的原因。根本原因是因为RCNN和SPPnet训练时的样本来自不同的图像，导致SPP层的反向传播非常低效。这种低效性来源于每个ROI基本都有一个非常大的感受野，经常就是整张图片。文中提出了一个有效的方法。在FRCN训练过程中，SGD mini-batches是分层抽样的，首先采样N张图片，然后采用对每一张图片采样R/N个ROIs。关键是在前向和反向计算时，来自同一张图片的ROIs共享计算和内存，这大大减少了一个mini-batch的计算。例如，当N=2,R=128时，这种方法比从128个不同的图像中提取一个ROI的方法要快64倍。这种策略的一个缺点在于其可能会减慢训练的收敛因为来自同一张图片的ROIs是相关的。但是在实践中这种担忧并没有出现，当N=2,R=128时，比RCNN使用更少的SGD迭代得到了更好的结果。Multi-task loss FRCN网络有两个子输出。第一个输出一个离散的概率分布(每一个ROI),p=,对应于K+1个类别。第二个输出边界框的回归偏移，这是文中用于多分类任务的损失函数,u是具体的物体类别，而v则代表边界框的回归目标。Mini-batch sampling 每个mini-batch来自于N=2张图片，mini-batch size取R=128，也就是从每张图片中取64个ROIs。25%的ROIs来自候选区域中和标注边界框有至少0.5(IoU)重叠，这些ROIs包含标记有前景对象类的示例，也就是u1的那些具体物体，剩下75%的ROIs取自最大IoU在[0.1,0.5)之间的候选区域,代表u=0的背景样例。训练时，图片以0.5的概率采用水平翻转，不采用其他的数据增强技术。Back-propagation through RoI pooling layers
这一部分是推导ROI层的前向和反向传播函数SGD hyper-parameters 分类和回归的全连接层分别被初始化为0均值的高斯分布，标准差分别是0.01和0.001.偏置项被初始化为0.所有层的learning rate初始化为0.001，30k次迭代后，lr降至0.0001，再训练10k次。但训练大数据集时，迭代更多次。momentum初始化为0.9，weight_decay初始化为0.00052.4 Scale invariance文中探索了两种实现尺度不变性的物体检测的方法：一种通过蛮力学习，另一种是用图像金字塔。3.Fast R-CNN detection一旦FRCN网络微调完成，检测任务只需要前向传播这一个简单的步骤就可以完成（假设候选区域已经被提前计算好了）。网络用一张图片（或一个图像金字塔）和用于评分的R个候选区域列表作为输入。3.1 Truncated SVD for faster detection对于整张图片分类，花在全连接层的时间要远小于卷积层。而对于检测任务，当ROIs的数量较大时，大约一半的时间都用于计算全连接层。这时，我们可以对全连接层采用SVD(奇异值分解)的方法，减少其参数，从而加速运算速度。4.Main Results接下来就是实验结果了，主要有三个贡献：1.在VOC07,上均得到了state-of-the-art mAP结果2.相比于RCNN和SPPnet更快的训练和测试过程3.在VGG16上微调卷积层提高了mAP但作者认为对于很深的网络（如VGG16），不是所有的卷积层都需要微调。因为conv1通常是一般性的，和任务无关的特征（通过可视化可以知道是颜色及边缘信息），所以微调conv1与否对最后的mAP影响不大，但会浪费许多时间。作者发现，微调conv3_1之后的层能得到最大的收益。5.Design evalution5.1 多任务训练是否有帮助？通过对比实验证明确实对提高performance有帮助5.2 尺度不变性:蛮力还是灵巧？对比实验表明，蛮力方法(single scale)更好，multi-scale只能带来少量的mAP提升，却造成了大量计算时间的增加。这也同时验证了SPPnet中的结果:深度卷积网络善于直接学习尺度不变性5.3 是否需要更多训练数据？显然是的。通过将合并VOC07和VOC12，得到了明显的mAP提升（66.9%提升到70.0%),同样的结果在VOC10和VOC12上也观察到了5.4 SVMs是否比softmax更优秀？事实说明并非如此5.5 更多候选区域是否总是更好？实验结果说明并非如此。这一点不通过实验恐怕很难解释，但似乎稀疏的候选区域结果会更好二.实践论文终于解读完了~^_^下面我们利用开源代码实践一下!RBG大神的代码开源在这里：主要是python代码和c++版本的caffe。对代码结构了解之后，我们可以复现论文中的结果，稍微修改之后，我们也可以在自己的数据集上训练模型。在windows下配置过程：1.首先编译caffe.这里我们需要添加roi_pooling_layer和smooth_L1_loss_layer,我们使用happynear的caffe版本中的这两个层参数，首先git clone /happynear/caffe-windows.git\n下载这个项目，我们遵循官方添加新层的过程：1）首先修改src/caffe/proto/caffe.proto文件，添加roi_pooling_layer参数层2）将happynear版本下的roi_pooling_layer.cpp(cu)和smooth_L1_loss_layer.cpp(cu)四个文件拷贝到我们的caffe-windows中src/caffe/layers/下，并将include/caffe/下的custom_layers.hpp对应copy过来3）在VS2013的libcaffe对应文件夹下添加这几个文件，然后编译即可，请预先编译pycaffe，因为马上就会用到2.然后使用git clone --recursive /rbgirshick/fast-rcnn.git\n将fast-rcnn项目克隆到本地3.为测试demo和我们自己的数据，我们需要下载已经预训练好的fast-rcnn模型,可以直接使用&frcn-root&/data/scripts/fetch_fast_rcnn_models.sh，但需要在windows下配置wget,而且下载速度比较慢，所有我直接从happynear分享出的云盘上下载的:，下载完成后，将fast_rcnn_models文件夹拷贝到&frcn-root&/data文件夹下即可4.我使用的是Anaconda2,cython已经默认装好了,只需要安装easydict即可pip install easydict\n5.将前面第一步编译好的caffe python接口下的内容复制到&frcn-root&/caffe-fast-rcnn/python文件夹下，覆盖原有的内容6.用文本编辑器打开&frcn-root&/lib/utils/nms.pyx，将第25行的np.int_t修改为np.intp_t7.用文本编辑器打开&frcn-root&/lib/setup.py，将第18行和23行的 \"-Wno-cpp\", \"-Wno-unused-function\"指令删除，只留下空的中括号[]即可8.打开cmd,首先定位至&frcn-root&/lib目录下，然后输入python setup.py install\n如果提示Unable to find vcvarsall.bat的话，请输入以下指令： SET VS90COMNTOOLS=%VS120COMNTOOLS% \nsetup.py安装完成后，到python_root/Lib/site-packages/utils中可以找到两个文件cython_bbox.pyd和cython_nms.pyd，把这两个文件复制到&frcn-root&/lib/utils中9.好了，接下来我们测试demo吧,在&frcn-root&下：python tools/demo.py\n首先看一下demo的结果图：运行结果可以看出，第一张图片用时0.966s,第二张图片用时0.408s,如果使用SVD压缩的话，处理每张图片大约只需要0.3s，基本上已经达到了实时的要求！注：demo的配置部分已经补齐，后面会添加ROI层的解释！三.后续faster-rcnn通过添加RPN(Region Proposal Network)来替代传统的提取候选区域方法，并通过Anchor来解决尺度不变性问题！使得基于proposal的目标检测方法几乎已经发展到最好！","state":"published","sourceUrl":"","pageCommentsCount":0,"canComment":false,"snapshotUrl":"","slug":,"publishedTime":"T22:06:55+08:00","url":"/p/","title":"Object Detection(2):Fast R-CNN","summary":"这篇承接上一篇，FRCN是rbgirshick在R-CNN基础上提出的改进，提出了一些创新式的做法，不仅提升了训练和测试时的速度，而且提升了精度。SPPnet是Kaiming He提出的一种结构，论文链接在这：可以看出，FRCN…","reviewingCommentsCount":0,"meta":{"previous":null,"next":null},"commentPermission":"anyone","commentsCount":0,"likesCount":0}},"commentsCount":50,"likesCount":82,"FULLINFO":true}},"User":{"fishjunyu":{"isFollowed":false,"name":"余俊","headline":"程序猿,入门CV,初学DL","avatarUrl":"/504fcc4057efb1e1c4b08d4cde2c96a5_s.jpg","isFollowing":false,"type":"people","slug":"fishjunyu","bio":"入门CV,初学deep learning","hash":"1e83d7f42dffb8ba714c0e08307b47db","uid":651600,"isOrg":false,"description":"程序猿,入门CV,初学DL","profileUrl":"/people/fishjunyu","avatar":{"id":"504fcc4057efb1e1c4b08d4cde2c96a5","template":"/{id}_{size}.jpg"},"isOrgWhiteList":false,"badge":{"identity":null,"bestAnswerer":null}}},"Comment":{},"favlists":{}},"me":{},"global":{},"columns":{"startdl":{"following":false,"canManage":false,"href":"/api/columns/startdl","name":"深度学习:从入门到放弃","creator":{"slug":"fishjunyu"},"url":"/startdl","slug":"startdl","avatar":{"id":"v2-0f430b44c7cc55c0b783bcc","template":"/{id}_{size}.jpg"}}},"columnPosts":{},"postComments":{},"postReviewComments":{"comments":[],"newComments":[],"hasMore":true},"favlistsByUser":{},"favlistRelations":{},"promotions":{},"env":{"isAppView":false,"appViewConfig":{"content_padding_top":128,"content_padding_bottom":56,"content_padding_left":16,"content_padding_right":16,"title_font_size":22,"body_font_size":16,"is_dark_theme":false,"can_auto_load_image":true,"app_info":"OS=iOS"},"isApp":false},"sys":{}}}