diff options
Diffstat (limited to 'elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier')
44 files changed, 1247 insertions, 91 deletions
diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java new file mode 100644 index 00000000..e4d1aaf2 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java @@ -0,0 +1,108 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredAutotuningRunner; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.RANSACCovarianceMatrixBuilder; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.WeightedCovarianceMatrixBuilder; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.ErfcWeight; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the COP algorithm. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class COPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testCOP() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.89476666); + testSingleScore(result, 416, 0.26795866); + } + + @Test + public void testCOPRobust() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + params.addParameter(COP.Parameterizer.PCARUNNER_ID, PCAFilteredAutotuningRunner.class); + params.addParameter(PCAFilteredAutotuningRunner.Parameterizer.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); + params.addParameter(WeightedCovarianceMatrixBuilder.Parameterizer.WEIGHT_ID, ErfcWeight.class); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.90166666); + testSingleScore(result, 416, 0.25705955); + } + + + @Test + public void testCOPRANSAC() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + params.addParameter(COP.Parameterizer.PCARUNNER_ID, PCAFilteredAutotuningRunner.class); + params.addParameter(PCAFilteredAutotuningRunner.Parameterizer.PCA_COVARIANCE_MATRIX, RANSACCovarianceMatrixBuilder.class); + params.addParameter(RANSACCovarianceMatrixBuilder.Parameterizer.ITER_ID, 25); + params.addParameter(RANSACCovarianceMatrixBuilder.Parameterizer.SEED_ID, 0); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.89269999); + testSingleScore(result, 416, 0.38287932); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java new file mode 100644 index 00000000..24bf71ca --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java @@ -0,0 +1,60 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the DWOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class DWOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testDWOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(DWOF.Parameterizer.K_ID, 20); + + // setup Algorithm + DWOF<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(DWOF.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.8098666); + testSingleScore(result, 416, 6.95226128); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianModel.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModelTest.java index 588222bd..53bb618c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianModel.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModelTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the GaussianModel algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestGaussianModel extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class GaussianModelTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testGaussianModel() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianUniformMixture.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixtureTest.java index 7c508b27..d42b4324 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianUniformMixture.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixtureTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the GaussianUniformMixture algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestGaussianUniformMixture extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class GaussianUniformMixtureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testGaussianUniformMixture() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestOPTICSOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOFTest.java index 6e04129e..3feb2450 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestOPTICSOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOFTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the OPTICS-OF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestOPTICSOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class OPTICSOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testOPTICSOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java new file mode 100644 index 00000000..effcd9b7 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java @@ -0,0 +1,60 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the SimpleCOP algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SimpleCOPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testSimpleCOP() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(SimpleCOP.Parameterizer.K_ID, 50); + + // setup Algorithm + SimpleCOP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(SimpleCOP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.833); + testSingleScore(result, 416, 0.); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABODTest.java index 00f93cfc..a216dade 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABODTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Note: we don't implement JUnit4Test, as this test is slow. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestABOD extends AbstractSimpleAlgorithmTest { +public class ABODTest extends AbstractSimpleAlgorithmTest { @Test public void testABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestFastABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABODTest.java index 6598c70d..ede44a57 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestFastABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABODTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the ABOD algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestFastABOD extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FastABODTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testFastABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestLBABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABODTest.java index 4b5b6920..aa5dc9ba 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestLBABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABODTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Note: we don't implement JUnit4Test, as this test is slow. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLBABOD extends AbstractSimpleAlgorithmTest { +public class LBABODTest extends AbstractSimpleAlgorithmTest { @Test public void testLBABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java new file mode 100644 index 00000000..590a7c29 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java @@ -0,0 +1,63 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + 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.em.EM; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the EM outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class EMOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testEMOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(EM.Parameterizer.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + EMOutlier<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(EMOutlier.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.54073333); + testSingleScore(result, 416, 0.00240242); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java new file mode 100644 index 00000000..8a40130a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java @@ -0,0 +1,64 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + 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.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KMeans outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testKMeansOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(KMeansOutlierDetection.Parameterizer.CLUSTERING_ID, KMeansHamerly.class); + params.addParameter(KMeans.K_ID, 10); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + KMeansOutlierDetection<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(KMeansOutlierDetection.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.86166666); + testSingleScore(result, 416, 0.01025466); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java new file mode 100644 index 00000000..0b43e532 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java @@ -0,0 +1,64 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + 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.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the Silhouette outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SilhouetteOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testSilhouetteOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(SilhouetteOutlierDetection.Parameterizer.CLUSTERING_ID, KMeansHamerly.class); + params.addParameter(KMeans.K_ID, 10); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + SilhouetteOutlierDetection<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(SilhouetteOutlierDetection.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.71993333); + testSingleScore(result, 416, 0.47335776); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierDetection.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetectionTest.java index 1c19366c..69ffff7d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierDetection.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetectionTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the DBOutlierDetection algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestDBOutlierDetection extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DBOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testDBOutlierDetection() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierScore.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScoreTest.java index 47fd73bf..cb70cabe 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierScore.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScoreTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the DBOutlierScore algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestDBOutlierScore extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DBOutlierScoreTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testDBOutlierScore() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java new file mode 100644 index 00000000..e1cd3a53 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KNNWeightOutlier algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class HilOutTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testHilOut() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(HilOut.Parameterizer.K_ID, 4); + params.addParameter(HilOut.Parameterizer.N_ID, 200); + + // setup Algorithm + HilOut<DoubleVector> hilout = ClassGenericsUtil.parameterizeOrAbort(HilOut.class, params); + testParameterizationOk(params); + + // run KNNWeightOutlier on database + OutlierResult result = hilout.run(db); + + testAUC(db, "Noise", result, 0.985398148); + testSingleScore(result, 945, 1.70927657); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlierTest.java index b7ac1bd8..2720ff28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestKNNOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KNNOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNWeightOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlierTest.java index 73f5db45..cb72b9d7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNWeightOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNWeightOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestKNNWeightOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KNNWeightOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNWeightOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestLocalIsolationCoefficient.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficientTest.java index c49beb5f..f781ed28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestLocalIsolationCoefficient.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficientTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LocalIsolationCoefficient algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestLocalIsolationCoefficient extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LocalIsolationCoefficientTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLocalIsolationCoefficient() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java new file mode 100644 index 00000000..1186bcac --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the ODIN algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ODINTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testODIN() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ODIN.Parameterizer.K_ID, 10); + + // setup Algorithm + ODIN<DoubleVector> odin = ClassGenericsUtil.parameterizeOrAbort(ODIN.class, params); + testParameterizationOk(params); + + // run KNNOutlier on database + OutlierResult result = odin.run(db); + + testSingleScore(result, 945, 0.7); + testAUC(db, "Noise", result, 0.9142037037); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java new file mode 100644 index 00000000..d9b96d09 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java @@ -0,0 +1,151 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + 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.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.AxisBasedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomGeneratedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomSampleReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.StarBasedReferencePoints; + +/** + * Tests the ReferenceBasedOutlierDetection algorithm. + * + * @author Lucia Cichella + * @author Erich Schubert + * @since 0.4.0 + */ +public class ReferenceBasedOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testReferenceBasedOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(GridBasedReferencePoints.Parameterizer.GRID_ID, 3); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.9693703703703); + testSingleScore(result, 945, 0.933574455); + } + + @Test + public void testReferenceBasedOutlierDetectionStar() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, StarBasedReferencePoints.class); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.910722222); + testSingleScore(result, 945, 0.920950222); + } + + @Test + public void testReferenceBasedOutlierDetectionAxis() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, AxisBasedReferencePoints.class); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.8110555); + testSingleScore(result, 945, 0.9523053); + } + + @Test + public void testReferenceBasedOutlierDetectionGenerated() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, RandomGeneratedReferencePoints.class); + params.addParameter(RandomGeneratedReferencePoints.Parameterizer.N_ID, 15); + params.addParameter(RandomGeneratedReferencePoints.Parameterizer.RANDOM_ID, 0); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.817407407); + testSingleScore(result, 945, 0.911353060); + } + + @Test + public void testReferenceBasedOutlierDetectionSample() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, RandomSampleReferencePoints.class); + params.addParameter(RandomSampleReferencePoints.Parameterizer.N_ID, 15); + params.addParameter(RandomSampleReferencePoints.Parameterizer.RANDOM_ID, 0); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.848472222); + testSingleScore(result, 945, 0.894389944); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java deleted file mode 100644 index de0991d0..00000000 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java +++ /dev/null @@ -1,61 +0,0 @@ -package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; - -/* - 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.database.Database; -import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; -import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; -import de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints; - -/** - * Tests the ReferenceBasedOutlierDetection algorithm. - * - * @author Lucia Cichella - */ -public class TestReferenceBasedOutlierDetection extends AbstractSimpleAlgorithmTest implements JUnit4Test { - @Test - public void testReferenceBasedOutlierDetection() { - Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); - - // Parameterization - ListParameterization params = new ListParameterization(); - params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); - params.addParameter(GridBasedReferencePoints.Parameterizer.GRID_ID, 3); - - // setup Algorithm - ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); - testParameterizationOk(params); - - // run ReferenceBasedOutlierDetection on database - OutlierResult result = referenceBasedOutlierDetection.run(db); - - testAUC(db, "Noise", result, 0.9418148148); - testSingleScore(result, 945, 0.87173403699); - } -}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlierTest.java index 3dfe5664..455f5730 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestParallelKNNOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelKNNOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNWeightOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlierTest.java index 7391bfed..1c298214 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNWeightOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNWeightOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestParallelKNNWeightOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelKNNWeightOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNWeightOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java new file mode 100644 index 00000000..378f8477 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the ALOCI algorithm. + * + * @author Lucia Cichella + * @since 0.4.0 + */ +public class ALOCITest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLOCI() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ALOCI.Parameterizer.SEED_ID, 0); + params.addParameter(ALOCI.Parameterizer.GRIDS_ID, 3); + + // setup Algorithm + ALOCI<DoubleVector> aloci = ClassGenericsUtil.parameterizeOrAbort(ALOCI.class, params); + testParameterizationOk(params); + + // run LOCI on database + OutlierResult result = aloci.run(db); + + testAUC(db, "Noise", result, 0.77011111); + testSingleScore(result, 146, 1.1242238186577); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java new file mode 100644 index 00000000..eac2f982 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the COF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class COFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testCOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COF.Parameterizer.K_ID, 10); + + // setup Algorithm + COF<DoubleVector> cof = ClassGenericsUtil.parameterizeOrAbort(COF.class, params); + testParameterizationOk(params); + + // run COF on database + OutlierResult result = cof.run(db); + + testSingleScore(result, 1293, 1.415457); + testAUC(db, "Noise", result, 0.8696806); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java new file mode 100644 index 00000000..c4165a00 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the LOF algorithm. + * + * @author Lucia Cichella + * @since 0.4.0 + */ +public class FlexibleLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testFlexibleLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(FlexibleLOF.Parameterizer.KREF_ID, 10); + + // setup Algorithm + FlexibleLOF<DoubleVector> flof = ClassGenericsUtil.parameterizeOrAbort(FlexibleLOF.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = flof.run(db); + + testSingleScore(result, 1293, 1.1945314199156365); + testAUC(db, "Noise", result, 0.8921680672268908); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestINFLO.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLOTest.java index 866effa6..d6c01b2a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestINFLO.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLOTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the INFLO algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestINFLO extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class INFLOTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testINFLO() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java new file mode 100644 index 00000000..096e3aa6 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java @@ -0,0 +1,65 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.EpanechnikovKernelDensityFunction; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KDEOS algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KDEOSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testKDEOS() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(KDEOS.Parameterizer.KERNEL_ID, EpanechnikovKernelDensityFunction.class); + params.addParameter(KDEOS.Parameterizer.KMIN_ID, 5); + params.addParameter(KDEOS.Parameterizer.KMAX_ID, 20); + params.addParameter(KDEOS.Parameterizer.KERNEL_SCALE_ID, 1.0); + + // setup Algorithm + KDEOS<DoubleVector> kdeos = ClassGenericsUtil.parameterizeOrAbort(KDEOS.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = kdeos.run(db); + + testAUC(db, "Noise", result, 0.7983529411764); + testSingleScore(result, 1293, 0.8788346606616); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java new file mode 100644 index 00000000..c724598b --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the LDF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class LDFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLDF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LDF.Parameterizer.K_ID, 10); + params.addParameter(LDF.Parameterizer.H_ID, 1); + + // setup Algorithm + LDF<DoubleVector> ldf = ClassGenericsUtil.parameterizeOrAbort(LDF.class, params); + testParameterizationOk(params); + + // run LDF on database + OutlierResult result = ldf.run(db); + + testSingleScore(result, 1293, 3.158819); + testAUC(db, "Noise", result, 0.9127619); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLDOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOFTest.java index c728e38e..8eb45790 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLDOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LDOF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLDOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LDOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLDOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOCI.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCITest.java index a2934701..2438f6cb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOCI.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCITest.java @@ -35,17 +35,18 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet /** * Tests the LOCI algorithm. - * + * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLOCI extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LOCITest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLOCI() { Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); // Parameterization ListParameterization params = new ListParameterization(); - params.addParameter(LOCI.RMAX_ID, 0.5); + params.addParameter(LOCI.Parameterizer.RMAX_ID, 0.5); // setup Algorithm LOCI<DoubleVector> loci = ClassGenericsUtil.parameterizeOrAbort(LOCI.class, params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOFTest.java index d54d760e..33ab6d2d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LOF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLoOP.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOPTest.java index 60dddb5d..110c02bd 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLoOP.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOPTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LoOP algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLoOP extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LoOPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLoOP() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestOnlineLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOFTest.java index f5fda922..947d6fcf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestOnlineLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOFTest.java @@ -63,9 +63,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * BUG: This currently does not appear to work correctly! * * @author Elke Achtert + * @since 0.4.0 */ @Ignore -public class TestOnlineLOF implements JUnit4Test { +public class OnlineLOFTest implements JUnit4Test { // the following values depend on the data set used! static String dataset = "data/testdata/unittests/3clusters-and-noise-2d.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java new file mode 100644 index 00000000..19223930 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java @@ -0,0 +1,63 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + 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.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.BiweightKernelDensityFunction; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the SimpleKernelDensityLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SimpleKernelDensityLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLDF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 20); + params.addParameter(SimpleKernelDensityLOF.Parameterizer.KERNEL_ID, BiweightKernelDensityFunction.class); + + // setup Algorithm + SimpleKernelDensityLOF<DoubleVector> klof = ClassGenericsUtil.parameterizeOrAbort(SimpleKernelDensityLOF.class, params); + testParameterizationOk(params); + + // run LDF on database + OutlierResult result = klof.run(db); + + testAUC(db, "Noise", result, 0.87192156); + testSingleScore(result, 1293, 12.271188); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestSimplifiedLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOFTest.java index 3ef40851..851bb5d6 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestSimplifiedLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LOF algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSimplifiedLOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SimplifiedLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testSimplifiedLOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestVarianceOfVolume.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolumeTest.java index 266e9f35..3cbe5b78 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestVarianceOfVolume.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolumeTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the Variance of Volume algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestVarianceOfVolume extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class VarianceOfVolumeTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testVOV() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); @@ -54,7 +55,7 @@ public class TestVarianceOfVolume extends AbstractSimpleAlgorithmTest implements // run LOF on database OutlierResult result = lof.run(db); - testSingleScore(result, 1293, 848349.0186); - testAUC(db, "Noise", result, 0.936448179271); + testSingleScore(result, 1293, 2.0733100852601836e13); + testAUC(db, "Noise", result, 0.9306946778); } }
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java new file mode 100644 index 00000000..7dcd568a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof.parallel; + +/* + 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.outlier.lof.LOF; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression tests the ParallelLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ParallelLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testParallelLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 10); + + // setup Algorithm + ParallelLOF<DoubleVector> lof = ClassGenericsUtil.parameterizeOrAbort(ParallelLOF.class, params); + testParameterizationOk(params); + + // run ParallelLOF on database + OutlierResult result = lof.run(db); + + testSingleScore(result, 1293, 1.1945314199156365); + testAUC(db, "Noise", result, 0.8921680672268908); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java new file mode 100644 index 00000000..5bea31e9 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof.parallel; + +/* + 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.outlier.lof.LOF; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression tests the parallel SimplifiedLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ParallelSimplifiedLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testParallelSimplifiedLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 10); + + // setup Algorithm + ParallelSimplifiedLOF<DoubleVector> lof = ClassGenericsUtil.parameterizeOrAbort(ParallelSimplifiedLOF.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = lof.run(db); + + testAUC(db, "Noise", result, 0.8892549019); + testSingleScore(result, 1293, 1.3025894); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestFeatureBagging.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBaggingTest.java index 91f20b28..b5fd84be 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestFeatureBagging.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBaggingTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the Feature Bagging algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestFeatureBagging extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FeatureBaggingTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testFeatureBaggingSum() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestHiCS.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCSTest.java index bb10269d..cfa904dc 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestHiCS.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCSTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the HiCS algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestHiCS extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class HiCSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testHiCSKS() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuEvolutionary.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionaryTest.java index 67168d3f..2961d6e7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuEvolutionary.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionaryTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the AggarwalYuEvolutionary algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestAggarwalYuEvolutionary extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AggarwalYuEvolutionaryTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testAggarwalYuEvolutionary() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuNaive.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaiveTest.java index 8ecdbe26..6e3eeb5d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuNaive.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaiveTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the AggarwalYuNaive algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestAggarwalYuNaive extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AggarwalYuNaiveTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testAggarwalYuNaive() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestSOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SODTest.java index d55f3f41..d7fee573 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestSOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SODTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the SOD algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestSOD extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SODTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testSOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); |