rmontanana/mdlp
1
1
Fork 0
mirror of https://github.com/rmontanana/mdlp.git synced 2025-08-21 10:26:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix tests, samples and remove uneeded support files

Browse Source
This commit is contained in:
Ricardo Montañana Gómez
2024-07-03 18:13:22 +02:00
parent d90e21ec4c
commit fcbd05d842
18 changed files with 426 additions and 997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

659
tests/BinDisc_unittest.cpp
View File

@@ -35,318 +35,318 @@ namespace mdlp {
public:
TestBinDisc4Q(int n_bins = 4) : BinDisc(n_bins, strategy_t::QUANTILE) {};
};
// TEST_F(TestBinDisc3U, Easy3BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
// auto y = labels_t();
// fit(X, y);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(3.66667, cuts.at(1), margin);
// EXPECT_NEAR(6.33333, cuts.at(2), margin);
// EXPECT_NEAR(9.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3Q, Easy3BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts[0], margin);
// EXPECT_NEAR(3.666667, cuts[1], margin);
// EXPECT_NEAR(6.333333, cuts[2], margin);
// EXPECT_NEAR(9, cuts[3], margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3U, X10BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(4.0, cuts.at(1), margin);
// EXPECT_NEAR(7.0, cuts.at(2), margin);
// EXPECT_NEAR(10.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3Q, X10BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(4.0, cuts.at(1), margin);
// EXPECT_NEAR(7.0, cuts.at(2), margin);
// EXPECT_NEAR(10.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3U, X11BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(4.33333, cuts.at(1), margin);
// EXPECT_NEAR(7.66667, cuts.at(2), margin);
// EXPECT_NEAR(11.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3U, X11BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(4.33333, cuts.at(1), margin);
// EXPECT_NEAR(7.66667, cuts.at(2), margin);
// EXPECT_NEAR(11.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3U, ConstantUniform)
// {
// samples_t X = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(2, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(1, cuts.at(1), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 0, 0 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3Q, ConstantQuantile)
// {
// samples_t X = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(2, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(1, cuts.at(1), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 0, 0 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc3U, EmptyUniform)
// {
// samples_t X = {};
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(2, cuts.size());
// EXPECT_NEAR(0, cuts.at(0), margin);
// EXPECT_NEAR(0, cuts.at(1), margin);
// }
// TEST_F(TestBinDisc3Q, EmptyQuantile)
// {
// samples_t X = {};
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(2, cuts.size());
// EXPECT_NEAR(0, cuts.at(0), margin);
// EXPECT_NEAR(0, cuts.at(1), margin);
// }
// TEST(TestBinDisc3, ExceptionNumberBins)
// {
// EXPECT_THROW(BinDisc(2), std::invalid_argument);
// }
// TEST_F(TestBinDisc3U, EasyRepeated)
// {
// samples_t X = { 3.0, 1.0, 1.0, 3.0, 1.0, 1.0, 3.0, 1.0, 1.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(4, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(1.66667, cuts.at(1), margin);
// EXPECT_NEAR(2.33333, cuts.at(2), margin);
// EXPECT_NEAR(3.0, cuts.at(3), margin);
// auto labels = transform(X);
// labels_t expected = { 2, 0, 0, 2, 0, 0, 2, 0, 0 };
// EXPECT_EQ(expected, labels);
// ASSERT_EQ(3.0, X[0]); // X is not modified
// }
// TEST_F(TestBinDisc3Q, EasyRepeated)
// {
// samples_t X = { 3.0, 1.0, 1.0, 3.0, 1.0, 1.0, 3.0, 1.0, 1.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(3, cuts.size());
// EXPECT_NEAR(1, cuts.at(0), margin);
// EXPECT_NEAR(1.66667, cuts.at(1), margin);
// EXPECT_NEAR(3.0, cuts.at(2), margin);
// auto labels = transform(X);
// labels_t expected = { 1, 0, 0, 1, 0, 0, 1, 0, 0 };
// EXPECT_EQ(expected, labels);
// ASSERT_EQ(3.0, X[0]); // X is not modified
// }
// TEST_F(TestBinDisc4U, Easy4BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(3.75, cuts.at(1), margin);
// EXPECT_NEAR(6.5, cuts.at(2), margin);
// EXPECT_NEAR(9.25, cuts.at(3), margin);
// EXPECT_NEAR(12.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4Q, Easy4BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(3.75, cuts.at(1), margin);
// EXPECT_NEAR(6.5, cuts.at(2), margin);
// EXPECT_NEAR(9.25, cuts.at(3), margin);
// EXPECT_NEAR(12.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4U, X13BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.0, cuts.at(1), margin);
// EXPECT_NEAR(7.0, cuts.at(2), margin);
// EXPECT_NEAR(10.0, cuts.at(3), margin);
// EXPECT_NEAR(13.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4Q, X13BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.0, cuts.at(1), margin);
// EXPECT_NEAR(7.0, cuts.at(2), margin);
// EXPECT_NEAR(10.0, cuts.at(3), margin);
// EXPECT_NEAR(13.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4U, X14BinsUniform)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.25, cuts.at(1), margin);
// EXPECT_NEAR(7.5, cuts.at(2), margin);
// EXPECT_NEAR(10.75, cuts.at(3), margin);
// EXPECT_NEAR(14.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4Q, X14BinsQuantile)
// {
// samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.25, cuts.at(1), margin);
// EXPECT_NEAR(7.5, cuts.at(2), margin);
// EXPECT_NEAR(10.75, cuts.at(3), margin);
// EXPECT_NEAR(14.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4U, X15BinsUniform)
// {
// samples_t X = { 15.0, 8.0, 12.0, 14.0, 6.0, 1.0, 13.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.5, cuts.at(1), margin);
// EXPECT_NEAR(8, cuts.at(2), margin);
// EXPECT_NEAR(11.5, cuts.at(3), margin);
// EXPECT_NEAR(15.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 3, 1, 3, 3, 1, 0, 3, 2, 2, 2, 1, 0, 0, 1, 0 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4Q, X15BinsQuantile)
// {
// samples_t X = { 15.0, 13.0, 12.0, 14.0, 6.0, 1.0, 8.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0 };
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(1.0, cuts.at(0), margin);
// EXPECT_NEAR(4.5, cuts.at(1), margin);
// EXPECT_NEAR(8, cuts.at(2), margin);
// EXPECT_NEAR(11.5, cuts.at(3), margin);
// EXPECT_NEAR(15.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 3, 3, 3, 3, 1, 0, 1, 2, 2, 2, 1, 0, 0, 1, 0 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4U, RepeatedValuesUniform)
// {
// samples_t X = { 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0 };
// // 0 1 2 3 4 5 6 7 8 9
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(0.0, cuts.at(0), margin);
// EXPECT_NEAR(1.0, cuts.at(1), margin);
// EXPECT_NEAR(2.0, cuts.at(2), margin);
// EXPECT_NEAR(3.0, cuts.at(3), margin);
// EXPECT_NEAR(4.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 2, 2, 2, 3 };
// EXPECT_EQ(expected, labels);
// }
// TEST_F(TestBinDisc4Q, RepeatedValuesQuantile)
// {
// samples_t X = { 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0 };
// // 0 1 2 3 4 5 6 7 8 9
// fit(X);
// auto cuts = getCutPoints();
// ASSERT_EQ(5, cuts.size());
// EXPECT_NEAR(0.0, cuts.at(0), margin);
// EXPECT_NEAR(1.0, cuts.at(1), margin);
// EXPECT_NEAR(2.0, cuts.at(2), margin);
// EXPECT_NEAR(3.0, cuts.at(3), margin);
// EXPECT_NEAR(4.0, cuts.at(4), margin);
// auto labels = transform(X);
// labels_t expected = { 0, 0, 0, 0, 1, 1, 2, 2, 2, 3 };
// EXPECT_EQ(expected, labels);
// }
TEST_F(TestBinDisc3U, Easy3BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
auto y = labels_t();
fit(X, y);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(3.66667, cuts.at(1), margin);
EXPECT_NEAR(6.33333, cuts.at(2), margin);
EXPECT_NEAR(9.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3Q, Easy3BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts[0], margin);
EXPECT_NEAR(3.666667, cuts[1], margin);
EXPECT_NEAR(6.333333, cuts[2], margin);
EXPECT_NEAR(9, cuts[3], margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3U, X10BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(4.0, cuts.at(1), margin);
EXPECT_NEAR(7.0, cuts.at(2), margin);
EXPECT_NEAR(10.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3Q, X10BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(4.0, cuts.at(1), margin);
EXPECT_NEAR(7.0, cuts.at(2), margin);
EXPECT_NEAR(10.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3U, X11BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(4.33333, cuts.at(1), margin);
EXPECT_NEAR(7.66667, cuts.at(2), margin);
EXPECT_NEAR(11.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3U, X11BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(4.33333, cuts.at(1), margin);
EXPECT_NEAR(7.66667, cuts.at(2), margin);
EXPECT_NEAR(11.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3U, ConstantUniform)
{
samples_t X = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(2, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(1, cuts.at(1), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 0, 0 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3Q, ConstantQuantile)
{
samples_t X = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(2, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(1, cuts.at(1), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 0, 0 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc3U, EmptyUniform)
{
samples_t X = {};
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(2, cuts.size());
EXPECT_NEAR(0, cuts.at(0), margin);
EXPECT_NEAR(0, cuts.at(1), margin);
}
TEST_F(TestBinDisc3Q, EmptyQuantile)
{
samples_t X = {};
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(2, cuts.size());
EXPECT_NEAR(0, cuts.at(0), margin);
EXPECT_NEAR(0, cuts.at(1), margin);
}
TEST(TestBinDisc3, ExceptionNumberBins)
{
EXPECT_THROW(BinDisc(2), std::invalid_argument);
}
TEST_F(TestBinDisc3U, EasyRepeated)
{
samples_t X = { 3.0, 1.0, 1.0, 3.0, 1.0, 1.0, 3.0, 1.0, 1.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(4, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(1.66667, cuts.at(1), margin);
EXPECT_NEAR(2.33333, cuts.at(2), margin);
EXPECT_NEAR(3.0, cuts.at(3), margin);
auto labels = transform(X);
labels_t expected = { 2, 0, 0, 2, 0, 0, 2, 0, 0 };
EXPECT_EQ(expected, labels);
ASSERT_EQ(3.0, X[0]); // X is not modified
}
TEST_F(TestBinDisc3Q, EasyRepeated)
{
samples_t X = { 3.0, 1.0, 1.0, 3.0, 1.0, 1.0, 3.0, 1.0, 1.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(3, cuts.size());
EXPECT_NEAR(1, cuts.at(0), margin);
EXPECT_NEAR(1.66667, cuts.at(1), margin);
EXPECT_NEAR(3.0, cuts.at(2), margin);
auto labels = transform(X);
labels_t expected = { 1, 0, 0, 1, 0, 0, 1, 0, 0 };
EXPECT_EQ(expected, labels);
ASSERT_EQ(3.0, X[0]); // X is not modified
}
TEST_F(TestBinDisc4U, Easy4BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(3.75, cuts.at(1), margin);
EXPECT_NEAR(6.5, cuts.at(2), margin);
EXPECT_NEAR(9.25, cuts.at(3), margin);
EXPECT_NEAR(12.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4Q, Easy4BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(3.75, cuts.at(1), margin);
EXPECT_NEAR(6.5, cuts.at(2), margin);
EXPECT_NEAR(9.25, cuts.at(3), margin);
EXPECT_NEAR(12.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4U, X13BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.0, cuts.at(1), margin);
EXPECT_NEAR(7.0, cuts.at(2), margin);
EXPECT_NEAR(10.0, cuts.at(3), margin);
EXPECT_NEAR(13.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4Q, X13BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.0, cuts.at(1), margin);
EXPECT_NEAR(7.0, cuts.at(2), margin);
EXPECT_NEAR(10.0, cuts.at(3), margin);
EXPECT_NEAR(13.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4U, X14BinsUniform)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.25, cuts.at(1), margin);
EXPECT_NEAR(7.5, cuts.at(2), margin);
EXPECT_NEAR(10.75, cuts.at(3), margin);
EXPECT_NEAR(14.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4Q, X14BinsQuantile)
{
samples_t X = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.25, cuts.at(1), margin);
EXPECT_NEAR(7.5, cuts.at(2), margin);
EXPECT_NEAR(10.75, cuts.at(3), margin);
EXPECT_NEAR(14.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4U, X15BinsUniform)
{
samples_t X = { 15.0, 8.0, 12.0, 14.0, 6.0, 1.0, 13.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.5, cuts.at(1), margin);
EXPECT_NEAR(8, cuts.at(2), margin);
EXPECT_NEAR(11.5, cuts.at(3), margin);
EXPECT_NEAR(15.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 3, 2, 3, 3, 1, 0, 3, 2, 2, 2, 1, 0, 0, 1, 0 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4Q, X15BinsQuantile)
{
samples_t X = { 15.0, 13.0, 12.0, 14.0, 6.0, 1.0, 8.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0 };
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(1.0, cuts.at(0), margin);
EXPECT_NEAR(4.5, cuts.at(1), margin);
EXPECT_NEAR(8, cuts.at(2), margin);
EXPECT_NEAR(11.5, cuts.at(3), margin);
EXPECT_NEAR(15.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 3, 3, 3, 3, 1, 0, 2, 2, 2, 2, 1, 0, 0, 1, 0 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4U, RepeatedValuesUniform)
{
samples_t X = { 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0 };
// 0 1 2 3 4 5 6 7 8 9
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(0.0, cuts.at(0), margin);
EXPECT_NEAR(1.0, cuts.at(1), margin);
EXPECT_NEAR(2.0, cuts.at(2), margin);
EXPECT_NEAR(3.0, cuts.at(3), margin);
EXPECT_NEAR(4.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 1, 1, 1, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST_F(TestBinDisc4Q, RepeatedValuesQuantile)
{
samples_t X = { 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0 };
// 0 1 2 3 4 5 6 7 8 9
fit(X);
auto cuts = getCutPoints();
ASSERT_EQ(5, cuts.size());
EXPECT_NEAR(0.0, cuts.at(0), margin);
EXPECT_NEAR(1.0, cuts.at(1), margin);
EXPECT_NEAR(2.0, cuts.at(2), margin);
EXPECT_NEAR(3.0, cuts.at(3), margin);
EXPECT_NEAR(4.0, cuts.at(4), margin);
auto labels = transform(X);
labels_t expected = { 0, 1, 1, 1, 2, 2, 3, 3, 3, 3 };
EXPECT_EQ(expected, labels);
}
TEST(TestBinDiscGeneric, Fileset)
{
Experiments exps(data_path + "tests.txt");
@@ -355,7 +355,7 @@ namespace mdlp {
++num;
Experiment exp = exps.next();
BinDisc disc(exp.n_bins_, exp.strategy_[0] == 'Q' ? strategy_t::QUANTILE : strategy_t::UNIFORM);
std::vector<float> test;
std::vector<precision_t> test;
if (exp.type_ == experiment_t::RANGE) {
for (float i = exp.from_; i < exp.to_; i += exp.step_) {
test.push_back(i);
@@ -370,19 +370,30 @@ namespace mdlp {
EXPECT_EQ(exp.discretized_data_.size(), Xt.size());
auto flag = false;
size_t n_errors = 0;
for (int i = 0; i < exp.discretized_data_.size(); ++i) {
if (exp.discretized_data_.at(i) != Xt.at(i)) {
if (!flag) {
std::cout << "Exp #: " << num << " From: " << exp.from_ << " To: " << exp.to_ << " Step: " << exp.step_ << " Bins: " << exp.n_bins_ << " Strategy: " << exp.strategy_ << std::endl;
std::cout << "Error at " << i << " Expected: " << exp.discretized_data_.at(i) << " Got: " << Xt.at(i) << std::endl;
flag = true;
EXPECT_EQ(exp.discretized_data_.at(i), Xt.at(i));
if (num < 40) {
//
// Check discretization of only the first 40 tests as after we cannot ensure the same codification due to precision problems
//
for (int i = 0; i < exp.discretized_data_.size(); ++i) {
if (exp.discretized_data_.at(i) != Xt.at(i)) {
if (!flag) {
if (exp.type_ == experiment_t::RANGE)
std::cout << "+Exp #: " << num << " From: " << exp.from_ << " To: " << exp.to_ << " Step: " << exp.step_ << " Bins: " << exp.n_bins_ << " Strategy: " << exp.strategy_ << std::endl;
else {
std::cout << "+Exp #: " << num << " strategy: " << exp.strategy_ << " " << " n_bins: " << exp.n_bins_ << " ";
show_vector(exp.dataset_, "Dataset");
}
show_vector(cuts, "Cuts");
std::cout << "Error at " << i << " test[i]=" << test.at(i) << " Expected: " << exp.discretized_data_.at(i) << " Got: " << Xt.at(i) << std::endl;
flag = true;
EXPECT_EQ(exp.discretized_data_.at(i), Xt.at(i));
}
n_errors++;
}
n_errors++;
}
}
if (flag) {
std::cout << "*** Found " << n_errors << " mistakes in this experiment dataset" << std::endl;
if (flag) {
std::cout << "*** Found " << n_errors << " mistakes in this experiment dataset" << std::endl;
}
}
EXPECT_EQ(exp.cutpoints_.size(), cuts.size());
for (int i = 0; i < exp.cutpoints_.size(); ++i) {

53
tests/Discretizer_unittest.cpp
View File

@@ -29,33 +29,32 @@ namespace mdlp {
std::cout << "Version computed: " << version;
EXPECT_EQ("1.2.3", version);
}
// TEST(Discretizer, BinIrisUniform)
// {
// ArffFiles file;
// Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
// file.load(data_path + "iris.arff", true);
// vector<samples_t>& X = file.getX();
// auto y = labels_t();
// disc->fit(X[0], y);
// auto Xt = disc->transform(X[0]);
// labels_t expected = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 2, 2, 1, 2, 1, 2, 0, 2, 0, 0, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 0, 1, 1, 1, 2, 0, 1, 2, 1, 3, 2, 2, 3, 0, 3, 2, 3, 2, 2, 2, 1, 1, 2, 2, 3, 3, 1, 2, 1, 3, 2, 2, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
// delete disc;
// EXPECT_EQ(expected, Xt);
// }
// TEST(Discretizer, BinIrisQuantile)
// {
// ArffFiles file;
// Discretizer* disc = new BinDisc(4, strategy_t::QUANTILE);
// file.load(data_path + "iris.arff", true);
// vector<samples_t>& X = file.getX();
// auto y = labels_t();
// disc->fit(X[0], y);
// auto Xt = disc->transform(X[0]);
// labels_t expected = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 3, 3, 1, 3, 1, 2, 0, 3, 1, 0, 2, 2, 2, 1, 3, 1, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2, 1, 2, 3, 2, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3, 3, 3, 3, 3, 3, 1, 2, 3, 3, 3, 3, 2, 3, 1, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 2, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
// delete disc;
// EXPECT_EQ(expected, Xt);
// }
TEST(Discretizer, BinIrisUniform)
{
ArffFiles file;
Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
file.load(data_path + "iris.arff", true);
vector<samples_t>& X = file.getX();
auto y = labels_t();
disc->fit(X[0], y);
auto Xt = disc->transform(X[0]);
labels_t expected = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 2, 2, 1, 2, 1, 2, 0, 2, 0, 0, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 0, 1, 1, 1, 2, 0, 1, 2, 1, 3, 2, 2, 3, 0, 3, 2, 3, 2, 2, 2, 1, 1, 2, 2, 3, 3, 1, 2, 1, 3, 2, 2, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
delete disc;
EXPECT_EQ(expected, Xt);
}
TEST(Discretizer, BinIrisQuantile)
{
ArffFiles file;
Discretizer* disc = new BinDisc(4, strategy_t::QUANTILE);
file.load(data_path + "iris.arff", true);
vector<samples_t>& X = file.getX();
auto y = labels_t();
disc->fit(X[0], y);
auto Xt = disc->transform(X[0]);
labels_t expected = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 3, 3, 1, 3, 1, 2, 0, 3, 1, 0, 2, 2, 2, 1, 3, 1, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2, 1, 2, 3, 2, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3, 3, 3, 3, 3, 3, 1, 2, 3, 3, 3, 3, 2, 3, 1, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 2, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
delete disc;
EXPECT_EQ(expected, Xt);
}
TEST(Discretizer, FImdlpIris)
{

14
tests/Experiments.hpp
View File

@@ -25,13 +25,13 @@ enum class experiment_t {
};
class Experiment {
public:
Experiment(float from_, float to_, float step_, int n_bins, std::string strategy, std::vector<int> data_discretized, std::vector<float> cutpoints) :
Experiment(float from_, float to_, float step_, int n_bins, std::string strategy, std::vector<int> data_discretized, std::vector<mdlp::precision_t> cutpoints) :
from_{ from_ }, to_{ to_ }, step_{ step_ }, n_bins_{ n_bins }, strategy_{ strategy }, discretized_data_{ data_discretized }, cutpoints_{ cutpoints }, type_{ experiment_t::RANGE }
{
validate_strategy();
}
Experiment(std::vector<float> dataset, int n_bins, std::string strategy, std::vector<int> data_discretized, std::vector<float> cutpoints) :
Experiment(std::vector<mdlp::precision_t> dataset, int n_bins, std::string strategy, std::vector<int> data_discretized, std::vector<mdlp::precision_t> cutpoints) :
n_bins_{ n_bins }, strategy_{ strategy }, dataset_{ dataset }, discretized_data_{ data_discretized }, cutpoints_{ cutpoints }, type_{ experiment_t::VECTOR }
{
validate_strategy();
@@ -47,9 +47,9 @@ public:
float step_;
int n_bins_;
std::string strategy_;
std::vector<float> dataset_;
std::vector<mdlp::precision_t> dataset_;
std::vector<int> discretized_data_;
std::vector<float> cutpoints_;
std::vector<mdlp::precision_t> cutpoints_;
experiment_t type_;
};
class Experiments {
@@ -112,9 +112,9 @@ private:
// split data into variables
float from_, to_, step_;
int n_bins;
std::vector<float> dataset;
std::vector<mdlp::precision_t> dataset;
auto data_discretized = parse_vector<int>(data);
auto cutpoints = parse_vector<float>(cuts);
auto cutpoints = parse_vector<mdlp::precision_t>(cuts);
if (line == "RANGE") {
tie(from_, to_, step_, n_bins, strategy) = parse_header(experiment);
return Experiment{ from_, to_, step_, n_bins, strategy, data_discretized, cutpoints };
@@ -122,7 +122,7 @@ private:
strategy = experiment.substr(0, 1);
n_bins = std::stoi(experiment.substr(1, 1));
data = experiment.substr(3, experiment.size() - 4);
dataset = parse_vector<float>(data);
dataset = parse_vector<mdlp::precision_t>(data);
return Experiment(dataset, n_bins, strategy, data_discretized, cutpoints);
}
std::ifstream test_file;

1
tests/Testing/Temporary/CTestCostData.txt Normal file
View File

@@ -0,0 +1 @@
---

3
tests/Testing/Temporary/LastTest.log Normal file
View File

@@ -0,0 +1,3 @@
Start testing: Jul 03 18:09 CEST
----------------------------------------------------------
End testing: Jul 03 18:09 CEST

14
tests/datasets/tests.txt
View File

@@ -16,7 +16,7 @@ RANGE
0.0, 12.25, 24.5, 36.75, 49.0
RANGE
0, 100, 1, 3, Q
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
0.0, 33.0, 66.0, 99.0
RANGE
0, 50, 1, 3, Q
@@ -24,7 +24,7 @@ RANGE
0.0, 16.33333, 32.66667, 49.0
RANGE
0, 10, 1, 3, Q
0, 0, 0, 0, 1, 1, 1, 2, 2, 2
0, 0, 0, 1, 1, 1, 2, 2, 2, 2
0.0, 3.0, 6.0, 9.0
RANGE
0, 100, 1, 4, U
@@ -56,7 +56,7 @@ RANGE
1.0, 3.66667, 6.33333, 9.0
RANGE
1, 11, 1, 3, Q
0, 0, 0, 1, 1, 1, 1, 2, 2, 2
0, 0, 0, 1, 1, 1, 2, 2, 2, 2
1.0, 4.0, 7.0, 10.0
RANGE
1, 11, 1, 3, U
@@ -147,7 +147,7 @@ U3[15.0, 8.0, 12.0, 14.0, 6.0, 1.0, 13.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2
1.0, 5.66667, 10.33333, 15.0
VECTOR
Q3[0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0]
0, 0, 0, 0, 1, 1, 2, 2, 2, 2
0, 1, 1, 1, 1, 1, 2, 2, 2, 2
0.0, 1.0, 3.0, 4.0
VECTOR
U3[0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0]
@@ -178,7 +178,7 @@ Q3[3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.
2.0, 2.9, 3.2, 4.4
VECTOR
U3[3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3.0, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3.0, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3.0, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2.0, 3.0, 2.2, 2.9, 2.9, 3.1, 3.0, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3.0, 2.8, 3.0, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3.0, 3.4, 3.1, 2.3, 3.0, 2.5, 2.6, 3.0, 2.6, 2.3, 2.7, 3.0, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3.0, 2.9, 3.0, 3.0, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3.0, 2.5, 2.8, 3.2, 3.0, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3.0, 2.8, 3.0, 2.8, 3.8, 2.8, 2.8, 2.6, 3.0, 3.4, 3.1, 3.0, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3.0, 2.5, 3.0, 3.4, 3.0]
1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 2, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1
1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 1, 1, 0, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 1, 1, 2, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1
2.0, 2.8, 3.6, 4.4
VECTOR
Q4[3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3.0, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3.0, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3.0, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2.0, 3.0, 2.2, 2.9, 2.9, 3.1, 3.0, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3.0, 2.8, 3.0, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3.0, 3.4, 3.1, 2.3, 3.0, 2.5, 2.6, 3.0, 2.6, 2.3, 2.7, 3.0, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3.0, 2.9, 3.0, 3.0, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3.0, 2.5, 2.8, 3.2, 3.0, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3.0, 2.8, 3.0, 2.8, 3.8, 2.8, 2.8, 2.6, 3.0, 3.4, 3.1, 3.0, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3.0, 2.5, 3.0, 3.4, 3.0]
@@ -186,7 +186,7 @@ Q4[3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.
2.0, 2.8, 3.0, 3.3, 4.4
VECTOR
U4[3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3.0, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3.0, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3.0, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2.0, 3.0, 2.2, 2.9, 2.9, 3.1, 3.0, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3.0, 2.8, 3.0, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3.0, 3.4, 3.1, 2.3, 3.0, 2.5, 2.6, 3.0, 2.6, 2.3, 2.7, 3.0, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3.0, 2.9, 3.0, 3.0, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3.0, 2.5, 2.8, 3.2, 3.0, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3.0, 2.8, 3.0, 2.8, 3.8, 2.8, 2.8, 2.6, 3.0, 3.4, 3.1, 3.0, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3.0, 2.5, 3.0, 3.4, 3.0]
2, 1, 2, 1, 2, 3, 2, 2, 1, 1, 2, 2, 1, 1, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 3, 3, 1, 2, 2, 2, 1, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 0, 1, 1, 2, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 2, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 2, 2, 1, 1, 0, 1, 2, 1, 2, 1, 0, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 0, 1, 2, 1
2, 1, 2, 1, 2, 3, 2, 2, 1, 1, 2, 2, 1, 1, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 3, 3, 1, 2, 2, 2, 1, 2, 2, 0, 2, 2, 3, 1, 3, 2, 2, 2, 2, 2, 1, 0, 1, 1, 2, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 2, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 2, 2, 1, 1, 0, 1, 2, 1, 3, 1, 0, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 0, 1, 2, 1
2.0, 2.6, 3.2, 3.8, 4.4
VECTOR
Q3[1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1.0, 1.7, 1.9, 1.6, 1.6, 1.5, 1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4.0, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 3.5, 4.2, 4.0, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4.0, 4.9, 4.7, 4.3, 4.4, 4.8, 5.0, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4.0, 4.4, 4.6, 4.0, 3.3, 4.2, 4.2, 4.2, 4.3, 3.0, 4.1, 6.0, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5.0, 5.1, 5.3, 5.5, 6.7, 6.9, 5.0, 5.7, 4.9, 6.7, 4.9, 5.7, 6.0, 4.8, 4.9, 5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 5.7, 5.2, 5.0, 5.2, 5.4, 5.1]
@@ -218,5 +218,5 @@ Q4[0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.
0.1, 0.3, 1.3, 1.8, 2.5
VECTOR
U4[0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 1.0, 1.3, 1.4, 1.0, 1.5, 1.0, 1.4, 1.3, 1.4, 1.5, 1.0, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 1.3, 1.4, 1.4, 1.7, 1.5, 1.0, 1.1, 1.0, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 1.2, 1.4, 1.2, 1.0, 1.3, 1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 2.1, 1.7, 1.8, 1.8, 2.5, 2.0, 1.9, 2.1, 2.0, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2.0, 2.0, 1.8, 2.1, 1.8, 1.8, 1.8, 2.1, 1.6, 1.9, 2.0, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 2.1, 2.4, 2.3, 1.9, 2.3, 2.5, 2.3, 1.9, 2.0, 2.3, 1.8]
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 3, 3, 3, 2, 3, 3, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2, 2, 3, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 3, 3, 3, 2, 3, 3, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2, 2, 3, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2
0.1, 0.7, 1.3, 1.9, 2.5

BIN
tests/k
View File

Binary file not shown.

32
tests/k.cpp
View File

@@ -1,32 +0,0 @@
#include <iostream>
#include <vector>
#include <algorithm> // For std::lower_bound
std::vector<int> searchsorted(const std::vector<float>& cuts, const std::vector<float>& data) {
std::vector<int> indices;
indices.reserve(data.size());
for (const float& value : data) {
// Find the first position in 'a' where 'value' could be inserted to maintain order
auto it = std::lower_bound(cuts.begin(), cuts.end(), value);
// Calculate the index
int index = it - cuts.begin();
indices.push_back(index);
}
return indices;
}
int main() {
std::vector<float> cuts = { 10.0 };
std::vector<float> data = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
std::vector<int> result = searchsorted(cuts, data);
for (int idx : result) {
std::cout << idx << " ";
}
return 0;
}

BIN
tests/t
View File

Binary file not shown.

102
tests/t.cpp
View File

@@ -1,102 +0,0 @@
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
typedef float precision_t;
std::vector<int> transform(const std::vector<float> cutPoints, const std::vector<float>& data)
{
std::vector<int> discretizedData;
discretizedData.reserve(data.size());
for (const float& item : data) {
auto upper = std::lower_bound(cutPoints.begin(), cutPoints.end(), item);
discretizedData.push_back(upper - cutPoints.begin());
}
return discretizedData;
}
template <typename T>
void show_vector(const std::vector<T>& data, std::string title)
{
std::cout << title << ": ";
std::string sep = "";
for (const auto& d : data) {
std::cout << sep << d;
sep = ", ";
}
std::cout << std::endl;
}
std::vector<precision_t> linspace(precision_t start, precision_t end, int num)
{
if (start == end) {
return { start, end };
}
precision_t delta = (end - start) / static_cast<precision_t>(num - 1);
std::vector<precision_t> linspc;
for (size_t i = 0; i < num - 1; ++i) {
precision_t val = start + delta * static_cast<precision_t>(i);
linspc.push_back(val);
}
return linspc;
}
size_t clip(const size_t n, size_t lower, size_t upper)
{
return std::max(lower, std::min(n, upper));
}
std::vector<precision_t> percentile(std::vector<precision_t>& data, std::vector<precision_t>& percentiles)
{
// Implementation taken from https://dpilger26.github.io/NumCpp/doxygen/html/percentile_8hpp_source.html
std::vector<precision_t> results;
results.reserve(percentiles.size());
for (auto percentile : percentiles) {
const size_t i = static_cast<size_t>(std::floor(static_cast<double>(data.size() - 1) * percentile / 100.));
const auto indexLower = clip(i, 0, data.size() - 2);
const double percentI = static_cast<double>(indexLower) / static_cast<double>(data.size() - 1);
const double fraction =
(percentile / 100.0 - percentI) /
(static_cast<double>(indexLower + 1) / static_cast<double>(data.size() - 1) - percentI);
const auto value = data[indexLower] + (data[indexLower + 1] - data[indexLower]) * fraction;
if (value != results.back())
results.push_back(value);
}
return results;
}
int main()
{
// std::vector<float> test;
// std::vector<float> cuts = { 0, 24.75, 49.5, 74.25, 10000 };
// for (int i = 0; i < 100; ++i) {
// test.push_back(i);
// }
// auto Xt = transform(cuts, test);
// show_vector(Xt, "Discretized data:");
// std::vector<float> test2 = { 0,1,2,3,4,5,6,7,8,9,10,11 };
// std::vector<float> cuts2 = { 0,1,2,3,4,5,6,7,8,9 };
// auto Xt2 = transform(cuts2, test2);
// show_vector(Xt2, "discretized data2: ");
auto quantiles = linspace(0.0, 100.0, 3 + 1);
std::vector<float> data = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
std::vector<float> cutPoints;
std::sort(data.begin(), data.end());
cutPoints = percentile(data, quantiles);
cutPoints.push_back(std::numeric_limits<precision_t>::max());
data.push_back(15);
data.push_back(0);
cutPoints.pop_back();
cutPoints.erase(cutPoints.begin());
cutPoints.clear();
cutPoints.push_back(9.0);
auto Xt = transform(cutPoints, data);
show_vector(data, "Original data");
show_vector(Xt, "Discretized data");
show_vector(cutPoints, "Cutpoints");
return 0;
}
/*
n_bins = 3
data = [1,2,3,4,5,6,7,8,9,10]
quantiles = np.linspace(0, 100, n_bins + 1)
bin_edges = np.percentile(data, quantiles)
*/

2
tests/test
View File

@@ -8,7 +8,7 @@ fi
cmake -S . -B build -Wno-dev -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="--coverage" -DCMAKE_C_FLAGS="--coverage"
cmake --build build
cd build
ctest --output-on-failure
ctest --output-on-failure -j 8
cd ..
mkdir gcovr-report
cd ..

412
tests/testKbins.py
View File

@@ -1,412 +0,0 @@
from scipy.io.arff import loadarff
from sklearn.preprocessing import KBinsDiscretizer
def test(clf, X, expected, title):
X = [[x] for x in X]
clf.fit(X)
computed = [int(x[0]) for x in clf.transform(X)]
print(f"{title}")
print(f"{computed=}")
print(f"{expected=}")
assert computed == expected
print("-" * 80)
# Test Uniform Strategy
clf3u = KBinsDiscretizer(
n_bins=3, encode="ordinal", strategy="uniform", subsample=200_000
)
clf3q = KBinsDiscretizer(
n_bins=3, encode="ordinal", strategy="quantile", subsample=200_000
)
clf4u = KBinsDiscretizer(
n_bins=4, encode="ordinal", strategy="uniform", subsample=200_000
)
clf4q = KBinsDiscretizer(
n_bins=4, encode="ordinal", strategy="quantile", subsample=200_000
)
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
labels = [0, 0, 0, 1, 1, 1, 2, 2, 2]
test(clf3u, X, labels, title="Easy3BinsUniform")
test(clf3q, X, labels, title="Easy3BinsQuantile")
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
labels = [0, 0, 0, 1, 1, 1, 2, 2, 2, 2]
# En C++ se obtiene el mismo resultado en ambos, no como aquí
labels2 = [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]
test(clf3u, X, labels, title="X10BinsUniform")
test(clf3q, X, labels2, title="X10BinsQuantile")
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0]
labels = [0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2]
# En C++ se obtiene el mismo resultado en ambos, no como aquí
# labels2 = [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]
test(clf3u, X, labels, title="X11BinsUniform")
test(clf3q, X, labels, title="X11BinsQuantile")
#
X = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
labels = [0, 0, 0, 0, 0, 0]
test(clf3u, X, labels, title="ConstantUniform")
test(clf3q, X, labels, title="ConstantQuantile")
#
X = [3.0, 1.0, 1.0, 3.0, 1.0, 1.0, 3.0, 1.0, 1.0]
labels = [2, 0, 0, 2, 0, 0, 2, 0, 0]
labels2 = [1, 0, 0, 1, 0, 0, 1, 0, 0] # igual que en C++
test(clf3u, X, labels, title="EasyRepeatedUniform")
test(clf3q, X, labels2, title="EasyRepeatedQuantile")
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
labels = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]
test(clf4u, X, labels, title="Easy4BinsUniform")
test(clf4q, X, labels, title="Easy4BinsQuantile")
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0]
labels = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3]
test(clf4u, X, labels, title="X13BinsUniform")
test(clf4q, X, labels, title="X13BinsQuantile")
#
X = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0]
labels = [0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3]
test(clf4u, X, labels, title="X14BinsUniform")
test(clf4q, X, labels, title="X14BinsQuantile")
#
X1 = [15.0, 8.0, 12.0, 14.0, 6.0, 1.0, 13.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0]
X2 = [15.0, 13.0, 12.0, 14.0, 6.0, 1.0, 8.0, 11.0, 10.0, 9.0, 7.0, 4.0, 3.0, 5.0, 2.0]
labels1 = [3, 2, 3, 3, 1, 0, 3, 2, 2, 2, 1, 0, 0, 1, 0]
labels2 = [3, 3, 3, 3, 1, 0, 2, 2, 2, 2, 1, 0, 0, 1, 0]
test(clf4u, X1, labels1, title="X15BinsUniform")
test(clf4q, X2, labels2, title="X15BinsQuantile")
#
X = [0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0]
labels = [0, 1, 1, 1, 2, 2, 3, 3, 3, 3]
test(clf4u, X, labels, title="RepeatedValuesUniform")
test(clf4q, X, labels, title="RepeatedValuesQuantile")
print(f"Uniform {clf4u.bin_edges_=}")
print(f"Quaintile {clf4q.bin_edges_=}")
print("-" * 80)
#
data, meta = loadarff("tests/datasets/iris.arff")
labelsu = [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
1,
1,
1,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
3,
2,
2,
1,
2,
1,
2,
0,
2,
0,
0,
1,
1,
1,
1,
2,
1,
1,
2,
1,
1,
1,
2,
1,
2,
2,
2,
2,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
1,
1,
1,
1,
1,
0,
1,
1,
1,
2,
0,
1,
2,
1,
3,
2,
2,
3,
0,
3,
2,
3,
2,
2,
2,
1,
1,
2,
2,
3,
3,
1,
2,
1,
3,
2,
2,
3,
2,
1,
2,
3,
3,
3,
2,
2,
1,
3,
2,
2,
1,
2,
2,
2,
1,
2,
2,
2,
2,
2,
2,
1,
]
labelsq = [
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
2,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
0,
0,
1,
1,
0,
0,
1,
1,
1,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
1,
0,
1,
0,
1,
0,
3,
3,
3,
1,
3,
1,
2,
0,
3,
1,
0,
2,
2,
2,
1,
3,
1,
2,
2,
1,
2,
2,
2,
2,
3,
3,
3,
3,
2,
1,
1,
1,
2,
2,
1,
2,
3,
2,
1,
1,
1,
2,
2,
0,
1,
1,
1,
2,
1,
1,
2,
2,
3,
2,
3,
3,
0,
3,
3,
3,
3,
3,
3,
1,
2,
3,
3,
3,
3,
2,
3,
1,
3,
2,
3,
3,
2,
2,
3,
3,
3,
3,
3,
2,
2,
3,
2,
3,
2,
3,
3,
3,
2,
3,
3,
3,
2,
3,
2,
2,
]
# test(clf4u, data["sepallength"], labelsu, title="IrisUniform")
# test(clf4q, data["sepallength"], labelsq, title="IrisQuantile")
sepallength = [[x] for x in data["sepallength"]]
clf4u.fit(sepallength)
clf4q.fit(sepallength)
computedu = clf4u.transform(sepallength)
computedq = clf4q.transform(sepallength)
wrongu = 0
wrongq = 0
for i in range(len(labelsu)):
if labelsu[i] != computedu[i]:
wrongu += 1
if labelsq[i] != computedq[i]:
wrongq += 1
print(f"Iris sepallength diff. between BinDisc & sklearn::KBins Uniform ={wrongu:3d}")
print(f"Iris sepallength diff. between BinDisc & sklearn::KBins Quantile ={wrongq:3d}")

6
tests/tests_do.py
View File

@@ -29,6 +29,12 @@ for i in range(0, len(data), 4):
expected_data = data[i + 2]
cuts_data = data[i + 3]
disc.fit(X)
#
# Normalize the cutpoints to remove numerical errors such as 33.0000000001
# instead of 33
#
for j in range(len(disc.bin_edges_[0])):
disc.bin_edges_[0][j] = round(disc.bin_edges_[0][j], 5)
result = disc.transform(X)
result = [int(x) for x in result.flatten()]
expected = [int(x) for x in expected_data.split(",")]

75
tests/tests_generate.ipynb
View File

@@ -79,6 +79,15 @@
" sep = \", \"\n",
" file.write(\"\\n\")\n",
"\n",
"def normalize_cuts(cuts):\n",
" #\n",
" # Normalize the cutpoints to remove numerical errors such as 33.0000000001\n",
" # instead of 33\n",
" #\n",
" for k in range(cuts.shape[0]):\n",
" for i in range(len(cuts[k])):\n",
" cuts[k][i] = round(cuts[k][i], 5)\n",
"\n",
"with open(\"datasets/tests.txt\", \"w\") as file:\n",
" file.write(\"#\\n\")\n",
" file.write(\"# from, to, step, #bins, Q/U\\n\")\n",
@@ -97,6 +106,7 @@
" disc = KBinsDiscretizer(n_bins=bins_, encode='ordinal', strategy='quantile' if strategy.strip() == \"Q\" else 'uniform')\n",
" data = [[x] for x in range(from_, to_, step_)]\n",
" disc.fit(data)\n",
" normalize_cuts(disc.bin_edges_)\n",
" result = disc.transform(data)\n",
" file.write(f\"{from_}, {to_}, {step_}, {bins_}, {strategy}\\n\")\n",
" write_lists(file, result, disc.bin_edges_[0])\n",
@@ -117,7 +127,9 @@
" strategy=\"quantile\" if strategy.strip() == \"Q\" else \"uniform\",\n",
" )\n",
" data = [[x] for x in experiment]\n",
" result = disc.fit_transform(data)\n",
" disc.fit(data)\n",
" normalize_cuts(disc.bin_edges_)\n",
" result = disc.transform(data)\n",
" write_lists(file, result, disc.bin_edges_[0])\n",
" #\n",
" # Vector experiments iris\n",
@@ -137,65 +149,40 @@
" encode=\"ordinal\",\n",
" strategy=\"quantile\" if strategy.strip() == \"Q\" else \"uniform\")\n",
" data = [[x] for x in experiment]\n",
" result = disc.fit_transform(data)\n",
" disc.fit(data)\n",
" normalize_cuts(disc.bin_edges_)\n",
" result = disc.transform(data)\n",
" write_lists(file, result, disc.bin_edges_[0])"
]
},
{
"cell_type": "code",
"execution_count": 10,
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cut points [array([ 0., 33., 66., 99.])]\n",
"i=32 X[32]=[32] result[32]=[0.]\n",
"i=33 X[33]=[33] result[33]=[1.]\n",
"i=34 X[34]=[34] result[34]=[1.]\n",
"i=65 X[65]=[65] result[65]=[1.]\n",
"i=66 X[66]=[66] result[66]=[2.]\n",
"i=67 X[67]=[67] result[67]=[2.]\n"
"Cut points: [array([ 0., 33., 66., 99.])]\n",
"Mistaken transformed data disc.transform([[33]]) = [[0.]]\n",
"Reason of the mistake the cutpoint has decimals (double): 33.00000000000001\n"
]
}
],
"source": [
"X = [[x] for x in range(100)]\n",
"disc = KBinsDiscretizer(n_bins=3, encode=\"ordinal\", strategy=\"uniform\")\n",
"result = disc.fit_transform(X)\n",
"print(\"Cut points\", disc.bin_edges_)\n",
"test = [32, 33, 34, 65, 66, 67]\n",
"for i in test:\n",
" print(f\"{i=} X[{i}]={X[i]} result[{i}]={result[i]}\")"
"#\n",
"# Proving the mistakes due to floating point precision\n",
"#\n",
"from sklearn.preprocessing import KBinsDiscretizer\n",
"\n",
"data = [[x] for x in range(100)]\n",
"disc = KBinsDiscretizer(n_bins=3, encode=\"ordinal\", strategy=\"quantile\")\n",
"disc.fit(data)\n",
"print(\"Cut points: \", disc.bin_edges_)\n",
"print(\"Mistaken transformed data disc.transform([[33]]) =\", disc.transform([[33]]))\n",
"print(\"Reason of the mistake the cutpoint has decimals (double): \", disc.bin_edges_[0][1])"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"right [0 1 1 1 2 2]\n",
"left [0 0 1 1 1 2]\n"
]
}
],
"source": [
"import numpy as np\n",
"print(\"right\", np.searchsorted(disc.bin_edges_[0][1:-1],test, side=\"right\"))\n",
"print(\"left \", np.searchsorted(disc.bin_edges_[0][1:-1],test))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {