caffe撸码：solver.cpp

野性酷女 2022-02-04 11:39 199阅读 0赞

template <typename Dtype>
    void Solver<Dtype>::Step(int iters) {
      const int start_iter = iter_;
      const int stop_iter = iter_ + iters;
      int average_loss = this->param_.average_loss();
      losses_.clear();
      smoothed_loss_ = 0;
      iteration_timer_.Start();
    
      while (iter_ < stop_iter) {
        // zero-init the params
        LOG(INFO) << "iter " << iter_;
        net_->ClearParamDiffs();
        if (param_.test_interval() && iter_ % param_.test_interval() == 0
            && (iter_ > 0 || param_.test_initialization())) {
          if (Caffe::root_solver()) {
            TestAll();
          }
          if (requested_early_exit_) {
            // Break out of the while loop because stop was requested while testing.
            break;
          }
        }
    
        for (int i = 0; i < callbacks_.size(); ++i) {
          callbacks_[i]->on_start();
        }
        const bool display = param_.display() && iter_ % param_.display() == 0;
        net_->set_debug_info(display && param_.debug_info());
        // accumulate the loss and gradient
        Dtype loss = 0;
        Dtype a=0;
        for (int i = 0; i < param_.iter_size(); ++i) {
          a=net_->ForwardBackward();//前向传播返回的误差，在sacnn中指的是euclidean.cpp中的loss
          LOG(INFO) << "net_->ForwardBackward() " << a;
          //loss += net_->ForwardBackward();
          loss += a;
          LOG(INFO) << "Step  loss " << loss;
        }
        LOG(INFO) << "param_.iter_size() " << param_.iter_size();
        loss /= param_.iter_size();
        LOG(INFO) << "loss /= param_.iter_size() " << loss;
        // average the loss across iterations for smoothed reporting
        UpdateSmoothedLoss(loss, start_iter, average_loss);//求取平均的loss值
        if (display) {
          float lapse = iteration_timer_.Seconds();
          float per_s = (iter_ - iterations_last_) / (lapse ? lapse : 1);
          //训练时输出的loss是平均loss： smoothed_loss_。
          LOG_IF(INFO, Caffe::root_solver()) << "Iteration " << iter_
              << " (" << per_s << " iter/s, " << lapse << "s/"
              << param_.display() << " iters), loss = " << smoothed_loss_;
          iteration_timer_.Start();
          iterations_last_ = iter_;
          const vector<Blob<Dtype>*>&  result = net_->output_blobs();
          int score_index = 0;
          for (int j = 0; j < result.size(); ++j) {
            const Dtype* result_vec = result[j]->cpu_data();
            const string& output_name =
                net_->blob_names()[net_->output_blob_indices()[j]];
            const Dtype loss_weight =
                net_->blob_loss_weights()[net_->output_blob_indices()[j]];
            for (int k = 0; k < result[j]->count();  ++k) {
              ostringstream loss_msg_stream;
              if (loss_weight) {
                loss_msg_stream << " (* " << loss_weight
                                << " = " << loss_weight * result_vec[k] << " loss)";
              }
             //网络有几个输出就输出几个值
              LOG_IF(INFO, Caffe::root_solver()) << "    Train net output #"
                  << score_index++ << ": " << output_name << " = "
                  << result_vec[k] << loss_msg_stream.str();
            }
          }
        }
        for (int i = 0; i < callbacks_.size(); ++i) {
          callbacks_[i]->on_gradients_ready();
        }
        ApplyUpdate();
        
        SolverAction::Enum request = GetRequestedAction();
    
        // Save a snapshot if needed.
        if ((param_.snapshot()
             && iter_ % param_.snapshot() == 0
             && Caffe::root_solver()) ||
             (request == SolverAction::SNAPSHOT)) {
          Snapshot();
        }
        if (SolverAction::STOP == request) {
          requested_early_exit_ = true;
          // Break out of training loop.
          break;
        }
      }
    }
    
    
    template <typename Dtype>
    void Solver<Dtype>::UpdateSmoothedLoss(Dtype loss, int start_iter,
        int average_loss) {
      if (losses_.size() < average_loss) {
    //在sacnn中指的是：首先更新losses_中的2400个值。2400指的是avearge_loss的值，通常取为训练样本的数目
        LOG(INFO) << "solver.cpp loss " << loss;
        losses_.push_back(loss);
        int size = losses_.size();
        smoothed_loss_ = (smoothed_loss_ * (size - 1) + loss) / size;
      } else {
    //每2400次都更新一次losses_的值，将losses_中保存的值用作下一次误差的计算。
        int idx = (iter_ - start_iter) % average_loss;
        smoothed_loss_ += (loss - losses_[idx]) / average_loss;
        losses_[idx] = loss;
      }
    }
    
    INSTANTIATE_CLASS(Solver);
    
    }  // namespace caffe

将上面的solver.cpp分析与下面博文结合起来看[https://blog.csdn.net/dcrmg/article/details/76099720][https_blog.csdn.net_dcrmg_article_details_76099720]

持续撸码↖(^ω^)↗

[https_blog.csdn.net_dcrmg_article_details_76099720]: https://blog.csdn.net/dcrmg/article/details/76099720