sklearn.cluster.DBSCAN

最新推荐文章于 2023-01-08 06:30:00 发布
最新推荐文章于 2023-01-08 06:30:00 发布
阅读量3.6k 收藏 3
点赞数 1
分类专栏： cluster analysis - 聚类分析 文章标签： sklearn.cluster.DBSCAN

sklearn.cluster.DBSCAN 

class sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=’euclidean’, metric_params=None, algorithm=’auto’, leaf_size=30, p=None, n_jobs=None)

Perform DBSCAN clustering from vector array or distance matrix.
DBSCAN - Density-Based Spatial Clustering of Applications with Noise. Finds core samples of high density and expands clusters from them. Good for data which contains clusters of similar density.

expand [ɪk'spænd; ek-]：vt. 扩张，使膨胀，详述 vi. 发展，张开，展开

Parameters

eps : float, optional
The maximum distance between two samples for them to be considered as in the same neighborhood.

min_samples : int, optional
The number of samples (or total weight) in a neighborhood for a point to be considered as a core point. This includes the point itself.

metric : string, or callable
The metric to use when calculating distance between instances in a feature array. If metric is a string or callable, it must be one of the options allowed by sklearn.metrics.pairwise_distances for its metric parameter. If metric is “precomputed”, X is assumed to be a distance matrix and must be square. X may be a sparse matrix, in which case only “nonzero” elements may be considered neighbors for DBSCAN.

metric_params : dict, optional
Additional keyword arguments for the metric function.

algorithm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional
The algorithm to be used by the NearestNeighbors module to compute pointwise distances and find nearest neighbors. See NearestNeighbors module documentation for details.

leaf_size : int, optional (default = 30)
Leaf size passed to BallTree or cKDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.

p : float, optional
The power of the Minkowski metric to be used to calculate distance between points.

n_jobs : int or None, optional (default=None)
The number of parallel jobs to run. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.

Attributes

core_sample_indices_ : array, shape = [n_core_samples]
Indices of core samples.

components_ : array, shape = [n_core_samples, n_features]
Copy of each core sample found by training.

labels_ : array, shape = [n_samples]
Cluster labels for each point in the dataset given to fit(). Noisy samples are given the label -1.

indices ['ɪndɪsiːz]：n. 指数，目录 (index 的复数)

Notes

For an example, see examples/cluster/plot_dbscan.py.

This implementation bulk-computes all neighborhood queries, which increases the memory complexity to O(n.d) where d is the average number of neighbors, while original DBSCAN had memory complexity O(n). It may attract a higher memory complexity when querying these nearest neighborhoods, depending on the algorithm.

One way to avoid the query complexity is to pre-compute sparse neighborhoods in chunks using NearestNeighbors.radius_neighbors_graph with mode='distance', then using metric='precomputed' here.

Another way to reduce memory and computation time is to remove (near-)duplicate points and use sample_weight instead.

query ['kwɪərɪ]：n. 疑问，质问，疑问号，查询 vt. 询问，对...表示疑问 vi. 询问，表示怀疑
brute [bruːt]：adj. 残忍的，无理性的 n. 畜生，残暴的人
bulk [bʌlk]：n. 体积，容量，大多数，大部分，大块 vt. 使扩大，使形成大量，使显得重要
estimator ['estɪmeɪtə]：n. 估计量，评价者

References

A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise

Examples

>>> from sklearn.cluster import DBSCAN
>>> import numpy as np
>>> X = np.array([[1, 2], [2, 2], [2, 3],
...               [8, 7], [8, 8], [25, 80]])
>>> clustering = DBSCAN(eps=3, min_samples=2).fit(X)
>>> clustering.labels_
array([ 0,  0,  0,  1,  1, -1])
>>> clustering 
DBSCAN(algorithm='auto', eps=3, leaf_size=30, metric='euclidean',
    metric_params=None, min_samples=2, n_jobs=None, p=None)

Methods

fit(X[, y, sample_weight])
Perform DBSCAN clustering from features or distance matrix.

fit_predict(X[, y, sample_weight])
Performs clustering on X and returns cluster labels.

get_params([deep])
Get parameters for this estimator.

set_params(**params)
Set the parameters of this estimator.

__init__(eps=0.5, min_samples=5, metric=’euclidean’, metric_params=None, algorithm=’auto’, leaf_size=30, p=None, n_jobs=None)

fit(X, y=None, sample_weight=None)
Perform DBSCAN clustering from features or distance matrix.

Parameters
X : array or sparse (CSR) matrix of shape (n_samples, n_features), or array of shape (n_samples, n_samples)
A feature array, or array of distances between samples if metric='precomputed'.

sample_weight : array, shape (n_samples,), optional
Weight of each sample, such that a sample with a weight of at least min_samples is by itself a core sample; a sample with negative weight may inhibit its eps-neighbor from being core. Note that weights are absolute, and default to 1.

y : Ignored

fit_predict(X, y=None, sample_weight=None)
Performs clustering on X and returns cluster labels.

Parameters
X : array or sparse (CSR) matrix of shape (n_samples, n_features), or array of shape (n_samples, n_samples)
A feature array, or array of distances between samples if metric='precomputed'.

sample_weight : array, shape (n_samples,), optional
Weight of each sample, such that a sample with a weight of at least min_samples is by itself a core sample; a sample with negative weight may inhibit its eps-neighbor from being core. Note that weights are absolute, and default to 1.

y : Ignored

Returns
y : ndarray, shape (n_samples,)
cluster labels

get_params(deep=True)
Get parameters for this estimator.

Parameters
deep : boolean, optional
If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns
params : mapping of string to any
Parameter names mapped to their values.

set_params(**params)
Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Returns
self

class DBSCAN(BaseEstimator, ClusterMixin):
    """Perform DBSCAN clustering from vector array or distance matrix.
    DBSCAN - Density-Based Spatial Clustering of Applications with Noise.
    Finds core samples of high density and expands clusters from them.
    Good for data which contains clusters of similar density.
    Read more in the :ref:`User Guide <dbscan>`.
    Parameters
    ----------
    eps : float, optional
        The maximum distance between two samples for them to be considered
        as in the same neighborhood.
    min_samples : int, optional
        The number of samples (or total weight) in a neighborhood for a point
        to be considered as a core point. This includes the point itself.
    metric : string, or callable
        The metric to use when calculating distance between instances in a
        feature array. If metric is a string or callable, it must be one of
        the options allowed by :func:`sklearn.metrics.pairwise_distances` for
        its metric parameter.
        If metric is "precomputed", X is assumed to be a distance matrix and
        must be square. X may be a sparse matrix, in which case only "nonzero"
        elements may be considered neighbors for DBSCAN.
        .. versionadded:: 0.17
           metric *precomputed* to accept precomputed sparse matrix.
    metric_params : dict, optional
        Additional keyword arguments for the metric function.
        .. versionadded:: 0.19
    algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
        The algorithm to be used by the NearestNeighbors module
        to compute pointwise distances and find nearest neighbors.
        See NearestNeighbors module documentation for details.
    leaf_size : int, optional (default = 30)
        Leaf size passed to BallTree or cKDTree. This can affect the speed
        of the construction and query, as well as the memory required
        to store the tree. The optimal value depends
        on the nature of the problem.
    p : float, optional
        The power of the Minkowski metric to be used to calculate distance
        between points.
    n_jobs : int or None, optional (default=None)
        The number of parallel jobs to run.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.
    Attributes
    ----------
    core_sample_indices_ : array, shape = [n_core_samples]
        Indices of core samples.
    components_ : array, shape = [n_core_samples, n_features]
        Copy of each core sample found by training.
    labels_ : array, shape = [n_samples]
        Cluster labels for each point in the dataset given to fit().
        Noisy samples are given the label -1.
    Examples
    --------
    >>> from sklearn.cluster import DBSCAN
    >>> import numpy as np
    >>> X = np.array([[1, 2], [2, 2], [2, 3],
    ...               [8, 7], [8, 8], [25, 80]])
    >>> clustering = DBSCAN(eps=3, min_samples=2).fit(X)
    >>> clustering.labels_
    array([ 0,  0,  0,  1,  1, -1])
    >>> clustering # doctest: +NORMALIZE_WHITESPACE
    DBSCAN(algorithm='auto', eps=3, leaf_size=30, metric='euclidean',
        metric_params=None, min_samples=2, n_jobs=None, p=None)
    Notes
    -----
    For an example, see :ref:`examples/cluster/plot_dbscan.py
    <sphx_glr_auto_examples_cluster_plot_dbscan.py>`.
    This implementation bulk-computes all neighborhood queries, which increases
    the memory complexity to O(n.d) where d is the average number of neighbors,
    while original DBSCAN had memory complexity O(n). It may attract a higher
    memory complexity when querying these nearest neighborhoods, depending
    on the ``algorithm``.
    One way to avoid the query complexity is to pre-compute sparse
    neighborhoods in chunks using
    :func:`NearestNeighbors.radius_neighbors_graph
    <sklearn.neighbors.NearestNeighbors.radius_neighbors_graph>` with
    ``mode='distance'``, then using ``metric='precomputed'`` here.
    Another way to reduce memory and computation time is to remove
    (near-)duplicate points and use ``sample_weight`` instead.
    References
    ----------
    Ester, M., H. P. Kriegel, J. Sander, and X. Xu, "A Density-Based
    Algorithm for Discovering Clusters in Large Spatial Databases with Noise".
    In: Proceedings of the 2nd International Conference on Knowledge Discovery
    and Data Mining, Portland, OR, AAAI Press, pp. 226-231. 1996
    """

    def __init__(self, eps=0.5, min_samples=5, metric='euclidean',
                 metric_params=None, algorithm='auto', leaf_size=30, p=None,
                 n_jobs=None):
        self.eps = eps
        self.min_samples = min_samples
        self.metric = metric
        self.metric_params = metric_params
        self.algorithm = algorithm
        self.leaf_size = leaf_size
        self.p = p
        self.n_jobs = n_jobs

    def fit(self, X, y=None, sample_weight=None):
        """Perform DBSCAN clustering from features or distance matrix.
        Parameters
        ----------
        X : array or sparse (CSR) matrix of shape (n_samples, n_features), or \
                array of shape (n_samples, n_samples)
            A feature array, or array of distances between samples if
            ``metric='precomputed'``.
        sample_weight : array, shape (n_samples,), optional
            Weight of each sample, such that a sample with a weight of at least
            ``min_samples`` is by itself a core sample; a sample with negative
            weight may inhibit its eps-neighbor from being core.
            Note that weights are absolute, and default to 1.
        y : Ignored
        """
        X = check_array(X, accept_sparse='csr')
        clust = dbscan(X, sample_weight=sample_weight,
                       **self.get_params())
        self.core_sample_indices_, self.labels_ = clust
        if len(self.core_sample_indices_):
            # fix for scipy sparse indexing issue
            self.components_ = X[self.core_sample_indices_].copy()
        else:
            # no core samples
            self.components_ = np.empty((0, X.shape[1]))
        return self

    def fit_predict(self, X, y=None, sample_weight=None):
        """Performs clustering on X and returns cluster labels.
        Parameters
        ----------
        X : array or sparse (CSR) matrix of shape (n_samples, n_features), or \
                array of shape (n_samples, n_samples)
            A feature array, or array of distances between samples if
            ``metric='precomputed'``.
        sample_weight : array, shape (n_samples,), optional
            Weight of each sample, such that a sample with a weight of at least
            ``min_samples`` is by itself a core sample; a sample with negative
            weight may inhibit its eps-neighbor from being core.
            Note that weights are absolute, and default to 1.
        y : Ignored
        Returns
        -------
        y : ndarray, shape (n_samples,)
            cluster labels
        """
        self.fit(X, sample_weight=sample_weight)
        return self.labels_
Yongqiang Cheng
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
dbscan.rar_DBSCAN_K.
09-20
linux c 实现k-means算法，利用这个源码，可以对数值类数据进行聚类，达到我们期望的效果
DBSCAN聚类︱scikit-learn中一种基于密度的聚类方式
素质云笔记
07-11 3万+
一、DBSCAN聚类概述基于密度的方法的特点是不依赖于距离，而是依赖于密度，从而克服基于距离的算法只能发现“球形”聚簇的缺点。 DBSCAN的核心思想是从某个核心点出发，不断向密度可达的区域扩张，从而得到一个包含核心点和边界点的最大化区域，区域中任意两点密度相连。1、伪代码 算法： DBSCAN 输入： E — 半径 MinPts — 给定点在 E 领域内成为核心对象的
sklearn聚类方法详解
热门推荐
ustbbsy的博客
07-08 8万+
1 KMeans 1.1 算法描述 随机选择k个中心 遍历所有样本，把样本划分到距离最近的一个中心 划分之后就有K个簇，计算每个簇的平均值作为新的质心 重复步骤2，直到达到停止条件 停止条件： 聚类中心不再发生变化；所有的距离最小；迭代次数达到设定值， 代价函数：误差平方和（SSE） 1.2 算法优缺点 优点： 算法容易理解，聚类效果不错 具有出色的速度 当簇近似高斯分...
python机器学习库sklearn——DBSCAN密度聚类
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
03-05 4万+
全栈工程师开发手册 （作者：栾鹏） python数据挖掘系列教程 DBSCAN密度聚类的相关的知识内容可以参考 http://blog.csdn.net/luanpeng825485697/article/details/79438025 DBSCAN The DBSCAN 算法将聚类视为被低密度区域分隔的高密度区域。由于这个相当普遍的观点， DBSCAN发现的聚类...
DBSCAN介绍及sklearn库中的使用
study with Ming
09-06 8783
DBSCAN 定义 DBSCAN的英文全程是Density-based spatial clustering of applications with noise，是一种以密度为本的聚类算法，在一个空间中，将距离近的点分为一类，将低密度的点抛弃。 算法 一个点ppp如果在他的半径rrr范围内有nnn个点，则称他为核心点，那些点称为由ppp直接可达. 如果点qqq是ppp可达的，则...
基于python中的sklearn.cluster库做k-means聚类
09-11
本程序是在python中完成，基于sklearn.cluster中的k-means聚类包来实现数据的聚类，对于里面使用的数据格式如下：（注意更改程序中的相关参数） 138 0 124 1 127 2 129 3 119 4 127 5 124 6 120 7 123 8 147 9 188 10 212 11 229 12 240 13 240 14 241 15 240 16 242 17 174 18 130 19 132 20 119 21 48 22 37 23 49 0 42 1 34 2 26 3 20 4 21 5 23 6 13 7 19 8 18 9 36 10 25 11 20 12 19 13 19 14 5 15 29 16 22 17 13 18 46 19 15 20 8 21 33 22 41 23 69 0 56 1 49 2 40 3 52 4 62 5 54 6 32 7 38 8 44 9 55 10 70 11 74 12 105 13 107 14 56 15 55 16 65 17 100 18 195 19 136 20 87 21 64 22 77 23 61 0 53 1 47 2 33 3 34 4 28 5 41 6 40 7 38 8 33 9 26 10 31 11 31 12 13 13 17 14 17 15 25 16 17 17 17 18 14 19 16 20 17 21 29 22 44 23 37 0 32 1 34 2 26 3 23 4 25 5 25 6 27 7 30 8 25 9 17 10 12 11 12 12 12 13 7 14 6 15 6 16 12 17 12 18 39 19 34 20 32 21 34 22 35 23 33 0 57 1 81 2 77 3 68 4 61 5 60 6 56 7 67 8 102 9 89 10 62 11 57 12 57 13 64 14 62 15 69 16 81 17 77 18 64 19 62 20 79 21 75 22 57 23 73 0 88 1 75 2 70 3 77 4 73 5 72 6 76 7 76 8 74 9 98 10 90 11 90 12 85 13 79 14 79 15 88 16 88 17 81 18 84 19 89 20 79 21 68 22 55 23 63 0 62 1 58 2 58 3 56 4 60 5 56 6 56 7 58 8 56 9 65 10 61 11 60 12 60 13 61 14 65 15 55 16 56 17 61 18 64 19 69 20 83 21 87 22 84 23 41 0 35 1 38 2 45 3 44 4 49 5 55 6 47 7 47 8 29 9 14 10 12 11 4 12 10 13 9 14 7 15 7 16 11 17 12 18 14 19 22 20 29 21 23 22 33 23 34 0 38 1 38 2 37 3 37 4 34 5 24 6 47 7 70 8 41 9 6 10 23 11 4 12 15 13 3 14 28 15 17 16 31 17 39 18 42 19 54 20 47 21 68 22
聚类算法学习----之----sklearn.cluster.DBSCAN
xiaoQL520的博客
10-30 8296
class DBSCAN(BaseEstimator, ClusterMixin): """Perform DBSCAN clustering from vector array or distance matrix. DBSCAN - Density-Based Spatial Clustering of Applications with Noise. ...
用scikit-learn学习DBSCAN聚类
weixin_34414196的博客
12-24 495
　　　　在DBSCAN密度聚类算法中，我们对DBSCAN聚类算法的原理做了总结，本文就对如何用scikit-learn来学习DBSCAN聚类做一个总结，重点讲述参数的意义和需要调参的参数。 1. scikit-learn中的DBSCAN类 　　　　在scikit-learn中，DBSCAN算法类为sklearn.cluster.DBSCAN。要熟练的掌握用DBSCAN类来聚类，除了对DBSCAN本...
ML：非监督学习之 聚类 之 2 DBSAN聚类（sklearn.cluster.dbscan))
htuhxf的博客
10-14 1552
一、算法图解 DBSCAN：Dense-Based Spatial Clustering of Applications with Noise（基于密度的&带噪点的空间聚类应用方法） 举个栗子： 1. 此处潜在设定条件：Min_smaples（或者叫MinPoints / Minpts）= 3； 2. 划分为QMP3个点、SOR3个点为圆心的圆内的点，共计2类；剩余的点为Noise（噪点）...
密度聚类sklearn.cluster包DBSCAN
as394349658的博客
08-16 1667
#coding=utf-8 import numpy as np from sklearn.cluster import DBSCAN import matplotlib.pyplot as plt #国家面积和人口 X = [ [9670250, 1392358258], # 中国 [2980000, 1247923065], # 印度 [9629091, 31740...
dbscan.rar_DBSCAN
09-21
基于单文档的数据库浏览dbscan.rar,很不错的vc源码，希望能对大家有所帮助
DBSCAN.zip_DBSCAN
09-24
在vs2010上实现的DBSCAN算法，改算法抗噪声能力强，但是缺点是时间复杂度为n的三分之四次方。
DBscan.rar_DBSCAN
09-19
algoritnno dbscan basado en densidad para agrupamiento de datos
DBSCAN.rar_DBSCAN_DBSCAN算法_dbscan C_dbscan.rar
09-24
基于C++的dbscan算法 应用程序向导已为您创建了此 DBSCAN 应用程序
scikit-learn之聚类算法之DBSCAN
涛涛不绝蕾蕾于冬
04-23 2391
算法流程 DBSCAN（Density-Based Spatial Clustering of Applications with Noise，具有噪声的基于密度的聚类方法）算法将聚类视为被低密度区域分隔的高密度区域。 核心样本：数据集中的一个样本，至少存在 min_samples 个其他样本在 eps 距离范围内，这些样本被定为核心样本的邻居 neighbors； 1、计算出所有的核心样...
浅谈sklearn中DBSCAN的欧式距离(Euclidean Distance)的计算
kraisi的博客
11-29 2398
DBSCAN根据密度聚类，常用欧式距离（Euclidean Distance）来度量数据之间的距离。笔者学习发现DBSCAN中欧式距离的计算先后调用了sklearn.neighbors.NearestNeighbors和sklearn.metrics.pairwise.euclidean_distances，并浅谈其中sklearn.metrics.pairwise.euclidean_distances对欧式距离计算公式的优化和不足。
sklearn机器学习之DBSCAN聚类
微小冷的学习笔记
01-08 4043
和其他聚类算法相比，DBSCAN存在一种去中心化的特性，即不存在一聚类中心，这样做的好处是，在面对不规则的数据时，有着更好的聚类效果。
聚类算法系列--sklearn DBSCAN学习
积跬步，至千里
09-09 1532
  class sklearn.cluster.DBSCAN（） 参数： eps：-邻域阈值，样本距离超过ϵ的样本点不在ϵ-邻域内。 min_samples：The number of samples (or total weight) in a neighborhood for a point to be considered as a core point. This includes...
sklearn.cluster聚类算法:K-means和DBSCAN 学习笔记
sanjianjixiang的博客
11-01 1339
首先放两个好玩的网页,动态可视化展示K-means和DBSCAN K-mean https://www.naftaliharris.com/blog/visualizing-k-means-clustering/ DBSCAN https://www.naftaliharris.com/blog/visualizing-dbscan-clustering/ import pandas as p...
sklearn.cluster.dbscan
最新发布
03-16
sklearn.cluster.dbscan是一种密度聚类算法，可以用于发现任意形状的聚类。它基于密度可达性原理，将数据点分为核心点、边界点和噪声点，并将核心点连接起来形成聚类。该算法的优点是可以处理噪声和异常值，但需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值