caffe训练网络的时候学习率应该怎么设置

1、会更新，finetune的过程相当于继续训练，跟直接训练的区别是初始化的时候：
a 直接训练是按照网络定义指定的方式初始化（如高斯随机初始化）
b finetune是用你已经有的参数文件来初始化（就是之前训练好的caffemodel）
2、嗯，这个问题有两种情况：比如有4个全连接层A->B->C->D
a 你希望C层的参数不会改变，C前面的AB层的参数也不会改变，这种情况也就是D层的梯度不往前反向传播到D层的输入blob（也就是C层的输出blob 没有得到梯度），你可以通过设置D层的propagate_down为false来做到。
propagate_down的数量与输入blob的数量相同，假如你某个层有2个输入blob，那么你应该在该layer的Param里面写上两行：
propagate_down : 0 # 第1个输入blob不会得到反向传播的梯度
propagate_down : 0 # 第2个输入blob不会得到反向传播的梯度
这样的话，你这个layer的梯度就不会反向传播啦，前面的所有layer的参数也就不会改变了
b 你希望C层的参数不会改变，但是C前面的AB层的参数会改变，这种情况，只是固定了C层的参数，C层得到的梯度依然会反向传播给前面的B层。只需要将对应的参数blob的学习率调整为0：
你在layer里面加上param { lr_mult: 0 }就可以了，比如全连接层里面：
layer {
type: "InnerProduct"
param { # 对应第1个参数blob的配置，也就是全连接层的参数矩阵的配置
lr_mult: 0 # 学习率为0，其他参数可以看caffeproto里面的ParamSpec这个类型
}
param { # 对应第2个参数blob的配置，也就是全连接层的偏置项的配置
lr_mult: 0 # 学习率为0
}
}
不知道这样说你能不能理解

集线器（HUB）是一种共享介质的网络设备，它的作用可以简单的理解为将一些机器连接起来组成一个局域网，HUB 本身不能识别目的地址。集线器上的所有端口争用一个共享信道的宽带，因此随着网络节点数量的增加，数据传输量的增大，每节点的可用带宽将随之减少。另外，集线器采用广播的形式传输数据，即向所有端口传送数据。如当同一局域网内的A 主机给B 主机传输数据时，数据包在以HUB 为架构的网络上是以广播方式传输的，对网络上所有节点同时发送同一信息，然后再由每一台终端通过验证数据包头的地址信息来确定是否接收。其实接收数据的一般来说只有一个终

Caffe是目前深度学习比较优秀好用的一个开源库，采样c++和CUDA实现，具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。Caffe的数据层可以从数据库（支持leveldb、lmdb、hdf5）、、和内存中读入。我们要在程序中使用，当然得从内存中读入，我们首先在模型定义文件中定义数据层：
layers {
name: "mydata"
type: MEMORY_DATA
top: "data"
top: "label"
transform_param {
scale: 000390625
}
memory_data_param {
batch_size: 10
channels: 1
height: 24
width: 24
}
}
这里必须设置memory_data_param中的四个参数，对应这些参数可以参见源码中caffeproto文件。现在，我们可以设计一个Classifier类来封装一下：
#ifndef CAFFE_CLASSIFIER_H
#define CAFFE_CLASSIFIER_H
#include <string>
#include <vector>
#include "caffe/nethpp"
#include "caffe/data_layershpp"
#include <opencv2/corehpp>
using cv::Mat;
namespace caffe {
template <typename Dtype>
class Classifier {
public:
explicit Classifier(const string& param_file, const string& weights_file);
Dtype test(vector<Mat> &images, vector<int> &labels, int iter_num);
virtual ~Classifier() {}
inline shared_ptr<Net<Dtype> > net() { return net_; }
void predict(vector<Mat> &images, vector<int> labels);
void predict(vector<Dtype> &data, vector<int> labels, int num);
void extract_feature(vector<Mat> &images, vector<vector<Dtype>> out);
protected:
shared_ptr<Net<Dtype> > net_;
MemoryDataLayer<Dtype> m_layer_;
int batch_size_;
int channels_;
int height_;
int width_;

DISABLE_COPY_AND_ASSIGN(Classifier);
};
}//namespace
#endif //CAFFE_CLASSIFIER_H
构造函数中我们通过模型定义文件（prototxt）和训练好的模型（caffemodel）文件构造一个Net对象，并用m_layer_指向Net中的memory data层，以便待会调用MemoryDataLayer中AddMatVector和Reset函数加入数据。
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include "caffe/nethpp"
#include "caffe/proto/caffepbh"
#include "caffe/util/iohpp"
#include "caffe/util/math_functionshpp"
#include "caffe/util/upgrade_protohpp"
#include "caffe_classifierh"
namespace caffe {
template <typename Dtype>
Classifier<Dtype>::Classifier(const string& param_file, const string& weights_file) : net_()
{
net_reset(new Net<Dtype>(param_file, TEST));
net_->CopyTrainedLayersFrom(weights_file);
//m_layer_ = (MemoryDataLayer<Dtype>)net_->layer_by_name("mnist")get();
m_layer_ = (MemoryDataLayer<Dtype>)net_->layers()[0]get();
batch_size_ = m_layer_->batch_size();
channels_ = m_layer_->channels();
height_ = m_layer_->height();
width_ = m_layer_->width();
}
template <typename Dtype>
Dtype Classifier<Dtype>::test(vector<Mat> &images, vector<int> &labels, int iter_num)
{
m_layer_->AddMatVector(images, labels);
//
int iterations = iter_num;
vector<Blob<Dtype> > bottom_vec;
vector<int> test_score_output_id;
vector<Dtype> test_score;
Dtype loss = 0;
for (int i = 0; i < iterations; ++i) {
Dtype iter_loss;
const vector<Blob<Dtype>>& result =
net_->Forward(bottom_vec, &iter_loss);
loss += iter_loss;
int idx = 0;
for (int j = 0; j < resultsize(); ++j) {
const Dtype result_vec = result[j]->cpu_data();
for (int k = 0; k < result[j]->count(); ++k, ++idx) {
const Dtype score = result_vec[k];
if (i == 0) {
test_scorepush_back(score);
test_score_output_idpush_back(j);
} else {
test_score[idx] += score;
}
const std::string& output_name = net_->blob_names()[
net_->output_blob_indices()[j]];
LOG(INFO) << "Batch " << i << ", " << output_name << " = " << score;
}
}
}
loss /= iterations;
LOG(INFO) << "Loss: " << loss;
return loss;
}
template <typename Dtype>
void Classifier<Dtype>::predict(vector<Mat> &images, vector<int> labels)
{
int original_length = imagessize();
if(original_length == 0)
return;
int valid_length = original_length / batch_size_ batch_size_;
if(original_length != valid_length)
{
valid_length += batch_size_;
for(int i = original_length; i < valid_length; i++)
{
imagespush_back(images[0]clone());
}
}
vector<int> valid_labels, predicted_labels;
valid_labelsresize(valid_length, 0);
m_layer_->AddMatVector(images, valid_labels);
vector<Blob<Dtype> > bottom_vec;
for(int i = 0; i < valid_length / batch_size_; i++)
{
const vector<Blob<Dtype>>& result = net_->Forward(bottom_vec);
const Dtype result_vec = result[1]->cpu_data();
for(int j = 0; j < result[1]->count(); j++)
{
predicted_labelspush_back(result_vec[j]);
}
}
if(original_length != valid_length)
{
imageserase(imagesbegin()+original_length, imagesend());
}
labels->resize(original_length, 0);
std::copy(predicted_labelsbegin(), predicted_labelsbegin() + original_length, labels->begin());
}
template <typename Dtype>
void Classifier<Dtype>::predict(vector<Dtype> &data, vector<int> labels, int num)
{
int size = channels_height_width_;
CHECK_EQ(datasize(), numsize);
int original_length = num;
if(original_length == 0)
return;
int valid_length = original_length / batch_size_ batch_size_;
if(original_length != valid_length)
{
valid_length += batch_size_;
for(int i = original_length; i < valid_length; i++)
{
for(int j = 0; j < size; j++)
datapush_back(0);
}
}
vector<int> predicted_labels;
Dtype label_ = new Dtype[valid_length];
memset(label_, 0, valid_length);
m_layer_->Reset(datadata(), label_, valid_length);
vector<Blob<Dtype> > bottom_vec;
for(int i = 0; i < valid_length / batch_size_; i++)
{
const vector<Blob<Dtype>>& result = net_->Forward(bottom_vec);
const Dtype result_vec = result[1]->cpu_data();
for(int j = 0; j < result[1]->count(); j++)
{
predicted_labelspush_back(result_vec[j]);
}
}
if(original_length != valid_length)
{
dataerase(databegin()+original_lengthsize, dataend());
}
delete [] label_;
labels->resize(original_length, 0);
std::copy(predicted_labelsbegin(), predicted_labelsbegin() + original_length, labels->begin());
}
template <typename Dtype>
void Classifier<Dtype>::extract_feature(vector<Mat> &images, vector<vector<Dtype>> out)
{
int original_length = imagessize();
if(original_length == 0)
return;
int valid_length = original_length / batch_size_ batch_size_;
if(original_length != valid_length)
{
valid_length += batch_size_;
for(int i = original_length; i < valid_length; i++)
{
imagespush_back(images[0]clone());
}
}
vector<int> valid_labels;
valid_labelsresize(valid_length, 0);
m_layer_->AddMatVector(images, valid_labels);
vector<Blob<Dtype> > bottom_vec;
out->clear();
for(int i = 0; i < valid_length / batch_size_; i++)
{
const vector<Blob<Dtype>>& result = net_->Forward(bottom_vec);
const Dtype result_vec = result[0]->cpu_data();
const int dim = result[0]->count(1);
for(int j = 0; j < result[0]->num(); j++)
{
const Dtype ptr = result_vec + j dim;
vector<Dtype> one_;
for(int k = 0; k < dim; ++k)
one_push_back(ptr[k]);
out->push_back(one_);
}
}
if(original_length != valid_length)
{
imageserase(imagesbegin()+original_length, imagesend());
out->erase(out->begin()+original_length, out->end());
}
}
INSTANTIATE_CLASS(Classifier);
} // namespace caffe
由于加入的数据个数必须是batch_size的整数倍，所以我们在加入数据时采用填充的方式。
CHECK_EQ(num % batch_size_, 0) <<
"The added data must be a multiple of the batch size"; //AddMatVector
在模型文件的最后，我们把训练时的loss层改为argmax层：
layers {
name: "predicted"
type: ARGMAX
bottom: "prob"
top: "predicted"
}

1首先要准备几样东西：
（1）要预测的图像，需要32×32大小;
（2）网络配置文件，prototxt,以及每个图像的路径及其序号。
（3）训练好的caffemodel以及均值二进制文件，貌似可以定值，需要通过数据训练计算得到。
（3）预测的主程序
内容：
View Code

2结果：
View Code

各个类别图示：
3后记
上面是用CPU跑的，我还等了几秒钟，用了下GPU处理，瞬间，真的很快，Enter完就出结果了。

flatten层用来扁平参数用，一般用在卷积层与全链接层之间，可以从vgg16网络中可以看出，但是在后来的网络中用GlobalAveragePooling2D代替了flatten层，可以从vgg16与inceptionV3网络对比看出。从参数的对比可以看出，显然这种改进大大的减少了参数的使用量，避免了过拟合现象。

from kerasmodels import Sequential

from keraslayerscore import Flatten

from keraslayersconvolutional import Convolution2D

from kerasutilsvis_utils import plot_model

model = Sequential()

modeladd(Convolution2D(64,3,3,border_mode="same",input_shape=(3,32,32)))

# now：modeloutput_shape==(None,64,32,32)

modeladd(Flatten())

# now: modeloutput_shape==(None,65536)

plot_model(model, to_file='Flattenpng', show_shapes=True)

扩展资料

应用

计算机视觉

香港中文大学的多媒体实验室是最早应用深度学习进行计算机视觉研究的华人团队。在世界级人工智能竞赛LFW（大规模人脸识别竞赛）上，该实验室曾力压FaceBook夺得冠军，使得人工智能在该领域的识别能力首次超越真人。

语音识别

微软研究人员通过与hinton合作，首先将RBM和DBN引入到语音识别声学模型训练中，并且在大词汇量语音识别系统中获得巨大成功，使得语音识别的错误率相对减低30%。但是，DNN还没有有效的并行快速算法，很多研究机构都是在利用大规模数据语料通过GPU平台提高DNN声学模型的训练效率。

在国际上，IBM、google等公司都快速进行了DNN语音识别的研究，并且速度飞快。

国内方面，阿里巴巴、科大讯飞、百度、中科院自动化所等公司或研究单位，也在进行深度学习在语音识别上的研究。

参考资料来源：百度百科-深度学习

---