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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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.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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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-5

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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.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

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

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.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
-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

-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.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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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

The random number generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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

The random number generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

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: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-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:

-loop.lambda <double>

The number of standard deviations to consider for density computation.

Default: 2.0

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.OnlineLOF
-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.SimpleKernelDensityLOF
-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.

-kernellof.kernel <class|object>

Kernel to use for kernel density LOF.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.SimplifiedLOF
-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.VarianceOfVolume
-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:

-vov.k <int>

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

de.lmu.ifi.dbs.elki.algorithm.outlier.lof.parallel.ParallelLOF
-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.parallel.ParallelSimplifiedLOF
-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.meta.ExternalDoubleOutlierScore
-externaloutlier.file <file>

The file name containing the (external) outlier scores.

-externaloutlier.idpattern <pattern>

The pattern to match object ID prefix

Default: ^ID=

-externaloutlier.scorepattern <pattern>

The pattern to match object score prefix

-externaloutlier.inverted <|true|false>

Flag to signal an inverted outlier score.

Default: false

-externaloutlier.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Default: de.lmu.ifi.dbs.elki.utilities.scaling.IdentityScaling

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.meta.FeatureBagging
-lof.k <int>

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

-fbagging.num <int>

The number of instances to use in the ensemble.

-fbagging.breadth <|true|false>

Use the breadth first combinations instead of the cumulative sum approach

Default: false

-fbagging.seed <long|Random>

Specify a particular random seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.algorithm.outlier.meta.HiCS
-hics.m <int>

The number of iterations in the Monte-Carlo processing.

Default: 50

-hics.alpha <double>

The discriminance value that determines the size of the test statistic .

Default: 0.1

-hics.algo <class|object>

The Algorithm that performs the actual outlier detection on the resulting set of subspace

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.OutlierAlgorithm

Default: de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF

Known implementations:

-hics.test <class|object>

The statistical test that is used to calculate the deviation of two data samples

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.tests.GoodnessOfFitTest

Default: de.lmu.ifi.dbs.elki.math.statistics.tests.KolmogorovSmirnovTest

Known implementations:

-hics.limit <int>

The threshold that determines how many d-dimensional subspace candidates to retain in each step of the generation

Default: 100

-hics.seed <long|Random>

The random seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.algorithm.outlier.meta.RescaleMetaOutlierAlgorithm
-algorithm <class|object>

Algorithm to run.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.OutlierAlgorithm

Known implementations:

-metaoutlier.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.meta.SimpleOutlierEnsemble
-algorithm <object_1|class_1,...,object_n|class_n>

Algorithm to run.

Known implementations:

-ensemble.voting <class|object>

Voting strategy to use in the ensemble.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.ensemble.EnsembleVoting

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuGLSBackwardSearchAlgorithm
-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:

-glsbs.alpha <double>

Significance niveau

-glsbs.k <int>

k nearest neighbors to use

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuMeanMultipleAttributes
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuMedianAlgorithm
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuMedianMultipleAttributes
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuMoranScatterplotOutlier
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuRandomWalkEC
-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:

-randomwalkec.k <int>

Number of nearest neighbors to use.

-randomwalkec.alpha <double>

Scaling exponent for value differences.

Default: 0.5

-randomwalkec.c <double>

The damping parameter c.

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuScatterplotOutlier
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.CTLuZTestOutlier
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.SLOM
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

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.EuclideanDistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.SOF
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

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.EuclideanDistanceFunction

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.TrimmedMeanApproach
-neighborhood <class|object>

The neighborhood predicate to use in comparison step.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

-tma.p <double>

the percentile parameter

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.ExtendedNeighborhood$Factory
-extendedneighbors.neighborhood <class|object>

The inner neighborhood predicate to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

-extendedneighbors.steps <int>

The number of steps allowed in the neighborhood graph.

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.ExternalNeighborhood$Factory
-externalneighbors.file <file>

The file listing the neighbors.

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.PrecomputedKNearestNeighborNeighborhood$Factory
-neighborhood.k <int>

the number of neighbors

-neighborhood.distancefunction <class|object>

the distance function to use

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

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.weighted.LinearWeightedExtendedNeighborhood$Factory
-extendedneighbors.neighborhood <class|object>

The inner neighborhood predicate to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

-extendedneighbors.steps <int>

The number of steps allowed in the neighborhood graph.

de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.weighted.UnweightedNeighborhoodAdapter$Factory
-neighborhood.inner <class|object>

Parameter for the non-weighted neighborhood to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate$Factory

Known implementations:

de.lmu.ifi.dbs.elki.algorithm.outlier.subspace.AggarwalYuEvolutionary
-ay.k <int>

Subspace dimensionality to search for.

-ay.phi <int>

The number of equi-depth grid ranges to use in each dimension.

-ay.m <int>

Population size for evolutionary algorithm.

-ay.seed <long|Random>

The random number generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.algorithm.outlier.subspace.AggarwalYuNaive
-ay.k <int>

Subspace dimensionality to search for.

-ay.phi <int>

The number of equi-depth grid ranges to use in each dimension.

de.lmu.ifi.dbs.elki.algorithm.outlier.subspace.OUTRES
-outres.epsilon <double>

Range value for OUTRES in 2 dimensions.

de.lmu.ifi.dbs.elki.algorithm.outlier.subspace.OutRankS1
-outrank.algorithm <class|object>

Subspace clustering algorithm to use.

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

Known implementations:

-outrank.s1.alpha <double>

Alpha parameter for S1 score.

Default: 0.25

de.lmu.ifi.dbs.elki.algorithm.outlier.subspace.SOD
-sod.similarity <class|object>

The similarity function used for the neighborhood set.

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

Default: de.lmu.ifi.dbs.elki.distance.similarityfunction.SharedNearestNeighborSimilarityFunction

Known implementations:

-sod.knn <int>

The number of most snn-similar objects to use as reference set for learning the subspace properties.

-sod.alpha <double>

The multiplier for the discriminance value for discerning small from large variances.

Default: 1.1

-sod.models <|true|false>

Report the models computed by SOD (default: report only scores).

Default: false

de.lmu.ifi.dbs.elki.algorithm.outlier.svm.LibSVMOneClassOutlierDetection
-svm.kernel <LINEAR | QUADRATIC | CUBIC | RBF | SIGMOID>

Kernel to use with SVM.

Default: RBF

de.lmu.ifi.dbs.elki.algorithm.outlier.trivial.ByLabelOutlier
-outlier.pattern <pattern>

Label pattern to match outliers.

Default: .*(Outlier|Noise).*

de.lmu.ifi.dbs.elki.algorithm.outlier.trivial.TrivialGeneratedOutlier
-modeloutlier.expect <double>

Expected amount of outliers, for making the scores more intuitive. When the value is 1, the CDF will be given instead.

Default: 0.01

de.lmu.ifi.dbs.elki.algorithm.statistics.AddSingleScale
-scales.minmax <double_1,...,double_n>

Forcibly set the scales to the given range.

de.lmu.ifi.dbs.elki.algorithm.statistics.AveragePrecisionAtK
-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:

-avep.k <int>

K to compute the average precision at.

-avep.sampling <double>

Relative amount of object to sample.

-avep.sampling-seed <long|Random>

Random seed for deterministic sampling.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-avep.includeself <|true|false>

Include the query object in the evaluation.

Default: false

de.lmu.ifi.dbs.elki.algorithm.statistics.DistanceQuantileSampler
-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:

-distsample.quantile <double>

Quantile to compute.

Default: 0.1

-distsample.sample <double>

Number of distances to compute, either relative (values less than 1), or absolute.

-distsample.nozeros <|true|false>

Ignore zero distances, beneficial for data sets with many duplicates.

Default: false

-distsample.seed <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.algorithm.statistics.DistanceStatisticsWithClasses
-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:

-diststat.bins <int>

Number of bins to use in the histogram. By default, it is only guaranteed to be within 1*n and 2*n of the given number.

Default: 20

-diststat.exact <|true|false>

In a first pass, compute the exact minimum and maximum, at the cost of O(2*n*n) instead of O(n*n). The number of resulting bins is guaranteed to be as requested.

Default: false

-diststat.sampling <|true|false>

Enable sampling of O(n) size to determine the minimum and maximum distances approximately. The resulting number of bins can be larger than the given n.

Default: false

de.lmu.ifi.dbs.elki.algorithm.statistics.EstimateIntrinsicDimensionality
-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:

-idist.estimator <class|object>

Estimation method for intrinsic dimensionality.

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

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

Known implementations:

-idist.k <double>

Number of kNN (absolute or relative)

Default: 50.0

-idist.sampling <double>

Sample size (absolute or relative)

Default: 0.1

de.lmu.ifi.dbs.elki.algorithm.statistics.EvaluateRankingQuality
-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:

-rankqual.bins <int>

Number of bins to use in the histogram

Default: 20

de.lmu.ifi.dbs.elki.algorithm.statistics.EvaluateRetrievalPerformance
-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:

-map.sampling <double>

Relative amount of object to sample.

-map.sampling-seed <long|Random>

Random seed for deterministic sampling.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-map.includeself <|true|false>

Include the query object in the evaluation.

Default: false

-map.maxk <int>

Maximum value of k for kNN evaluation.

de.lmu.ifi.dbs.elki.algorithm.statistics.HopkinsStatisticClusteringTendency
-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:

-hopkins.rep <int>

The number of times to repeat the experiment (default: 1)

Default: 1

-hopkins.k <int>

Nearest neighbor to use for the statistic

Default: 1

-hopkins.samplesize <int>

Number of object / random samples to analyze.

-hopkins.seed <long|Random>

The random number generator.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-hopkins.min <double_1,...,double_n>

Minimum values in each dimension. If no value is specified, the minimum value in each dimension will be used. If only one value is specified, this value will be used for all dimensions.

-hopkins.max <double_1,...,double_n>

Maximum values in each dimension. If no value is specified, the maximum value in each dimension will be used. If only one value is specified, this value will be used for all dimensions.

de.lmu.ifi.dbs.elki.algorithm.statistics.RangeQuerySelectivity
-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:

-selectivity.radius <double>

Radius to use for selectivity estimation.

-selectivity.sampling <double>

Relative amount of object to sample.

-selectivity.sampling-seed <long|Random>

Random seed for deterministic sampling.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.algorithm.statistics.RankingQualityHistogram
-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:

-rankqual.bins <int>

Number of bins to use in the histogram

Default: 100

de.lmu.ifi.dbs.elki.application.jsmap.JSONResultHandler
-json.port <int>

Port for the JSON web server to listen on.

Default: 8080

de.lmu.ifi.dbs.elki.data.projection.FeatureSelection
-projectionfilter.selectedattributes <int_1,...,int_n>

a comma separated array of integer values d_i, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for projection. If this parameter is not set, no dimensions will be considered, i.e. the projection is a zero-dimensional feature space

de.lmu.ifi.dbs.elki.data.projection.LatLngToECEFProjection
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.data.projection.LngLatToECEFProjection
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.data.projection.NumericalFeatureSelection
-projectionfilter.selectedattributes <int_1,...,int_n>

a comma separated array of integer values d_i, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for projection. If this parameter is not set, no dimensions will be considered, i.e. the projection is a zero-dimensional feature space

de.lmu.ifi.dbs.elki.data.projection.RandomProjection
-randomproj.family <class|object>

Projection family to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.RandomProjectionFamily

Default: de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.AchlioptasRandomProjectionFamily

Known implementations:

-randomproj.dimensionality <int>

Amount of dimensions to project to.

de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.SimpleGaussianUncertainifier
-uo.uncertainty.min3sigma <double>

Minimum 3-sigma deviation of uncertain region.

Default: 0.0

-uo.uncertainty.max3sigma <double>

Maximum 3-sigma deviation of uncertain region.

-uo.symmetric <|true|false>

Generate a symetric uncertain region, centered around the exact data.

Default: false

de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.UniformUncertainifier
-uo.uncertainty.min <double>

Minimum deviation of uncertain bounding box.

Default: 0.0

-uo.uncertainty.max <double>

Maximum deviation of uncertain bounding box.

-uo.symmetric <|true|false>

Generate a symetric uncertain region, centered around the exact data.

Default: false

de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.UnweightedDiscreteUncertainifier
-uo.discrete.generator <class|object>

Class to generate the point distribution.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.Uncertainifier

Known implementations:

-uo.quantity.max <int>

Maximum points per uncertain object.

Default: 10

-uo.quantity.min <int>

Minimum points per uncertain object (defaults to maximum.

de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.WeightedDiscreteUncertainifier
-uo.discrete.generator <class|object>

Class to generate the point distribution.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.Uncertainifier

Known implementations:

-uo.quantity.max <int>

Maximum points per uncertain object.

Default: 10

-uo.quantity.min <int>

Minimum points per uncertain object (defaults to maximum.

de.lmu.ifi.dbs.elki.database.HashmapDatabase
-dbc <class|object>

Database connection class.

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

Default: de.lmu.ifi.dbs.elki.datasource.FileBasedDatabaseConnection

Known implementations:

-db.index <object_1|class_1,...,object_n|class_n>

Database indexes to add.

Known implementations:

de.lmu.ifi.dbs.elki.database.StaticArrayDatabase
-dbc <class|object>

Database connection class.

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

Default: de.lmu.ifi.dbs.elki.datasource.FileBasedDatabaseConnection

Known implementations:

-db.index <object_1|class_1,...,object_n|class_n>

Database indexes to add.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.BundleDatabaseConnection
-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-bundle.input <file>

Bundle file to load the data from.

de.lmu.ifi.dbs.elki.datasource.ConcatenateFilesDatabaseConnection
-dbc.in <file_1,...,file_n>

The name of the input file to be parsed.

-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-dbc.parser <class|object>

Parser to provide the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.parser.Parser

Default: de.lmu.ifi.dbs.elki.datasource.parser.NumberVectorLabelParser

Known implementations:

de.lmu.ifi.dbs.elki.datasource.DBIDRangeDatabaseConnection
-idgen.start <int>

First integer DBID to generate.

Default: 0

-idgen.count <int>

Number of DBID to generate.

de.lmu.ifi.dbs.elki.datasource.ExternalIDJoinDatabaseConnection
-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-join.sources <object_1|class_1,...,object_n|class_n>

The data sources to join.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.FileBasedDatabaseConnection
-dbc.in <file>

The name of the input file to be parsed.

-dbc.parser <class|object>

Parser to provide the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.parser.Parser

Default: de.lmu.ifi.dbs.elki.datasource.parser.NumberVectorLabelParser

Known implementations:

-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.GeneratorXMLDatabaseConnection
-bymodel.spec <file>

The generator specification file.

-bymodel.sizescale <double>

Factor for scaling the specified cluster sizes.

Default: 1.0

-bymodel.reassign <pattern>

Pattern to specify clusters to reassign.

-bymodel.randomseed <long|Random>

The random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.InputStreamDatabaseConnection
-dbc.parser <class|object>

Parser to provide the database.

Class Restriction: implements de.lmu.ifi.dbs.elki.datasource.parser.Parser

Default: de.lmu.ifi.dbs.elki.datasource.parser.NumberVectorLabelParser

Known implementations:

-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.LabelJoinDatabaseConnection
-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-join.sources <object_1|class_1,...,object_n|class_n>

The data sources to join.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.PresortedBlindJoinDatabaseConnection
-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-join.sources <object_1|class_1,...,object_n|class_n>

The data sources to join.

Known implementations:

de.lmu.ifi.dbs.elki.datasource.RandomDoubleVectorDatabaseConnection
-dbc.filter <object_1|class_1,...,object_n|class_n>

The filters to apply to the input data.

Known implementations:

-dbc.dim <int>

Dimensionality of the vectors to generate.

-dbc.size <int>

Database size to generate.

-dbc.genseed <long|Random>

Seed for randomly generating vectors

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.FixedDBIDsFilter
-dbc.startid <int>

Object ID to start counting with

Default: 0

de.lmu.ifi.dbs.elki.datasource.filter.cleaning.ReplaceNaNWithRandomFilter
-nanfilter.replacement <class|object>

Distribution to sample replacement values from.

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

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.cleaning.VectorDimensionalityFilter
-filter.dim <int>

Dimensionality of vectors to retain.

de.lmu.ifi.dbs.elki.datasource.filter.normalization.columnwise.AttributeWiseBetaNormalization
-betanormalize.distributions <object_1|class_1,...,object_n|class_n>

A list of the distribution estimators to try.

Default: [class de.lmu.ifi.dbs.elki.math.statistics.distribution.estimator.meta.BestFitEstimator]

Known implementations:

-betanormalize.alpha <double>

Alpha parameter to control the shape of the output distribution.

Default: 0.1

de.lmu.ifi.dbs.elki.datasource.filter.normalization.columnwise.AttributeWiseCDFNormalization
-normalize.distributions <object_1|class_1,...,object_n|class_n>

A list of the distribution estimators to try.

Default: [class de.lmu.ifi.dbs.elki.math.statistics.distribution.estimator.meta.BestFitEstimator]

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.normalization.columnwise.AttributeWiseMinMaxNormalization
-normalize.min <double_1,...,double_n>

a comma separated concatenation of the minimum values in each dimension that are mapped to 0. If no value is specified, the minimum value of the attribute range in this dimension will be taken.

-normalize.max <double_1,...,double_n>

a comma separated concatenation of the maximum values in each dimension that are mapped to 1. If no value is specified, the maximum value of the attribute range in this dimension will be taken.

de.lmu.ifi.dbs.elki.datasource.filter.normalization.columnwise.AttributeWiseVarianceNormalization
-normalize.mean <double_1,...,double_n>

a comma separated concatenation of the mean values in each dimension that are mapped to 0. If no value is specified, the mean value of the attribute range in this dimension will be taken.

-normalize.stddev <double_1,...,double_n>

a comma separated concatenation of the standard deviations in each dimension that are scaled to 1. If no value is specified, the standard deviation of the attribute range in this dimension will be taken.

de.lmu.ifi.dbs.elki.datasource.filter.normalization.instancewise.InstanceMinMaxNormalization
-normalization.min <double>

Minimum value to assign to objects.

Default: 0.0

-normalization.max <double>

Maximum value to assign to objects.

Default: 1.0

de.lmu.ifi.dbs.elki.datasource.filter.normalization.instancewise.LengthNormalization
-normalization.norm <class|object>

Norm (length function) to use for computing the vector length.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.normalization.instancewise.Log1PlusNormalization
-log1pscale.boost <double>

Boosting factor. Larger values will yield a steeper curve.

Default: 1.0

de.lmu.ifi.dbs.elki.datasource.filter.selection.ByLabelFilter
-patternfilter.pattern <pattern>

The filter pattern to use.

-patternfilter.invert <|true|false>

Flag to invert pattern.

Default: false

de.lmu.ifi.dbs.elki.datasource.filter.selection.RandomSamplingStreamFilter
-sampling.p <double>

Sampling probability. Each object has a chance of being samples with this probability.

-sampling.seed <long|Random>

Random generator seed for sampling.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.selection.ShuffleObjectsFilter
-shuffle.seed <long|Random>

Seed for randomly shuffling the rows for the database. If the parameter is not set, a random seed will be used.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.transform.ClassicMultidimensionalScalingTransform
-mds.dim <int>

Output dimensionality.

-mds.distance <class|object>

Distance function to use.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.transform.FastMultidimensionalScalingTransform
-mds.dim <int>

Output dimensionality.

-mds.distance <class|object>

Distance function to use.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.transform.GlobalPrincipalComponentAnalysisTransform
-globalpca.filter <class|object>

Filter to use for dimensionality reduction.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.EigenPairFilter

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.transform.HistogramJitterFilter
-jitter.amount <double>

Jitter amount relative to data.

-jitter.seed <long|Random>

Jitter random seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.transform.LatLngToECEFFilter
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.transform.LinearDiscriminantAnalysisFilter
-projection.dim <int>

Projection dimensionality

Default: 2

de.lmu.ifi.dbs.elki.datasource.filter.transform.LngLatToECEFFilter
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.transform.NumberVectorFeatureSelectionFilter
-projectionfilter.selectedattributes <int_1,...,int_n>

a comma separated array of integer values d_i, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for projection. If this parameter is not set, no dimensions will be considered, i.e. the projection is a zero-dimensional feature space

de.lmu.ifi.dbs.elki.datasource.filter.transform.NumberVectorRandomFeatureSelectionFilter
-randomprojection.numberselected <int>

number of selected attributes

Default: 1

-randomprojection.seed <long|Random>

Seed for random selection of projection attributes.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.transform.PerturbationFilter
-perturbationfilter.scalingreference <UNITCUBE | STDDEV | MINMAX>

The reference for scaling the Gaussian noise. Default is UNITCUBE, parameter perturbationfilter.percentage will then directly define the standard deviation of all noise Gaussians. For options STDDEV and MINMAX, the percentage of the attributewise standard deviation or extension, repectively, will define the attributewise standard deviation of the noise Gaussians.

Default: UNITCUBE

-perturbationfilter.noisedistribution <GAUSSIAN | UNIFORM>

The nature of the noise distribution, default is UNIFORM

Default: UNIFORM

-perturbationfilter.percentage <double>

Percentage of the standard deviation of the random Gaussian noise generation per attribute, given the standard deviation of the corresponding attribute in the original data distribution (assuming a Gaussian distribution there).

Default: 0.01

-perturbationfilter.seed <long>

Seed for random noise generation.

-perturbationfilter.min <double_1,...,double_n>

Only used, if MINMAX is set as scaling reference: a comma separated concatenation of the minimum values in each dimension assumed as a reference. If no value is specified, the minimum value of the attribute range in this dimension will be taken.

-perturbationfilter.max <double_1,...,double_n>

Only used, if MINMAX is set as scaling reference: a comma separated concatenation of the maximum values in each dimension assumed as a reference. If no value is specified, the maximum value of the attribute range in this dimension will be taken.

de.lmu.ifi.dbs.elki.datasource.filter.transform.ProjectionFilter
-projection <class|object>

Projection to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.projection.Projection

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.ClassLabelFilter
-dbc.classLabelIndex <int>

The index of the label to be used as class label. The first label is 0, negative indexes are relative to the end.

-dbc.classLabelClass <class|object>

Class label class to use.

Class Restriction: extends de.lmu.ifi.dbs.elki.data.ClassLabel$Factory

Default: de.lmu.ifi.dbs.elki.data.SimpleClassLabel.Factory

Known implementations:

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.ClassLabelFromPatternFilter
-class.pattern <pattern>

Regular expression to identify positive objects.

-class.positive <string>

Class label to use for positive instances.

Default: positive

-class.negative <string>

Class label to use for negative instances.

Default: negative

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.ExternalIDFilter
-dbc.externalIdIndex <int>

The index of the label to be used as external Id. The first label is 0; negative indexes are relative to the end.

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.MultivariateTimeSeriesFilter
-series.variates <int>

Number of variates this time series has.

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.SplitNumberVectorFilter
-split.dims <int_1,...,int_n>

Dimensions to split into the first relation.

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.UncertainSplitFilter
-uncertain.dimensionality <int>

Dimensionality of the data set (used for splitting).

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.UncertainifyFilter
-uofilter.generator <class|object>

Generator to derive uncertain objects from certain vectors.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.uncertain.uncertainifier.Uncertainifier

Known implementations:

-uofilter.keep <|true|false>

Keep the original data as well.

Default: false

-uofilter.seed <long|Random>

Random seed for uncertainification.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.WeightedUncertainSplitFilter
-uncertain.dimensionality <int>

Dimensionality of the data set (used for splitting).

-uncertain.probability.column <int>

Column in which the probability is stored, starting at 0. -1 is the last column.

de.lmu.ifi.dbs.elki.datasource.parser.ArffParser
-arff.externalid <pattern>

Pattern to recognize external ID attributes.

Default: (External-?ID)

-arff.classlabel <pattern>

Pattern to recognize class label attributes.

Default: (Class|Class-?Label)

de.lmu.ifi.dbs.elki.datasource.parser.CSVReaderFormat
-parser.colsep <pattern>

Column separator pattern. The default assumes whitespace separated data.

Default: \s*[,;\s]\s*

-parser.quote <string>

Quotation characters. By default, both double and single ASCII quotes are accepted.

Default: "'

-string.comment <pattern>

Ignore lines in the input file that satisfy this pattern.

Default: ^\s*(#|//|;).*$

de.lmu.ifi.dbs.elki.datasource.parser.CategorialDataAsNumberVectorParser
-parser.labelIndices <int_1,...,int_n>

A comma separated list of the indices of labels (may be numeric), counting whitespace separated entries in a line starting with 0. The corresponding entries will be treated as a label.

-parser.vector-type <class|object>

The type of vectors to create for numerical attributes.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.NumberVector$Factory

Default: de.lmu.ifi.dbs.elki.data.DoubleVector.Factory

Known implementations:

de.lmu.ifi.dbs.elki.datasource.parser.LibSVMFormatParser
-parser.vector-type <class|object>

The type of vectors to create for numerical attributes.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.SparseNumberVector$Factory

Default: de.lmu.ifi.dbs.elki.data.SparseFloatVector.Factory

Known implementations:

de.lmu.ifi.dbs.elki.datasource.parser.NumberVectorLabelParser
-parser.labelIndices <int_1,...,int_n>

A comma separated list of the indices of labels (may be numeric), counting whitespace separated entries in a line starting with 0. The corresponding entries will be treated as a label.

-parser.vector-type <class|object>

The type of vectors to create for numerical attributes.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.NumberVector$Factory

Default: de.lmu.ifi.dbs.elki.data.DoubleVector.Factory

Known implementations:

de.lmu.ifi.dbs.elki.datasource.parser.SparseNumberVectorLabelParser
-parser.labelIndices <int_1,...,int_n>

A comma separated list of the indices of labels (may be numeric), counting whitespace separated entries in a line starting with 0. The corresponding entries will be treated as a label.

-parser.vector-type <class|object>

The type of vectors to create for numerical attributes.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.SparseNumberVector$Factory

Default: de.lmu.ifi.dbs.elki.data.SparseFloatVector.Factory

Known implementations:

de.lmu.ifi.dbs.elki.datasource.parser.StringParser
-string.comment <pattern>

Ignore lines in the input file that satisfy this pattern.

Default: ^\s*#.*$

-string.trim <|true|false>

Remove leading and trailing whitespace from each line.

Default: false

de.lmu.ifi.dbs.elki.datasource.parser.TermFrequencyParser
-parser.labelIndices <int_1,...,int_n>

A comma separated list of the indices of labels (may be numeric), counting whitespace separated entries in a line starting with 0. The corresponding entries will be treated as a label.

-parser.vector-type <class|object>

The type of vectors to create for numerical attributes.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.SparseNumberVector$Factory

Default: de.lmu.ifi.dbs.elki.data.SparseFloatVector.Factory

Known implementations:

-tf.normalize <|true|false>

Normalize vectors to manhattan length 1 (convert term counts to term frequencies)

Default: false

de.lmu.ifi.dbs.elki.distance.distancefunction.SharedNearestNeighborJaccardDistanceFunction
-distancefunction.index <class|object>

Distance index to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex$Factory

Default: de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborPreprocessor.Factory

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.WeightedCanberraDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.ArccosSimilarityAdapter
-adapter.similarityfunction <class|object>

Similarity function to derive the distance between database objects from.

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

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.LinearAdapterLinear
-adapter.similarityfunction <class|object>

Similarity function to derive the distance between database objects from.

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

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.LnSimilarityAdapter
-adapter.similarityfunction <class|object>

Similarity function to derive the distance between database objects from.

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

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.colorhistogram.HSBHistogramQuadraticDistanceFunction
-hsbhist.bpp <int_1,...,int_n>

The dimensionality of the histogram in hue, saturation and brightness.

de.lmu.ifi.dbs.elki.distance.distancefunction.colorhistogram.RGBHistogramQuadraticDistanceFunction
-rgbhist.bpp <int>

The dimensionality of the histogram in each color

de.lmu.ifi.dbs.elki.distance.distancefunction.correlation.WeightedPearsonCorrelationDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.correlation.WeightedSquaredPearsonCorrelationDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.external.DiskCacheBasedDoubleDistanceFunction
-distance.matrix <file>

The name of the file containing the distance matrix.

de.lmu.ifi.dbs.elki.distance.distancefunction.external.DiskCacheBasedFloatDistanceFunction
-distance.matrix <file>

The name of the file containing the distance matrix.

de.lmu.ifi.dbs.elki.distance.distancefunction.external.FileBasedDoubleDistanceFunction
-distance.matrix <file>

The name of the file containing the distance matrix.

-distance.parser <class|object>

Parser used to load the distance matrix.

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

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.external.AsciiDistanceParser

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.external.FileBasedFloatDistanceFunction
-distance.matrix <file>

The name of the file containing the distance matrix.

-distance.parser <class|object>

Parser used to load the distance matrix.

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

Default: de.lmu.ifi.dbs.elki.distance.distancefunction.external.AsciiDistanceParser

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.geo.DimensionSelectingLatLngDistanceFunction
-distance.latitudedim <int>

The dimension containing the latitude.

-distance.longitudedim <int>

The dimension containing the longitude.

-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.geo.LatLngDistanceFunction
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.geo.LngLatDistanceFunction
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.LPIntegerNormDistanceFunction
-lpnorm.p <int>

the degree of the L-P-Norm (positive number)

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.LPNormDistanceFunction
-lpnorm.p <double>

the degree of the L-P-Norm (positive number)

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SparseLPNormDistanceFunction
-lpnorm.p <double>

the degree of the L-P-Norm (positive number)

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.WeightedEuclideanDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.WeightedLPNormDistanceFunction
-lpnorm.p <double>

the degree of the L-P-Norm (positive number)

-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.WeightedManhattanDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.WeightedMaximumDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.WeightedSquaredEuclideanDistanceFunction
-distance.weights <double_1,...,double_n>

Weights to use for the distance function.

de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.OnedimensionalDistanceFunction
-dim <int>

an integer between 1 and the dimensionality of the feature space 1 specifying the dimension to be considered for distance computation.

de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.SubspaceEuclideanDistanceFunction
-distance.dims <int_1,...,int_n>

a comma separated array of integer values, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for distance computation. If this parameter is not set, no dimensions will be considered, i.e. the distance between two objects is always 0.

de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.SubspaceLPNormDistanceFunction
-lpnorm.p <double>

the degree of the L-P-Norm (positive number)

-distance.dims <int_1,...,int_n>

a comma separated array of integer values, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for distance computation. If this parameter is not set, no dimensions will be considered, i.e. the distance between two objects is always 0.

de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.SubspaceManhattanDistanceFunction
-distance.dims <int_1,...,int_n>

a comma separated array of integer values, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for distance computation. If this parameter is not set, no dimensions will be considered, i.e. the distance between two objects is always 0.

de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.SubspaceMaximumDistanceFunction
-distance.dims <int_1,...,int_n>

a comma separated array of integer values, where 0 <= d_i < the dimensionality of the feature space specifying the dimensions to be considered for distance computation. If this parameter is not set, no dimensions will be considered, i.e. the distance between two objects is always 0.

de.lmu.ifi.dbs.elki.distance.distancefunction.timeseries.DTWDistanceFunction
-edit.bandsize <double>

The band size for time series alignment. By default, no constraint is used. If the value is larger than 0, it will be considered absolute, otherwise relative to the longer sequence. Note that 0 does not make sense: use Euclidean distance then instead.

de.lmu.ifi.dbs.elki.distance.distancefunction.timeseries.EDRDistanceFunction
-edit.bandsize <double>

The band size for time series alignment. By default, no constraint is used. If the value is larger than 0, it will be considered absolute, otherwise relative to the longer sequence. Note that 0 does not make sense: use Euclidean distance then instead.

-edr.delta <double>

the delta parameter (similarity threshold) for EDR (positive number)

Default: 1.0

de.lmu.ifi.dbs.elki.distance.distancefunction.timeseries.ERPDistanceFunction
-edit.bandsize <double>

The band size for time series alignment. By default, no constraint is used. If the value is larger than 0, it will be considered absolute, otherwise relative to the longer sequence. Note that 0 does not make sense: use Euclidean distance then instead.

-erp.g <double>

The g parameter of ERP - comparison value to use in gaps.

Default: 0.0

de.lmu.ifi.dbs.elki.distance.distancefunction.timeseries.LCSSDistanceFunction
-lcss.pDelta <double>

the allowed deviation in x direction for LCSS alignment (positive double value, 0 <= pDelta <= 1)

Default: 0.1

-lcss.pEpsilon <double>

the allowed deviation in y direction for LCSS alignment (positive double value, 0 <= pEpsilon <= 1)

Default: 0.05

de.lmu.ifi.dbs.elki.distance.similarityfunction.FractionalSharedNearestNeighborSimilarityFunction
-similarityfunction.preprocessor <class|object>

Preprocessor to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex$Factory

Default: de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborPreprocessor.Factory

Known implementations:

de.lmu.ifi.dbs.elki.distance.similarityfunction.SharedNearestNeighborSimilarityFunction
-similarityfunction.preprocessor <class|object>

Preprocessor to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex$Factory

Default: de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborPreprocessor.Factory

Known implementations:

de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.LaplaceKernelFunction
-kernel.laplace.sigma <double>

Standard deviation of the laplace RBF kernel.

Default: 1.0

de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.PolynomialKernelFunction
-kernel.polynomial.degree <int>

The degree of the polynomial kernel function. Default: 2

Default: 2

-kernel.polynomial.bias <double>

The bias of the polynomial kernel, a constant that is added to the scalar product.

de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.RadialBasisFunctionKernelFunction
-kernel.rbf.sigma <double>

Standard deviation of the Gaussian RBF kernel.

Default: 1.0

de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.RationalQuadraticKernelFunction
-kernel.rationalquadratic.c <double>

Constant term in the rational quadratic kernel.

Default: 1.0

de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.SigmoidKernelFunction
-kernel.sigmoid.c <double>

Sigmoid c parameter (scaling).

Default: 1.0

-kernel.sigmoid.theta <double>

Sigmoid theta parameter (bias).

Default: 0.0

de.lmu.ifi.dbs.elki.evaluation.classification.holdout.DisjointCrossValidation
-holdout.seed <long|Random>

Random generator seed for holdout evaluation.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-nfold <int>

Number of folds for cross-validation.

Default: 10

de.lmu.ifi.dbs.elki.evaluation.classification.holdout.RandomizedCrossValidation
-holdout.seed <long|Random>

Random generator seed for holdout evaluation.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-nfold <int>

positive number of folds for cross-validation

Default: 10

de.lmu.ifi.dbs.elki.evaluation.classification.holdout.StratifiedCrossValidation
-nfold <int>

Number of folds for cross-validation

Default: 10

de.lmu.ifi.dbs.elki.evaluation.clustering.EvaluateClustering
-paircounting.reference <class|object>

Reference clustering to compare with. Defaults to a by-label clustering.

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

Default: de.lmu.ifi.dbs.elki.algorithm.clustering.trivial.ByLabelOrAllInOneClustering

Known implementations:

-paircounting.noisespecial <|true|false>

Use special handling for noise clusters.

Default: false

-paircounting.selfpair <|true|false>

Enable self-pairing for cluster comparison.

Default: false

de.lmu.ifi.dbs.elki.evaluation.clustering.internal.EvaluateCIndex
-c-index.distance <class|object>

Distance function to use for computing the c-index.

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

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

Known implementations:

-c-index.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.evaluation.clustering.internal.EvaluateConcordantPairs
-concordant.distance <class|object>

Distance function to use for measuring concordant and discordant pairs.

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

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

Known implementations:

-davies-bouldin.noisehandling <MERGE_NOISE | TREAT_NOISE_AS_SINGLETONS | IGNORE_NOISE>

option, how noise should be treated.

Default: TREAT_NOISE_AS_SINGLETONS

de.lmu.ifi.dbs.elki.evaluation.clustering.internal.EvaluateDaviesBouldin
-davies-bouldin.distance <class|object>

Distance function to use for computing the davies-bouldin index.

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

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

Known implementations:

-davies-bouldin.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.evaluation.clustering.internal.EvaluatePBMIndex
-pbm.distance <class|object>

Distance function to use for computing PBM.

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

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

Known implementations:

-pbm.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.evaluation.clustering.internal.EvaluateSilhouette
-silhouette.distance <class|object>

Distance function to use for computing the silhouette.

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

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

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.evaluation.clustering.internal.EvaluateSimplifiedSilhouette
-silhouette.distance <class|object>

Distance function to use for computing the silhouette.

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

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

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.evaluation.clustering.internal.EvaluateSquaredErrors
-ssq.distance <class|object>

Distance function to use for computing the SSQ.

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

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

Known implementations:

-ssq.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.evaluation.clustering.internal.EvaluateVarianceRatioCriteria
-vrc.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.evaluation.histogram.ComputeOutlierHistogram
-comphist.positive <pattern>

Class label for the 'positive' class.

-comphist.bins <int>

number of bins

Default: 50

-comphist.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Default: de.lmu.ifi.dbs.elki.utilities.scaling.IdentityScaling

Known implementations:

-histogram.splitfreq <|true|false>

Use separate frequencies for outliers and non-outliers.

Default: false

de.lmu.ifi.dbs.elki.evaluation.outlier.JudgeOutlierScores
-comphist.positive <pattern>

Class label for the 'positive' class.

-comphist.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Default: de.lmu.ifi.dbs.elki.utilities.scaling.IdentityScaling

Known implementations:

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierPrecisionAtKCurve
-precision.positive <pattern>

Class label for the 'positive' class.

-precision.maxk <int>

Maximum value of 'k' to compute the curve up to.

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierPrecisionRecallCurve
-precision.positive <pattern>

Class label for the 'positive' class.

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierROCCurve
-rocauc.positive <pattern>

Class label for the 'positive' class.

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierRankingEvaluation
-outliereval.positive <pattern>

Class label for the 'positive' class.

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierSmROCCurve
-rocauc.positive <pattern>

Class label for the 'positive' class.

de.lmu.ifi.dbs.elki.evaluation.outlier.OutlierThresholdClustering
-thresholdclust.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Default: de.lmu.ifi.dbs.elki.utilities.scaling.IdentityScaling

Known implementations:

-thresholdclust.threshold <double_1,...,double_n>

Threshold(s) to apply.

de.lmu.ifi.dbs.elki.evaluation.scores.PrecisionAtKEvaluation
-precision.k <int>

k value for precision@k. Can be set to 0, to get R-precision, or the precision-recall-break-even-point.

Default: 0

de.lmu.ifi.dbs.elki.evaluation.similaritymatrix.ComputeSimilarityMatrixImage
-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:

-simmatrix.scaling <class|object>

Class to use as scaling function.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction

Known implementations:

-simmatrix.skipzero <|true|false>

Skip zero values when computing the colors to increase contrast.

Default: false

de.lmu.ifi.dbs.elki.index.distancematrix.PrecomputedDistanceMatrix$Factory
-matrix.distance <class|object>

Distance function for the precomputed distance matrix.

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

Known implementations:

de.lmu.ifi.dbs.elki.index.idistance.InMemoryIDistanceIndex$Factory
-idistance.distance <class|object>

Distance function to build the index for.

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

Known implementations:

-idistance.reference <class|object>

Method to choose the reference points.

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

Known implementations:

-idistance.k <int>

Number of reference points to use.

de.lmu.ifi.dbs.elki.index.lsh.InMemoryLSHIndex
-lsh.family <class|object>

Hash function family to use for LSH.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.lsh.hashfamilies.LocalitySensitiveHashFunctionFamily

Known implementations:

-lsh.tables <int>

Number of hash tables to use.

-lsh.buckets <int>

Number of hash buckets to use.

Default: 7919

de.lmu.ifi.dbs.elki.index.lsh.hashfamilies.CosineHashFunctionFamily
-lsh.projection.random <long|Random>

Random seed for generating the projections.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-lsh.projection.projections <int>

Number of projections to use for each hash function.

de.lmu.ifi.dbs.elki.index.lsh.hashfamilies.EuclideanHashFunctionFamily
-lsh.projection.random <long|Random>

Random seed for generating the projections.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-lsh.projection.width <double>

Bin width for random projections.

-lsh.projection.projections <int>

Number of projections to use for each hash function.

de.lmu.ifi.dbs.elki.index.lsh.hashfamilies.ManhattanHashFunctionFamily
-lsh.projection.random <long|Random>

Random seed for generating the projections.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-lsh.projection.width <double>

Bin width for random projections.

-lsh.projection.projections <int>

Number of projections to use for each hash function.

de.lmu.ifi.dbs.elki.index.preprocessed.fastoptics.RandomProjectedNeighborsAndDensities
-fastoptics.randomproj.seed <long|Random>

Random seed for generating projections.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.CachedDoubleDistanceKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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

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

Known implementations:

-external.knnfile <file>

Filename with the precomputed k nearest neighbors.

de.lmu.ifi.dbs.elki.index.preprocessed.knn.KNNJoinMaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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.index.preprocessed.knn.MaterializeKNNAndRKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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.index.preprocessed.knn.MaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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.index.preprocessed.knn.MetricalIndexApproximationMaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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.index.preprocessed.knn.NaiveProjectedKNNPreprocessor$Factory
-projections.windowmult <double>

Window size multiplicator.

Default: 10.0

-projections.projections <int>

Number of projections to use.

-projections.family <class|object>

Random projection family to use. The default is to use the original axes.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.RandomProjectionFamily

Known implementations:

-projections.seed <long|Random>

Random generator.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.PartitionApproximationMaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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

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

Known implementations:

-partknn.p <int>

The number of partitions to use for approximate kNN.

-partknn.seed <long|Random>

The random number generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.RandomSampleKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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

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

Known implementations:

-randomknn.share <double>

The relative amount of objects to consider for kNN computations.

-randomknn.seed <long|Random>

The random number seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.SpacefillingKNNPreprocessor$Factory
-sfcknn.curves <object_1|class_1,...,object_n|class_n>

Space filling curve generators to use for kNN approximation.

Known implementations:

-sfcknn.windowmult <double>

Window size multiplicator.

Default: 10.0

-sfcknn.variants <int>

Number of curve variants to generate.

Default: 1

-sfcknn.dim <int>

Number of dimensions to use for each curve.

-sfcknn.proj <class|object>

Random projection to use.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.RandomProjectionFamily

Known implementations:

-sfcknn.seed <long|Random>

Random generator.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.SpacefillingMaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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

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

Known implementations:

-sfcknn.curves <object_1|class_1,...,object_n|class_n>

Space filling curve generators to use for kNN approximation.

Known implementations:

-sfcknn.windowmult <double>

Window size multiplicator.

Default: 10.0

-sfcknn.variants <int>

Number of curve variants to generate.

Default: 1

-sfcknn.seed <long|Random>

Random generator.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.preprocessed.knn.SpatialApproximationMaterializeKNNPreprocessor$Factory
-materialize.k <int>

The number of nearest neighbors of an object to be materialized.

-materialize.distance <class|object>

the distance function to materialize the nearest neighbors

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.index.preprocessed.localpca.KNNQueryFilteredPCAIndex$Factory
-localpca.distancefunction <class|object>

The distance function used to select objects for running PCA.

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

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

Known implementations:

-localpca.k <int>

The number of nearest neighbors considered in the PCA. If this parameter is not set, k ist set to three times of the dimensionality of the database objects.

de.lmu.ifi.dbs.elki.index.preprocessed.preference.DiSHPreferenceVectorIndex$Factory
-dish.minpts <int>

Positive threshold for minumum numbers of points in the epsilon-neighborhood of a point. The value of the preference vector in dimension d_i is set to 1 if the epsilon neighborhood contains more than dish.minpts points and the following condition holds: for all dimensions d_j: |neighbors(d_i) intersection neighbors(d_j)| >= dish.minpts.

-dish.epsilon <double_1,...,double_n>

A comma separated list of positive doubles specifying the maximum radius of the neighborhood to be considered in each dimension for determination of the preference vector (default is 0.001 in each dimension). If only one value is specified, this value will be used for each dimension.

Default: [D@42deb43a

-dish.strategy <APRIORI | MAX_INTERSECTION>

The strategy for determination of the preference vector, available strategies are: [APRIORI| MAX_INTERSECTION](default is MAX_INTERSECTION)

Default: MAX_INTERSECTION

de.lmu.ifi.dbs.elki.index.preprocessed.preference.HiSCPreferenceVectorIndex$Factory
-hisc.alpha <double>

The maximum absolute variance along a coordinate axis.

Default: 0.01

-hisc.k <int>

The number of nearest neighbors considered to determine the preference vector. If this value is not defined, k ist set to three times of the dimensionality of the database objects.

de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborPreprocessor$Factory
-sharedNearestNeighbors <int>

number of nearest neighbors to consider (at least 1)

-SNNDistanceFunction <class|object>

the distance function to asses the nearest neighbors

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.index.projected.LatLngAsECEFIndex$Factory
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

-projindex.inner <class|object>

Index to use on the projected data.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.IndexFactory

Known implementations:

-projindex.materialize <|true|false>

Flag to materialize the projected data.

Default: false

-projindex.disable-refine <|true|false>

Flag to disable refinement of distances.

Default: false

de.lmu.ifi.dbs.elki.index.projected.LngLatAsECEFIndex$Factory
-geo.model <class|object>

Earth model to use for projection. Default: spherical model.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.geodesy.EarthModel

Default: de.lmu.ifi.dbs.elki.math.geodesy.SphericalVincentyEarthModel

Known implementations:

-projindex.inner <class|object>

Index to use on the projected data.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.IndexFactory

Known implementations:

-projindex.materialize <|true|false>

Flag to materialize the projected data.

Default: false

-projindex.disable-refine <|true|false>

Flag to disable refinement of distances.

Default: false

de.lmu.ifi.dbs.elki.index.projected.PINN
-projindex.inner <class|object>

Index to use on the projected data.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.IndexFactory

Known implementations:

-pinn.t <int>

Target dimensionality.

-pinn.s <double>

Sparsity of the random projection.

Default: 1.0

-pinn.hmult <double>

Multiplicator for neighborhood size.

Default: 3.0

-pinn.seed <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.projected.ProjectedIndex$Factory
-projindex.proj <class|object>

Projection to use for the projected index.

Class Restriction: implements de.lmu.ifi.dbs.elki.data.projection.Projection

Known implementations:

-projindex.inner <class|object>

Index to use on the projected data.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.IndexFactory

Known implementations:

-projindex.materialize <|true|false>

Flag to materialize the projected data.

Default: false

-projindex.disable-refine <|true|false>

Flag to disable refinement of distances.

Default: false

-projindex.kmulti <double>

Multiplier for k.

Default: 1.0

de.lmu.ifi.dbs.elki.index.tree.metrical.covertree.CoverTree$Factory
-covertree.distancefunction <class|object>

Distance function to determine the distance between objects.

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

Known implementations:

-covertree.truncate <int>

Truncate tree when branches have less than this number of instances.

Default: 10

-covertree.expansionrate <double>

Expansion rate of the tree (Default: 1.3).

Default: 1.3

de.lmu.ifi.dbs.elki.index.tree.metrical.covertree.SimplifiedCoverTree$Factory
-covertree.distancefunction <class|object>

Distance function to determine the distance between objects.

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

Known implementations:

-covertree.truncate <int>

Truncate tree when branches have less than this number of instances.

Default: 10

-covertree.expansionrate <double>

Expansion rate of the tree (Default: 1.3).

Default: 1.3

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mkapp.MkAppTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-mtree.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:

-mtree.split <class|object>

Split strategy to use for constructing the M-tree.

Class Restriction: extends de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MTreeSplit

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MLBDistSplit

Known implementations:

-mtree.insert <class|object>

Insertion strategy to use for constructing the M-tree.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MTreeInsert

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MinimumEnlargementInsert

Known implementations:

-mkapp.k <int>

positive integer specifying the maximum number k of reverse k nearest neighbors to be supported.

-mkapp.p <int>

positive integer specifying the order of the polynomial approximation.

-mkapp.nolog <|true|false>

Flag to indicate that the approximation is done in the ''normal'' space instead of the log-log space (which is default).

Default: false

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mkcop.MkCopTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-mtree.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:

-mtree.split <class|object>

Split strategy to use for constructing the M-tree.

Class Restriction: extends de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MTreeSplit

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MLBDistSplit

Known implementations:

-mtree.insert <class|object>

Insertion strategy to use for constructing the M-tree.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MTreeInsert

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MinimumEnlargementInsert

Known implementations:

-mkcop.k <int>

positive integer specifying the maximum number k of reverse k nearest neighbors to be supported.

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mkmax.MkMaxTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-mtree.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:

-mtree.split <class|object>

Split strategy to use for constructing the M-tree.

Class Restriction: extends de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MTreeSplit

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MLBDistSplit

Known implementations:

-mtree.insert <class|object>

Insertion strategy to use for constructing the M-tree.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MTreeInsert

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MinimumEnlargementInsert

Known implementations:

-mktree.kmax <int>

Specifies the maximal number k of reverse k nearest neighbors to be supported.

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mktab.MkTabTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-mtree.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:

-mtree.split <class|object>

Split strategy to use for constructing the M-tree.

Class Restriction: extends de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MTreeSplit

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MLBDistSplit

Known implementations:

-mtree.insert <class|object>

Insertion strategy to use for constructing the M-tree.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MTreeInsert

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MinimumEnlargementInsert

Known implementations:

-mktree.kmax <int>

Specifies the maximal number k of reverse k nearest neighbors to be supported.

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mtree.MTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-mtree.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:

-mtree.split <class|object>

Split strategy to use for constructing the M-tree.

Class Restriction: extends de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MTreeSplit

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MLBDistSplit

Known implementations:

-mtree.insert <class|object>

Insertion strategy to use for constructing the M-tree.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MTreeInsert

Default: de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.insert.MinimumEnlargementInsert

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.RandomSplit
-mtree.randomsplit.random <long|Random>

Random generator / seed for the randomized split.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.index.tree.spatial.kd.MinimalisticMemoryKDTree$Factory
-kd.leafsize <int>

Maximum leaf size for the k-d-tree. Nodes will be split until their size is smaller than this threshold.

Default: 1

de.lmu.ifi.dbs.elki.index.tree.spatial.kd.SmallMemoryKDTree$Factory
-kd.leafsize <int>

Maximum leaf size for the k-d-tree. Nodes will be split until their size is smaller than this threshold.

Default: 1

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.deliclu.DeLiCluTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-rtree.insertionstrategy <class|object>

The strategy to use for object insertion.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.CombinedInsertionStrategy

Known implementations:

-rtree.splitstrategy <class|object>

The strategy to use for node splitting.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.SplitStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.TopologicalSplitter

Known implementations:

-rtree.minimum-fill <double>

Minimum relative fill required for data pages.

Default: 0.4

-rtree.overflowtreatment <class|object>

The strategy to use for handling overflows.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.OverflowTreatment

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.LimitedReinsertOverflowTreatment

Known implementations:

-spatial.bulkstrategy <class|object>

The class to perform the bulk split with.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.BulkSplit

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.flat.FlatRStarTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-rtree.insertionstrategy <class|object>

The strategy to use for object insertion.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.CombinedInsertionStrategy

Known implementations:

-rtree.splitstrategy <class|object>

The strategy to use for node splitting.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.SplitStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.TopologicalSplitter

Known implementations:

-rtree.minimum-fill <double>

Minimum relative fill required for data pages.

Default: 0.4

-rtree.overflowtreatment <class|object>

The strategy to use for handling overflows.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.OverflowTreatment

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.LimitedReinsertOverflowTreatment

Known implementations:

-spatial.bulkstrategy <class|object>

The class to perform the bulk split with.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.BulkSplit

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rdknn.RdKNNTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-rtree.insertionstrategy <class|object>

The strategy to use for object insertion.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.CombinedInsertionStrategy

Known implementations:

-rtree.splitstrategy <class|object>

The strategy to use for node splitting.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.SplitStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.TopologicalSplitter

Known implementations:

-rtree.minimum-fill <double>

Minimum relative fill required for data pages.

Default: 0.4

-rtree.overflowtreatment <class|object>

The strategy to use for handling overflows.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.OverflowTreatment

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.LimitedReinsertOverflowTreatment

Known implementations:

-spatial.bulkstrategy <class|object>

The class to perform the bulk split with.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.BulkSplit

Known implementations:

-rdknn.k <int>

positive integer specifying the maximal number k of reverse k nearest neighbors to be supported.

-rdknn.distancefunction <class|object>

Distance function to determine the distance between database objects.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rstar.RStarTreeFactory
-index.pagefile <class|object>

The pagefile factory for storing the index.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory

Known implementations:

-rtree.insertionstrategy <class|object>

The strategy to use for object insertion.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.CombinedInsertionStrategy

Known implementations:

-rtree.splitstrategy <class|object>

The strategy to use for node splitting.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.SplitStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.TopologicalSplitter

Known implementations:

-rtree.minimum-fill <double>

Minimum relative fill required for data pages.

Default: 0.4

-rtree.overflowtreatment <class|object>

The strategy to use for handling overflows.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.OverflowTreatment

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.LimitedReinsertOverflowTreatment

Known implementations:

-spatial.bulkstrategy <class|object>

The class to perform the bulk split with.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.BulkSplit

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.SpatialSortBulkSplit
-rtree.bulk.spatial-sort <class|object>

Strategy for spatial sorting in bulk loading.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.spacefillingcurves.SpatialSorter

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.ApproximativeLeastOverlapInsertionStrategy
-rtree.insertion-candidates <int>

defines how many children are tested for finding the child generating the least overlap when inserting an object.

Default: 32

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.CombinedInsertionStrategy
-rtree.insert-directory <class>

Insertion strategy for directory nodes.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.LeastEnlargementWithAreaInsertionStrategy

Known implementations:

-rtree.insert-leaf <class>

Insertion strategy for leaf nodes.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.InsertionStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.LeastOverlapInsertionStrategy

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.overflow.LimitedReinsertOverflowTreatment
-rtree.reinsertion-strategy <class|object>

The strategy to select candidates for reinsertion.

Class Restriction: implements de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.reinsert.ReinsertStrategy

Default: de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.reinsert.CloseReinsert

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.reinsert.CloseReinsert
-rtree.reinsertion-amount <double>

The amount of entries to reinsert.

Default: 0.3

-rtree.reinsertion-distancce <class|object>

The distance function to compute reinsertion candidates by.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.reinsert.FarReinsert
-rtree.reinsertion-amount <double>

The amount of entries to reinsert.

Default: 0.3

-rtree.reinsertion-distancce <class|object>

The distance function to compute reinsertion candidates by.

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

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

Known implementations:

de.lmu.ifi.dbs.elki.index.vafile.PartialVAFile$Factory
-pagefile.pagesize <int>

The size of a page in bytes.

Default: 1024

-vafile.partitions <int>

Number of partitions to use in each dimension.

de.lmu.ifi.dbs.elki.index.vafile.VAFile$Factory
-pagefile.pagesize <int>

The size of a page in bytes.

Default: 1024

-vafile.partitions <int>

Number of partitions to use in each dimension.

de.lmu.ifi.dbs.elki.math.dimensionsimilarity.HiCSDimensionSimilarity
-hics.m <int>

The number of iterations in the Monte-Carlo processing.

Default: 50

-hics.alpha <double>

The discriminance value that determines the size of the test statistic .

Default: 0.1

-hics.test <class|object>

The statistical test that is used to calculate the deviation of two data samples

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.tests.GoodnessOfFitTest

Default: de.lmu.ifi.dbs.elki.math.statistics.tests.KolmogorovSmirnovTest

Known implementations:

-hics.seed <long|Random>

The random seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.CompositeEigenPairFilter
-pca.filter.composite.list <object_1|class_1,...,object_n|class_n>

A comma separated list of the class names of the filters to be used. The specified filters will be applied sequentially in the given order.

Known implementations:

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.DropEigenPairFilter
-pca.filter.weakalpha <double>

The minimum strength of the statistically expected variance (1/n) share an eigenvector needs to have to be considered 'strong'.

Default: 0.0

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.FirstNEigenPairFilter
-pca.filter.n <int>

The number of strong eigenvectors: n eigenvectors with the n highesteigenvalues are marked as strong eigenvectors.

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.LimitEigenPairFilter
-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.01

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredAutotuningRunner
-pca.covariance <class|object>

Class used to compute the covariance matrix.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.CovarianceMatrixBuilder

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

Known implementations:

-pca.filter <class|object>

Filter class to determine the strong and weak eigenvectors.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.EigenPairFilter

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

Known implementations:

-pca.big <double>

A constant big value to reset high eigenvalues.

Default: 1.0

-pca.small <double>

A constant small value to reset low eigenvalues.

Default: 0.0

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredRunner
-pca.covariance <class|object>

Class used to compute the covariance matrix.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.CovarianceMatrixBuilder

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

Known implementations:

-pca.filter <class|object>

Filter class to determine the strong and weak eigenvectors.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.EigenPairFilter

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

Known implementations:

-pca.big <double>

A constant big value to reset high eigenvalues.

Default: 1.0

-pca.small <double>

A constant small value to reset low eigenvalues.

Default: 0.0

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCARunner
-pca.covariance <class|object>

Class used to compute the covariance matrix.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.CovarianceMatrixBuilder

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

Known implementations:

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PercentageEigenPairFilter
-pca.filter.alpha <double>

The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors.The filter class will choose the number of strong eigenvectors by this share.

Default: 0.85

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.ProgressiveEigenPairFilter
-pca.filter.progressivealpha <double>

The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors.The filter class will choose the number of strong eigenvectors by this share.

Default: 0.5

-pca.filter.weakalpha <double>

The minimum strength of the statistically expected variance (1/n) share an eigenvector needs to have to be considered 'strong'.

Default: 0.95

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.RANSACCovarianceMatrixBuilder
-ransacpca.iterations <int>

The number of iterations to perform.

Default: 1000

-ransacpca.seed <long|Random>

Random seed (optional).

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.RelativeEigenPairFilter
-pca.filter.relativealpha <double>

The sensitivity niveau for weak eigenvectors: An eigenvector which is at less than the given share of the statistical average variance is considered weak.

Default: 1.1

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.SignificantEigenPairFilter
-pca.filter.weakalpha <double>

The minimum strength of the statistically expected variance (1/n) share an eigenvector needs to have to be considered 'strong'.

Default: 0.0

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.WeakEigenPairFilter
-pca.filter.weakalpha <double>

The minimum strength of the statistically expected variance (1/n) share an eigenvector needs to have to be considered 'strong'.

Default: 0.95

de.lmu.ifi.dbs.elki.math.linearalgebra.pca.WeightedCovarianceMatrixBuilder
-pca.weight <class|object>

Weight function to use in weighted PCA.

Class Restriction: implements de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.WeightFunction

Default: de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.ConstantWeight

Known implementations:

de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.AchlioptasRandomProjectionFamily
-randomproj.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-achlioptas.sparsity <double>

Frequency of zeros in the projection matrix.

Default: 3.0

de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.CauchyRandomProjectionFamily
-randomproj.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.GaussianRandomProjectionFamily
-randomproj.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.RandomSubsetProjectionFamily
-randomproj.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.linearalgebra.randomprojections.SimplifiedRandomHyperplaneProjectionFamily
-randomproj.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.statistics.dependence.HiCSDependenceMeasure
-hics.m <int>

The number of iterations in the Monte-Carlo processing.

Default: 50

-hics.alpha <double>

The discriminance value that determines the size of the test statistic .

Default: 0.1

-hics.test <class|object>

The statistical test that is used to calculate the deviation of two data samples

Class Restriction: implements de.lmu.ifi.dbs.elki.math.statistics.tests.GoodnessOfFitTest

Default: de.lmu.ifi.dbs.elki.math.statistics.tests.KolmogorovSmirnovTest

Known implementations:

-hics.seed <long|Random>

The random seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.math.statistics.distribution.BetaDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.beta.alpha <double>

Beta distribution alpha parameter

-distribution.beta.beta <double>

Beta distribution beta parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.CauchyDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.cauchy.shape <double>

Cauchy distribution gamma/shape parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.ChiDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.chi.dof <double>

Chi distribution degrees of freedom parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.ChiSquaredDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.chi.dof <double>

Chi distribution degrees of freedom parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.ConstantDistribution
-distribution.constant <double>

Constant value.

de.lmu.ifi.dbs.elki.math.statistics.distribution.ExponentialDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.exponential.rate <double>

Exponential distribution rate (lambda) parameter (inverse of scale).

de.lmu.ifi.dbs.elki.math.statistics.distribution.ExponentiallyModifiedGaussianDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.exponential.rate <double>

Exponential distribution rate (lambda) parameter (inverse of scale).

de.lmu.ifi.dbs.elki.math.statistics.distribution.GammaDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.gamma.k <double>

Gamma distribution k = alpha parameter.

-distribution.gamma.theta <double>

Gamma distribution theta = 1/beta parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.GeneralizedExtremeValueDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.GeneralizedLogisticAlternateDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.GeneralizedLogisticDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.GeneralizedParetoDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.GumbelDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.HaltonUniformDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.min <double>

Minimum value of distribution.

-distribution.max <double>

Maximum value of distribution.

de.lmu.ifi.dbs.elki.math.statistics.distribution.KappaDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.kappa.shape1 <double>

First shape parameter of kappa distribution.

-distribution.kappa.shape2 <double>

Second shape parameter of kappa distribution.

de.lmu.ifi.dbs.elki.math.statistics.distribution.LaplaceDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.laplace.rate <double>

Laplace distribution rate (lambda) parameter (inverse of scale).

de.lmu.ifi.dbs.elki.math.statistics.distribution.LogGammaAlternateDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.gamma.k <double>

Gamma distribution k = alpha parameter.

-distribution.gamma.theta <double>

Gamma distribution theta = 1/beta parameter.

-distribution.loggamma.shift <double>

Shift offset parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.LogGammaDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.gamma.k <double>

Gamma distribution k = alpha parameter.

-distribution.gamma.theta <double>

Gamma distribution theta = 1/beta parameter.

-distribution.loggamma.shift <double>

Shift offset parameter.

de.lmu.ifi.dbs.elki.math.statistics.distribution.LogLogisticDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.LogNormalDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.lognormal.logmean <double>

Mean of the distribution before logscaling.

-distribution.lognormal.logstddev <double>

Standard deviation of the distribution before logscaling.

-distribution.lognormal.shift <double>

Shifting offset, so the distribution does not begin at 0.

Default: 0.0

de.lmu.ifi.dbs.elki.math.statistics.distribution.LogisticDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.scale <double>

Distribution scale parameter

-distribution.location <double>

Distribution location parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.NormalDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.PoissonDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.poisson.n <int>

Number of trials.

-distribution.poisson.probability <double>

Success probability.

de.lmu.ifi.dbs.elki.math.statistics.distribution.RayleighDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

Default: 0.0

-distribution.scale <double>

Distribution scale parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.SkewGeneralizedNormalDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.scale <double>

Distribution scale parameter

-distribution.skewgnormal.skew <double>

Skew of the distribution.

de.lmu.ifi.dbs.elki.math.statistics.distribution.StudentsTDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.studentst.nu <int>

Degrees of freedom.

de.lmu.ifi.dbs.elki.math.statistics.distribution.UniformDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.min <double>

Minimum value of distribution.

-distribution.max <double>

Maximum value of distribution.

de.lmu.ifi.dbs.elki.math.statistics.distribution.WaldDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.WeibullDistribution
-distribution.random <long|Random>

Random generation data source.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

-distribution.location <double>

Distribution location parameter

Default: 0.0

-distribution.scale <double>

Distribution scale parameter

-distribution.shape <double>

Distribution shape parameter

de.lmu.ifi.dbs.elki.math.statistics.distribution.estimator.meta.TrimmedEstimator
-trimmedestimate.inner <class|object>

Estimator to use on the trimmed data.

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

Known implementations:

-trimmedestimate.trim <double>

Relative amount of data to trim on each end, must be 0 < trim < 0.5

de.lmu.ifi.dbs.elki.math.statistics.distribution.estimator.meta.WinsorisingEstimator
-winsorize.inner <class|object>

Estimator to use on the winsorized data.

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

Known implementations:

-winsorize.winsorize <double>

Relative amount of data to winsorize on each end, must be 0 < winsorize < 0.5

de.lmu.ifi.dbs.elki.persistent.LRUCachePageFileFactory
-pagefile.pagefile <class|object>

The backing pagefile for the cache.

Class Restriction: implements de.lmu.ifi.dbs.elki.persistent.PageFileFactory

Default: de.lmu.ifi.dbs.elki.persistent.PersistentPageFileFactory

Known implementations:

-pagefile.cachesize <int>

The size of the cache in bytes.

de.lmu.ifi.dbs.elki.persistent.MemoryPageFileFactory
-pagefile.pagesize <int>

The size of a page in bytes.

Default: 4000

de.lmu.ifi.dbs.elki.persistent.OnDiskArrayPageFileFactory
-pagefile.pagesize <int>

The size of a page in bytes.

Default: 4000

-pagefile.file <file>

The name of the file storing the page file.

de.lmu.ifi.dbs.elki.persistent.PersistentPageFileFactory
-pagefile.pagesize <int>

The size of a page in bytes.

Default: 4000

-pagefile.file <file>

The name of the file storing the page file.

de.lmu.ifi.dbs.elki.result.ClusteringVectorDumper
-clustering.output <file>

Output file name. When not given, the result will be written to stdout.

-clustering.output.append <|true|false>

Always append to the output file.

Default: false

-clustering.label <string>

Parameter to override the clustering label, mostly to give a more descriptive label.

de.lmu.ifi.dbs.elki.result.KMLOutputHandler
-out <file>

Filename the KMZ file (compressed KML) is written to.

-kml.scaling <class|object>

Additional scaling function for KML colorization.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction

Default: de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierLinearScaling

Known implementations:

-kml.compat <|true|false>

Use simpler KML objects, compatibility mode.

Default: false

-kml.autoopen <|true|false>

Automatically open the result file.

Default: false

de.lmu.ifi.dbs.elki.result.ResultWriter
-out <file>

Directory name (or name of an existing file) to write the obtained results in. If this parameter is omitted, per default the output will sequentially be given to STDOUT.

-out.gzip <|true|false>

Enable gzip compression of output files.

Default: false

-out.silentoverwrite <|true|false>

Silently overwrite output files.

Default: false

-out.filter <pattern>

Filter pattern for output selection. Only output streams that match the given pattern will be written.

de.lmu.ifi.dbs.elki.utilities.ensemble.EnsembleVotingMedian
-ensemble.median.quantile <double>

Quantile to use in median voting.

Default: 0.5

de.lmu.ifi.dbs.elki.utilities.referencepoints.AxisBasedReferencePoints
-axisref.scale <double>

Scale the data space extension by the given factor.

Default: 1.0

de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints
-grid.size <int>

The number of partitions in each dimension. Points will be placed on the edges of the grid, except for a grid size of 0, where only the mean is generated as reference point.

Default: 1

-grid.scale <double>

Scale the grid by the given factor. This can be used to obtain reference points outside the used data space.

Default: 1.0

de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomGeneratedReferencePoints
-generate.n <int>

The number of reference points to be generated.

-generate.scale <double>

Scale the grid by the given factor. This can be used to obtain reference points outside the used data space.

Default: 1.0

-generate.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomSampleReferencePoints
-sample.n <int>

The number of samples to draw.

-sample.random <long|Random>

Random generator seed.

Default: de.lmu.ifi.dbs.elki.math.random.RandomFactory@5af9926a

de.lmu.ifi.dbs.elki.utilities.referencepoints.StarBasedReferencePoints
-star.nocenter <|true|false>

Do not use the center as extra reference point.

Default: false

-star.scale <double>

Scale the reference points by the given factor. This can be used to obtain reference points outside the used data space.

Default: 1.0

de.lmu.ifi.dbs.elki.utilities.scaling.ClipScaling
-clipscale.min <double>

Minimum value to allow.

-clipscale.max <double>

Maximum value to allow.

de.lmu.ifi.dbs.elki.utilities.scaling.GammaScaling
-scaling.gamma <double>

Gamma value for scaling.

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.COPOutlierScaling
-copscaling.phi <double>

Phi parameter, expected rate of outliers. Set to 0 to use raw CDF values.

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.MinusLogStandardDeviationScaling
-stddevscale.mean <double>

Fixed mean to use in standard deviation scaling.

-stddevscale.lambda <double>

Significance level to use for error function.

Default: 3.0

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierGammaScaling
-gammascale.normalize <|true|false>

Regularize scores before using Gamma scaling.

Default: false

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierLinearScaling
-linearscale.min <double>

Fixed minimum to use in linear scaling.

-linearscale.max <double>

Fixed maximum to use in linear scaling.

-linearscale.usemean <|true|false>

Use the mean as minimum for scaling.

Default: false

-linearscale.ignorezero <|true|false>

Ignore zero entries when computing the minimum and maximum.

Default: false

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierSqrtScaling
-sqrtscale.min <double>

Fixed minimum to use in sqrt scaling.

-sqrtscale.max <double>

Fixed maximum to use in sqrt scaling.

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.SqrtStandardDeviationScaling
-sqrtstddevscale.min <double>

Fixed minimum to use in sqrt scaling.

-sqrtstddevscale.mean <double>

Fixed mean to use in standard deviation scaling.

-sqrtstddevscale.lambda <double>

Significance level to use for error function.

Default: 3.0

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.StandardDeviationScaling
-stddevscale.mean <double>

Fixed mean to use in standard deviation scaling.

-stddevscale.lambda <double>

Significance level to use for error function.

Default: 3.0

de.lmu.ifi.dbs.elki.utilities.scaling.outlier.TopKOutlierScaling
-topk.k <int>

Number of outliers to keep.

-topk.binary <|true|false>

Make the top k a binary scaling.

Default: false

de.lmu.ifi.dbs.elki.visualization.ExportVisualizations
-vis.output <file>

The output folder.

-vis.ratio <double>

The width/heigh ratio of the output.

Default: 1.33

de.lmu.ifi.dbs.elki.visualization.VisualizerParameterizer
-vis.sampling <int>

Maximum number of objects to visualize by default (for performance reasons).

Default: 10000

-visualizer.stylesheet <string>

Style properties file to use, included properties: classic, default, greyscale, neon, presentation, print

Default: default

-vis.enable <pattern>

Visualizers to enable by default.

de.lmu.ifi.dbs.elki.visualization.gui.ResultVisualizer
-vis.window.title <string>

Title to use for visualization window.

-vis.window.single <|true|false>

Embed visualizers in a single window, not using thumbnails and detail views.

Default: false

de.lmu.ifi.dbs.elki.visualization.projector.HistogramFactory
-vis.maxdim <int>

Maximum number of dimensions to display.

Default: 10

de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotFactory
-vis.maxdim <int>

Maximum number of dimensions to display.

Default: 10

de.lmu.ifi.dbs.elki.visualization.visualizers.histogram.ColoredHistogramVisualizer
-projhistogram.curves <|true|false>

Use curves instead of the stacked histogram style.

Default: false

-projhistogram.bins <int>

Number of bins in the distribution histogram

Default: 80

de.lmu.ifi.dbs.elki.visualization.visualizers.parallel.cluster.ClusterOutlineVisualization
-hull.alpha <double>

Alpha value for hull drawing (in projected space!).

Default: Infinity

-parallel.clusteroutline.straight <|true|false>

Draw straight lines

Default: false

de.lmu.ifi.dbs.elki.visualization.visualizers.parallel.index.RTreeParallelVisualization
-index.fill <|true|false>

Partially transparent filling of index pages.

Default: true

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.TooltipScoreVisualization
-tooltip.digits <int>

Number of digits to show (e.g. when visualizing outlier scores)

Default: 4

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster.ClusterHullVisualization
-hull.alpha <double>

Alpha value for hull drawing (in projected space!).

Default: Infinity

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster.VoronoiVisualization
-voronoi.mode <VORONOI | DELAUNAY | V_AND_D>

Mode for drawing the voronoi cells (and/or delaunay triangulation)

Default: VORONOI

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.index.TreeMBRVisualization
-index.fill <|true|false>

Partially transparent filling of index pages.

Default: false

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.index.TreeSphereVisualization
-index.fill <|true|false>

Partially transparent filling of index pages.

Default: false

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.outlier.BubbleVisualization
-bubble.fill <|true|false>

Half-transparent filling of bubbles.

Default: false

-bubble.scaling <class|object>

Additional scaling function for bubbles.

Class Restriction: implements de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction

Known implementations:

de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection.SelectionCubeVisualization
-selectionrange.nofill <|true|false>

Use wireframe style for selection ranges.

Default: false

de.lmu.ifi.dbs.elki.workflow.AlgorithmStep
-time <|true|false>

Enable logging of runtime data. Do not combine with more verbose logging, since verbose logging can significantly impact performance.

Default: false

-algorithm <object_1|class_1,...,object_n|class_n>

Algorithm to run.

Known implementations:

de.lmu.ifi.dbs.elki.workflow.EvaluationStep
-evaluator <object_1|class_1,...,object_n|class_n>

Class to evaluate the results with.

Default: [class de.lmu.ifi.dbs.elki.evaluation.AutomaticEvaluation]

Known implementations:

de.lmu.ifi.dbs.elki.workflow.InputStep
-db <class|object>

Database class.

Class Restriction: implements de.lmu.ifi.dbs.elki.database.Database

Default: de.lmu.ifi.dbs.elki.database.StaticArrayDatabase

Known implementations:

de.lmu.ifi.dbs.elki.workflow.LoggingStep
-verbose <|true|false>

Enable verbose messages.

Default: false

-enableDebug <string>

Parameter to enable debugging for particular packages.

de.lmu.ifi.dbs.elki.workflow.OutputStep
-resulthandler <object_1|class_1,...,object_n|class_n>

Result handler class.

Known implementations: