diff options
Diffstat (limited to 'elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans')
26 files changed, 931 insertions, 19 deletions
diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestCLARA.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARATest.java index f9c0b779..89599bda 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestCLARA.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARATest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestCLARA extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class CLARATest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run CLARA with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java new file mode 100644 index 00000000..bab15c09 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java @@ -0,0 +1,68 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for batched Lloyd k-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansBatchedLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansBatchedLloyd() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + params.addParameter(KMeansBatchedLloyd.Parameterizer.BLOCKS_ID, 10); + params.addParameter(KMeansBatchedLloyd.Parameterizer.RANDOM_ID, 0); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansBatchedLloyd.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansBisecting.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisectingTest.java index 06d55028..cb407e28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansBisecting.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisectingTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KMeansBisecting * * @author Stephan Baier + * @since 0.6.0 */ -public class TestKMeansBisecting extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansBisectingTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeansBisecting with fixed parameters and compare cluster size to * expected value. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java new file mode 100644 index 00000000..fead9461 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java @@ -0,0 +1,66 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for Compare k-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansCompareTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansCompare() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansCompare.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansElkan.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkanTest.java index 95f28c5d..2d1cbe5a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansElkan.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkanTest.java @@ -35,26 +35,27 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** - * Regression test for Hamerly k-means. - * + * Regression test for Elkan k-means. + * * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansElkan extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansElkanTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException */ @Test - public void testKMeansLloyd() { + public void testKMeansElkan() { Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); // Setup algorithm ListParameterization params = new ListParameterization(); params.addParameter(KMeans.K_ID, 5); params.addParameter(KMeans.SEED_ID, 2); - AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansHamerly.class, params); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansElkan.class, params); testParameterizationOk(params); // run KMeans on database diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansHamerly.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerlyTest.java index e709861e..328211fb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansHamerly.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerlyTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Regression test for Hamerly k-means. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansHamerly extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansHamerlyTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. @@ -47,7 +48,7 @@ public class TestKMeansHamerly extends AbstractSimpleAlgorithmTest implements JU * @throws ParameterException */ @Test - public void testKMeansLloyd() { + public void testKMeansHamerly() { Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); // Setup algorithm diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java new file mode 100644 index 00000000..390f5c3d --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a full KMeans run, and compares the result with a clustering derived + * from the data set labels. This test ensures that KMeans's performance doesn't + * unexpectedly drop on this data set (and also ensures that the algorithms + * work, as a side effect). + * + * @author Katharina Rausch + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansHybridLloydMacQueenTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansHybridLloydMacQueen() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansHybridLloydMacQueen.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansLloyd.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloydTest.java index 15d73657..a0edbe5e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansLloyd.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloydTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansLloyd extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansMacQueen.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueenTest.java index b4289b9f..6271929d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansMacQueen.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueenTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansMacQueen extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansMacQueenTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java new file mode 100644 index 00000000..b7b20097 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java @@ -0,0 +1,66 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for Sort-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansSortTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansSort() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansSort.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMediansLloyd.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloydTest.java index ab451cab..c7abf806 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMediansLloyd.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloydTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMediansLloyd extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMediansLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedians with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsEM.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEMTest.java index ecfafffe..eee1c799 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsEM.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEMTest.java @@ -41,8 +41,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMedoidsEM extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMedoidsEMTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedoidsEM with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsPAM.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAMTest.java index 4bb98041..a7fe2712 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsPAM.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAMTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMedoidsPAM extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMedoidsPAMTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedians PAM with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java new file mode 100644 index 00000000..c20790b9 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java @@ -0,0 +1,67 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a full KMeans run, and compares the result with a clustering derived + * from the data set labels. This test ensures that KMeans's performance doesn't + * unexpectedly drop on this data set (and also ensures that the algorithms + * work, as a side effect). + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SingleAssignmentKMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + */ + @Test + public void testSingleAssignmentKMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + // Unsurprisingly, these results are much worse than normal k-means + testFMeasure(db, result, 0.7936860577); + testClusterSizes(result, new int[] { 52, 151, 200, 201, 396 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestXMeans.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeansTest.java index 58871f75..91ec25e2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestXMeans.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeansTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.4.0 */ -public class TestXMeans extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class XMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testXMeans() { Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java new file mode 100644 index 00000000..f077abf7 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FarthestPointsInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFarthestPointsInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, FarthestPointsInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.88132453); + testClusterSizes(result, new int[] { 128, 199, 201, 201, 271 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java new file mode 100644 index 00000000..2f592fb3 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FarthestSumPointsInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFarthestSumPointsInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, FarthestSumPointsInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.80399668933); + testClusterSizes(result, new int[] { 32, 169, 199, 201, 399 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java new file mode 100644 index 00000000..dbcd91da --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java @@ -0,0 +1,69 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FirstKInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFirstKInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.INIT_ID, FirstKInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.62025907); + testClusterSizes(result, new int[] { 23, 38, 226, 258, 455 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java new file mode 100644 index 00000000..0b9355e3 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansPlusPlusInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testSingleAssignmentKMeansPlusPlus() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, KMeansPlusPlusInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.99800500); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java new file mode 100644 index 00000000..c0d2b46d --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java @@ -0,0 +1,69 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class PAMInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testPAMInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.INIT_ID, PAMInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.99800500); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java new file mode 100644 index 00000000..a1e36fde --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class RandomlyChosenInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testRandomlyChosenInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, RandomlyChosenInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.793686); + testClusterSizes(result, new int[] { 52, 151, 200, 201, 396 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java new file mode 100644 index 00000000..045e6b4f --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class RandomlyGeneratedInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testRandomlyGeneratedInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, RandomlyGeneratedInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.7597720973); + testClusterSizes(result, new int[] { 66, 200, 200, 245, 289 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java new file mode 100644 index 00000000..9d9e4a2a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java @@ -0,0 +1,74 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SampleKMeansInitializationTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testSampleKMeansInitialization() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, SampleKMeansInitialization.class); + params.addParameter(SampleKMeansInitialization.Parameterizer.KMEANS_ID, KMeansHamerly.class); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(SampleKMeansInitialization.Parameterizer.SAMPLE_ID, 100); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.780753320); + testClusterSizes(result, new int[] { 75, 125, 200, 205, 395 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/TestParallelLloydKMeans.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeansTest.java index a396cf73..cf6151cf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/TestParallelLloydKMeans.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeansTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestParallelLloydKMeans extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelLloydKMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterMeanDistanceQualityMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasureTest.java index f4531305..d2f619e7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterMeanDistanceQualityMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasureTest.java @@ -47,8 +47,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Test cluster quality measure computations. * * @author Stephan Baier + * @since 0.6.0 */ -public class TestWithinClusterMeanDistanceQualityMeasure extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class WithinClusterMeanDistanceQualityMeasureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Test cluster average overall distance. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterVarianceQualityMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasureTest.java index 57b6ba75..eee4bf74 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterVarianceQualityMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasureTest.java @@ -47,8 +47,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Test cluster quality measure computations. * * @author Stephan Baier + * @since 0.6.0 */ -public class TestWithinClusterVarianceQualityMeasure extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class WithinClusterVarianceQualityMeasureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Test cluster variance. */ |