[YDF] Fail on distributed tuning cross-validation

This option was exposed, but didn't actually use cross-validation. Now it fails with an error.

PiperOrigin-RevId: 985124213

Author: rstz

yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer.cc

@@ -207,8 +207,24 @@ HyperParameterOptimizerLearner::TrainWithStatusImpl(
     const dataset::VerticalDataset& train_dataset,
     std::optional<std::reference_wrapper<const dataset::VerticalDataset>>
         valid_dataset) const {
+  // The effective configuration is the user configuration + the default value +
+  // the automatic configuration (if enabled) + the copy of the non-specified
+  // training configuration field from the learner to the sub-learner (e.g. copy
+  // of the label name).
+  model::proto::TrainingConfig effective_config;
+  model::proto::TrainingConfigLinking config_link;
+  RETURN_IF_ERROR(GetEffectiveConfiguration(train_dataset.data_spec(),
+                                            &effective_config, &config_link));
+  const proto::HyperParametersOptimizerLearnerTrainingConfig& spe_config =
+      effective_config.GetExtension(proto::hyperparameters_optimizer_config);
+
   if (deployment().execution_case() ==
       model::proto::DeploymentConfig::ExecutionCase::kDistribute) {
+    if (spe_config.evaluation().has_cross_validation()) {
+      return absl::InvalidArgumentError(
+          "The cross-validation evaluation of the hyper-parameter candidates "
+          "is not supported with distributed training");
+    }
     // Export the dataset to file and run the training on file.
     return TrainFromFileOnMemoryDataset(train_dataset, valid_dataset);
   }
@@ -222,17 +238,6 @@ HyperParameterOptimizerLearner::TrainWithStatusImpl(
         "deployment configs.");
   }
 
-  // The effective configuration is the user configuration + the default value +
-  // the automatic configuration (if enabled) + the copy of the non-specified
-  // training configuration field from the learner to the sub-learner (e.g. copy
-  // of the label name).
-  model::proto::TrainingConfig effective_config;
-  model::proto::TrainingConfigLinking config_link;
-  RETURN_IF_ERROR(GetEffectiveConfiguration(train_dataset.data_spec(),
-                                            &effective_config, &config_link));
-  const proto::HyperParametersOptimizerLearnerTrainingConfig& spe_config =
-      effective_config.GetExtension(proto::hyperparameters_optimizer_config);
-
   // Initialize the learner with the base hyperparameters.
   ASSIGN_OR_RETURN(auto base_learner,
                    BuildBaseLearner(spe_config, /*for_tuning=*/true));
@@ -345,6 +350,12 @@ HyperParameterOptimizerLearner::TrainWithStatusImpl(
   const proto::HyperParametersOptimizerLearnerTrainingConfig& spe_config =
       effective_config.GetExtension(proto::hyperparameters_optimizer_config);
 
+  if (spe_config.evaluation().has_cross_validation()) {
+    return absl::InvalidArgumentError(
+        "The cross-validation evaluation of the hyper-parameter candidates "
+        "is not supported with distributed training");
+  }
+
   // Initialize the remote workers.
   ASSIGN_OR_RETURN(auto manager, CreateDistributeManager(spe_config));
 
@@ -652,7 +663,8 @@ HyperParameterOptimizerLearner::SearchBestHyperparameterInProcess(
 
   LOG(INFO) << "Start local tuner with "
             << spe_config.optimizer().parallel_trials()
-            << " parallel trial(s), each with " << deployment().num_threads()
+            << " parallel trial(s), each with "
+            << spe_config.base_learner_deployment().num_threads()
             << " thread(s)";
   async_evaluator.StartWorkers();
 
@@ -822,7 +834,12 @@ absl::StatusOr<double> HyperParameterOptimizerLearner::EvaluateCandidateLocally(
                                        *base_learner, train_dataset,
                                        fold_generator, evaluation_options,
                                        spe_config.base_learner_deployment()));
+      break;
     }
+    default:
+      return absl::InvalidArgumentError(absl::StrCat(
+          "Unsupported evaluation source: ",
+          static_cast<int>(spe_config.evaluation().source_case())));
   }
 
   ASSIGN_OR_RETURN(const auto score, EvaluationToScore(spe_config, evaluation));

yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer.proto

@@ -84,7 +84,8 @@ message Evaluation {
     // Uses the self reported model evaluation e.g. validation score or OOB
     // evaluation. Default.
     SelfEvaluation self_model_evaluation = 3;
-    // Uses cross-validation on the training dataset.
+    // Uses cross-validation on the training dataset. Not supported for
+    // distributed training.
     CrossValidation cross_validation = 4;
   }
 

yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer_test.cc

@@ -167,17 +167,40 @@ TEST_F(OnAdult, RandomTuner_MemoryDataset_LocalTraining) {
 }
 
 TEST_F(OnAdult, RandomTuner_MemoryDataset_LocalTrainingCrossValidation) {
-  SetLocalTraining();
+  SetTrainConfig("RANDOM", "random", 10);
   auto* spe_config = train_config_.MutableExtension(
       hyperparameters_optimizer_v2::proto::hyperparameters_optimizer_config);
-  spe_config->mutable_evaluation()->mutable_cross_validation();
-  SetTrainConfig("RANDOM", "random", 10);
+  spe_config->mutable_evaluation()
+      ->mutable_cross_validation()
+      ->mutable_fold_generator()
+      ->set_num_folds(3);
+
+  SetLocalTraining();
   TrainAndEvaluateModel();
   EXPECT_GE(metric::Accuracy(evaluation_), 0.865);
   EXPECT_LT(metric::LogLoss(evaluation_), 0.30);
   EXPECT_EQ(model_->hyperparameter_optimizer_logs()->steps_size(), 10);
 }
 
+TEST_F(OnAdult, CrossValidationWithDistributedTraining_Fail) {
+  SetTrainConfig("RANDOM", "random", 5);
+  auto* spe_config = train_config_.MutableExtension(
+      hyperparameters_optimizer_v2::proto::hyperparameters_optimizer_config);
+  spe_config->mutable_evaluation()->mutable_cross_validation();
+
+  SetDistributedTraining();
+  PrepareDataset();
+
+  std::unique_ptr<model::AbstractLearner> learner;
+  ASSERT_OK(model::GetLearner(train_config_, &learner, deployment_config_));
+
+  auto model_or = learner->TrainWithStatus(train_dataset_);
+  EXPECT_FALSE(model_or.ok());
+  EXPECT_EQ(model_or.status().code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(model_or.status().message(),
+              HasSubstr("not supported with distributed training"));
+}
+
 TEST_F(OnAdult, RandomTuner_FileDataset_LocalTraining) {
   pass_training_dataset_as_path_ = true;
   SetLocalTraining();
@@ -195,18 +218,6 @@ TEST_F(OnAdult, RandomTuner_MemoryDataset_DistributedTraining) {
   EXPECT_EQ(model_->hyperparameter_optimizer_logs()->steps_size(), 25);
 }
 
-TEST_F(OnAdult, RandomTuner_MemoryDataset_DistributedTrainingCrossValidation) {
-  SetDistributedTraining();
-  auto* spe_config = train_config_.MutableExtension(
-      hyperparameters_optimizer_v2::proto::hyperparameters_optimizer_config);
-  spe_config->mutable_evaluation()->mutable_cross_validation();
-  SetTrainConfig("RANDOM", "random", 10);
-  TrainAndEvaluateModel();
-  EXPECT_GE(metric::Accuracy(evaluation_), 0.865);
-  EXPECT_LT(metric::LogLoss(evaluation_), 0.30);
-  EXPECT_EQ(model_->hyperparameter_optimizer_logs()->steps_size(), 10);
-}
-
 TEST_F(OnAdult, RandomTuner_FileDataset_DistributedTraining) {
   SetDistributedTraining();
   pass_training_dataset_as_path_ = true;