template <typename Dtype>

 void Net<Dtype>::Init(const NetParameter& in_param) {

   ........//过滤校验参数FilterNet

   FilterNet(in_param, &filtered_param);

   .........//插入Splits层

   InsertSplits(filtered_param, &param);

   .......// 构建网络中输入输出存储结构

   bottom_vecs_.resize(param.layer_size());

   top_vecs_.resize(param.layer_size());

   bottom_id_vecs_.resize(param.layer_size());

   param_id_vecs_.resize(param.layer_size());

   top_id_vecs_.resize(param.layer_size());

   bottom_need_backward_.resize(param.layer_size());

   for (int layer_id = ; layer_id < param.layer_size(); ++layer_id) {

    ...//创建层

  layers_.push_back(LayerRegistry<Dtype>::CreateLayer(layer_param));

     layer_names_.push_back(layer_param.name());

     LOG_IF(INFO, Caffe::root_solver())

         << "Creating Layer " << layer_param.name();

     bool need_backward = false;

     // Figure out this layer's input and output

     for (int bottom_id = ; bottom_id < layer_param.bottom_size();

          ++bottom_id) {

       const int blob_id = AppendBottom(param, layer_id, bottom_id,

                                        &available_blobs, &blob_name_to_idx);

    ........//创建相关blob

     // If the layer specifies that AutoTopBlobs() -> true and the LayerParameter

     // specified fewer than the required number (as specified by

     // ExactNumTopBlobs() or MinTopBlobs()), allocate them here.

     Layer<Dtype>* layer = layers_[layer_id].get();

     if (layer->AutoTopBlobs()) {

       const int needed_num_top =

           std::max(layer->MinTopBlobs(), layer->ExactNumTopBlobs());

       for (; num_top < needed_num_top; ++num_top) {

         // Add "anonymous" top blobs -- do not modify available_blobs or

         // blob_name_to_idx as we don't want these blobs to be usable as input

         // to other layers.

         AppendTop(param, layer_id, num_top, NULL, NULL);

       }

     }

     .....//执行SetUp()

     // After this layer is connected, set it up.

     layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]);

     LOG_IF(INFO, Caffe::root_solver())

         << "Setting up " << layer_names_[layer_id];

     for (int top_id = ; top_id < top_vecs_[layer_id].size(); ++top_id) {

       if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) {

         blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + , Dtype());

       }

       blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id);

       LOG_IF(INFO, Caffe::root_solver())

           << "Top shape: " << top_vecs_[layer_id][top_id]->shape_string();

       if (layer->loss(top_id)) {

         LOG_IF(INFO, Caffe::root_solver())

             << "    with loss weight " << layer->loss(top_id);

       }

       memory_used_ += top_vecs_[layer_id][top_id]->count();

     }

     LOG_IF(INFO, Caffe::root_solver())

         << "Memory required for data: " << memory_used_ * sizeof(Dtype);

     const int param_size = layer_param.param_size();

     const int num_param_blobs = layers_[layer_id]->blobs().size();

     CHECK_LE(param_size, num_param_blobs)

         << "Too many params specified for layer " << 

 template <typename Dtype>

 void SGDSolver<Dtype>::ApplyUpdate()

 {

     // 获取当前学习速率

     Dtype rate = GetLearningRate();

     if (this->param_.display() && this->iter_ % this->param_.display() == )

     {

         LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate;

     }  

     // 在计算当前梯度的时候，如果该值超过了阈值clip_gradients，则将梯度直接设置为该阈值

     // 此处阈值设为-1，即不起作用

     ClipGradients();  

     // 逐层更新网络中的可学习层

     for (int param_id = ; param_id < this->net_->learnable_params().size();

        ++param_id)

     {

         // 归一化

         Normalize(param_id);

         // L2范数正则化添加衰减权重

         Regularize(param_id);

         // 随机梯度下降法计算更新值

         ComputeUpdateValue(param_id, rate);

     }

     // 更新权重

     this->net_->Update();

 }