【一般聚类/时序聚类】python实现多密度自适应聚类：Multi-DBSCAN

最新推荐文章于 2024-05-31 16:23:12 发布
最新推荐文章于 2024-05-31 16:23:12 发布
阅读量4.4k 收藏 93
点赞数 7
分类专栏： python 时序聚类 文章标签： 聚类 DBSCAN 自适应 多密度 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37960007/article/details/115216211
版权

本文代码基于该篇进行魔改，功能调用更加方便，速度经测试快了几十倍

import math
import copy
import numpy as np
from sklearn.cluster import DBSCAN
import sklearn.metrics.pairwise as pairwise


class Adapter_DBSCAN():

    # 默认统计聚类个数在2-25之间的聚类情况, 参数符合python左闭右开
    def __init__(self,num_cluster_range=(2,26)):
        self.num_cluster_range = num_cluster_range
    

    def returnEpsCandidate(self,dataSet):
        """
        :param dataSet: 数据集
        :return: eps候选集合
        """
        #self.DistMatrix = self.CalculateDistMatrix(dataSet)
        self.DistMatrix = pairwise.euclidean_distances(dataSet)
        tmp_matrix = copy.deepcopy(self.DistMatrix)
        for i in range(len(tmp_matrix)):
            tmp_matrix[i].sort()
        EpsCandidate = []
        for k in range(1,len(dataSet)):
            #Dk = self.returnDk(tmp_matrix,k)
            Dk = tmp_matrix[:,k]
            # DkAverage = self.returnDkAverage(Dk)
            # 快160+倍
            DkAverage = np.mean(Dk)
            EpsCandidate.append(DkAverage)
        return EpsCandidate
    

    def returnMinptsCandidate(self,DistMatrix,EpsCandidate,X):
        """
        :param DistMatrix: 距离矩阵
        :param EpsCandidate: Eps候选列表
        :return: Minpts候选列表
        """
        MinptsCandidate = []
        for k in range(len(EpsCandidate)):
            tmp_eps = EpsCandidate[k]
            tmp_count = 0
            # for i in range(len(DistMatrix)):
            #     for j in range(len(DistMatrix[i])):
            #         if DistMatrix[i][j] <= tmp_eps:
            #             tmp_count = tmp_count + 1
            # 快250+倍
            tmp_count = np.sum(DistMatrix <= tmp_eps)
            MinptsCandidate.append(tmp_count/len(X))
        return MinptsCandidate
    

    def fit(self,X):
        self.EpsCandidate = self.returnEpsCandidate(X)
        self.MinptsCandidate = self.returnMinptsCandidate(self.DistMatrix,self.EpsCandidate,X)
        self.do_multi_dbscan(X)
        self.set_num_clusters_range(self.num_cluster_range)


    def do_multi_dbscan(self,X):
        self.all_predict_dict = {}
        self.all_param_dict = {}

        for i in range(len(self.EpsCandidate)):
            eps = self.EpsCandidate[i]
            minpts = self.MinptsCandidate[i]
            db = DBSCAN(eps=eps,min_samples=minpts).fit(X)
            num_clusters = max(db.labels_) + 1
            # 统计符合范围的聚类情况

            if num_clusters not in self.all_predict_dict.keys():
                self.all_predict_dict[num_clusters] = []
                self.all_param_dict[num_clusters] = []

            self.all_predict_dict[num_clusters].append(db.labels_)
            self.all_param_dict[num_clusters].append({"eps":eps,"minpts":minpts})


    # 筛选聚类个数，比如Multi-DBSCAN共产生了3聚类、15聚类、136聚类三种情况
    # 我想只看10～20的聚类情况，就可以设置set_num_clusters_range(10~21)后调用get_predict_dict()
    def set_num_clusters_range(self,num_cluster_range:tuple):
        self.predict_dict = {}
        self.param_dict = {}
        # 统计符合范围的聚类情况

        for num_cluster, labels, params in zip(self.all_predict_dict.keys(),\
            self.all_predict_dict.values(), self.all_param_dict.values()):
            if num_cluster >= num_cluster_range[0] and \
                num_cluster < num_cluster_range[1]:
                self.predict_dict[num_cluster] = labels
                self.param_dict[num_cluster] = params


    # 获取当前Multi-DBSCAN的聚类预测信息,格式为{聚类个数:[[预测可能1],[预测可能2],...]}
    # 比如聚类个数为3的情况可能有多种，所以有预测可能1、预测可能2...
    def get_predict_dict(self):
        if self.predict_dict is None:
            raise RuntimeError("get_predict_dict before fit")
        return self.predict_dict


    # 获取当前Multi-DBSCAN的聚类参数信息,格式为{聚类个数:[{"eps":x1,"minpts":y1},{"eps":x2,"minpts":y2},...]}
    def get_info_dict(self):
        if self.param_dict is None:
            raise RuntimeError("get_info_dict before fit")
        return self.param_dict

实验用到的数据集格式，共788行：

测试：

def loadDataSet(fileName):
    """
    输入：文件名
    输出：数据集
    描述：从文件读入数据集
    """
    dataSet = []
    with open(fileName) as fr:
        for line in fr.readlines():
            curline = line.strip().split(",")
            fltline = list(map(float, curline))
            dataSet.append(fltline)
    return np.array(dataSet)


if __name__ == '__main__':

    X = loadDataSet('common/788points.txt')
    DB = Adapter_DBSCAN()
    DB.fit(X)
    
    # 输出15聚类的情况
    DB.set_num_clusters_range((15,16))
    # label预测信息
    predict_dict = DB.get_predict_dict()
    # 参数信息
    info_dict = DB.get_info_dict()

    print(predict_dict)
    print("================================")
    print(info_dict)

# 注意到整个Multi-DBSCAN过程中eps、minpts参数都不需要你手工设置
# 还可以控制输出聚类个数范围，是不是很方便？

打印：

{15: [array([-1, -1, -1,  0,  0,  0,  0,  0, -1, -1,  0,  0,  0, -1, -1, -1,  0,
        0,  0,  0,  0,  0, -1,  0,  0, -1, -1, -1, -1, -1,  1,  1,  1,  1,
        1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
        1,  1,  1,  1,  3,  1, -1, -1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
        1, -1,  1,  2, -1,  1, -1, -1, -1,  2,  2,  2,  2,  2,  2,  2,  2,
        2,  2,  2,  2,  2, -1,  4,  4,  2,  2,  2,  2,  3,  3,  3,  4,  4,
        4,  4,  5,  5,  5,  5, -1,  6,  3,  6,  6,  6,  6,  6,  6, -1,  7,
        7,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, -1, -1,  3,  3,  3,
        3,  3,  3,  3,  3,  3,  3,  3, -1, -1, -1,  3,  3,  3,  6,  7,  7,
        3, -1, -1, -1,  7,  7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        8,  8,  8, -1,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
        8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
       -1, -1,  9,  9, -1,  9,  9,  9,  9,  9,  9,  9,  9, -1,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, -1,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, -1,
        9,  9,  9,  9,  9,  9, -1,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, -1, -1,  9,  9,
        9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9, -1,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9, 10, 10, 10, 10, 10, -1, 10, -1, -1, -1, 11, -1, 10, 10, 10, 10,
       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -1, 10, -1, 10, 10, 11,
       11, 11, -1, -1, 11, 11, 11, 11, 11, -1, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, -1, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, -1, -1, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, -1, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -1,
       -1, -1, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -1, 13, 13, 13, 13,
       13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
       -1, 13, 13, 13, 13, 13, 13, 13, 13, -1, 13, 13, 13, 13, 13, 13, -1,
       13, -1, -1, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
       14, 14, 14, 14, 14, 14]), array([-1, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1,  0,  0,
        0,  0,  0,  0,  0, -1,  0,  0,  0,  0, -1, -1, -1, -1,  1,  1,  1,
        1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
        1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
        1,  1,  1,  1,  1,  1,  1,  1, -1,  2,  2,  1,  1,  1,  1,  1,  1,
        1,  2,  2, -1, -1, -1, -1,  3,  2,  2,  3,  3,  3,  3,  3,  3,  3,
        3, -1, -1, -1, -1, -1, -1, -1,  3, -1, -1, -1, -1, -1, -1, -1, -1,
       -1,  3,  3,  3,  3,  3,  3,  3,  3,  3, -1, -1, -1, -1, -1, -1, -1,
       -1,  3,  3,  3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
        4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
       -1, -1, -1, -1, -1, -1,  5, -1,  5,  5,  5,  5,  5,  5, -1, -1,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, -1,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, -1,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, -1,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
       -1,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
        5,  5,  5,  5, -1,  5, -1,  5,  5,  5, -1,  5,  5,  5,  5,  5,  5,
        5,  6,  6, -1,  6, -1, -1, -1, -1, -1,  7,  7, -1, -1,  6,  6,  6,
        6,  6,  6,  6,  6,  6,  6, -1, -1,  6,  6, -1, -1, -1, -1,  6,  8,
        8,  6, -1, -1, -1,  7,  7,  7,  7,  7,  7,  7,  9, -1,  8,  8,  8,
        8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,
       -1,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
        9,  9,  9,  9,  8,  8,  8,  8,  8,  8, -1, -1, -1, -1,  9,  9,  9,
        9, -1, -1, -1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
       10, 10, 10, 10, 10, 10, 10, 11, 10, 10, 11, 11, 11, 11, 11, 11, -1,
       11, 12, 12, 12, 12, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -1,
       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -1, 10, 10, 10,
       10, 10, 10, 10, 10, 10, -1, 10, 10, 10, 10, 10, 10, 10, 12, 10, 12,
       12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -1, -1, -1, -1, -1,
       12, 12, 10, 10, -1, -1, -1, -1, -1, -1, -1, 10, 13, 13, 13, 13, 13,
       13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -1, 13, 13, -1,
       -1, 13, 13, 13, 13, 13, 13, 13, 13, -1, 13, 13, 13, 13, 13, 13, -1,
       13, 13, -1, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
       14, 14, 14, 14, 14, 14])]}
================================
{15: [{'eps': 1.0547224554276167, 'minpts': 5.916243654822335}, {'eps': 1.238569836383374, 'minpts': 8.055837563451776}]}

上述结果显示了Multi-DBSCAN在15聚类情况下的2种可能

时序聚类测试

再测试时序聚类，选取东海、渤海、黄海等海面温等数据，样本比较少，60多个，每个样本单要素，2800+时间点（已降维成100），形成shape=(60+,100)的数据

import time
import numpy as np
import matplotlib.pyplot as plt
import sklearn.metrics.pairwise as pairwise
from sklearn.cluster import DBSCAN
from common.my_clustering import Adapter_DBSCAN
from sklearn.metrics.cluster import \
    silhouette_score as sklearn_silhouette_score


# 自动根据聚类个数布局行列
def multip_decomposition(num_cluster):
    s = math.sqrt(num_cluster)
    col = math.ceil(s)
    row = int(s)
    flag = False
    while(col * row < num_cluster):
        if flag:
            row += 1
            flag = True
        else:
            col += 1
            flag = False
    return row, col


def test_multi_dbscan(config):
    X = np.loadtxt(config["data_path"],dtype=np.float32)
    adb = Adapter_DBSCAN(num_cluster_range=(2,30))
 
    t0 = time.time()
    adb.fit(X)
    t1 = time.time()

    predict_dict = adb.get_predict_dict()
    info_dict = adb.get_info_dict()

    for num_cluster, labels, infos in zip(predict_dict.keys(),predict_dict.values(),info_dict.values()):
        for possible,y_pred in enumerate(labels):
            # 时序图横着放更好看，所以是col,row而不是row,col
            col,row = multip_decomposition(num_cluster + 2)
            y_pred_valid = []
            X_valid = []
            for yi in range(num_cluster):
                plt.subplot(row, col, yi + 1)
                clusters_yi = X[y_pred == yi]
                for xs in clusters_yi:
                    X_valid.append(xs.tolist())
                    y_pred_valid.append(yi)
                for xx in clusters_yi:
                    plt.plot(xx.ravel(), "k-", alpha=.3)
                plt.plot(np.mean(clusters_yi,axis=0).ravel(), "r-")
            
            X_valid = np.array(X_valid)
            y_pred_valid = np.array(y_pred_valid)
            print(X_valid.shape)
            print(y_pred_valid.shape)

            plt.subplot(row, col, num_cluster + 1)
            clusters_noise = X[y_pred == -1]
            for xx in clusters_noise:
                    plt.plot(xx.ravel(), "k-", alpha=.3)
            plt.plot(np.mean(clusters_noise,axis=0).ravel(), "r-")
            plt.text(0.55, 0.85,'noise',
                        transform=plt.gca().transAxes)

            plt.subplot(row, col, num_cluster + 2)
            clusters_uncertain = X[y_pred == -2]
            for xx in clusters_uncertain:
                    plt.plot(xx.ravel(), "k-", alpha=.3)
            plt.plot(np.mean(clusters_uncertain,axis=0).ravel(), "r-")
            plt.text(0.55, 0.85,'uncertain',
                        transform=plt.gca().transAxes)

            plt.tight_layout()

            # prefix, suffix = filepath.split(".")
            # prefix = data_process.exp_replace(prefix,"exp4") 
            # img_save_path = "{}_{}_{}minpts_{}clusters_possible{}.png".format(\
            #   prefix,config["test_name"],"%.2f" % infos[possible]["minpts"],num_cluster,possible)
            # logger.log_img("聚类结果图: {}".format(img_save_path),img_save_path)
            # 自己找地方保存plt的图像

            # 轮廓系数
            t2 = time.time()
            dists = pairwise.pairwise_distances(X_valid,metric=config["cdists_method"],n_jobs=-1)
            score = sklearn_silhouette_score(dists,y_pred_valid,metric=config["method"])
            t3 = time.time()
            # logger.log("silhouette_score="+str(score)+", time cost: "+str(t3 - t2)+"s\n\n")
            # 自己找地方保存轮廓系数

# 测试
filepath=...
config = {"method":"precomputed","cdists_method":"l2", "test_name":"multidbscan", "data_path":filepath,"seed":0}
test_multi_dbscan(config)

由于该部分数据海域选取的地理点较近，且样本较少，较杂且较难区分

实验结果：

实验日志显示除noise外的数据仍有较好的轮廓系数0.5+，说明聚类结果算理想（相比于KMeans系列轮廓系数只有0.2+）：

 

青春依旧_
关注
  • 7
    点赞
  • 踩
  • 93
    收藏
    觉得还不错? 一键收藏
  • 53
    评论
专栏目录
【聚类】一种自适应Eps和Minpts的DBSCAN方法（python实现）
liyihao17的博客
04-18 2万+
一、算法来源 1、DBSCAN算法原型 这个算法原型非常简单，有很多博主都有写，大家自己去看看就好了，也不用花太多时间，顶多十分钟就能了解个大概。 2、自适应Eps和Minpts参数 由于该算法对Eps和Minpts参数十分敏感，所以如何确定这两个参数对于DBSCAN来说是很重要的一步，这篇博文是基于李文杰老师的论文《自适应确定DBSCAN算法参数的算法研究》，...
利用Python对时间序列进行分类与聚类
12-13
可靠的方法去判断两个时间序列是否相似，截下来便可以使用k-NN算法进行分类。根据经验，最优解一般出现在k=1的时候。下面就利用DTW欧氏距离的1-NN算法。在该算法中，train是时间序列示例的训练集，其中时间序列所属的类被附加到时间序列的末尾。test是相应的测试集，它所属于的类别就是我们想要预测的结果。在该算法中，对于测试集中的每一个时间序列，每一遍搜索必须遍历训练集中的所有点，从而可以找到最多的相似点。考虑到DTW算法是二次方的，计算过程会耗费非常长时间。我们可以通过LB Keogh下界方法来提高分类算法的计算速度。计算机运行LB Keogh的速度会比运行DTW的速度快很多。另外，当LB
什么是自适应近邻图学习的多视角聚类方法？
最新发布
...
05-31 531
自适应近邻图学习的多视角聚类方法是一种高级的机器学习技术，旨在处理含有（或称为“视角”）的数据集，每个视角提供关于数据的不同侧面或特征信息。这种方法通过整合多个视角下的信息来改善聚类效果，特别是在数据具有复杂结构和高维度的情况下更为有效。核心思想是利用自适应机制来优化邻近关系的建模，以及跨视角的相似性融合，从而达到更准确的聚类。
DBSCAN聚类算法
yixon_oss的博客
05-03 3241
本文主要介绍了DBSCAN聚类算法的基本原理, 给出了半圆形数据分簇和啤酒聚类分析两个简单实例的python程序实现，小结了算法存在的优缺点，希望后续通过自适应过程弥补算法的不足。最后，补充了DBSCAN算法的MATLAB代码及测试用例仅供参考。
DBSCAN（自适应密度聚类）算法解析
qq_29462849的博客
07-20 6776
自适应近聚类（Clustering and Projected Clustering with Adaptive Neighbors）
Robert_Gordon的博客
06-11 5607
  在谱聚类中，构造邻接矩阵时，对于每个边的权重需要用高斯核函数来构造，对此需要调节参数σ\sigmaσ,嗯嗯…我们知道调参是一件很无意义的事情，鲁棒性不是很好。 那么如何解决这个问题？   聂飞平大佬14年提出了自适应近邻构造图的方法（CAN），Clustering and Projected Clustering with Adaptive Neighbors，接下来我们简单的介绍一下CAN方法。   该算法的含义很简单：“距离较小的数据点成为邻居的可能性较大”这一先验知识的前提下，引入了概率邻居，在
新类识别/领域自适应-聚类
爱吃火锅的博客
09-22 1834
前言 这块应用在实际业务中非常常见，比如新意图识别等等，不管具体任务是什么，本质上就是在做一个事：给样本分类，但是又没有标签数据。 一般来说就是通过聚类来完成，使用的feature多种多样，比如现在大火的预训练模型，关于这块的研究其实也有不少，也有很多trick，但是网上很少有这块的总结，这里就列举一些该领域的一些近期paper，供提供思路。 CDAC+ 论文：https://ojs.aaai.org/index.php/AAAI/article/view/6353 论文源码：https:
聚类分析-基于密度的聚类方法DBSCAN及其Python实现 包含数据集
03-31
本文将深入探讨一种基于密度的聚类方法——DBSCAN（Density-Based Spatial Clustering of Applications with Noise），并介绍如何使用Python进行实现。** DBSCAN是一种非参数聚类算法，与K-means等中心点依赖的算法...
聚类分析-基于密度的聚类方法DBSCAN及其Python实现
03-30
数据挖掘|聚类分析|基于密度的聚类方法DBSCAN及其Python实现
dbscan-python:使用DBSCAN算法的图像像素聚类
05-12
在Python项目中，`dbscan-python-master`可能是一个包含示例代码和数据的文件夹。通常，它会包含一个主文件（如`main.py`）和可能的辅助函数文件。这些文件可能演示了如何将上述步骤应用到具体图像上。通过阅读和...
DBSCAN聚类.rar_DBSCAN_python算法_密度峰值聚类_密度聚类python_峰值聚类算法
07-14
Python密度聚类 最近在Science上的一篇基于密度的聚类算法《Clustering by fast search and find of density peaks》引起了大家的关注(在我的博文“论文中的机器学习算法——基于密度峰值的聚类算法”中也进行了中文...
dbscan1d:DBSCAN聚类算法的有效一维实现
05-08
在每种情况下，DBSCAN1D都比scikit Learn的实现快得多。 安装 只需使用pip安装dbscan1d： pip install dbscan1d 它只需要numpy。 快速开始 dbscan1d设计为在几乎所有情况下都可以与sklearn的实现互换。 唯一的...
一种改进的自适应快速AF-DBSCAN聚类算法
热门推荐
dwf_android的博客
09-22 1万+
针对基于密度的DBSCAN聚类算法及其改进算法在全局参数Eps与MinPts选择上需人工干预以及区域查询方式过程复杂和查询易丢失对象等不足，提出一种改进的参数自适应以及区域快速查询的密度聚类算法。根据KNN分布与数学统计分析自适应计算出最优全局参数Eps与MinPts，避免聚类过程中的人工干预，实现聚类过程的全自动化。通过改进种子代表对象选取方式进行区域查询，无需漏检操作，有效提高聚类的效率。对4种典型数据集的密度聚类实验结果表明，提出的方法有效解决了DBSCAN算法参数选取困难和算法效率的问题。
基于低能耗自适应聚类层次结构(LEACH)（Matlab代码实现）
weixin_46039719的博客
07-29 840
研究人员在WSN（无线传感器网络）中面临的主要挑战是电池寿命（节点的能量）。本文考虑了多跳WN（无线网络）分布式机制的一般框架。基于集群的路由协议，如低能耗自适应集群层次结构（LEACH），混合能效协议（HEEP），阈值敏感节能网络协议（TEEN）和PEGASIS，可有效管理能源使用。但这些协议仍然应该彻底研究和修订，以实现更高的能源效率。本文重点介绍LEACH协议，其中簇头（CH）选择过程称为“圆形”（r）。每一轮都花费了网络的设置和稳态阶段。...
MATLAB聚类 自适应 从类别数目的选择到聚类
乱七八糟的笔记
09-18 7519
聚类是很快的，所以不需要自适应，只需要[1.....N]个类中心，遍历一遍，得到N个评估值，[1.....N]选一个最好的类中心数目即可。 类中心个数的评估： eva = evalclusters(mat,'kmeans','CalinskiHarabasz',... 'klist',[1:6]) eva = evalclusters(mat,'linkage','CalinskiH...
Matlab实现(KNN)自适应谱聚类
bwangk的博客
04-14 5587
自适应谱聚类谱聚类中常用构造K近邻关系的相似度矩阵，这里引用实现相关算法，首先根据输入的数据data和K值求解KNN矩阵：get_knn_distance.mfunction [A]=get_knn_distance(data,K) % Input : data: N*D 维的数据，N表示数据点数，D表示数据维数 % K: 近邻数 % % Output :A:KNN矩阵 d
探索数据之美：Python聚类算法DBSCAN实例分析
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
09-21 77
DBSCAN是一种基于密度的聚类算法，它通过考察数据点周围的密度来确定数据点是否属于一个簇。DBSCAN的优点之一是它能够自动识别任意形状的簇，而不需要事先指定簇的数量。此外，DBSCAN还可以识别噪声点，这使得它在真实世界的数据集中非常有用。DBSCAN是一种强大的聚类算法，适用于各种数据分析任务。本文深入探讨了DBSCAN的核心思想、工作流程以及Python中的实现方式。通过实际示例，你可以更好地理解如何使用Python来应用DBSCAN算法。
python数据分类聚类案例_Python数据挖掘—聚类—KMeans划分法
weixin_39606361的博客
11-25 575
概念聚类分析：是按照个体的特征将它们分类，让同一个类别内的个体之间具有较高的相似度，不同类别之间具有较大差异性无分类目标变量(Y)——无监督学习K-Means划分法、DBSCAN密度法、层次聚类法1、导入数据1 importpandas2 from sklearn.cluster importKMeans3 from sklearn.decomposition importPCA45 import...
通俗易懂的机器学习——python手动实现DBSCAN聚类算法（不依赖已有框架）
艾醒的博客
11-25 2514
手动实现DBSCAN算法、DBSCAN的工作原理、代码测试DBSCAN的特点以及应用场景
自适应DBSCAN算法有哪些
04-23
优点和缺点？ 自适应DBSCAN算法的优点包括： 1. 可以自动调整聚类的参数，适应数据的特征。因为聚类的密度和距离相关，自适应DBSCAN可以自动判断哪些参数更适合当前数据集并进行聚类。 2. 适用于非凸的、不规则形状的簇。相对于K-means等传统聚类算法，自适应DBSCAN可以找到任意形状的簇。 3. 抗噪声能力强。自适应DBSCAN会将离群点排除在聚类范围之外，因此能够更好地适应于噪声干扰的数据集。 自适应DBSCAN算法的缺点包括： 1. 需要较长的计算时间。自适应DBSCAN需要在所有数据集合之间计算距离，从而决定邻域半径，因此需要较长的处理时间。 2. 对参数的依赖性强。自适应DBSCAN需要提供一个合适的邻域半径和一个最小点数来定义簇，这些参数的不同设置会对聚类结果造成一定的影响。 3. 对聚类结果敏感。在数据集存在较高的重叠区域时，自适应DBSCAN容易出现聚类结果不稳定的情况。
评论 53
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值