Hendrik/xgboost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Integration tests for interaction constraints with column-wise data split (#9611)

Browse Source
This commit is contained in:
Rong Ou 2023-09-26 17:27:43 -07:00 committed by GitHub
parent c75a3bc0a9
commit d6d14d0fb9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 59 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
tests/cpp/test_learner.cc
View File

@ -720,48 +720,39 @@ INSTANTIATE_TEST_SUITE_P(ColumnSplitObjective, TestColumnSplit,
}); });
namespace { namespace {
void VerifyColumnSplitColumnSampler(std::string const& tree_method, bool use_gpu, Json GetModelWithArgs(std::shared_ptr<DMatrix> dmat, std::string const& tree_method,
Json const& expected_model) { std::string const& device, Args const& args) {
std::unique_ptr<Learner> learner{Learner::Create({dmat})};
learner->SetParam("tree_method", tree_method);
learner->SetParam("device", device);
learner->SetParam("objective", "reg:logistic");
learner->SetParams(args);
learner->UpdateOneIter(0, dmat);
Json model{Object{}}; Json model{Object{}};
{ learner->SaveModel(&model);
auto const world_size = collective::GetWorldSize(); return model;
auto const rank = collective::GetRank(); }
auto const objective = "reg:logistic";
auto p_fmat = MakeFmatForObjTest(objective); void VerifyColumnSplitWithArgs(std::string const& tree_method, bool use_gpu, Args const& args,
std::shared_ptr<DMatrix> sliced{p_fmat->SliceCol(world_size, rank)}; Json const& expected_model) {
std::unique_ptr<Learner> learner{Learner::Create({sliced})}; auto const world_size = collective::GetWorldSize();
learner->SetParam("tree_method", tree_method); auto const rank = collective::GetRank();
if (use_gpu) { auto p_fmat = MakeFmatForObjTest("");
auto gpu_id = common::AllVisibleGPUs() == 1 ? 0 : rank; std::shared_ptr<DMatrix> sliced{p_fmat->SliceCol(world_size, rank)};
learner->SetParam("device", "cuda:" + std::to_string(gpu_id)); std::string device = "cpu";
} if (use_gpu) {
learner->SetParam("objective", objective); auto gpu_id = common::AllVisibleGPUs() == 1 ? 0 : rank;
learner->SetParam("colsample_bytree", "0.5"); device = "cuda:" + std::to_string(gpu_id);
learner->SetParam("colsample_bylevel", "0.6");
learner->SetParam("colsample_bynode", "0.7");
learner->UpdateOneIter(0, sliced);
learner->SaveModel(&model);
} }
auto model = GetModelWithArgs(sliced, tree_method, device, args);
ASSERT_EQ(model, expected_model); ASSERT_EQ(model, expected_model);
} }
void TestColumnSplitColumnSampler(std::string const& tree_method, bool use_gpu) { void TestColumnSplitWithArgs(std::string const& tree_method, bool use_gpu, Args const& args) {
Json model{Object{}}; auto p_fmat = MakeFmatForObjTest("");
{ std::string device = use_gpu ? "cuda:0" : "cpu";
auto objective = "reg:logistic"; auto model = GetModelWithArgs(p_fmat, tree_method, device, args);
auto p_fmat = MakeFmatForObjTest(objective);
std::unique_ptr<Learner> learner{Learner::Create({p_fmat})};
learner->SetParam("tree_method", tree_method);
if (use_gpu) {
learner->SetParam("device", "cuda:0");
}
learner->SetParam("objective", objective);
learner->SetParam("colsample_bytree", "0.5");
learner->SetParam("colsample_bylevel", "0.6");
learner->SetParam("colsample_bynode", "0.7");
learner->UpdateOneIter(0, p_fmat);
learner->SaveModel(&model);
}
auto world_size{3}; auto world_size{3};
if (use_gpu) { if (use_gpu) {
world_size = common::AllVisibleGPUs(); world_size = common::AllVisibleGPUs();
@ -770,9 +761,19 @@ void TestColumnSplitColumnSampler(std::string const& tree_method, bool use_gpu)
world_size = 3; world_size = 3;
} }
} }
RunWithInMemoryCommunicator(world_size, VerifyColumnSplitColumnSampler, tree_method, use_gpu, RunWithInMemoryCommunicator(world_size, VerifyColumnSplitWithArgs, tree_method, use_gpu, args,
model); model);
} }
void TestColumnSplitColumnSampler(std::string const& tree_method, bool use_gpu) {
Args args{{"colsample_bytree", "0.5"}, {"colsample_bylevel", "0.6"}, {"colsample_bynode", "0.7"}};
TestColumnSplitWithArgs(tree_method, use_gpu, args);
}
void TestColumnSplitInteractionConstraints(std::string const& tree_method, bool use_gpu) {
Args args{{"interaction_constraints", "[[0, 5, 7], [2, 8, 9], [1, 3, 6]]"}};
TestColumnSplitWithArgs(tree_method, use_gpu, args);
}
} // anonymous namespace } // anonymous namespace
TEST(ColumnSplitColumnSampler, Approx) { TestColumnSplitColumnSampler("approx", false); } TEST(ColumnSplitColumnSampler, Approx) { TestColumnSplitColumnSampler("approx", false); }
@ -780,8 +781,26 @@ TEST(ColumnSplitColumnSampler, Approx) { TestColumnSplitColumnSampler("approx",
TEST(ColumnSplitColumnSampler, Hist) { TestColumnSplitColumnSampler("hist", false); } TEST(ColumnSplitColumnSampler, Hist) { TestColumnSplitColumnSampler("hist", false); }
#if defined(XGBOOST_USE_CUDA) #if defined(XGBOOST_USE_CUDA)
TEST(ColumnSplitColumnSampler, GPUApprox) { TestColumnSplitColumnSampler("approx", true); } TEST(MGPUColumnSplitColumnSampler, GPUApprox) { TestColumnSplitColumnSampler("approx", true); }
TEST(ColumnSplitColumnSampler, GPUHist) { TestColumnSplitColumnSampler("hist", true); } TEST(MGPUColumnSplitColumnSampler, GPUHist) { TestColumnSplitColumnSampler("hist", true); }
#endif // defined(XGBOOST_USE_CUDA)
TEST(ColumnSplitInteractionConstraints, Approx) {
TestColumnSplitInteractionConstraints("approx", false);
}
TEST(ColumnSplitInteractionConstraints, Hist) {
TestColumnSplitInteractionConstraints("hist", false);
}
#if defined(XGBOOST_USE_CUDA)
TEST(MGPUColumnSplitInteractionConstraints, GPUApprox) {
TestColumnSplitInteractionConstraints("approx", true);
}
TEST(MGPUColumnSplitInteractionConstraints, GPUHist) {
TestColumnSplitInteractionConstraints("hist", true);
}
#endif // defined(XGBOOST_USE_CUDA) #endif // defined(XGBOOST_USE_CUDA)
} // namespace xgboost } // namespace xgboost