Method TrainOneIter_new

src/boosting/gbdt.cpp:467–548

bool GBDT::TrainOneIter_new(const score_t* gradients, const score_t* hessians,const score_t* gradients2, const score_t* hessians2) {
  std::vector<double> init_scores(num_tree_per_iteration_, 0.0);

  // bagging logic
  Bagging(iter_);

  bool should_continue = false;
  for (int cur_tree_id = 0; cur_tree_id < num_tree_per_iteration_; ++cur_tree_id) {
    const size_t offset = static_cast<size_t>(cur_tree_id) * num_data_;
    for (int cur_tree_id2 = 0; cur_tree_id2 < config_->num_labels; ++cur_tree_id2) {
        const size_t offset2 = static_cast<size_t>(cur_tree_id2) * num_data_;
        std::unique_ptr<Tree> new_tree(new Tree(2));

        if (class_need_train_[cur_tree_id] && train_data_->num_features() > 0) {
          auto grad = gradients + offset;
          auto hess = hessians + offset;
          auto grad2 = gradients2 + offset2;
          auto hess2 = hessians2 + offset2;
          if (is_use_subset_ && bag_data_cnt_ < num_data_) {

            for (int i = 0; i < bag_data_cnt_; ++i) {
              gradients_[offset + i] = grad[bag_data_indices_[i]];
              hessians_[offset + i] = hess[bag_data_indices_[i]];
            }
            grad = gradients_.data() + offset;
            hess = hessians_.data() + offset;
          }
          new_tree.reset(tree_learner_->Train(grad, hess, is_constant_hessian_, forced_splits_json_));
//           new_tree.reset(tree_learner_->Train_serial2(grad, hess,grad, hess, is_constant_hessian_, forced_splits_json_));
          tree_learner_->Train_serial2(new_tree.get(), grad2, hess2);
        }


        if (new_tree->num_leaves() > 1) {
          should_continue = true;
          auto score_ptr = train_score_updater_->score() + offset2;
          auto residual_getter = [score_ptr](const label_t* label, int i) {return static_cast<double>(label[i]) - score_ptr[i]; };
//           tree_learner_->RenewTreeOutput(new_tree.get(), objective_function_, residual_getter,
//                                          num_data_, bag_data_indices_.data(), bag_data_cnt_);
          // shrinkage by learning rate
          new_tree->Shrinkage(shrinkage_rate_);
          // update score
          UpdateScore(new_tree.get(), cur_tree_id2);
          if (std::fabs(init_scores[cur_tree_id]) > kEpsilon) {
            Log::Warning("please set grad and hess both.");
            new_tree->AddBias(init_scores[cur_tree_id]);
          }
        } else {
          // only add default score one-time
          if (models_.size() < static_cast<size_t>(num_tree_per_iteration_)) {
            double output = 0.0;
            if (!class_need_train_[cur_tree_id2]) {
              if (objective_function_ != nullptr) {
                output = objective_function_->BoostFromScore(cur_tree_id2);
              }
            } else {
              output = init_scores[cur_tree_id];
            }