一、前言
本文主要部分转载自 https://buptldy.github.io/2016/10/09/2016-10-09-Caffe_Code/，并加入一些自己的见解
本篇主要重点分析 caffe训练过程相关的主要代码。
二、caffe训练main函数入口
这里以训练lenet模型（入门必备）为例， 训练 lenet 网络模型的基本命令为 ./build/tools/caffe train --solver=/opt/caffe-master/examples/mnist/lenet_solver.prototxt , main函数入口在 caffe-master/tools/caffe.cpp 。在main函数中，首先调用了
//caffe.cpp
return GetBrewFunction(caffe::string(argv[1]))();在函数GetBrewFunction中，调用了
//caffe.cpp
return g_brew_map[name];在main函数之外RegisterBrewFunction这个宏在每一个实现主要功能的函数之后将这个函数的名字和其对应的函数指针添加到了g_brew_map中,具体分别为train()，test()，device_query()，time()这四个函数。故这里g_brew_map的key值为 argv[1]，也即是 “train”，则实际调用了
//caffe.cpp
int train() 三、Solver对象初始化
进入train() 函数，主要使用Solver类完成整个训练过程。Solver类中包含Net类对象，而Net类对象又包含了Layers类对象和Blob类对象
首先需要从argv[2] 中的lenet_solver.prototxt 读取训练模型参数，以下2句初始化了读取参数的 SolverParameter对象 solver_param
//caffe.cpp
caffe::SolverParameter solver_param;
caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param);接着，初始化了一个指向Solver<float>类型的shared_ptr智能指针solver ，通过调用SolverRegistry这个类的静态成员函数CreateSolver构造solver指针所指向的类对象空间。尽管solver是一个指向基类Solver类型对象的指针，但由于C++多态的特性，solver这个智能指针调用各个成员函数时会调用到各个子类(SGDSolver等)的函数。
//caffe.cpp
shared_ptr<caffe::Solver<float> >
solver(caffe::SolverRegistry<float>::CreateSolver(solver_param)); 因为在caffe.proto文件中默认的优化type为SGD,所以上面的代码会实例化一个SGDSolver的对象，SGDSolver 类继承于Solver类，在新建SGDSolver对象时会调用其构造函数如下所示：
//sgd_solvers.hpp
explicit SGDSolver(const SolverParameter& param)
: Solver<Dtype>(param) { PreSolve(); } //solver.cpp
template <typename Dtype>
Solver<Dtype>::Solver(const SolverParameter& param)
: net_(), callbacks_(), requested_early_exit_(false) {
Init(param);
} //solver.cpp
InitTrainNet(); //即初始化Solver类的Net类型的成员变量net_
InitTestNets(); //初始化测试网络这里重点关注InitTrainNet()函数所做的事，在InitTrainNet()函数中首先会设置一些基本参数，包括设置网络的状态为TRAIN，读取lenet_train_text.prototxt,保存至net_param 、确定训练网络只有一个等，然后通过下面这条语句新建了一个Net对象。
//solver.cpp
net_.reset(new Net<Dtype>(net_param)); //net.cpp
template <typename Dtype>
Net<Dtype>::Net(const NetParameter& param) {
Init(param);
} //net.cpp
for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) { //遍历着初始化每个层 //net.cpp
const LayerParameter& layer_param = param.layer(layer_id);
....
layers_.push_back(LayerRegistry<Dtype>::CreateLayer(layer_param));<1> AppendBottom：设置每一层的输入数据
<2> AppendTop：设置每一层的输出数据
<3> layers_[layer_id]->SetUp：对上面设置的输入输出数据计算分配空间，并设置每层的可学习参数(权值和偏置),下面会详细降到这个函数
<4> AppendParam：对上面申请的可学习参数进行设置，主要包括学习率和正则率等
//net.cpp
/*下面的两个for循环将此layer的bottom blob的指针和top blob的指针放入bottom_vecs_和top_vecs_,
bottom blob和top blob的实例全都存放在blobs_中。相邻的两层，前一层的top blob是后一层的bottom blob，
所以blobs_的同一个blob既可能是bottom blob，也可能使top blob。*/
for (int bottom_id = 0; bottom_id < layer_param.bottom_size(); ++bottom_id) {
const int blob_id = AppendBottom(param, layer_id, bottom_id,
&available_blobs, &blob_name_to_idx);
}
.....
for (int top_id = 0; top_id < num_top; ++top_id) {
AppendTop(param, layer_id, top_id, &available_blobs, &blob_name_to_idx);
}
.....
// 调用layer类的Setup函数进行初始化，输入参数：每个layer的输入blobs以及输出blobs,为每个blob设置大小
layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]);
.....
//接下来的工作是将每层的parameter的指针塞进params_，尤其是learnable_params_。
for (int param_id = 0; param_id < num_param_blobs; ++param_id) {
AppendParam(param, layer_id, param_id);
}LayerSetUp(bottom, top)：由Layer类派生出的特定类都需要重写这个函数，主要功能是设置权值参数(包括偏置)的空间以及对权值参数经行随机初始化。
Reshape(bottom, top)：根据输出blob和权值参数计算输出blob的维数，并申请空间。
//layer.hpp
// layer 初始化设置
void SetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
InitMutex();
CheckBlobCounts(bottom, top);
LayerSetUp(bottom, top);
Reshape(bottom, top);
SetLossWeights(top);
}四、Solver对象迭代训练模型过程
如第三节所示，调用完以下语句后，solver这一智能指针所指的Solver类型实例就被初始化完成，也即完成了整个网络的初始化。
//caffe.cpp
shared_ptr<caffe::Solver<float> >
solver(caffe::SolverRegistry<float>::CreateSolver(solver_param)); //caffe.cpp
solver->Solve(); //默认参数为NULL //solver.cpp
template <typename Dtype>
void Solver<Dtype>::Solve(const char* resume_file) {
......
int start_iter = iter_;
......
// 然后调用了'Step'函数，这个函数执行了实际的逐步的迭代过程
Step(param_.max_iter() - iter_);
......
LOG(INFO) << "Optimization Done.";
}Step()的参数中param.max_iter()为lenet_solver.prototxt中的max_iter ，iter_ 在初始化Solver时被初始化为0。进入Step函数，在尽心迭代前先进行初始化，如下：
//solver.cpp
void Solver<Dtype>::Step(int iters) {
const int start_iter = iter_; //start_iter仅被用于while循环里的UpdateSmoothedLoss
const int stop_iter = iter_ + iters; //迭代的总次数，这里就跟solver.prototxt中的max_iter一致
int average_loss = this->param_.average_loss(); //初始的平均损失值，为1
losses_.clear(); //保存loss的vector容器，空间先清0
smoothed_loss_ = 0; //smooth后的loss，清0
while (iter_ < stop_iter) { //开始迭代
......
}
} <1> 首先将网络的权值梯度清0，之后判断 iter_ %param_.test_interval()是否为0 ，然后调用一次TestAll()，实际上也即是 solver.prototxt上 每隔test_interval 次训练迭代就开始 test_iter次测试。测试验证集只涉及前向传播；
<2> 接下来则是进行第 iter_ 次的训练迭代，本来直接读取batch_size张图片作前向和反向即可，但为了避免一次大的batch_size导致显存不足，代码中将 iter_size × batch_size作为实际的batch_size， 例如在训练网络时一个批次图片数量为128,可以在 train_text.prototxt 中设置128，但在solver.prototxt中设置iter_size为1（或者干脆不设置，则默认设为1）；也可以在 train_text.prototxt 中设置了32，但在solver.prototxt中设置iter_size为 4 ，只要两者相乘为128 即可。最后把iter_size次计算得的loss作 loss/iter_size 作为一次前向的loss值。
<3> 对loss作平滑，由于Caffe的训练方式是SGD，我们无法把所有的数据同时放入模型进行训练，那么部分数据产生的Loss就可能会和全样本的平均Loss不同，在必要时候将 loss 和历史过程中更新的 loss 求平均就可以减少Loss的震荡问题。
<4> 最后调用了 ApplyUpdate() 函数， 执行梯度的更新，这个函数在基类 Solver 中没有实现，会调用每个子类自己的实现。
相关代码如下：
//solver.cpp
......
while (iter_ < stop_iter) { //开始迭代
net_->ClearParamDiffs(); // 将权值梯度清0
if (param_.test_interval() && iter_ % param_.test_interval() == 0 // iter_为0,或test_interval的整数倍
&& (iter_ > 0 || param_.test_initialization())) {
if (Caffe::root_solver()) {
TestAll(); // 函数内进行了 test_iter次测试
}
......
}
......
Dtype loss = 0;
for (int i = 0; i < param_.iter_size(); ++i) { //作iter_size次前向和反向传播
loss += net_->ForwardBackward();
}
loss /= param_.iter_size(); //对loss取平均作前向的loss
......
UpdateSmoothedLoss(loss, start_iter, average_loss); //平滑loss
......
ApplyUpdate(); //使用反向传播计算得的梯度对网络模型的权值作更新
++iter_; //迭代次数加1
......
}<2> loss += net_->ForwardBackward();
这行代码通过Net类的net_指针调用其成员函数ForwardBackward()，其代码如下所示,分别调用了成员函数Forward(&loss)和成员函数Backward()来进行前向传播和反向传播。
// net.hpp
// 进行一次正向传播，一次反向传播
Dtype ForwardBackward() {
Dtype loss;
Forward(&loss);
Backward();
return loss;
} //net.cpp
for (int i = start; i <= end; ++i) {
// 对每一层进行前向计算，返回每层的loss，其实只有最后一层loss不为0
Dtype layer_loss = layers_[i]->Forward(bottom_vecs_[i], top_vecs_[i]);
loss += layer_loss;
if (debug_info_) { ForwardDebugInfo(i); }
}这个函数是Solver类的纯虚函数，需要派生类来实现，比如SGDSolver类实现的ApplyUpdate();函数如下，主要内容包括：设置参数的学习率；对梯度进行Normalize；对反向求导得到的梯度添加正则项的梯度；最后根据SGD算法计算最终的梯度；最后的最后把计算得到的最终梯度对权值进行更新。相关代码如下：
//sgd_solver.cpp
template <typename Dtype>
void SGDSolver<Dtype>::ApplyUpdate() {
CHECK(Caffe::root_solver());
// GetLearningRate根据设置的lr_policy来计算当前迭代的learning rate的值
Dtype rate = GetLearningRate();
// 判断是否需要输出当前的learning rate
if (this->param_.display() && this->iter_ % this->param_.display() == 0) {
LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate;
}
// 避免梯度爆炸，如果梯度的二范数超过了某个数值则进行scale操作，将梯度减小
ClipGradients();
// 对所有可更新的网络参数进行操作
for (int param_id = 0; param_id < this->net_->learnable_params().size();
++param_id) {
// 将第param_id个参数的梯度除以iter_size，
// 这一步的作用是保证实际的batch_size=iter_size*设置的batch_size
Normalize(param_id);
// 将正则化部分的梯度降入到每个参数的梯度中
Regularize(param_id);
// 计算SGD算法的梯度(momentum等)
ComputeUpdateValue(param_id, rate);
}
// 调用`Net::Update`更新所有的参数
this->net_->Update();
}