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

Unify evaluation functions. (#6037)

Browse Source
This commit is contained in:
Jiaming Yuan
2020-08-26 14:23:27 +08:00
committed by GitHub
parent 80c8547147
commit 2fcc4f2886
29 changed files with 570 additions and 734 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
tests/cpp/test_serialization.cc
View File

@@ -11,6 +11,51 @@
namespace xgboost {
void CompareJSON(Json l, Json r) {
switch (l.GetValue().Type()) {
case Value::ValueKind::kString: {
ASSERT_EQ(l, r);
break;
}
case Value::ValueKind::kNumber: {
ASSERT_NEAR(get<Number>(l), get<Number>(r), kRtEps);
break;
}
case Value::ValueKind::kInteger: {
ASSERT_EQ(l, r);
break;
}
case Value::ValueKind::kObject: {
auto const &l_obj = get<Object const>(l);
auto const &r_obj = get<Object const>(r);
ASSERT_EQ(l_obj.size(), r_obj.size());
for (auto const& kv : l_obj) {
ASSERT_NE(r_obj.find(kv.first), r_obj.cend());
CompareJSON(l_obj.at(kv.first), r_obj.at(kv.first));
}
break;
}
case Value::ValueKind::kArray: {
auto const& l_arr = get<Array const>(l);
auto const& r_arr = get<Array const>(r);
ASSERT_EQ(l_arr.size(), r_arr.size());
for (size_t i = 0; i < l_arr.size(); ++i) {
CompareJSON(l_arr[i], r_arr[i]);
}
break;
}
case Value::ValueKind::kBoolean: {
ASSERT_EQ(l, r);
break;
}
case Value::ValueKind::kNull: {
ASSERT_EQ(l, r);
break;
}
}
}
void TestLearnerSerialization(Args args, FeatureMap const& fmap, std::shared_ptr<DMatrix> p_dmat) {
for (auto& batch : p_dmat->GetBatches<SparsePage>()) {
batch.data.HostVector();
@@ -104,7 +149,7 @@ void TestLearnerSerialization(Args args, FeatureMap const& fmap, std::shared_ptr
Json m_0 = Json::Load(StringView{continued_model.c_str(), continued_model.size()});
Json m_1 = Json::Load(StringView{model_at_2kiter.c_str(), model_at_2kiter.size()});
ASSERT_EQ(m_0, m_1);
CompareJSON(m_0, m_1);
}
// Test training continuation with data from device.
@@ -323,7 +368,7 @@ TEST_F(SerializationTest, ConfigurationCount) {
occureences ++;
pos += target.size();
}
ASSERT_EQ(occureences, 2);
ASSERT_EQ(occureences, 2ul);
xgboost::ConsoleLogger::Configure({{"verbosity", "2"}});
}

18
tests/cpp/tree/gpu_hist/test_driver.cu
View File

@@ -9,12 +9,12 @@ TEST(GpuHist, DriverDepthWise) {
EXPECT_TRUE(driver.Pop().empty());
DeviceSplitCandidate split;
split.loss_chg = 1.0f;
ExpandEntry root(0, 0, split);
ExpandEntry root(0, 0, split, .0f, .0f, .0f);
driver.Push({root});
EXPECT_EQ(driver.Pop().front().nid, 0);
driver.Push({ExpandEntry{1, 1, split}});
driver.Push({ExpandEntry{2, 1, split}});
driver.Push({ExpandEntry{3, 2, split}});
driver.Push({ExpandEntry{1, 1, split, .0f, .0f, .0f}});
driver.Push({ExpandEntry{2, 1, split, .0f, .0f, .0f}});
driver.Push({ExpandEntry{3, 2, split, .0f, .0f, .0f}});
// Should return entries from level 1
auto res = driver.Pop();
EXPECT_EQ(res.size(), 2);
@@ -34,12 +34,12 @@ TEST(GpuHist, DriverLossGuided) {
Driver driver(TrainParam::kLossGuide);
EXPECT_TRUE(driver.Pop().empty());
ExpandEntry root(0, 0, high_gain);
ExpandEntry root(0, 0, high_gain, .0f, .0f, .0f);
driver.Push({root});
EXPECT_EQ(driver.Pop().front().nid, 0);
// Select high gain first
driver.Push({ExpandEntry{1, 1, low_gain}});
driver.Push({ExpandEntry{2, 2, high_gain}});
driver.Push({ExpandEntry{1, 1, low_gain, .0f, .0f, .0f}});
driver.Push({ExpandEntry{2, 2, high_gain, .0f, .0f, .0f}});
auto res = driver.Pop();
EXPECT_EQ(res.size(), 1);
EXPECT_EQ(res[0].nid, 2);
@@ -48,8 +48,8 @@ TEST(GpuHist, DriverLossGuided) {
EXPECT_EQ(res[0].nid, 1);
// If equal gain, use nid
driver.Push({ExpandEntry{2, 1, low_gain}});
driver.Push({ExpandEntry{1, 1, low_gain}});
driver.Push({ExpandEntry{2, 1, low_gain, .0f, .0f, .0f}});
driver.Push({ExpandEntry{1, 1, low_gain, .0f, .0f, .0f}});
res = driver.Pop();
EXPECT_EQ(res[0].nid, 1);
res = driver.Pop();

82
tests/cpp/tree/gpu_hist/test_evaluate_splits.cu
View File

@@ -5,11 +5,21 @@
namespace xgboost {
namespace tree {
namespace {
auto ZeroParam() {
auto args = Args{{"min_child_weight", "0"},
{"lambda", "0"}};
TrainParam tparam;
tparam.UpdateAllowUnknown(args);
return tparam;
}
} // anonymous namespace
TEST(GpuHist, EvaluateSingleSplit) {
thrust::device_vector<DeviceSplitCandidate> out_splits(1);
GradientPair parent_sum(0.0, 1.0);
GPUTrainingParam param{};
TrainParam tparam = ZeroParam();
GPUTrainingParam param{tparam};
thrust::device_vector<bst_feature_t> feature_set =
std::vector<bst_feature_t>{0, 1};
@@ -31,10 +41,10 @@ TEST(GpuHist, EvaluateSingleSplit) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
EvaluateSingleSplit(dh::ToSpan(out_splits), input);
dh::ToSpan(feature_histogram)};
TreeEvaluator tree_evaluator(tparam, feature_min_values.size(), 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSingleSplit(dh::ToSpan(out_splits), evaluator, input);
DeviceSplitCandidate result = out_splits[0];
EXPECT_EQ(result.findex, 1);
@@ -48,7 +58,8 @@ TEST(GpuHist, EvaluateSingleSplit) {
TEST(GpuHist, EvaluateSingleSplitMissing) {
thrust::device_vector<DeviceSplitCandidate> out_splits(1);
GradientPair parent_sum(1.0, 1.5);
GPUTrainingParam param{};
TrainParam tparam = ZeroParam();
GPUTrainingParam param{tparam};
thrust::device_vector<bst_feature_t> feature_set =
std::vector<bst_feature_t>{0};
@@ -66,10 +77,11 @@ TEST(GpuHist, EvaluateSingleSplitMissing) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
EvaluateSingleSplit(dh::ToSpan(out_splits), input);
dh::ToSpan(feature_histogram)};
TreeEvaluator tree_evaluator(tparam, feature_set.size(), 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSingleSplit(dh::ToSpan(out_splits), evaluator, input);
DeviceSplitCandidate result = out_splits[0];
EXPECT_EQ(result.findex, 0);
@@ -86,8 +98,13 @@ TEST(GpuHist, EvaluateSingleSplitEmpty) {
thrust::device_vector<DeviceSplitCandidate> out_split(1);
out_split[0] = nonzeroed;
EvaluateSingleSplit(dh::ToSpan(out_split),
TrainParam tparam = ZeroParam();
TreeEvaluator tree_evaluator(tparam, 1, 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSingleSplit(dh::ToSpan(out_split), evaluator,
EvaluateSplitInputs<GradientPair>{});
DeviceSplitCandidate result = out_split[0];
EXPECT_EQ(result.findex, -1);
EXPECT_LT(result.loss_chg, 0.0f);
@@ -97,7 +114,9 @@ TEST(GpuHist, EvaluateSingleSplitEmpty) {
TEST(GpuHist, EvaluateSingleSplitFeatureSampling) {
thrust::device_vector<DeviceSplitCandidate> out_splits(1);
GradientPair parent_sum(0.0, 1.0);
GPUTrainingParam param{};
TrainParam tparam = ZeroParam();
tparam.UpdateAllowUnknown(Args{});
GPUTrainingParam param{tparam};
thrust::device_vector<bst_feature_t> feature_set =
std::vector<bst_feature_t>{1};
@@ -118,10 +137,11 @@ TEST(GpuHist, EvaluateSingleSplitFeatureSampling) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
EvaluateSingleSplit(dh::ToSpan(out_splits), input);
dh::ToSpan(feature_histogram)};
TreeEvaluator tree_evaluator(tparam, feature_min_values.size(), 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSingleSplit(dh::ToSpan(out_splits), evaluator, input);
DeviceSplitCandidate result = out_splits[0];
EXPECT_EQ(result.findex, 1);
@@ -134,7 +154,9 @@ TEST(GpuHist, EvaluateSingleSplitFeatureSampling) {
TEST(GpuHist, EvaluateSingleSplitBreakTies) {
thrust::device_vector<DeviceSplitCandidate> out_splits(1);
GradientPair parent_sum(0.0, 1.0);
GPUTrainingParam param{};
TrainParam tparam = ZeroParam();
tparam.UpdateAllowUnknown(Args{});
GPUTrainingParam param{tparam};
thrust::device_vector<bst_feature_t> feature_set =
std::vector<bst_feature_t>{0, 1};
@@ -155,10 +177,11 @@ TEST(GpuHist, EvaluateSingleSplitBreakTies) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
EvaluateSingleSplit(dh::ToSpan(out_splits), input);
dh::ToSpan(feature_histogram)};
TreeEvaluator tree_evaluator(tparam, feature_min_values.size(), 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSingleSplit(dh::ToSpan(out_splits), evaluator, input);
DeviceSplitCandidate result = out_splits[0];
EXPECT_EQ(result.findex, 0);
@@ -168,7 +191,9 @@ TEST(GpuHist, EvaluateSingleSplitBreakTies) {
TEST(GpuHist, EvaluateSplits) {
thrust::device_vector<DeviceSplitCandidate> out_splits(2);
GradientPair parent_sum(0.0, 1.0);
GPUTrainingParam param{};
TrainParam tparam = ZeroParam();
tparam.UpdateAllowUnknown(Args{});
GPUTrainingParam param{tparam};
thrust::device_vector<bst_feature_t> feature_set =
std::vector<bst_feature_t>{0, 1};
@@ -193,9 +218,7 @@ TEST(GpuHist, EvaluateSplits) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram_left),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
dh::ToSpan(feature_histogram_left)};
EvaluateSplitInputs<GradientPair> input_right{
2,
parent_sum,
@@ -204,10 +227,11 @@ TEST(GpuHist, EvaluateSplits) {
dh::ToSpan(feature_segments),
dh::ToSpan(feature_values),
dh::ToSpan(feature_min_values),
dh::ToSpan(feature_histogram_right),
ValueConstraint(),
dh::ToSpan(monotonic_constraints)};
EvaluateSplits(dh::ToSpan(out_splits), input_left, input_right);
dh::ToSpan(feature_histogram_right)};
TreeEvaluator tree_evaluator(tparam, feature_min_values.size(), 0);
auto evaluator = tree_evaluator.GetEvaluator<GPUTrainingParam>();
EvaluateSplits(dh::ToSpan(out_splits), evaluator, input_left, input_right);
DeviceSplitCandidate result_left = out_splits[0];
EXPECT_EQ(result_left.findex, 1);

4
tests/cpp/tree/test_gpu_hist.cu
View File

@@ -215,10 +215,6 @@ TEST(GpuHist, EvaluateRootSplit) {
info.num_row_ = kNRows;
info.num_col_ = kNCols;
maker.node_value_constraints.resize(1);
maker.node_value_constraints[0].lower_bound = -1.0;
maker.node_value_constraints[0].upper_bound = 1.0;
DeviceSplitCandidate res = maker.EvaluateRootSplit({6.4f, 12.8f});
ASSERT_EQ(res.findex, 7);

18
tests/cpp/tree/test_quantile_hist.cc
View File

@@ -29,10 +29,9 @@ class QuantileHistMock : public QuantileHistMaker {
BuilderMock(const TrainParam& param,
std::unique_ptr<TreeUpdater> pruner,
std::unique_ptr<SplitEvaluator> spliteval,
FeatureInteractionConstraintHost int_constraint,
DMatrix const* fmat)
: RealImpl(param, std::move(pruner), std::move(spliteval),
: RealImpl(param, std::move(pruner),
std::move(int_constraint), fmat) {}
public:
@@ -195,7 +194,7 @@ class QuantileHistMock : public QuantileHistMaker {
this->hist_rows_adder_->AddHistRows(this, &starting_index, &sync_count, tree);
const size_t n_nodes = this->nodes_for_explicit_hist_build_.size();
ASSERT_EQ(n_nodes, 2);
ASSERT_EQ(n_nodes, 2ul);
this->row_set_collection_.AddSplit(0, (*tree)[0].LeftChild(),
(*tree)[0].RightChild(), 4, 4);
this->row_set_collection_.AddSplit(1, (*tree)[1].LeftChild(),
@@ -331,10 +330,6 @@ class QuantileHistMock : public QuantileHistMaker {
for (const auto& e : row_gpairs) {
total_gpair += GradientPairPrecise(e);
}
// Initialize split evaluator
std::unique_ptr<SplitEvaluator> evaluator(SplitEvaluator::Create("elastic_net"));
evaluator->Init(&this->param_);
// Now enumerate all feature*threshold combination to get best split
// To simplify logic, we make some assumptions:
// 1) no missing values in data
@@ -368,9 +363,9 @@ class QuantileHistMock : public QuantileHistMaker {
}
}
// Now compute gain (change in loss)
const auto split_gain
= evaluator->ComputeSplitScore(0, fid, GradStats(left_sum),
GradStats(right_sum));
auto evaluator = this->tree_evaluator_.GetEvaluator();
const auto split_gain = evaluator.CalcSplitGain(
this->param_, 0, fid, GradStats(left_sum), GradStats(right_sum));
if (split_gain > best_split_gain) {
best_split_gain = split_gain;
best_split_feature = fid;
@@ -476,14 +471,12 @@ class QuantileHistMock : public QuantileHistMaker {
const bool single_precision_histogram = false, bool batch = true) :
cfg_{args} {
QuantileHistMaker::Configure(args);
spliteval_->Init(&param_);
dmat_ = RandomDataGenerator(kNRows, kNCols, 0.8).Seed(3).GenerateDMatrix();
if (single_precision_histogram) {
float_builder_.reset(
new BuilderMock<float>(
param_,
std::move(pruner_),
std::unique_ptr<SplitEvaluator>(spliteval_->GetHostClone()),
int_constraint_,
dmat_.get()));
if (batch) {
@@ -498,7 +491,6 @@ class QuantileHistMock : public QuantileHistMaker {
new BuilderMock<double>(
param_,
std::move(pruner_),
std::unique_ptr<SplitEvaluator>(spliteval_->GetHostClone()),
int_constraint_,
dmat_.get()));
if (batch) {