ELKI command line parameter overview:

de.lmu.ifi.dbs.elki.algorithm.DependencyDerivator
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-derivator.accuracy <int>

Threshold for output accuracy fraction digits.

Default: 4

-derivator.sampleSize <int>

Threshold for the size of the random sample to use. Default value is size of the complete dataset.

-derivator.randomSample <|true|false>

Flag to use random sample (use knn query around centroid, if flag is not set).

Default: false

de.lmu.ifi.dbs.elki.algorithm.KNNDistancesSampler
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knndistanceorder.k <int>

Specifies the distance of the k-distant object to be assessed, ignoring the query object.

-knndistanceorder.sample <double>

The percentage of objects to use for sampling, or the absolute number of samples.

Default: 1.0

-knndistanceorder.seed <long|Random>

Random generator seed for sampling.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.KNNJoin
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knnjoin.k <int>

Specifies the k-nearest neighbors to be assigned.

Default: 1

de.lmu.ifi.dbs.elki.algorithm.MaterializeDistances
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.benchmark.KNNBenchmarkAlgorithm
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knnbench.k <int>

Number of neighbors to retreive for kNN benchmarking.

-knnbench.query <class|object>

Data source for the queries. If not set, the queries are taken from the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.DatabaseConnection

Known implementations:

-knnbench.sampling <double>

Sampling size parameter. If the value is less or equal 1, it is assumed to be the relative share. Larger values will be interpreted as integer sizes. By default, all data will be used.

-knnbench.random <long|Random>

Random generator for sampling.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.benchmark.RangeQueryBenchmarkAlgorithm
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-rangebench.query <class|object>

Data source for the queries. If not set, the queries are taken from the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.DatabaseConnection

Known implementations:

-rangebench.sampling <double>

Sampling size parameter. If the value is less or equal 1, it is assumed to be the relative share. Larger values will be interpreted as integer sizes. By default, all data will be used.

-rangebench.random <long|Random>

Random generator for sampling.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.benchmark.ValidateApproximativeKNNIndex
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-validateknn.k <int>

Number of neighbors to retreive for kNN benchmarking.

-validateknn.pattern <pattern>

Pattern to select query points.

-validateknn.query <class|object>

Data source for the queries. If not set, the queries are taken from the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.DatabaseConnection

Known implementations:

-validateknn.sampling <double>

Sampling size parameter. If the value is less or equal 1, it is assumed to be the relative share. Larger values will be interpreted as integer sizes. By default, all data will be used.

-validateknn.force-linear <|true|false>

Force the use of linear scanning as reference.

Default: false

-validateknn.random <long|Random>

Random generator for sampling.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.classification.KNNClassifier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knnclassifier.k <int>

The number of neighbors to take into account for classification.

Default: 1

de.lmu.ifi.dbs.elki.algorithm.clustering.CanopyPreClustering
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-canopy.t1 <double>

Inclusion threshold for canopy clustering. t1 >= t2!

-canopy.t2 <double>

Removal threshold for canopy clustering. t1 >= t2!

de.lmu.ifi.dbs.elki.algorithm.clustering.DBSCAN
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

de.lmu.ifi.dbs.elki.algorithm.clustering.GriDBSCAN
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: extends de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.LPNormDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

-gridbscan.gridwidth <double>

Width of the grid used, must be at least two times epsilon.

de.lmu.ifi.dbs.elki.algorithm.clustering.NaiveMeanShiftClustering
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-meanshift.kernel <class|object>

Kernel function to use with mean-shift clustering.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction

Default: de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.EpanechnikovKernelDensityFunction

Known implementations:

-meanshift.kernel-bandwidth <double>

Range of the kernel to use (aka: radius, bandwidth).

de.lmu.ifi.dbs.elki.algorithm.clustering.SNNClustering
-snn.epsilon <int>

The minimum SNN density.

-snn.minpts <int>

Threshold for minimum number of points in the epsilon-SNN-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation.AffinityPropagationClusteringAlgorithm
-ap.initialization <class|object>

Similarity matrix initialization..

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation.AffinityPropagationInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation.DistanceBasedInitializationWithMedian

Known implementations:

-ap.lambda <double>

Dampening factor lambda. Usually 0.5 to 1.

Default: 0.5

-ap.convergence <int>

Number of stable iterations for convergence.

Default: 15

-ap.maxiter <int>

Maximum number of iterations.

Default: 1000

de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation.DistanceBasedInitializationWithMedian
-ap.distance <class|object>

Distance function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-ap.quantile <double>

Quantile to use for diagonal entries.

Default: 0.5

de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation.SimilarityBasedInitializationWithMedian
-ap.similarity <class|object>

Similarity function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.LinearKernelFunction

Known implementations:

-ap.quantile <double>

Quantile to use for diagonal entries.

Default: 0.5

de.lmu.ifi.dbs.elki.algorithm.clustering.biclustering.ChengAndChurch
-chengandchurch.delta <double>

Threshold value to determine the maximal acceptable score (mean squared residue) of a bicluster.

-chengandchurch.n <int>

The number of biclusters to be found.

Default: 1

-chengandchurch.alpha <double>

Parameter for multiple node deletion to accelerate the algorithm.

Default: 1.0

-chengandchurch.replacement <class|object>

Distribution of replacement values when masking found clusters.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution

Default: de.lmu.ifi.dbs.elki.math.statistics.distribution.UniformDistribution

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.CASH
-cash.minpts <int>

Threshold for minimum number of points in a cluster.

-cash.maxlevel <int>

The maximum level for splitting the hypercube.

-cash.mindim <int>

The minimum dimensionality of the subspaces to be found.

Default: 1

-cash.jitter <double>

The maximum jitter for distance values.

-cash.adjust <|true|false>

Flag to indicate that an adjustment of the applied heuristic for choosing an interval is performed after an interval is selected.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.COPAC$Settings
-copac.knn <int>

Number of neighbors to use for PCA.

-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.ERiC$Settings
-eric.k <int>

Number of neighbors to use for PCA.

-ericdf.delta <double>

Threshold for approximate linear dependency: the strong eigenvectors of q are approximately linear dependent from the strong eigenvectors p if the following condition holds for all stroneg eigenvectors q_i of q (lambda_q < lambda_p): q_i' * M^check_p * q_i <= delta^2.

Default: 0.1

-ericdf.tau <double>

Threshold for the maximum distance between two approximately linear dependent subspaces of two objects p and q (lambda_q < lambda_p) before considering them as parallel.

Default: 0.1

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.FourC$Settings
-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

-pca.filter.absolute <|true|false>

Flag to mark delta as an absolute value.

Default: false

-pca.filter.delta <double>

The threshold for strong Eigenvalues. If not otherwise specified, delta is a relative value w.r.t. the (absolute) highest Eigenvalues and has to be a double between 0 and 1. To mark delta as an absolute value, use the option -pca.filter.absolute.

Default: 0.1

-predecon.kappa <double>

Penalty factor for deviations in preferred (low-variance) dimensions.

Default: 20.0

-predecon.lambda <int>

Maximum dimensionality to consider for core points.

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.HiCO
-hico.mu <int>

Specifies the smoothing factor. The mu-nearest neighbor is used to compute the correlation reachability of an object.

-hico.k <int>

Optional parameter to specify the number of nearest neighbors considered in the PCA. If this parameter is not set, k is set to the value of parameter mu.

-hico.delta <double>

Threshold of a distance between a vector q and a given space that indicates that q adds a new dimension to the space.

Default: 0.25

-hico.alpha <double>

The threshold for 'strong' eigenvectors: the 'strong' eigenvectors explain a portion of at least alpha of the total variance.

Default: 0.85

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.LMCLUS
-lmclus.maxdim <int>

Maximum linear manifold dimension to search.

-lmclus.minsize <int>

Minimum cluster size to allow.

-lmclus.sampling-level <int>

A number used to determine how many samples are taken in each search.

Default: 100

-lmclus.threshold <double>

Threshold to determine if a cluster was found.

-lmclus.seed <long|Random>

Random generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.ORCLUS
-projectedclustering.k <int>

The number of clusters to find.

-projectedclustering.k_i <int>

The multiplier for the initial number of seeds.

Default: 30

-projectedclustering.l <int>

The dimensionality of the clusters to find.

-orclus.alpha <double>

The factor for reducing the number of current clusters in each iteration.

Default: 0.5

-orclus.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.em.DiagonalGaussianModelFactory
-em.centers <class|object>

Method to choose the initial cluster centers.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyGeneratedInitialMeans

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.em.EM
-em.k <int>

The number of clusters to find.

-em.model <class|object>

Model factory.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.em.EMClusterModelFactory

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.em.MultivariateGaussianModelFactory

Known implementations:

-em.delta <double>

The termination criterion for maximization of E(M): E(M) - E(M') < em.delta

Default: 1.0E-7

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

de.lmu.ifi.dbs.elki.algorithm.clustering.em.MultivariateGaussianModelFactory
-em.centers <class|object>

Method to choose the initial cluster centers.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyGeneratedInitialMeans

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.em.SphericalGaussianModelFactory
-em.centers <class|object>

Method to choose the initial cluster centers.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyGeneratedInitialMeans

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.EpsilonNeighborPredicate
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.GeneralizedDBSCAN
-gdbscan.neighborhood <class|object>

Neighborhood predicate for Generalized DBSCAN

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.NeighborPredicate

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.EpsilonNeighborPredicate

Known implementations:

-gdbscan.core <class|object>

Core point predicate for Generalized DBSCAN

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.CorePredicate

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.MinPtsCorePredicate

Known implementations:

-gdbscan.core-model <|true|false>

Use a model that keeps track of core points. Needs more memory.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.LSDBC
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-lsdbc.k <int>

Neighborhood size (k)

-lsdbc.alpha <double>

Density difference factor

de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan.MinPtsCorePredicate
-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.AGNES
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-hierarchical.linkage <class|object>

Linkage method to use (e.g. Ward, Single-Link)

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.LinkageMethod

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.WardLinkageMethod

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.AnderbergHierarchicalClustering
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-hierarchical.linkage <class|object>

Linkage method to use (e.g. Ward, Single-Link)

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.LinkageMethod

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.WardLinkageMethod

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.CLINK
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.HDBSCANLinearMemory
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-hdbscan.minPts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point (including this point).

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.SLINK
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.SLINKHDBSCANLinearMemory
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-hdbscan.minPts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point (including this point).

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.ExtractFlatClusteringFromHierarchy
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.HierarchicalClusteringAlgorithm

Known implementations:

-hierarchical.threshold-mode <BY_MINCLUSTERS | BY_THRESHOLD | NO_THRESHOLD>

The thresholding mode to use for extracting clusters: by desired number of clusters, or by distance threshold.

Default: BY_MINCLUSTERS

-hierarchical.minclusters <int>

The minimum number of clusters to extract (there may be more clusters when tied).

-hierarchical.threshold <double>

The threshold level for which to extract the clusters.

-hierarchical.hierarchy <|true|false>

Generate a truncated hierarchical clustering result (or strict partitions).

Default: false

-hierarchical.mergesingletons <|true|false>

Merge singleton clusters into parent. This produces a more complex hierarchy, but that is easier to understand.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.HDBSCANHierarchyExtraction
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.HierarchicalClusteringAlgorithm

Known implementations:

-hdbscan.minclsize <int>

The minimum cluster size.

Default: 1

-hdbscan.hierarchical <|true|false>

Produce a hierarchical output.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.SimplifiedHierarchyExtraction
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.HierarchicalClusteringAlgorithm

Known implementations:

-hdbscan.minclsize <int>

The minimum cluster size.

Default: 1

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.BestOfMultipleKMeans
-kmeans.trials <int>

The number of trials to run.

-kmeans.algorithm <class|object>

KMeans variant to run multiple times.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Known implementations:

-kmeans.qualitymeasure <class|object>

Quality measure variant for deciding which run to keep.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.quality.KMeansQualityMeasure

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.CLARA
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMedoidsInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.PAMInitialMeans

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-clara.samples <int>

Number of samples (iterations) to run.

Default: 5

-clara.samplesize <double>

The size of the sample.

-clara.random <long|Random>

Random generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansBatchedLloyd
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-kmeans.blocks <int>

Number of blocks to use for processing. Means will be recomputed after each block.

Default: 10

-kmeans.blocks.random <long|Random>

Random source for producing blocks.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansBisecting
-kmeans.k <int>

The number of clusters to find.

-bisecting.kmeansvariant <class|object>

KMeans variant

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.BestOfMultipleKMeans

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansCompare
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansElkan
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-kmeans.varstat <|true|false>

Compute the final clustering variance statistic. Needs an additional full pass over the data set.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-kmeans.varstat <|true|false>

Compute the final clustering variance statistic. Needs an additional full pass over the data set.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHybridLloydMacQueen
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansLloyd
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansMacQueen
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansSort
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMediansLloyd
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMedoidsEM
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMedoidsInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.FarthestPointsInitialMeans

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMedoidsPAM
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMedoidsInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.PAMInitialMeans

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.XMeans
-xmeans.k_min <int>

The minimum number of clusters to find.

Default: 2

-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-xmeans.seed <long|Random>

Random seed for splitting clusters.

Default: use global random seed

-xmeans.kmeans <class|object>

kMeans algorithm to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansLloyd

Known implementations:

-xmeans.quality <class|object>

The quality measure to evaluate splits (e.g. AIC, BIC)

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.quality.KMeansQualityMeasure

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.FarthestPointsInitialMeans
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

-farthest.keepfirst <|true|false>

Keep the first object chosen (which is chosen randomly) for the farthest points heuristic.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.FarthestSumPointsInitialMeans
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

-farthest.keepfirst <|true|false>

Keep the first object chosen (which is chosen randomly) for the farthest points heuristic.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansPlusPlusInitialMeans
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.PredefinedInitialMeans
-kmeans.means <double_11,...,double_1n:...:double_m1,...,double_mn>

Initial means for k-means.

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyGeneratedInitialMeans
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.SampleKMeansInitialization
-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

-kmeans.algorithm <class|object>

KMeans variant to run multiple times.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Known implementations:

-kmeans.samplesize <double>

Sample set size (if > 1) or sampling rante (if < 1).

de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.parallel.ParallelLloydKMeans
-kmeans.k <int>

The number of clusters to find.

-kmeans.initialization <class|object>

Method to choose the initial means.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.RandomlyChosenInitialMeans

Known implementations:

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction

Known implementations:

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

de.lmu.ifi.dbs.elki.algorithm.clustering.meta.ExternalClustering
-externalcluster.file <file>

The file name containing the (external) cluster vector.

de.lmu.ifi.dbs.elki.algorithm.clustering.onedimensional.KNNKernelDensityMinimaClustering
-kernelcluster.dim <int>

Dimension to use for clustering. For one-dimensional data, use 0.

Default: 0

-kernelcluster.kernel <class|object>

Kernel function for density estimation.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction

Default: de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.EpanechnikovKernelDensityFunction

Known implementations:

-kernelcluster.mode <BALLOON | SAMPLE>

Kernel density estimation mode (baloon estimator vs. sample point estimator).

Default: BALLOON

-kernelcluster.knn <int>

Number of nearest neighbors to use for bandwidth estimation.

-kernelcluster.window <int>

Half width of sliding window to find local minima.

de.lmu.ifi.dbs.elki.algorithm.clustering.optics.DeLiClu
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-deliclu.minpts <int>

Threshold for minimum number of points within a cluster.

de.lmu.ifi.dbs.elki.algorithm.clustering.optics.FastOPTICS
-optics.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICSHeap
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-optics.epsilon <double>

The maximum radius of the neighborhood to be considered.

-optics.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICSList
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-optics.epsilon <double>

The maximum radius of the neighborhood to be considered.

-optics.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICSXi
-opticsxi.xi <double>

Threshold for the steepness requirement.

-opticsxi.algorithm <class>

The actual OPTICS-type algorithm to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICSTypeAlgorithm

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICSHeap

Known implementations:

-opticsxi.nocorrect <|true|false>

Disable the predecessor correction.

Default: false

-opticsxi.keepsteep <|true|false>

Keep the steep up/down areas of the plot.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.CLIQUE
-clique.xsi <int>

The number of intervals (units) in each dimension.

-clique.tau <double>

The density threshold for the selectivity of a unit, where the selectivity isthe fraction of total feature vectors contained in this unit.

-clique.prune <|true|false>

Flag to indicate that only subspaces with large coverage (i.e. the fraction of the database that is covered by the dense units) are selected, the rest will be pruned.

Default: false

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.DOC
-doc.alpha <double>

Minimum relative density for a set of points to be considered a cluster (|C|>=doc.alpha*|S|).

Default: 0.2

-doc.beta <double>

Preference of cluster size versus number of relevant dimensions (higher value means higher priority on larger clusters).

Default: 0.8

-doc.w <double>

Maximum extent of scattering of points along a single attribute for the attribute to be considered relevant.

Default: 0.05

-doc.fastdoc <|true|false>

Use heuristics as described, thus using the FastDOC algorithm (not yet implemented).

Default: false

-doc.random-seed <long|Random>

Random seed, for reproducible experiments.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.DiSH
-dish.epsilon <double>

The maximum radius of the neighborhood to be considered in each dimension for determination of the preference vector.

Default: 0.001

-dish.mu <int>

The minimum number of points as a smoothing factor to avoid the single-link-effekt.

Default: 1

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.HiSC
-hisc.alpha <double>

The maximum absolute variance along a coordinate axis.

Default: 0.01

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.P3C
-p3c.alpha <double>

The significance level for uniform testing in the initial binning step.

Default: 0.001

-p3c.threshold <double>

The threshold value for the poisson test used when merging signatures.

Default: 1.0E-4

-p3c.em.maxiter <int>

The maximum number of iterations for the EM step. Use -1 to run until delta convergence.

Default: 20

-p3c.em.delta <double>

The change delta for the EM step below which to stop.

Default: 1.0E-5

-p3c.minsize <int>

The minimum size of a cluster, otherwise it is seen as noise (this is a cheat, it is not mentioned in the paper).

Default: 1

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.PROCLUS
-projectedclustering.k <int>

The number of clusters to find.

-projectedclustering.k_i <int>

The multiplier for the initial number of seeds.

Default: 30

-projectedclustering.l <int>

The dimensionality of the clusters to find.

-proclus.mi <int>

The multiplier for the initial number of medoids.

Default: 10

-proclus.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.PreDeCon$Settings
-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

-predecon.delta <double>

A double specifying the variance threshold for small Eigenvalues.

-predecon.kappa <double>

Penalty factor for deviations in preferred (low-variance) dimensions.

Default: 20.0

-predecon.lambda <int>

Maximum dimensionality to consider for core points.

de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.SUBCLU
-subclu.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.DimensionSelectingSubspaceDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.SubspaceEuclideanDistanceFunction

Known implementations:

-subclu.epsilon <double>

The maximum radius of the neighborhood to be considered.

-subclu.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.clustering.trivial.ByLabelClustering
-bylabelclustering.multiple <|true|false>

Flag to indicate that only subspaces with large coverage (i.e. the fraction of the database that is covered by the dense units) are selected, the rest will be pruned.

Default: false

-bylabelclustering.noise <pattern>

Pattern to recognize noise classes by their label.

de.lmu.ifi.dbs.elki.algorithm.clustering.trivial.ByModelClustering
-bymodel.noise <pattern>

Pattern to recognize noise models by their label.

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.CKMeans
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.CenterOfMassMetaClustering
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.ClusteringAlgorithm

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.FDBSCAN
-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-dbscan.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point. The suggested value is '2 * dim - 1'.

-fdbscan.samplesize <int>

The number of samples to draw from each uncertain object to determine the epsilon-neighborhood.

-fdbscan.threshold <double>

The amount of samples that have to be epsilon-close for two objects to be neighbors.

Default: 0.5

-fdbscan.seed <long|Random>

Random generator used to draw samples.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.FDBSCANNeighborPredicate
-dbscan.epsilon <double>

The maximum radius of the neighborhood to be considered.

-fdbscan.samplesize <int>

The number of samples to draw from each uncertain object to determine the epsilon-neighborhood.

-fdbscan.threshold <double>

The amount of samples that have to be epsilon-close for two objects to be neighbors.

Default: 0.5

-fdbscan.seed <long|Random>

Random generator used to draw samples.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.RepresentativeUncertainClustering
-pwc.distance <class|object>

Distance measure of clusterings.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.similarityfunction.cluster.ClusteringDistanceSimilarityFunction

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.cluster.ClusteringAdjustedRandIndexSimilarityFunction

Known implementations:

-pwc.metaclustering <class|object>

Algorithm used to aggregate clustering results. Must be a distance-based clustering algorithm.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.ClusteringAlgorithm

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMedoidsEM

Known implementations:

-pwc.clustering <class|object>

Clustering algorithm used on the samples.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.ClusteringAlgorithm

Known implementations:

-pwc.samples <int>

Number of clusterings to produce on samples.

Default: 10

-pwc.samples.keep <|true|false>

Retain all sampled relations, not only the representative results.

Default: false

-pwc.random <long|Random>

Random generator used for sampling.

Default: use global random seed

-pwc.alpha <double>

Alpha threshold for estimating the confidence probability.

Default: 0.95

de.lmu.ifi.dbs.elki.algorithm.clustering.uncertain.UKMeans
-kmeans.k <int>

The number of clusters to find.

-kmeans.maxiter <int>

The maximum number of iterations to do. 0 means no limit.

Default: 0

-kmeans.seed <long|Random>

The random number generator seed.

Default: use global random seed

de.lmu.ifi.dbs.elki.algorithm.itemsetmining.APRIORI
-itemsetmining.minsupp <double>

Threshold for minimum support as minimally required number of transactions (if > 1) or the minimum frequency (if <= 1).

-itemsetmining.minlength <int>

Minimum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

-itemsetmining.maxlength <int>

Maximum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

de.lmu.ifi.dbs.elki.algorithm.itemsetmining.Eclat
-itemsetmining.minsupp <double>

Threshold for minimum support as minimally required number of transactions (if > 1) or the minimum frequency (if <= 1).

-itemsetmining.minlength <int>

Minimum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

-itemsetmining.maxlength <int>

Maximum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

de.lmu.ifi.dbs.elki.algorithm.itemsetmining.FPGrowth
-itemsetmining.minsupp <double>

Threshold for minimum support as minimally required number of transactions (if > 1) or the minimum frequency (if <= 1).

-itemsetmining.minlength <int>

Minimum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

-itemsetmining.maxlength <int>

Maximum length of frequent itemsets to report. This can help to reduce the output size to only the most interesting patterns.

de.lmu.ifi.dbs.elki.algorithm.outlier.COP
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-cop.k <int>

The number of nearest neighbors of an object to be considered for computing its COP_SCORE.

-cop.dist <CHISQUARED | GAMMA>

The assumed distribution of squared distances. ChiSquared is faster, Gamma expected to be more accurate but could also overfit.

Default: GAMMA

-cop.expect <double>

Expected share of outliers. Only affect score normalization.

Default: 0.001

-cop.pcarunner <class|object>

The class to compute (filtered) PCA.

Class Restriction: extends de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCARunner

Default: de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCARunner

Known implementations:

-cop.models <|true|false>

Include COP models (error vectors) in output. This needs more memory.

Default: false

de.lmu.ifi.dbs.elki.algorithm.outlier.DWOF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dwof.k <int>

Number of neighbors to get for DWOF score outlier detection.

-dwof.delta <double>

Radius increase factor.

Default: 1.1

de.lmu.ifi.dbs.elki.algorithm.outlier.GaussianModel
-gaussod.invert <|true|false>

Invert the value range to [0:1], with 1 being outliers instead of 0.

Default: false

de.lmu.ifi.dbs.elki.algorithm.outlier.GaussianUniformMixture
-mmo.c <double>

cutoff

Default: 1.0E-7

de.lmu.ifi.dbs.elki.algorithm.outlier.OPTICSOF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-optics.minpts <int>

Threshold for minimum number of points in the epsilon-neighborhood of a point.

de.lmu.ifi.dbs.elki.algorithm.outlier.SimpleCOP
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-cop.k <int>

The number of nearest neighbors of an object to be considered for computing its COP_SCORE.

-cop.pcarunner <class|object>

The class to compute (filtered) PCA.

Class Restriction: extends de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredRunner

Default: de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredRunner

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.anglebased.ABOD
-abod.kernelfunction <class|object>

Kernel function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.PolynomialKernelFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.anglebased.FastABOD
-abod.kernelfunction <class|object>

Kernel function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.PolynomialKernelFunction

Known implementations:

-fastabod.k <int>

Number of nearest neighbors to use for ABOD.

de.lmu.ifi.dbs.elki.algorithm.outlier.anglebased.LBABOD
-abod.kernelfunction <class|object>

Kernel function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.PolynomialKernelFunction

Known implementations:

-fastabod.k <int>

Number of nearest neighbors to use for ABOD.

-abod.l <int>

Number of top outliers to compute.

de.lmu.ifi.dbs.elki.algorithm.outlier.clustering.KMeansOutlierDetection
-kmeans.algorithm <class|object>

Clustering algorithm to use for detecting outliers.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansLloyd

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.clustering.SilhouetteOutlierDetection
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-silhouette.clustering <class|object>

Clustering algorithm to use for the silhouette coefficients.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.clustering.ClusteringAlgorithm

Known implementations:

-silhouette.noisehandling <MERGE_NOISE | TREAT_NOISE_AS_SINGLETONS | IGNORE_NOISE>

Control how noise should be treated.

Default: TREAT_NOISE_AS_SINGLETONS

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.DBOutlierDetection
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dbod.d <double>

size of the D-neighborhood

-dbod.p <double>

minimum fraction of objects that must be outside the D-neighborhood of an outlier

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.DBOutlierScore
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-dbod.d <double>

size of the D-neighborhood

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.HilOut
-HilOut.k <int>

Compute up to k next neighbors

Default: 5

-HilOut.n <int>

Compute n outliers

Default: 10

-HilOut.h <int>

Max. Hilbert-Level

Default: 32

-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: extends de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.LPNormDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-HilOut.tn <All | TopN>

output of Top n or all elements

Default: TopN

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.KNNOutlier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knno.k <int>

The k nearest neighbor, excluding the query point (i.e. query point is the 0-nearest-neighbor)

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.KNNWeightOutlier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knnwod.k <int>

The k nearest neighbor, excluding the query point (i.e. query point is the 0-nearest-neighbor)

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.LocalIsolationCoefficient
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-lic.k <int>

The k nearest neighbor, excluding the query point (i.e. query point is the 0-nearest-neighbor)

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.ODIN
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-odin.k <int>

Number of neighbors to use for kNN graph.

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.ReferenceBasedOutlierDetection
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-refod.k <int>

The number of nearest neighbors

-refod.refp <class|object>

The heuristic for finding reference points.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.referencepoints.ReferencePointsHeuristic

Default: de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.parallel.ParallelKNNOutlier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knno.k <int>

The k nearest neighbor, excluding the query point (i.e. query point is the 0-nearest-neighbor)

de.lmu.ifi.dbs.elki.algorithm.outlier.distance.parallel.ParallelKNNWeightOutlier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-knnwod.k <int>

The k nearest neighbor, excluding the query point (i.e. query point is the 0-nearest-neighbor)

de.lmu.ifi.dbs.elki.algorithm.outlier.intrinsic.IDOS
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-idos.estimator <class|object>

Estimator of intrinsic dimensionality.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.intrinsicdimensionality.IntrinsicDimensionalityEstimator

Default: de.lmu.ifi.dbs.elki.math.statistics.intrinsicdimensionality.HillEstimator

Known implementations:

-idos.kc <int>

Context set size (ID estimation).

-idos.kr <int>

Reference set size.

de.lmu.ifi.dbs.elki.algorithm.outlier.intrinsic.IntrinsicDimensionalityOutlier
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-id.k <int>

Number of nearest neighbors to use for ID estimation (usually 20-100).

-id.estimator <class|object>

Class to estimate ID from distance distribution.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.intrinsicdimensionality.IntrinsicDimensionalityEstimator

Default: de.lmu.ifi.dbs.elki.math.statistics.intrinsicdimensionality.MOMEstimator

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.ALOCI
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-loci.nmin <int>

Minimum neighborhood size to be considered.

Default: 20

-loci.g <int>

The number of Grids to use.

Default: 1

-loci.seed <long|Random>

The seed to use for initializing Random.

Default: use global random seed

-loci.alpha <int>

Scaling factor for averaging neighborhood

Default: 4

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.COF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-cof.k <int>

The number of neighbors (not including the query object) to use for computing the COF score.

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.FlexibleLOF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-lof.krefer <int>

The number of nearest neighbors of an object to be considered for computing its LOF score.

-lof.kreach <int>

The number of nearest neighbors of an object to be considered for computing its LOF score.

-lof.reachdistfunction <class|object>

Distance function to determine the reachability distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.INFLO
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-inflo.m <double>

The pruning threshold

Default: 1.0

-inflo.k <int>

The number of nearest neighbors of an object to be considered for computing its INFLO score.

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.KDEOS
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-kdeos.kernel <class|object>

Kernel density function to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction

Default: de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.GaussianKernelDensityFunction

Known implementations:

-kdeos.k.min <int>

Minimum value of k to analyze.

-kdeos.k.max <int>

Maximum value of k to analyze.

-kdeos.kernel.scale <double>

Scaling factor for the kernel function.

Default: 0.5

-kdeos.kernel.minbw <double>

Minimum bandwidth for kernel density estimation.

-kdeos.idim <int>

Intrinsic dimensionality of this data set. Use -1 for using the true data dimensionality, but values such as 0-2 often offer better performance.

Default: -1

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LDF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-ldf.k <int>

Number of neighbors to use for LDF.

-ldf.kernel <class|object>

Kernel to use for LDF.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction

Default: de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.GaussianKernelDensityFunction

Known implementations:

-ldf.h <double>

Kernel bandwidth multiplier for LDF.

-ldf.c <double>

Score scaling parameter for LDF.

Default: 0.1

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LDOF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-ldof.k <int>

The number of nearest neighbors of an object to be considered for computing its LDOF_SCORE.

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOCI
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-loci.rmax <double>

The maximum radius of the neighborhood to be considered.

-loci.nmin <int>

Minimum neighborhood size to be considered.

Default: 20

-loci.alpha <double>

Scaling factor for averaging neighborhood

Default: 0.5

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF
-algorithm.distancefunction <class|object>

Distance function to determine the distance between database objects.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-lof.k <int>

The number of nearest neighbors (not including the query point) of an object to be considered for computing its LOF score.

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LoOP
-loop.kcomp <int>

The number of nearest neighbors of an object to be considered for computing its LOOP_SCORE.

-loop.comparedistfunction <class|object>

Distance function to determine the reference set of an object.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction

Known implementations:

-loop.kref <int>

The number of nearest neighbors of an object to be used for the PRD value.

-loop.referencedistfunction <class|object>

Distance function to determine the density of an object.

Class Restriction: implements de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction

Known implementations: