View source for DBSCAN

{{short description|Density-based data clustering algorithm}}
{{Machine learning|Clustering}}
'''Density-based spatial clustering of applications with noise''' ('''DBSCAN''') is a [[data clustering]] [[algorithm]] proposed by [[Martin Ester]], [[Hans-Peter Kriegel]], [[Jörg Sander]], and [[Xiaowei Xu]] in 1996.<ref name="dbscan">{{Cite conference
 | author1-link = Martin Ester | author1-first = Martin | author1-last = Ester | author2-link = Hans-Peter Kriegel | author2-first = Hans-Peter | author2-last =Kriegel | first3 = Jörg | last3 = Sander | first4 = Xiaowei | last4 = Xu
 | title = A density-based algorithm for discovering clusters in large spatial databases with noise
 | url = https://cdn.aaai.org/KDD/1996/KDD96-037.pdf
 |  pages = 226–231
 | editor1-first = Evangelos | editor1-last = Simoudis | editor2-first = Jiawei | editor2-last = Han | editor3-first = Usama M. | editor3-last = Fayyad
 | conference = Proceedings of the Second International Conference on Knowledge Discovery and Data Mining (KDD-96)
 | publisher = [[AAAI Press]]
 | year = 1996
 | isbn = 1-57735-004-9 
 | citeseerx = 10.1.1.121.9220
}}</ref>
It is a [[Cluster analysis#Density-based clustering|density-based clustering]] non-parametric algorithm: given a set of points in some space, it groups together points that are closely packed (points with many [[Fixed-radius near neighbors|nearby neighbors]]), and marks as outliers points that lie alone in low-density regions (those whose nearest neighbors are too far away).
DBSCAN is one of the most commonly used and cited clustering algorithms.<ref>{{cite web |url=http://academic.research.microsoft.com/CSDirectory/paper_category_7.htm |title=Microsoft Academic Search: Papers |access-date=2010-04-18 |url-status=dead |archive-url=https://web.archive.org/web/20100421170848/http://academic.research.microsoft.com/CSDirectory/paper_category_7.htm |archive-date=April 21, 2010 }} Most cited data mining articles according to Microsoft academic search; DBSCAN is on rank 24.</ref>

In 2014, the algorithm was awarded the Test of Time Award (an award given to algorithms which have received substantial attention in theory and practice) at the leading data mining conference, ACM [[SIGKDD]].<ref>{{cite web|url=http://www.kdd.org/News/view/2014-sigkdd-test-of-time-award|date=2014-08-18|access-date=2016-07-27|title=2014 SIGKDD Test of Time Award|publisher=[[Association for Computing Machinery|ACM]] SIGKDD}}</ref> {{As of|2020|July}}, the follow-up paper "DBSCAN Revisited, Revisited: Why and How You Should (Still) Use DBSCAN"<ref name="tods" /> appears in the list of the 8 most downloaded articles of the prestigious [[ACM Transactions on Database Systems|ACM Transactions on Database Systems (TODS)]] journal.<ref>{{Cite web|title=TODS Home|url=https://dl.acm.org/journal/tods#pane-cc36fa1b-c28c-425f-9325-f853cff8882901|access-date=2020-07-16|website=tods.acm.org|publisher=[[Association for Computing Machinery]]|language=en}}</ref>

Another follow-up, '''HDBSCAN*''', was initially published by Ricardo J. G. Campello, David Moulavi, and Jörg Sander in 2013,<ref name="hdbscan1">{{Cite conference |last1=Campello |first1=Ricardo J. G. B. |title=Density-Based Clustering Based on Hierarchical Density Estimates |date=2013 |url=http://link.springer.com/10.1007/978-3-642-37456-2_14 |conference=Advances in Knowledge Discovery and Data Mining |volume=7819 |pages=160–172 |editor-last=Pei |editor-first=Jian |access-date=2023-08-18 |place=Berlin, Heidelberg |publisher=Springer Berlin Heidelberg |doi=10.1007/978-3-642-37456-2_14 |isbn=978-3-642-37455-5 |last2=Moulavi |first2=Davoud |last3=Sander |first3=Joerg |editor2-last=Tseng |editor2-first=Vincent S. |editor3-last=Cao |editor3-first=Longbing |editor4-last=Motoda |editor4-first=Hiroshi}}</ref> then expanded upon with [[Arthur Zimek]] in 2015.<ref name="hdbscan2">{{cite journal|last1=Campello|first1=Ricardo J. G. B.|last2=Moulavi|first2=Davoud|last3=Zimek|first3=Arthur|author-link3=Arthur Zimek|last4=Sander|first4=Jörg|title=Hierarchical Density Estimates for Data Clustering, Visualization, and Outlier Detection|journal=ACM Transactions on Knowledge Discovery from Data|volume=10|issue=1|year=2015|pages=1–51|issn=1556-4681|doi=10.1145/2733381|s2cid=2887636}}</ref> It revises some of the original decisions such as the border points, and produces a hierarchical instead of a flat result.

==History==
In 1972, Robert F. Ling published a closely related algorithm in "The Theory and Construction of k-Clusters"<ref name=":1">{{Cite journal|last=Ling|first=R. F.|date=1972-01-01|title=On the theory and construction of k-clusters|url=https://academic.oup.com/comjnl/article/15/4/326/351493|journal=The Computer Journal|language=en|volume=15|issue=4|pages=326–332|doi=10.1093/comjnl/15.4.326|issn=0010-4620|doi-access=}}</ref> in ''[[The Computer Journal]]'' with an estimated runtime complexity of O(n³).<ref name=":1" /> DBSCAN has a worst-case of O(n²), and the database-oriented range-query formulation of DBSCAN allows for index acceleration. The algorithms slightly differ in their handling of border points.

==Preliminary==

Consider a set of points in some space to be clustered. Let {{mvar|ε}} be a parameter specifying the radius of a neighborhood with respect to some point. For the purpose of DBSCAN clustering, the points are classified as ''core points'', (''directly''-)'' reachable points'' and ''outliers'', as follows:

* A point {{mvar|p}} is a ''core point'' if at least {{math|{{not a typo|minPts}}}} points are within distance {{mvar|ε}} of it (including {{mvar|p}}). 
* A point {{mvar|q}} is ''directly reachable'' from {{mvar|p}} if point {{mvar|q}} is within distance {{mvar|ε}} from core point {{mvar|p}}. Points are only said to be directly reachable from core points.
* A point {{mvar|q}} is ''reachable'' from {{mvar|p}} if there is a path {{math|''p''<sub>1</sub>, ..., ''p<sub>n</sub>''}} with {{math|''p''<sub>1</sub> {{=}} ''p''}} and {{math|''p<sub>n</sub>'' {{=}} ''q''}}, where each {{math|''p''<sub>''i''+1</sub>}} is directly reachable from {{mvar|p<sub>i</sub>}}. Note that this implies that the initial point and all points on the path must be core points, with the possible exception of {{mvar|q}}.
* All points not reachable from any other point are ''outliers'' or ''noise points''.

Now if {{mvar|p}} is a core point, then it forms a ''cluster'' together with all points (core or non-core) that are reachable from it. Each cluster contains at least one core point; non-core points can be part of a cluster, but they form its "edge", since they cannot be used to reach more points.

[[File:DBSCAN-Illustration.svg|thumb|center|400px|In this diagram, {{math|{{not a typo|minPts}} {{=}} 4}}. Point A and the other red points are core points, because the area surrounding these points in an {{mvar|ε}} radius contain at least 4 points (including the point itself). Because they are all reachable from one another, they form a single cluster.

Points B and C are not core points, but are reachable from A (via other core points) and thus belong to the cluster as well. Point N is a noise point that is neither a core point nor directly-reachable.]]

Reachability is not a symmetric relation: by definition, only core points can reach non-core points. The opposite is not true, so a non-core point may be reachable, but nothing can be reached from it. Therefore, a further notion of ''connectedness'' is needed to formally define the extent of the clusters found by DBSCAN. Two points {{mvar|p}} and {{mvar|q}} are density-connected if there is a point {{mvar|o}} such that both {{mvar|p}} and {{mvar|q}} are reachable from {{mvar|o}}. Density-connectedness ''is'' symmetric.

A cluster then satisfies two properties:
# All points within the cluster are mutually density-connected.
# If a point is density-reachable from some point of the cluster, it is part of the cluster as well.

==Algorithm==

=== Original query-based algorithm ===
DBSCAN requires two parameters: ε (eps) and the minimum number of points required to form a dense region{{efn|name=minpts|While {{not a typo|minPts}} intuitively is the minimum cluster size, in some cases DBSCAN ''can'' produce smaller clusters.<ref name="tods" /> A DBSCAN cluster consists of at least ''one core point''.<ref name="tods" /> As other points may be border points to more than one cluster, there is no guarantee that at least {{not a typo|minPts}} points are included in every cluster.}} ({{not a typo|minPts}}). It starts with an arbitrary starting point that has not been visited. This point's ε-neighborhood is retrieved, and if it contains sufficiently many points, a cluster is started. Otherwise, the point is labeled as noise. Note that this point might later be found in a sufficiently sized ε-environment of a different point and hence be made part of a cluster.

If a point is found to be a dense part of a cluster, its ε-neighborhood is also part of that cluster. Hence, all points that are found within the ε-neighborhood are added, as is their own ε-neighborhood when they are also dense. This process continues until the density-connected cluster is completely found. Then, a new unvisited point is retrieved and processed, leading to the discovery of a further cluster or noise.

DBSCAN can be used with any distance function<ref name="dbscan" /><ref name="tods" /> (as well as similarity functions or other predicates).<ref name=":0" /> The distance function (dist) can therefore be seen as an additional parameter.

The algorithm can be expressed in [[pseudocode]] as follows:<ref name="tods" />

 DBSCAN(DB, distFunc, eps, {{not a typo|minPts}}) {
     C := 0                                                  ''/* Cluster counter */''
     '''for each''' point P '''in''' database DB {
         '''if''' label(P) ≠ undefined '''then''' '''[[Continue (keyword)|continue]]'''               ''/* Previously processed in inner loop */''
         Neighbors N := RangeQuery(DB, distFunc, P, eps)     ''/* Find neighbors */''
         '''if''' |N| < {{not a typo|minPts}} '''then''' {                              ''/* Density check */''
             label(P) := Noise                               ''/* Label as Noise */''
             '''continue'''
         }
         C := C + 1                                          ''/* next cluster label */''
         label(P) := C                                       ''/* Label initial point */''
         SeedSet S := N \ {P}                                ''/* Neighbors to expand */''
         '''for each''' point Q '''in''' S {                             ''/* Process every seed point Q */''
             '''if''' label(Q) = Noise '''then''' label(Q) := C          ''/* Change Noise to border point */''
             '''if''' label(Q) ≠ undefined '''then''' '''continue'''           ''/* Previously processed (e.g., border point) */''
             label(Q) := C                                   ''/* Label neighbor */''
             Neighbors N := RangeQuery(DB, distFunc, Q, eps) ''/* Find neighbors */''
             '''if''' |N| ≥ {{not a typo|minPts}} '''then''' {                          ''/* Density check (if Q is a core point) */''
                 S := S ∪ N                                  ''/* Add new neighbors to seed set */''
             }
         }
     }
 }

where RangeQuery can be implemented using a database index for better performance, or using a slow linear scan:

 RangeQuery(DB, distFunc, Q, eps) {
     Neighbors N := empty list
     '''for each''' point P '''in''' database DB {                      ''/* Scan all points in the database */''
         '''if''' distFunc(Q, P) ≤ eps '''then''' {                     ''/* Compute distance and check epsilon */''
             N := N ∪ {P}                                   ''/* Add to result */''
         }
     }
     '''return''' N
 }

=== Abstract algorithm ===

The DBSCAN algorithm can be abstracted into the following steps:<ref name="tods" />

# Find the points in the ε (eps) neighborhood of every point, and identify the core points with more than {{not a typo|minPts}} neighbors.
# Find the [[Connected component (graph theory)|connected components]] of ''core'' points on the neighbor graph, ignoring all non-core points.
# Assign each non-core point to a nearby cluster if the cluster is an ε (eps) neighbor, otherwise assign it to noise.

A naive implementation of this requires storing the neighborhoods in step 1, thus requiring substantial memory. The original DBSCAN algorithm does not require this by performing these steps for one point at a time.

=== Optimization Criterion ===
DBSCAN optimizes the following loss function:<ref>{{cite book |last1=Beer |first1=Anna |last2=Draganov |first2=Andrew |last3=Hohma |first3=Ellen |last4=Jahn |first4=Philipp |last5=Frey |first5=Christian M.M. |last6=Assent |first6=Ira |title=Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining |chapter=Connecting the Dots -- Density-Connectivity Distance unifies DBSCAN, k-Center and Spectral Clustering |date=6 August 2023 |pages=80–92 |doi=10.1145/3580305.3599283 |chapter-url=https://dl.acm.org/doi/pdf/10.1145/3580305.3599283 |publisher=ACM |isbn=9798400701030 |s2cid=260499476 |language=en}}</ref>
For any possible clustering <math>C= \{C_1, \ldots , C_l\} </math> out of the set of all clusterings <math>\mathcal{C}</math>, it minimizes the number of clusters under the condition that every pair of points in a cluster is density-reachable, which corresponds to the original two properties "maximality" and "connectivity" of a cluster:<ref name="dbscan" />

<math display="block">\min_{C \subset \mathcal{C},~ d_{db}(p, q)\leq \varepsilon ~\forall p, q \in C_i ~ \forall C_i \in C}  |C|</math>

where <math>d_{db}(p,q)</math> gives the smallest <math>\varepsilon</math> such that two points {{mvar|p}} and {{mvar|q}} are density-connected.

==Complexity==
DBSCAN visits each point of the database, possibly multiple times (e.g., as candidates to different clusters). For practical considerations, however, the time complexity is mostly governed by the number of {{not a typo|regionQuery}} invocations. DBSCAN executes exactly one such query for each point, and if an [[spatial index|indexing structure]] is used that executes a [[fixed-radius near neighbors|neighborhood query]] in {{math|O(log ''n'')}}, an overall average runtime complexity of {{math|O(''n'' log ''n'')}} is obtained (if parameter {{math|ε}} is chosen in a meaningful way, i.e. such that on average only {{math|O(log ''n'')}} points are returned). Without the use of an accelerating index structure, or on degenerated data (e.g. all points within a distance less than {{math|ε}}), the worst case run time complexity remains {{math|O(''n''²)}}. The <math>\textstyle\binom n2</math> {{math|- ''n''}} = {{math|(''n''²-''n'')/2}}-sized upper triangle of the distance matrix can be materialized to avoid distance recomputations, but this needs {{math|O(''n''²)}} memory, whereas a non-matrix based implementation of DBSCAN only needs {{math|O(''n'')}} memory.

[[File:DBSCAN-density-data.svg|thumb|DBSCAN can find non-linearly separable clusters. This dataset cannot be adequately clustered with k-means or Gaussian Mixture EM clustering.]]

==Advantages==

# DBSCAN does not require one to specify the number of clusters in the data a priori, as opposed to [[K-means algorithm|k-means]].
# DBSCAN can find arbitrarily-shaped clusters. It can even find a cluster completely surrounded by (but not connected to) a different cluster. Due to the MinPts parameter, the so-called single-link effect (different clusters being connected by a thin line of points) is reduced.
# DBSCAN has a notion of noise, and is robust to [[anomaly detection|outliers]].
# DBSCAN requires just two parameters and is mostly insensitive to the ordering of the points in the database. (However, points sitting on the edge of two different clusters might swap cluster membership if the ordering of the points is changed, and the cluster assignment is unique only up to isomorphism.)
# DBSCAN is designed for use with databases that can accelerate region queries, e.g. using an [[R* tree]].
# The parameters {{not a typo|minPts}} and ε can be set by a domain expert, if the data is well understood.

==Disadvantages==
# DBSCAN is not entirely deterministic: border points that are reachable from more than one cluster can be part of either cluster, depending on the order the data are processed. For most data sets and domains, this situation does not arise often and has little impact on the clustering result:<ref name="tods">{{Cite journal|last1=Schubert|first1=Erich|last2=Sander|first2=Jörg|last3=Ester|first3=Martin|last4=Kriegel|first4=Hans Peter|author-link4=Hans-Peter Kriegel|last5=Xu|first5=Xiaowei|date=July 2017|title=DBSCAN Revisited, Revisited: Why and How You Should (Still) Use DBSCAN|url=https://www.vitavonni.de/research/acm.html#item3068335|journal=ACM Trans. Database Syst.|volume=42|issue=3|pages=19:1–19:21|doi=10.1145/3068335|s2cid=5156876|issn=0362-5915}}</ref> both on core points and noise points, DBSCAN is deterministic. DBSCAN*<ref name="hdbscan1" /><ref name="hdbscan2" /> is a variation that treats border points as noise, and this way achieves a fully deterministic result as well as a more consistent statistical interpretation of density-connected components.
# The quality of DBSCAN depends on the [[Metric (mathematics)|distance measure]] used in the function {{not a typo|regionQuery(P,ε)}}. The most common distance metric used is [[Euclidean distance]]. Especially for [[clustering high-dimensional data|high-dimensional data]], this metric can be rendered almost useless due to the so-called "[[Curse of dimensionality#Distance functions|Curse of dimensionality]]", making it difficult to find an appropriate value for ε. This effect, however, is also present in any other algorithm based on Euclidean distance.
# DBSCAN cannot cluster data sets well with large differences in densities, since the {{not a typo|minPts}}-ε combination cannot then be chosen appropriately for all clusters.<ref name="WIREs">{{Cite journal | author1-link = Hans-Peter Kriegel | first1 = Hans-Peter | last1 = Kriegel | first2 = Peer | last2 = Kröger | author3-first = Jörg | author3-last = Sander | author4-first = Arthur | author4-last = Zimek | author-link4 = Arthur Zimek | title = Density-based Clustering | journal = WIREs Data Mining and Knowledge Discovery | volume = 1 | issue = 3 | year = 2011 | pages = 231–240 | url = http://wires.wiley.com/WileyCDA/WiresArticle/wisId-WIDM30.html | doi = 10.1002/widm.30 | s2cid = 36920706 | access-date = 2011-12-12 | archive-date = 2016-11-17 | archive-url = https://web.archive.org/web/20161117070919/http://wires.wiley.com/WileyCDA/WiresArticle/wisId-WIDM30.html | url-status = dead }}</ref>
# If the data and scale are not well understood, choosing a meaningful distance threshold ε can be difficult.

See the section below on extensions for algorithmic modifications to handle these issues.

==Parameter estimation==

Every data mining task has the problem of parameters. Every parameter influences the algorithm in specific ways. For DBSCAN, the parameters ε and ''{{not a typo|minPts}}'' are needed. The parameters must be specified by the user. Ideally, the value of ε is given by the problem to solve (e.g. a physical distance), and ''{{not a typo|minPts}}'' is then the desired minimum cluster size.{{efn|name=minpts}}

* ''MinPts'': As a rule of thumb, a minimum ''{{not a typo|minPts}}'' can be derived from the number of dimensions ''D'' in the data set, as ''{{not a typo|minPts}}'' ≥ ''D'' + 1. The low value of ''{{not a typo|minPts}}'' = 1 does not make sense, as then every point is a core point by definition. With ''{{not a typo|minPts}}'' ≤ 2, the result will be the same as of [[hierarchical clustering]] with the single link metric, with the dendrogram cut at height ε. Therefore, ''{{not a typo|minPts}}'' must be chosen at least 3. However, larger values are usually better for data sets with noise and will yield more significant clusters. As a rule of thumb, ''{{not a typo|minPts}}'' = 2·''dim'' can be used,<ref name=":0" /> but it may be necessary to choose larger values for very large data, for noisy data or for data that contains many duplicates.<ref name="tods" />
* ε: The value for ε can then be chosen by using a [[Nearest neighbor graph|k-distance graph]], plotting the distance to the ''k'' = ''{{not a typo|minPts}}''-1 nearest neighbor ordered from the largest to the smallest value.<ref name="tods" /> Good values of ε are where this plot shows an "elbow":<ref name="dbscan" /><ref name=":0" /><ref name="tods" /> if ε is chosen much too small, a large part of the data will not be clustered; whereas for a too high value of ε, clusters will merge and the majority of objects will be in the same cluster. In general, small values of ε are preferable,<ref name="tods" /> and as a rule of thumb only a small fraction of points should be within this distance of each other. Alternatively, an [[OPTICS algorithm|OPTICS]] plot can be used to choose ε,<ref name="tods" /> but then the OPTICS algorithm itself can be used to cluster the data.
* Distance function: The choice of distance function is tightly coupled to the choice of ε, and has a major impact on the results. In general, it will be necessary to first identify a reasonable measure of similarity for the data set, before the parameter ε can be chosen. There is no estimation for this parameter, but the distance functions needs to be chosen appropriately for the data set. For example, on geographic data, the [[great-circle distance]] is often a good choice.

[[OPTICS algorithm|OPTICS]] can be seen as a generalization of DBSCAN that replaces the ε parameter with a maximum value that mostly affects performance. ''MinPts'' then essentially becomes the minimum cluster size to find. While the algorithm is much easier to parameterize than DBSCAN, the results are a bit more difficult to use, as it will usually produce a hierarchical clustering instead of the simple data partitioning that DBSCAN produces.

Recently, one of the original authors of DBSCAN has revisited DBSCAN and OPTICS, and published a refined version of hierarchical DBSCAN (HDBSCAN*),<ref name="hdbscan1" /><ref name="hdbscan2" /> which no longer has the notion of border points. Instead, only the core points form the cluster.

== Relationship to spectral clustering ==
A spectral implementation of DBSCAN is related to [[spectral clustering]] in the trivial case of determining [[Connected component (graph theory)|connected graph components]] — the optimal clusters with no edges cut.<ref>{{Cite conference|last1=Schubert|first1=Erich|last2=Hess|first2=Sibylle|last3=Morik|first3=Katharina|author3-link=Katharina Morik|date=2018|title=The Relationship of DBSCAN to Matrix Factorization and Spectral Clustering|url=http://ceur-ws.org/Vol-2191/paper38.pdf|conference=Lernen, Wissen, Daten, Analysen (LWDA)|pages=330–334|via=CEUR-WS.org}}</ref> However, it can be computationally intensive, up to <math>O(n^3)</math>. Additionally, one has to choose the number of eigenvectors to compute. For performance reasons, the original DBSCAN algorithm remains preferable to its spectral implementation.

==Extensions==

Generalized DBSCAN (GDBSCAN)<ref name=":0">{{Cite journal
 | first1 = Jörg       | last1 = Sander
 | first2 = Martin     | last2 = Ester
 | first3 = Hans-Peter | last3 = Kriegel | author-link3 =Hans-Peter Kriegel
 | first4 = Xiaowei    | last4 = Xu
 | title = Density-Based Clustering in Spatial Databases: The Algorithm GDBSCAN and Its Applications
 | pages = 169–194
 | publisher = [[Springer-Verlag]]
 | place = Berlin
 | year = 1998
 | doi = 10.1023/A:1009745219419
 | journal = Data Mining and Knowledge Discovery
 | volume = 2
 | issue = 2
| bibcode = 1998DMKD....2..169S
 | s2cid = 445002
 }}</ref><ref>{{Cite book | first = Jörg | last = Sander | title = Generalized Density-Based Clustering for Spatial Data Mining | isbn=3-89675-469-6 | year=1998 | place = München | publisher = Herbert Utz Verlag }}</ref> is a generalization by the same authors to arbitrary "neighborhood" and "dense" predicates. The ε and ''{{not a typo|minPts}}'' parameters are removed from the original algorithm and moved to the predicates. For example, on polygon data, the "neighborhood" could be any intersecting polygon, whereas the density predicate uses the polygon areas instead of just the object count.

Various extensions to the DBSCAN algorithm have been proposed, including methods for parallelization, parameter estimation, and support for uncertain data. The basic idea has been extended to hierarchical clustering by the [[OPTICS algorithm]]. DBSCAN is also used as part of subspace clustering algorithms like PreDeCon and [[SUBCLU]]. HDBSCAN*<ref name="hdbscan1" /><ref name="hdbscan2" /> is a hierarchical version of DBSCAN which is also faster than OPTICS, from which a flat partition consisting of the most prominent clusters can be extracted from the hierarchy.<ref>{{Cite journal | last1 = Campello | first1 = R. J. G. B. | last2 = Moulavi | first2 = D. | last3 = Zimek | first3 = A. |author-link3 = Arthur Zimek | last4 = Sander | first4 = J. | title = A framework for semi-supervised and unsupervised optimal extraction of clusters from hierarchies | doi = 10.1007/s10618-013-0311-4 | journal = Data Mining and Knowledge Discovery | volume = 27 | issue = 3 | pages = 344 | year = 2013 | s2cid = 8144686 }}</ref>

==Availability==

Different implementations of the same algorithm were found to exhibit enormous performance differences, with the fastest on a test data set finishing in 1.4 seconds, the slowest taking 13803 seconds.<ref>{{cite journal|last1=Kriegel|first1=Hans-Peter|author-link1=Hans-Peter Kriegel|last2=Schubert|first2=Erich|last3=Zimek|first3=Arthur|author-link3 = Arthur Zimek |title=The (black) art of runtime evaluation: Are we comparing algorithms or implementations?|journal=Knowledge and Information Systems|volume=52|issue=2|pages=341|year=2016|issn=0219-1377|doi=10.1007/s10115-016-1004-2|s2cid=40772241}}</ref> The differences can be attributed to implementation quality, language and compiler differences, and the use of indexes for acceleration.

* [[Apache Commons]] [http://commons.apache.org/proper/commons-math/ Math] contains a Java implementation of the algorithm running in quadratic time.
* [[ELKI]] offers an implementation of DBSCAN as well as GDBSCAN and other variants. This implementation can use various index structures for sub-quadratic runtime and supports arbitrary distance functions and arbitrary data types, but it may be outperformed by low-level optimized (and specialized) implementations on small data sets.
* [[mlpack]] includes an implementation of DBSCAN accelerated with dual-tree range search techniques.
* [[PostGIS]] includes ST_ClusterDBSCAN – a 2D implementation of DBSCAN that uses R-tree index. Any geometry type is supported, e.g. Point, LineString, Polygon, etc.
* [[R (programming language)|R]] contains implementations of DBSCAN in the packages [https://cran.r-project.org/package=dbscan dbscan] and [https://cran.r-project.org/package=fpc fpc]. Both packages support arbitrary distance functions via distance matrices. The package fpc does not have index support (and thus has quadratic runtime and memory complexity) and is rather slow due to the R interpreter. The package dbscan provides a fast C++ implementation using [[k-d tree]]s (for Euclidean distance only) and also includes implementations of DBSCAN*, HDBSCAN*, OPTICS, OPTICSXi, and other related methods.
* [[scikit-learn]] includes a Python implementation of DBSCAN for arbitrary [[Minkowski distance|Minkowski metrics]], which can be accelerated using [[k-d tree]]s and [[ball tree]]s but which uses worst-case quadratic memory. A [https://github.com/scikit-learn-contrib/hdbscan contribution to scikit-learn] provides an implementation of the HDBSCAN* algorithm.
* [https://github.com/annoviko/pyclustering pyclustering] library includes a Python and C++ implementation of DBSCAN for Euclidean distance only as well as OPTICS algorithm.
* [http://www.philippe-fournier-viger.com/spmf/ SPMF] includes an implementation of the DBSCAN algorithm with k-d tree support for Euclidean distance only.
* [[Weka (machine learning)|Weka]] contains (as an optional package in latest versions) a basic implementation of DBSCAN that runs in quadratic time and linear memory.
* [https://docs.rs/linfa-clustering/latest/linfa_clustering/struct.Dbscan.html linfa] includes an implementation of the DBSCAN for the [[Rust (programming language)|rust programming language]].
* [[Julia (programming language)|Julia]] includes an implementation of DBSCAN in the Julia Statistics's Clustering.jl package.
<!-- -->
<!-- before adding yet another implementation, verify that it is of notability. Wikipedia is not a collection of links! -->

==See also==
* {{annotated link|Cluster analysis}}
* {{annotated link|k-means clustering}}

==Notes==
{{notelist}}

==References==
{{Reflist}}

{{DEFAULTSORT:Dbscan}}
[[Category:Cluster analysis algorithms]]