Package 'dbscan' reference manual

Title:	Density-Based Spatial Clustering of Applications with Noise (DBSCAN) and Related Algorithms
Description:	A fast reimplementation of several density-based algorithms of the DBSCAN family. Includes the clustering algorithms DBSCAN (density-based spatial clustering of applications with noise) and HDBSCAN (hierarchical DBSCAN), the ordering algorithm OPTICS (ordering points to identify the clustering structure), shared nearest neighbor clustering, and the outlier detection algorithms LOF (local outlier factor) and GLOSH (global-local outlier score from hierarchies). The implementations use the kd-tree data structure (from library ANN) for faster k-nearest neighbor search. An R interface to fast kNN and fixed-radius NN search is also provided. Hahsler, Piekenbrock and Doran (2019) <doi:10.18637/jss.v091.i01>.
Authors:	Michael Hahsler [aut, cre, cph], Matthew Piekenbrock [aut, cph], Sunil Arya [ctb, cph], David Mount [ctb, cph]
Maintainer:	Michael Hahsler <[email protected]>
License:	GPL (>= 2)
Version:	1.1-12-1
Built:	2024-05-05 21:20:57 UTC
Source:	https://github.com/mhahsler/dbscan

Density-based Spatial Clustering of Applications with Noise (DBSCAN)

Description

Fast reimplementation of the DBSCAN (Density-based spatial clustering of applications with noise) clustering algorithm using a kd-tree.

Usage

dbscan(x, eps, minPts = 5, weights = NULL, borderPoints = TRUE, ...)

is.corepoint(x, eps, minPts = 5, ...)

## S3 method for class 'dbscan_fast'
predict(object, newdata, data, ...)

Arguments

`x`	a data matrix, a data.frame, a dist object or a frNN object with fixed-radius nearest neighbors.
`eps`	size (radius) of the epsilon neighborhood. Can be omitted if `x` is a frNN object.
`minPts`	number of minimum points required in the eps neighborhood for core points (including the point itself).
`weights`	numeric; weights for the data points. Only needed to perform weighted clustering.
`borderPoints`	logical; should border points be assigned to clusters. The default is `TRUE` for regular DBSCAN. If `FALSE` then border points are considered noise (see DBSCAN* in Campello et al, 2013).
`...`	additional arguments are passed on to the fixed-radius nearest neighbor search algorithm. See `frNN()` for details on how to control the search strategy.
`object`	clustering object.
`newdata`	new data points for which the cluster membership should be predicted.
`data`	the data set used to create the clustering object.

Details

The implementation is significantly faster and can work with larger data sets than fpc::dbscan() in fpc. Use dbscan::dbscan() (with specifying the package) to call this implementation when you also load package fpc.

The algorithm

This implementation of DBSCAN follows the original algorithm as described by Ester et al (1996). DBSCAN performs the following steps:

Estimate the density around each data point by counting the number of points in a user-specified eps-neighborhood and applies a used-specified minPts thresholds to identify
- core points (points with more than minPts points in their neighborhood),
- border points (non-core points with a core point in their neighborhood) and
- noise points (all other points).
Core points form the backbone of clusters by joining them into a cluster if they are density-reachable from each other (i.e., there is a chain of core points where one falls inside the eps-neighborhood of the next).
Border points are assigned to clusters. The algorithm needs parameters eps (the radius of the epsilon neighborhood) and minPts (the density threshold).

Border points are arbitrarily assigned to clusters in the original algorithm. DBSCAN* (see Campello et al 2013) treats all border points as noise points. This is implemented with borderPoints = FALSE.

Specifying the data

If x is a matrix or a data.frame, then fast fixed-radius nearest neighbor computation using a kd-tree is performed using Euclidean distance. See frNN() for more information on the parameters related to nearest neighbor search. Note that only numerical values are allowed in x.

Any precomputed distance matrix (dist object) can be specified as x. You may run into memory issues since distance matrices are large.

A precomputed frNN object can be supplied as x. In this case eps does not need to be specified. This option us useful for large data sets, where a sparse distance matrix is available. See frNN() how to create frNN objects.

Setting parameters for DBSCAN

The parameters minPts and eps define the minimum density required in the area around core points which form the backbone of clusters. minPts is the number of points required in the neighborhood around the point defined by the parameter eps (i.e., the radius around the point). Both parameters depend on each other and changing one typically requires changing the other one as well. The parameters also depend on the size of the data set with larger datasets requiring a larger minPts or a smaller eps.

⁠minPts:⁠ The original DBSCAN paper (Ester et al, 1996) suggests to start by setting $\text{minPts} \ge d + 1$ , the data dimensionality plus one or higher with a minimum of 3. Larger values are preferable since increasing the parameter suppresses more noise in the data by requiring more points to form clusters. Sander et al (1998) uses in the examples two times the data dimensionality. Note that setting $\text{minPts} \le 2$ is equivalent to hierarchical clustering with the single link metric and the dendrogram cut at height eps.
⁠eps:⁠ A suitable neighborhood size parameter eps given a fixed value for minPts can be found visually by inspecting the kNNdistplot() of the data using $k = \text{minPts} - 1$ (minPts includes the point itself, while the k-nearest neighbors distance does not). The k-nearest neighbor distance plot sorts all data points by their k-nearest neighbor distance. A sudden increase of the kNN distance (a knee) indicates that the points to the right are most likely outliers. Choose eps for DBSCAN where the knee is.

Predict cluster memberships

predict() can be used to predict cluster memberships for new data points. A point is considered a member of a cluster if it is within the eps neighborhood of a core point of the cluster. Points which cannot be assigned to a cluster will be reported as noise points (i.e., cluster ID 0). Important note: predict() currently can only use Euclidean distance to determine the neighborhood of core points. If dbscan() was called using distances other than Euclidean, then the neighborhood calculation will not be correct and only approximated by Euclidean distances. If the data contain factor columns (e.g., using Gower's distance), then the factors in data and query first need to be converted to numeric to use the Euclidean approximation.

Value

dbscan() returns an object of class dbscan_fast with the following components:

`eps`	value of the `eps` parameter.
`minPts`	value of the `minPts` parameter.
`cluster`	A integer vector with cluster assignments. Zero indicates noise points.

is.corepoint() returns a logical vector indicating for each data point if it is a core point.

Author(s)

Michael Hahsler

References

Hahsler M, Piekenbrock M, Doran D (2019). dbscan: Fast Density-Based Clustering with R. Journal of Statistical Software, 91(1), 1-30. doi:10.18637/jss.v091.i01

Martin Ester, Hans-Peter Kriegel, Joerg Sander, Xiaowei Xu (1996). A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise. Institute for Computer Science, University of Munich. Proceedings of 2nd International Conference on Knowledge Discovery and Data Mining (KDD-96), 226-231. https://dl.acm.org/doi/10.5555/3001460.3001507

Campello, R. J. G. B.; Moulavi, D.; Sander, J. (2013). Density-Based Clustering Based on Hierarchical Density Estimates. Proceedings of the 17th Pacific-Asia Conference on Knowledge Discovery in Databases, PAKDD 2013, Lecture Notes in Computer Science 7819, p. 160. doi:10.1007/978-3-642-37456-2_14

Sander, J., Ester, M., Kriegel, HP. et al. (1998). Density-Based Clustering in Spatial Databases: The Algorithm GDBSCAN and Its Applications. Data Mining and Knowledge Discovery 2, 169-194. doi:10.1023/A:1009745219419

Examples

## Example 1: use dbscan on the iris data set
data(iris)
iris <- as.matrix(iris[, 1:4])

## Find suitable DBSCAN parameters:
## 1. We use minPts = dim + 1 = 5 for iris. A larger value can also be used.
## 2. We inspect the k-NN distance plot for k = minPts - 1 = 4
kNNdistplot(iris, minPts = 5)

## Noise seems to start around a 4-NN distance of .7
abline(h=.7, col = "red", lty = 2)

## Cluster with the chosen parameters
res <- dbscan(iris, eps = .7, minPts = 5)
res

pairs(iris, col = res$cluster + 1L)

## Use a precomputed frNN object
fr <- frNN(iris, eps = .7)
dbscan(fr, minPts = 5)

## Example 2: use data from fpc
set.seed(665544)
n <- 100
x <- cbind(
  x = runif(10, 0, 10) + rnorm(n, sd = 0.2),
  y = runif(10, 0, 10) + rnorm(n, sd = 0.2)
  )

res <- dbscan(x, eps = .3, minPts = 3)
res

## plot clusters and add noise (cluster 0) as crosses.
plot(x, col = res$cluster)
points(x[res$cluster == 0, ], pch = 3, col = "grey")

hullplot(x, res)

## Predict cluster membership for new data points
## (Note: 0 means it is predicted as noise)
newdata <- x[1:5,] + rnorm(10, 0, .3)
hullplot(x, res)
points(newdata, pch = 3 , col = "red", lwd = 3)
text(newdata, pos = 1)

pred_label <- predict(res, newdata, data = x)
pred_label
points(newdata, col = pred_label + 1L,  cex = 2, lwd = 2)

## Compare speed against fpc version (if microbenchmark is installed)
## Note: we use dbscan::dbscan to make sure that we do now run the
## implementation in fpc.
## Not run: 
if (requireNamespace("fpc", quietly = TRUE) &&
    requireNamespace("microbenchmark", quietly = TRUE)) {
  t_dbscan <- microbenchmark::microbenchmark(
    dbscan::dbscan(x, .3, 3), times = 10, unit = "ms")
  t_dbscan_linear <- microbenchmark::microbenchmark(
    dbscan::dbscan(x, .3, 3, search = "linear"), times = 10, unit = "ms")
  t_dbscan_dist <- microbenchmark::microbenchmark(
    dbscan::dbscan(x, .3, 3, search = "dist"), times = 10, unit = "ms")
  t_fpc <- microbenchmark::microbenchmark(
    fpc::dbscan(x, .3, 3), times = 10, unit = "ms")

  r <- rbind(t_fpc, t_dbscan_dist, t_dbscan_linear, t_dbscan)
  r

  boxplot(r,
    names = c('fpc', 'dbscan (dist)', 'dbscan (linear)', 'dbscan (kdtree)'),
    main = "Runtime comparison in ms")

  ## speedup of the kd-tree-based version compared to the fpc implementation
  median(t_fpc$time) / median(t_dbscan$time)
}
## End(Not run)

## Example 3: manually create a frNN object for dbscan (dbscan only needs ids and eps)
nn <- structure(list(ids = list(c(2,3), c(1,3), c(1,2,3), c(3,5), c(4,5)), eps = 1),
  class =  c("NN", "frNN"))
nn
dbscan(nn, minPts = 2)

Framework for the Optimal Extraction of Clusters from Hierarchies

Description

Generic reimplementation of the Framework for Optimal Selection of Clusters (FOSC; Campello et al, 2013) to extract clusterings from hierarchical clustering (i.e., hclust objects). Can be parameterized to perform unsupervised cluster extraction through a stability-based measure, or semisupervised cluster extraction through either a constraint-based extraction (with a stability-based tiebreaker) or a mixed (weighted) constraint and stability-based objective extraction.

Usage

extractFOSC(
  x,
  constraints,
  alpha = 0,
  minPts = 2L,
  prune_unstable = FALSE,
  validate_constraints = FALSE
)

Arguments

`x`	a valid hclust object created via `hclust()` or `hdbscan()`.
`constraints`	Either a list or matrix of pairwise constraints. If missing, an unsupervised measure of stability is used to make local cuts and extract the optimal clusters. See details.
`alpha`	numeric; weight between $[0, 1]$ for mixed-objective semi-supervised extraction. Defaults to 0.
`minPts`	numeric; Defaults to 2. Only needed if class-less noise is a valid label in the model.
`prune_unstable`	logical; should significantly unstable subtrees be pruned? The default is `FALSE` for the original optimal extraction framework (see Campello et al, 2013). See details for what `TRUE` implies.
`validate_constraints`	logical; should constraints be checked for validity? See details for what are considered valid constraints.

Details

Campello et al (2013) suggested a Framework for Optimal Selection of Clusters (FOSC) as a framework to make local (non-horizontal) cuts to any cluster tree hierarchy. This function implements the original extraction algorithms as described by the framework for hclust objects. Traditional cluster extraction methods from hierarchical representations (such as hclust objects) generally rely on global parameters or cutting values which are used to partition a cluster hierarchy into a set of disjoint, flat clusters. This is implemented in R in function cutree(). Although such methods are widespread, using global parameter settings are inherently limited in that they cannot capture patterns within the cluster hierarchy at varying local levels of granularity.

Rather than partitioning a hierarchy based on the number of the cluster one expects to find ( $k$ ) or based on some linkage distance threshold ( $H$ ), the FOSC proposes that the optimal clusters may exist at varying distance thresholds in the hierarchy. To enable this idea, FOSC requires one parameter (minPts) that represents the minimum number of points that constitute a valid cluster. The first step of the FOSC algorithm is to traverse the given cluster hierarchy divisively, recording new clusters at each split if both branches represent more than or equal to minPts. Branches that contain less than minPts points at one or both branches inherit the parent clusters identity. Note that using FOSC, due to the constraint that minPts must be greater than or equal to 2, it is possible that the optimal cluster solution chosen makes local cuts that render parent branches of sizes less than minPts as noise, which are denoted as 0 in the final solution.

Traversing the original cluster tree using minPts creates a new, simplified cluster tree that is then post-processed recursively to extract clusters that maximize for each cluster $C_i$ the cost function

$\max_{\delta_2, \dots, \delta_k} J = \sum\limits_{i=2}^{k} \delta_i S(C_i)$

where $S(C_i)$ is the stability-based measure as

$S(C_i) = \sum_{x_j \in C_i}(\frac{1}{h_{min} (x_j, C_i)} - \frac{1}{h_{max} (C_i)})$

$\delta_i$ represents an indicator function, which constrains the solution space such that clusters must be disjoint (cannot assign more than 1 label to each cluster). The measure $S(C_i)$ used by FOSC is an unsupervised validation measure based on the assumption that, if you vary the linkage/distance threshold across all possible values, more prominent clusters that survive over many threshold variations should be considered as stronger candidates of the optimal solution. For this reason, using this measure to detect clusters is referred to as an unsupervised, stability-based extraction approach. In some cases it may be useful to enact instance-level constraints that ensure the solution space conforms to linkage expectations known a priori. This general idea of using preliminary expectations to augment the clustering solution will be referred to as semisupervised clustering. If constraints are given in the call to extractFOSC(), the following alternative objective function is maximized:

$J = \frac{1}{2n_c}\sum\limits_{j=1}^n \gamma (x_j)$

$n_c$ is the total number of constraints given and $\gamma(x_j)$ represents the number of constraints involving object $x_j$ that are satisfied. In the case of ties (such as solutions where no constraints were given), the unsupervised solution is used as a tiebreaker. See Campello et al (2013) for more details.

As a third option, if one wishes to prioritize the degree at which the unsupervised and semisupervised solutions contribute to the overall optimal solution, the parameter $\alpha$ can be set to enable the extraction of clusters that maximize the mixed objective function

$J = \alpha S(C_i) + (1 - \alpha) \gamma(C_i))$

FOSC expects the pairwise constraints to be passed as either 1) an $n(n-1)/2$ vector of integers representing the constraints, where 1 represents should-link, -1 represents should-not-link, and 0 represents no preference using the unsupervised solution (see below for examples). Alternatively, if only a few constraints are needed, a named list representing the (symmetric) adjacency list can be used, where the names correspond to indices of the points in the original data, and the values correspond to integer vectors of constraints (positive indices for should-link, negative indices for should-not-link). Again, see the examples section for a demonstration of this.

The parameters to the input function correspond to the concepts discussed above. The minPts parameter to represent the minimum cluster size to extract. The optional constraints parameter contains the pairwise, instance-level constraints of the data. The optional alpha parameters controls whether the mixed objective function is used (if alpha is greater than 0). If the validate_constraints parameter is set to true, the constraints are checked (and fixed) for symmetry (if point A has a should-link constraint with point B, point B should also have the same constraint). Asymmetric constraints are not supported.

Unstable branch pruning was not discussed by Campello et al (2013), however in some data sets it may be the case that specific subbranches scores are significantly greater than sibling and parent branches, and thus sibling branches should be considered as noise if their scores are cumulatively lower than the parents. This can happen in extremely nonhomogeneous data sets, where there exists locally very stable branches surrounded by unstable branches that contain more than minPts points. prune_unstable = TRUE will remove the unstable branches.

Value

A list with the elements:

`cluster`	A integer vector with cluster assignments. Zero indicates noise points (if any).
`hc`	The original hclust object with additional list elements `"stability"`, `"constraint"`, and `"total"` for the $n - 1$ cluster-wide objective scores from the extraction.

Author(s)

Matt Piekenbrock

References

Campello, Ricardo JGB, Davoud Moulavi, Arthur Zimek, and Joerg Sander (2013). A framework for semi-supervised and unsupervised optimal extraction of clusters from hierarchies. Data Mining and Knowledge Discovery 27(3): 344-371. doi:10.1007/s10618-013-0311-4

Examples

data("moons")

## Regular HDBSCAN using stability-based extraction (unsupervised)
cl <- hdbscan(moons, minPts = 5)
cl$cluster

## Constraint-based extraction from the HDBSCAN hierarchy
## (w/ stability-based tiebreaker (semisupervised))
cl_con <- extractFOSC(cl$hc, minPts = 5,
  constraints = list("12" = c(49, -47)))
cl_con$cluster

## Alternative formulation: Constraint-based extraction from the HDBSCAN hierarchy
## (w/ stability-based tiebreaker (semisupervised)) using distance thresholds
dist_moons <- dist(moons)
cl_con2 <- extractFOSC(cl$hc, minPts = 5,
  constraints = ifelse(dist_moons < 0.1, 1L,
                ifelse(dist_moons > 1, -1L, 0L)))

cl_con2$cluster # same as the second example

`x`	the NN object representing the graph or a dist object
`...`	further arguments are currently unused.
`eps`	threshold on the distance
`mutual`	for a pair of points, do both have to be in each other's neighborhood?

`x`	a data matrix, a dist object or a frNN object.
`eps`	neighbors radius.
`query`	a data matrix with the points to query. If query is not specified, the NN for all the points in `x` is returned. If query is specified then `x` needs to be a data matrix.
`sort`	sort the neighbors by distance? This is expensive and can be done later using `sort()`.
`search`	nearest neighbor search strategy (one of `"kdtree"`, `"linear"` or `"dist"`).
`bucketSize`	max size of the kd-tree leafs.
`splitRule`	rule to split the kd-tree. One of `"STD"`, `"MIDPT"`, `"FAIR"`, `"SL_MIDPT"`, `"SL_FAIR"` or `"SUGGEST"` (SL stands for sliding). `"SUGGEST"` uses ANNs best guess.
`approx`	use approximate nearest neighbors. All NN up to a distance of a factor of `1 + approx` eps may be used. Some actual NN may be omitted leading to spurious clusters and noise points. However, the algorithm will enjoy a significant speedup.
`decreasing`	sort in decreasing order?
`...`	further arguments

`id`	a list of integer vectors. Each vector contains the ids of the fixed radius nearest neighbors.
`dist`	a list with distances (same structure as `id`).
`eps`	neighborhood radius `eps` that was used.

`x`	an hclust object, data matrix, or dist object.
`k`	size of the neighborhood.
`...`	further arguments are passed on to `kNN()`.

`x`	a data matrix (Euclidean distances are used) or a dist object calculated with an arbitrary distance metric.
`minPts`	integer; Minimum size of clusters. See details.
`gen_hdbscan_tree`	logical; should the robust single linkage tree be explicitly computed (see cluster tree in Chaudhuri et al, 2010).
`gen_simplified_tree`	logical; should the simplified hierarchy be explicitly computed (see Campello et al, 2013).
`verbose`	report progress.
`...`	additional arguments are passed on.
`scale`	integer; used to scale condensed tree based on the graphics device. Lower scale results in wider trees.
`gradient`	character vector; the colors to build the condensed tree coloring with.
`show_flat`	logical; whether to draw boxes indicating the most stable clusters.
`coredist`	numeric vector with precomputed core distances (optional).
`object`	clustering object.
`newdata`	new data points for which the cluster membership should be predicted.
`data`	the data set used to create the clustering object.

`x`	a data matrix. If more than 2 columns are provided, then the data is plotted using the first two principal components.
`cl`	a clustering. Either a numeric cluster assignment vector or a clustering object (a list with an element named `cluster`).
`col`	colors used for clusters. Defaults to the standard palette. The first color (default is black) is used for noise/unassigned points (cluster id 0).
`cex`	expansion factor for symbols.
`hull_lwd`, `hull_lty`	line width and line type used for the convex hull.
`solid`, `alpha`	draw filled polygons instead of just lines for the convex hulls? alpha controls the level of alpha shading.
`main`	main title.
`...`	additional arguments passed on to plot.

`x`	a data matrix/data.frame (Euclidean distance is used), a precomputed dist object or a kNN object created with `kNN()`.
`k`	Neighborhood size for nearest neighbor sparsification. If `x` is a kNN object then `k` may be missing.
`kt`	threshold on the number of shared nearest neighbors (including the points themselves) to form clusters. Range: $[1, k]$
`...`	additional arguments are passed on to the k nearest neighbor search algorithm. See `kNN()` for details on how to control the search strategy.

`cluster`	A integer vector with cluster assignments. Zero indicates noise points.
`type`	name of used clustering algorithm.
`param`	list of used clustering parameters.

`x`	a data matrix, a dist object or a kNN object.
`k`	number of neighbors to find.
`query`	a data matrix with the points to query. If query is not specified, the NN for all the points in `x` is returned. If query is specified then `x` needs to be a data matrix.
`sort`	sort the neighbors by distance? Note that some search methods already sort the results. Sorting is expensive and `sort = FALSE` may be much faster for some search methods. kNN objects can be sorted using `sort()`.
`search`	nearest neighbor search strategy (one of `"kdtree"`, `"linear"` or `"dist"`).
`bucketSize`	max size of the kd-tree leafs.
`splitRule`	rule to split the kd-tree. One of `"STD"`, `"MIDPT"`, `"FAIR"`, `"SL_MIDPT"`, `"SL_FAIR"` or `"SUGGEST"` (SL stands for sliding). `"SUGGEST"` uses ANNs best guess.
`approx`	use approximate nearest neighbors. All NN up to a distance of a factor of `1 + approx` eps may be used. Some actual NN may be omitted leading to spurious clusters and noise points. However, the algorithm will enjoy a significant speedup.
`decreasing`	sort in decreasing order?
`...`	further arguments

`dist`	a matrix with distances.
`id`	a matrix with `ids`.
`k`	number `k` used.

`x`	the data set as a matrix of points (Euclidean distance is used) or a precalculated dist object.
`k`	number of nearest neighbors used for the distance calculation. For `kNNdistplot()` also a range of values for `k` or `minPts` can be specified.
`all`	should a matrix with the distances to all k nearest neighbors be returned?
`...`	further arguments (e.g., kd-tree related parameters) are passed on to `kNN()`.
`minPts`	to use a k-NN plot to determine a suitable `eps` value for `dbscan()`, `minPts` used in dbscan can be specified and will set `k = minPts - 1`.

`x`	a data matrix or a dist object.
`minPts`	number of nearest neighbors used in defining the local neighborhood of a point (includes the point itself).
`...`	further arguments are passed on to `kNN()`. Note: `sort` cannot be specified here since `lof()` uses always `sort = TRUE`.

`x`	a `NN` object
`...`	further parameters past on to `plot()`.
`decreasing`	sort in decreasing order?
`data`	that was used to create `x`
`main`	title
`pch`	plotting character.
`col`	color used for the data points (nodes).
`linecol`	color used for edges.

`x`	a data matrix or a dist object.
`eps`	upper limit of the size of the epsilon neighborhood. Limiting the neighborhood size improves performance and has no or very little impact on the ordering as long as it is not set too low. If not specified, the largest minPts-distance in the data set is used which gives the same result as infinity.
`minPts`	the parameter is used to identify dense neighborhoods and the reachability distance is calculated as the distance to the minPts nearest neighbor. Controls the smoothness of the reachability distribution. Default is 5 points.
`...`	additional arguments are passed on to fixed-radius nearest neighbor search algorithm. See `frNN()` for details on how to control the search strategy.
`cluster`, `predecessor`	plot clusters and predecessors.
`object`	clustering object.
`eps_cl`	Threshold to identify clusters (`eps_cl <= eps`).
`xi`	Steepness threshold to identify clusters hierarchically using the Xi method.
`minimum`	logical, representing whether or not to extract the minimal (non-overlapping) clusters in the Xi clustering algorithm.
`correctPredecessors`	logical, correct a common artifact by pruning the steep up area for points that have predecessors not in the cluster–found by the ELKI framework, see details below.
`newdata`	new data points for which the cluster membership should be predicted.
`data`	the data set used to create the clustering object.

`eps`	value of `eps` parameter.
`minPts`	value of `minPts` parameter.
`order`	optics order for the data points in `x`.
`reachdist`	reachability distance for each data point in `x`.
`coredist`	core distance for each data point in `x`.

`x`	a data matrix.
`eps`	radius of the eps-neighborhood, i.e., bandwidth of the uniform kernel).
`type`	`"frequency"` or `"density"`. should the raw count of points inside the eps-neighborhood or the kde be returned.
`search`, `bucketSize`, `splitRule`, `approx`	algorithmic parameters for `frNN()`.

`eps_cl`	the value of the `eps_cl` parameter.
`cluster`	assigned cluster labels in the order of the data points in `x`.

`xi`	Steepness threshold`x`.
`cluster`	assigned cluster labels in the order of the data points in `x`.
`clusters_xi`	data.frame containing the start and end of each cluster found in the OPTICS ordering.

`x`	object of class `reachability`.
`...`	graphical parameters are passed on to `plot()`, or arguments for other methods.
`order_labels`	whether to plot text labels for each points reachability distance.
`xlab`	x-axis label.
`ylab`	y-axis label.
`main`	Title of the plot.
`object`	any object that can be coerced to class `reachability`, such as an object of class optics or stats::dendrogram.

`order`	order to use for the data points in `x`.
`reachdist`	reachability distance for each data point in `x`.

`x`	a data matrix, a dist object or a kNN object.
`k`	number of neighbors to consider to calculate the shared nearest neighbors.
`kt`	minimum threshold on the number of shared nearest neighbors to build the shared nearest neighbor graph. Edges are only preserved if `kt` or more neighbors are shared.
`jp`	use the definition by Javis and Patrick (1973), where shared neighbors are only counted between points that are in each other's neighborhood, otherwise 0 is returned. If `FALSE`, then the number of shared neighbors is returned, even if the points are not neighbors.
`sort`	sort by the number of shared nearest neighbors? Note that this is expensive and `sort = FALSE` is much faster. sNN objects can be sorted using `sort()`.
`search`	nearest neighbor search strategy (one of `"kdtree"`, `"linear"` or `"dist"`).
`bucketSize`	max size of the kd-tree leafs.
`splitRule`	rule to split the kd-tree. One of `"STD"`, `"MIDPT"`, `"FAIR"`, `"SL_MIDPT"`, `"SL_FAIR"` or `"SUGGEST"` (SL stands for sliding). `"SUGGEST"` uses ANNs best guess.
`approx`	use approximate nearest neighbors. All NN up to a distance of a factor of `⁠(1 + approx) eps⁠` may be used. Some actual NN may be omitted leading to spurious clusters and noise points. However, the algorithm will enjoy a significant speedup.
`decreasing`	logical; sort in decreasing order?
`...`	additional parameters are passed on.

`id`	a matrix with ids.
`dist`	a matrix with the distances.
`shared`	a matrix with the number of shared nearest neighbors.
`k`	number of `k` used.

Package 'dbscan'

Help Index

Find Connected Components in a Nearest-neighbor Graph

Description

Usage

Arguments

Details

Value

Author(s)

See Also

Examples

Density-based Spatial Clustering of Applications with Noise (DBSCAN)

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Coersions to Dendrogram

Description

Usage

Arguments

Details

DS3: Spatial data with arbitrary shapes

Description

Format

Source

References

Examples

Framework for the Optimal Extraction of Clusters from Hierarchies

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Find the Fixed Radius Nearest Neighbors

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Global-Local Outlier Score from Hierarchies

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Hierarchical DBSCAN (HDBSCAN)

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Plot Convex Hulls of Clusters

Description

Usage

Arguments

Author(s)

Examples

Jarvis-Patrick Clustering

Description