精华内容
下载资源
问答
  • 数学文化之机器学习;统计与机器学习;机器学习;机器学习;机器学习;统计与机器学习;机器学习聚类 (Clustering;机器学习聚类 (Clustering;机器学习聚类 (Clustering;机器学习聚类 (Clustering;...机器学习聚类
  • 机器学习聚类-山东大学;机器学习;机器学习;机器学习;统计与机器学习;机器学习聚类 (CLUSTERING;机器学习聚类 (CLUSTERING;机器学习聚类 (CLUSTERING;机器学习聚类 (CLUSTERING;机器学习聚类 (CLUSTERING;机器学习...
  • 机器学习聚类组合算法及其应用.pdf
  • 基于机器学习聚类算法的学习者自动分类研究.pdf
  • 机器学习聚类组合算法及其应用 (2).pdf
  • 机器学习 聚类算法

    2013-06-24 20:32:12
    机器学习 K-means 聚类算法 电子版课件教程
  • 机器学习 聚类篇——python实现DBSCAN(基于密度的聚类方法)摘要python实现代码计算实例 摘要 DBSCAN(Density-Based Spatial Clustering of Applications with Noise) 为一种基于密度的聚类算法,它不仅可以找出...

    机器学习 聚类篇——python实现DBSCAN(基于密度的聚类方法)

    摘要

    DBSCAN(Density-Based Spatial Clustering of Applications with Noise) 为一种基于密度的聚类算法,它不仅可以找出具有任何形状的簇,而且还可以用于检测离群值。其基本思想为数据点分布紧凑的应被划分为一类,而周围未分布有或仅有极少数点的数据点则有可能为离群值。本文通过python实现了该聚类方法,并将代码进行了封装,方便读者调用。
    下图为正文计算实例的可视化图形。
    在这里插入图片描述

    python实现代码

    eps:邻域半径(float)
    MinPts:密度阈值(int)
    .fit(X):对待聚类的数据集进行聚类
    用法:指定邻域半径密度阈值,这两个参数对应于不同的数据集需要进行调整,然后直接调用fit(X) 进行数据集的聚类。

    # -*- coding: utf-8 -*-
    # @Time : 2020/12/21 16:34
    # @Author : CyrusMay WJ
    # @FileName: cyrus_dbscan.py
    # @Software: PyCharm
    # @Blog :https://blog.csdn.net/Cyrus_May
    
    import sys
    import logging
    import numpy as np
    import random
    
    class CyrusDBSCAN(object):
        def __init__(self,eps=0.1,MinPts=3):
            """
            :param eps: 邻域半径
            :param MinPts: 密度阈值
            """
            self.__build_logger()
            self.eps = eps
            self.MinPts = MinPts
    
        def __build_logger(self):
            self.logger = logging.getLogger()
            self.logger.setLevel(logging.INFO)
            screen_handler = logging.StreamHandler(sys.stdout)
            screen_handler.setLevel(logging.INFO)
            formatter = logging.Formatter('%(asctime)s - %(module)s.%(funcName)s:%(lineno)d - %(levelname)s - %(message)s')
            screen_handler.setFormatter(formatter)
            self.logger.addHandler(screen_handler)
    
        def fit(self,X):
            # 初始化数据点状态及索引号
            self.X = np.array(X)
            global index,state,class_cluster
            index = [i for i in np.arange(X.shape[0])]
            state = [0] * X.shape[0]
            class_cluster = 1
            while 1:
                if self.choice() is not None:
                    # 从未划分的数据点中随机选择一个
                    point = self.choice()
                    # 计算在其领域半径内的点
                    not_use_index = self.not_use_point()
                    temp = []
                    for i in not_use_index:
                        if i != point:
                            if self.cal_dist(self.X[i, :], self.X[point, :]) <= self.eps:
                                temp.append(i)
                    if len(temp) >= self.MinPts:
                        self.logger.info("搜索到第{}簇!".format(class_cluster))
                        self.cal_eps_count([point])
                        self.logger.info("第{}簇搜索完成!".format(class_cluster))
                        class_cluster += 1
                    else:
                        state[point] = "noise"
                else:
                    break
            return state
        def cal_eps_count(self,points):
            flag = []
            for point in points:
                temp = []
                for i in self.not_use_point():
                    if self.cal_dist(self.X[i,:],self.X[point,:]) <= self.eps and i != point:
                        state[i] = class_cluster
                        temp.append(i)
                        self.logger.info("第{}簇新增一个数据点!".format(class_cluster))
                if len(temp) >= self.MinPts:
                    flag += temp
            if flag:
                return self.cal_eps_count(flag)
    
        def cal_dist(self,x1,x2):
            return (((x1-x2)**2).sum())**0.5
    
        def not_use_point(self):
            temp = []
            for i in index:
                if state[i] in [0,"noise"]:
                    temp.append(i)
            return temp
    
        def choice(self):
            temp = []
            for i in index:
                if state[i] == 0:
                    temp.append(i)
            if len(temp) == 1:
                state[temp[0]] = "noise"
                return None
            elif len(temp) == 0:
                return None
            else:
                return random.choice(temp)
    

    计算实例

    对加入噪声的月亮形状数据集进行聚类

    if __name__ == '__main__':
        dbscan = CyrusDBSCAN(eps=0.25,MinPts=3)
        from sklearn.datasets import make_moons
        import matplotlib.pyplot as plt
        moons = make_moons(n_samples=1000,noise=0.05)
        y = dbscan.fit(moons[0])
        dbscan.logger.info(y)
        plt.scatter(moons[0][:, 0], moons[0][:, 1], c=[["r", "b"][i-1] if i != "noise" else "g" for i in y])
        plt.show()
    
    2020-12-21 21:14:32,952 - cyrus_dbscan.cal_eps_count:68 - INFO - 第2簇新增一个数据点!
    2020-12-21 21:14:32,952 - cyrus_dbscan.cal_eps_count:68 - INFO - 第2簇新增一个数据点!
    2020-12-21 21:14:32,955 - cyrus_dbscan.fit:53 - INFO - 第2簇搜索完成!
    2020-12-21 21:14:32,956 - cyrus_dbscan.<module>:103 - INFO - [1, 1, 1, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 2, 2, 1, 2, 1, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 2, 1, 2, 2, 2, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 2, 1, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1, 2, 1, 2, 2, 2, 1, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 2, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 2, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 1, 1, 1, 1, 2, 1, 2]
    

    在这里插入图片描述

    by CyrusMay 2020 12 21

    我没有任何天分
    我却有梦的天真
    我是傻 不是蠢
    我将会证明
    用我的一生
    ——————五月天(咸鱼)——————

    展开全文
  • Standford机器学习 聚类算法(clustering)和非监督学习
  • 机器学习 聚类篇——DBSCAN的参数选择及其应用于离群值检测摘要python实现代码计算实例 摘要 DBSCAN(Density-Based Spatial Clustering of Applications with Noise) 为一种基于密度的聚类算法, python实现代码 ...

    摘要

    DBSCAN(Density-Based Spatial Clustering of Applications with Noise) 为一种基于密度的聚类算法,本文主要介绍了DBSCAN算法的原理和参数选择方法,并实现了一个离群值检测案例,供读者参考。

    1. DBSCAN算法原理

    1.1 基本概念定义

    DBSCAN算法主要有两个参数:
    领域半径:Eps
    成为核心对象的在领域半径内的最少点数:MinPts
    以上两个参数都会在下面的概念介绍中提到。

    • Eps领域(Eps-neighborhood of a point)
      点p的Eps邻域,记为NEps(p),定义为NEps(p)= {q∈D | dist(p,q)≤Eps}。

    • 核心对象 (core points)
      如果给定对象Eps领域内的样本点数大于等于MinPts,则称该对象为核心对象。

    • 直接密度可达(directly density-reachable)
      若:
      1) p∈ NEps(q)
      2)|NEps(q)| ≥ MinPts
      则称对象p从核心对象q是直接密度可达的。

    • 密度可达(density-reachable)
      对于对象p1,p2, …, pn
      令p1= q, pn = p。
      若pi+1是从pi直接密度可达的,则称p是从q密度可达的。

    • 密度相连(density-connected)
      对于点p和点q,若点p点q都是从点o密度可达的,则称点p和点q密度相连。

    • (cluster)
      对于数据集D,若C是其中一个簇,C中的点需要满足以下两个条件:
      1)∀ p, q,如果 p∈ C且q 是从p密度可达的,则 q∈ C。
      2)∀ p, q ∈ C,p和q是密度相连的。

    • 噪音(noise)
      不属于任何簇的点为噪音数据。

    1.2 算法流程

    • 1)给定领域半径:Eps和成为核心对象的在领域半径内的最少点数:MinPts
    • 2)从任意点p开始,将其标记为”visited“,检查其是否为核心点(即p的Eps邻域至少有MinPts个对象),如果不是核心点,则将其标记为噪声点。否则为p创建一个新的簇C,并且把把p的Eps邻域中的所有对象都放到候选集合N中。
    • -3)迭代地把N中不属于其它簇的对象添加至C中,在此过程中,对于N中标记为”unvisited"的对象p‘,把它标记为“visited”,并且检查它的Eps邻域,如果p’也为核心对象,则p’的Eps邻域中的对象都被添加至N中。继续添加对象至C中,直到C不能扩展,即直到N为空。此时,簇C完全生成。
    • 4)从剩余的对象中随机选择下一个未访问对象,重复3)的过程,直到所有对象都被访问。

    2. 参数选择

    2.1 领域半径:Eps的选取方法(k-distance函数

    • 1)选取k值,建议取k为2*维度-1。(其中维度为特征数)
    • 2) 计算并绘制k-distance图。(计算出每个点到距其第k近的点的距离,然后将这些距离从大到小排序后进行绘图。)
    • 3)找到拐点位置的距离,即为Eps的值。
      如下图所示:
      在这里插入图片描述

    2.2 MinPts的选取方法

    • MinPts的取值为上述k值加1,即

    M i n P t s = k + 1 MinPts = k+1 MinPts=k+1

    3. Python实现

    链接: 参考我的另一篇博客.

    4. 检测离群值的实例

    4.1 导包及设置随机种子

    import numpy as np
    from sklearn.datasets import make_moons
    import matplotlib.pyplot as plt
    from sklearn.cluster import DBSCAN
    
    np.random.seed(2021)
    

    4.2 生成moon数据并绘图

    data = np.ones([1005,2])
    data[:1000] = make_moons(n_samples=1000,noise=0.05,random_state=2022)[0]
    data[1000:] = [[-1,-0.5],
                    [-0.5,-1],
                    [-1,1.5],
                    [2.5,-0.5],
                    [2,1.5]]
    print(data.shape)
    plt.scatter(data[:,0],data[:,1],color="c")
    plt.show()
    

    在这里插入图片描述

    4.3 选择参数

    def select_MinPts(data,k):
        k_dist = []
        for i in range(data.shape[0]):
            dist = (((data[i] - data)**2).sum(axis=1)**0.5)
            dist.sort()
            k_dist.append(dist[k])
        return np.array(k_dist)
    k = 3  # 此处k取 2*2 -1 
    k_dist = select_MinPts(data,k)
    k_dist.sort()
    plt.plot(np.arange(k_dist.shape[0]),k_dist[::-1])
    

    在这里插入图片描述
    有明显拐点

    # 由拐点确定邻域半径
    eps = k_dist[::-1][15]
    plt.scatter(15,eps,color="r")
    plt.plot([0,15],[eps,eps],linestyle="--",color = "r")
    plt.plot([15,15],[0,eps],linestyle="--",color = "r")
    plt.show()
    

    在这里插入图片描述

    4.4 建立聚类模型

    dbscan_model = DBSCAN(eps=eps,min_samples=k+1)
    label = dbscan_model.fit_predict(data)
    print(label)
    
    [ 0  0  0 ... -1 -1 -1]
    

    4.5 可视化展示

    class_1 = []
    class_2 = []
    noise = []
    for index,value in enumerate(label):
        if value == 0:
            class_1.append(index)
        elif value == 1:
            class_2.append(index)
        elif value == -1:
            noise.append(index)
    plt.scatter(data[class_1,0],data[class_1,1],color="g",label="class 1")
    plt.scatter(data[class_2,0],data[class_2,1],color="b",label = "class 2")
    plt.scatter(data[noise,0],data[noise,1],color="r",label = "noise")
    plt.legend()
    plt.show()
    

    在这里插入图片描述

    by CyrusMay 2021 02 03

    你和我背着空空的书包
    逃出名为日常的监牢
    忘了要长大
    忘了要变老
    忘了时间有脚
    ——————五月天(好好)——————

    展开全文
  • 用python爬取虎扑体育https://nba.hupu.com/stats/players中球员数据,包括球员姓名、...并且以散点图和雷达图展现出球员数据,对数据进行标准化处理,然后使用聚类算法将球员进行聚类,最后呈现出6个簇的聚类结果。
  • 机器学习的五种聚类算法包括训练数据,基于python实现
  • PAGE 2 人工智能与机器学习 实 验 报 告 年级_ xxxx班_ 专业_xxxxx_ _ 学号_6315070301XX_ 姓名_gllh_ 日期_2018-5-12 _ 实验五 聚类算法实现 一实验目的 1了解常用聚类算法及其优缺点 2掌握k-means聚类算法对数据...
  • 聚类算法 在机器学习十大算法中,聚类算法是一种重要的无监督的学习算法,它...基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作 市场分割 大型的互联网企业一般都有自己的服务器机房来保证软件和网站的运行

    聚类算法

    在机器学习十大算法中,聚类算法是一种重要的无监督的学习算法,它可以将数据集中的样本点归结为一系列特定的组合。训练样本的标记信息是未知的,目标是通过对无标记训练样本的学习来揭示数据的内在性质和规律,最常用的就是“聚类”算法。

    聚类算法的应用

    电子商务平台的卖家需要将客户分成不同的客户群,这样卖家可以对不同类型的客户分别销售产品,这就是聚类算法在市场分割中的作用。
    在这里插入图片描述

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    市场分割

    大型的互联网企业一般都有自己的服务器机房来保证软件和网站的运行,这么大的计算机集群,我们可以使用聚类算法看看哪些计算机经常一起协作,然后重新布局,更好的统一管理。在这里插入图片描述

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    计算机集群管理

    星系是怎么形成的,很多天文学家对此都不知疲倦的研究,而聚类算法也可以应用在天文学中帮助天文学家了解到星系形成的原因。

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作

    聚类算法了解星系的形成原因

    常用的聚类算法——K均值算法

    K均值(K-Means)聚类是一个迭代算法,假设我们想要将数据聚类成k个组,其方法为:

    第一步:首先选择 k 个随机的样本点,称为聚类中心。

    第二步:遍历数据集中的每一个数据,计算距离 K 个中心点的距离,将其与距离最近的中心点关联起来,与同一个中心点关联的所有点聚成一类。

    第三步:计算每一个组的平均值,将该组所关联的中心点移动到平均值的位置。

    第四步:重复执行2-3步,直至中心点不再变化。
    在这里插入图片描述

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    聚类算法的过程在这里插入图片描述

    k均值算法完成彩色图片压缩操作

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    彩色图片

    我们现在有如上所示一张彩色图片,我们知道有些彩色图片所占硬盘空间太大,那么我们可以对其进行压缩操作,我们使用k均值算法来对其进行压缩操作。k均值算法实现图像的压缩是均值聚类算法的一个经典的应用,它把一个彩色图变成了灰度图,灰度图不再使用三个通道,而使用单通道图,也就是变成了灰度图。在这里插入图片描述

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    k均值压缩之后的效果

    如上所示就是k均值算法压缩彩色图之后的效果,我们还是可以隐约的看出来一些原来彩色图的轮廓,这样的图片称为灰度图,它比彩色图所占的硬盘空间要小很多,如此这样就实现了压缩的操作。

    k均值算法压缩彩色图片的原理

    一张彩色图片是由红、绿、蓝三种颜色通道构成的,也就是说一张彩色图片可以切分为空间中的三张,也就是红色通道一张、绿色通道一张、蓝色通道一张,这三张叠加在一起就构建了原来彩色图像。

    基于机器学习聚类算法K-means完成经典的压缩彩色图像的操作
    一张彩色图片的红绿蓝三通道在这里插入图片描述

    无论是哪个通道都是由一个一个的像素点构成的,像素值的范围为0~255,分别对应其红、绿、蓝三种颜色的色彩强度,所以彩色图像中每个像素点都右3个像素值表示 。我们可以将彩色图像样本化,其中每一个彩色像素点为一个样本,那么这个像素点的红、绿、蓝三通道的像素值作为这个样本的特征,也就是说我们的这个彩色图片中有多少像素点就有多少样本,每个样本有三个特征。

    每个特征的值的范围是0~255,下面我们使用聚类算法,将这些个样本聚成128簇。为什么要聚成128呢?

    因为我们知道,我们的特征值的范围是0~255,这就相当于是256个可能,我们聚成128个簇,以后的每个样本所属的簇就作为压缩图片的像素值了,那么像素值最大为128,所以图像就压缩了。

    算法的具体过程为:

    第一步:取聚类个数K=128

    第二步:随机产生K个初始中心作为颜色聚类初始中心点

    第三步:迭代开始,枚举图像中所有像素点,对每个像素点计算其颜色到所有K个中心点的距离,选取距其最近的中心点所代表的聚类作为该像素点颜色的聚类

    第四步:在所有像素点确定其颜色的新聚类后,更新每个颜色聚类的新中心点(求平均值)

    第五步:重复3、4直到最大迭代次数

    k均值算法压缩彩色图片的代码实现

    from skimage import io
    from sklearn.cluster import KMeans
    import numpy as np
    image = io.imread('caise.jpg')
    rows = image.shape[0]
    cols = image.shape[1]
    image = image.reshape(image.shape[0]*image.shape[1],3)
    kmeans = KMeans(n_clusters=128, n_init=10, max_iter=200)
    kmeans.fit(image)
    clusters = np.asarray(kmeans.cluster_centers_, dtype=np.uint8)
    labels = np.asarray(kmeans.labels_, dtype=np.uint8)
    labels = labels.reshape(rows, cols);
    io.imsave('yasuo.jpg', labels)
    image = io.imread('yasuo.jpg')
    io.imshow(image)
    io.show()
    

    至此我们就完成了经典的聚类算法——k-means算法的理论到实践(压缩彩色图片)的应用。

    展开全文
  • 机器学习聚类算法

    2017-06-01 13:38:04
    (1)层次聚类: 层次聚类算法: 自下而上聚合层次聚类方法(或凝聚层次聚类)。这种自下而上策略就是最初将每个对象(自身)作为一个簇,然后将这些簇进行聚合以构造越来越大的簇,直到所有对象均聚合为一个簇,或满足...

    (1)层次聚类:

    层次聚类算法:

    自下而上聚合层次聚类方法(或凝聚层次聚类)。这种自下而上策略就是最初将每个对象(自身)作为一个簇,然后将这些簇进行聚合以构造越来越大的簇,直到所有对象均聚合为一个簇,或满足一定终止条件为止。

    自顶向下分解层次聚类方法(或分裂层次聚类)。这种策略的作法与自下而上策略的作法相反。它首先将所有对象看成一个簇的内容,将其不断分解以使其变成越来越小但个数越来越多的小簇,直到所有对象均独自构成一个簇,或满足一定终止条件为止。

    层次聚类的流程:

    凝聚型层次聚类的策略是先将每个对象作为一个簇,然后合并这些原子簇为越来越大的簇,直到所有对象都在一个簇中,或者某个终结条件被满足。绝大多数层次聚类属于凝聚型层次聚类,它们只是在簇间相似度的定义上有所不同。 这里给出采用最小距离的凝聚层次聚类算法流程:

    (1) 将每个对象看作一类,计算两两之间的最小距离;
    (2) 将距离最小的两个类合并成一个新类;
    (3) 重新计算新类与所有类之间的距离;
    (4) 重复(2)、(3),直到所有类最后合并成一类。

    层次聚类算法的分析:

    层次聚类法的优点是可以通过设置不同的相关参数值,得到不同粒度上的多层次聚类结构;在聚类形状方面,层次聚类适用于任意形状的聚类,并且对样本的输入顺序是不敏感的。 

    层次聚类的不足之处是算法的时间复杂度大,层次聚类的结果依赖聚类的合并点和分裂点的选择。并且层次聚类过程最明显的特点就是不可逆性,由于对象在合并或分裂之后,下一次聚类会在前一次聚类基础之上继续进行合并或分裂,也就是说,一旦聚类结果形成,想要再重新合并来优化聚类的性能是不可能的了。聚类终止的条件的不精确性是层次聚类的另一个缺点,层次聚类要求指定一个合并或分解的终止条件,比如指定聚类的个数或是两个距离最近的聚类之间最小距离阈值。

    (2)K-均值聚类:

    K-均值聚类算法:

    在聚类分析中,K-均值聚类算法(k-means algorithm)是无监督分类中的一种基本方法,其也称为C-均值算法,其基本思想是:通过迭代的方法,逐次更新各聚类中心的值,直至得到最好的聚类结果。 

    K-均值聚类的流程:

    假设要把样本集分为c个类别,算法如下: 

    (1)适当选择c个类的初始中心; 
    (2)在第k次迭代中,对任意一个样本,求其到c个中心的距离,将该样本归到距离最短的中心所在的类, 
    (3)利用均值等方法更新该类的中心值; 
    (4)对于所有的c个聚类中心,如果利用(2)(3)的迭代法更新后,值保持不变(目标函数收敛),则迭代结束,否则继续迭代

    层次聚类算法的分析:

    (1)对于离群点和孤立点敏感:
    离群点检测的LOF算法,通过去除离群点后再聚类,可以减少离群点和孤立点对于聚类效果的影响。
    (2)k值选择:
    可以通过在一开始给定一个适合的数值给k,通过一次K-means算法得到一次聚类中心。对于得到的聚类中心,根据得到的k个聚类的距离情况,合并距离最近的类,因此聚类中心数减小,当将其用于下次聚类时,相应的聚类数目也减小了,最终得到合适数目的聚类数。可以通过一个评判值E来确定聚类数得到一个合适的位置停下来,而不继续合并聚类中心。重复上述循环,直至评判函数收敛为止,最终得到较优聚类数的聚类结果。
    (3)初始聚类中心的选择:
    首先随机选择一个点作为第一个初始类簇中心点,然后选择距离该点最远的那个点作为第二个初始类簇中心点,然后再选择距离前两个点的最近距离最大的点作为第三个初始类簇的中心点,以此类推,直至选出K个初始类簇中心点。
    (4)只能发现球状簇:
    只能获取球状簇的根本原因在于,距离度量的方式。如果数据集中有不规则的数据,往往通过基于密度的聚类算法更加适合,比如DESCAN算法。

    (3)基于密度的聚类DBscan:

    DBSCAN聚类算法:

    对象的ε-邻域:给定对象在半径 ε内的区域。
    核心对象:对于给定的数目m,如果一个对象的ε-邻域至少包含 m 个对象,则称该对象为核心对象。
    直接密度可达:给定一个对象集合D,如果 p 是在核心对象 q 的ε-邻域内,我们说从对象 q 出发到对象p是直接密度可达的。
    密度可达:如果存在一个对象链p1、p2…pn,p1=q,pn=p,对 pi∈D,(1≤i≤n),pi+1是从 pi(核心对象) 关于 ε 和 m 直接密度可达的,则对象 p 是从核心对象 q 关于 ε 和 m 密度可达的。
    密度相连:如果对象集合D中存在一个核心对象o,使得对象 p 和 q 是从 o 关于 ε 和 m 密度可达的,那么对象 p 和 q 是关于 ε 和 m 密度相连的。
    簇:密度相连的点的最大集合。
    噪声:不包含在任何簇中的对象称为噪声。

    DBSCAN聚类的流程 :

    扫描整个数据集,找到任意一个核心点,对该核心点进行扩充。扩充的方法是寻找从该核心点出发的所有密度相连的数据点(注意是密度相连)。遍历该核心点的邻域内的所有核心点(因为边界点是无法扩充的),寻找与这些数据点密度相连的点,直到没有可以扩充的数据点为止。最后聚类成的簇的边界节点都是非核心数据点。之后就是重新扫描数据集(不包括之前寻找到的簇中的任何数据点),寻找没有被聚类的核心点,再重复上面的步骤,对该核心点进行扩充直到数据集中没有新的核心点为止。数据集中没有包含在任何簇中的数据点就构成异常点。

    DBSCAN聚类算法的分析:

    优点:
    1. 与K-means方法相比,DBSCAN不需要事先知道要形成的簇类的数量。
    2. 与K-means方法相比,DBSCAN可以发现任意形状的簇类。
    3. 同时,DBSCAN能够识别出噪声点。
    4.DBSCAN对于数据库中样本的顺序不敏感,即Pattern的输入顺序对结果的影响不大。但是,对于处于簇类之间边界样本,可能会根据哪个簇类优先被探测到而其归属有所摆动。
    缺点:
    1. DBScan不能很好反映高尺寸数据。
    2. DBScan不能很好反映数据集变化的密度。
    3.对于高维数据,点之间极为稀疏,密度就很难定义了。
     

     
     
     
    展开全文
  • 聚类的主要思想就是一个拉普拉斯降维,将思维转化为图的方式求解
  • 此压缩包包含吴恩达机器学习课程中无监督学习的K-means聚类和PCA降维的相关课后题,以及自己做的答案解析,欢迎下载!
  • 什么是聚类 聚类就是按照某个特定标准(如距离准则)把一个数据集分割成不同的类或簇,使得同一个簇内的数据对象的相似性尽可能大,同时不在同一个簇中的数据对象的差异性也尽可能地大。即聚类后同一类的数据尽可能...
  • 算法的目的 :聚类算法是“无监督学习”中最常用的一个算法,通过对无标记训练样本的学习将数据集划分成若干个不相交的子集,来解释数据的内在性质以及规律,为进一步数据分析提供基础。也可以作为一个单独的过程,...
  • 机器学习聚类算法Kmeans与DBSCAN

    千次阅读 2018-04-16 20:46:36
    自己对两种聚类方法的一点理解。1. KMeans1.1 算法概述Kmeans是一种划分聚类的方法,基本K-Means算法的思想很简单,事先确定常数K,常数K意味着最终的聚类类别数,首先随机选定初始点为质心,并通过计算每一个样本与...
  • 机器学习聚类算法——K-means聚类

    千次阅读 2017-03-03 16:20:59
    k均值聚类
  • 聚类算法是机器学习中经典的非监督学习算法之一,相比于分类算法,聚类不依赖预定义的样本标签,而是让算法通过对数据的学习从而找到其内部的规律,该算法对有相同特征的样本进行聚类聚类的时候,我们并不关心某一...
  • 最近比较喜欢听《认真的老去》这首歌,那就抓这个豆瓣评论做数据集吧,,做个评论的聚类分析。   一、抓到数据   抓出来140条评论~~    放代码~~    import requests from bs4 import ...
  • 最近闲着没事了解一下聚类算法,闵可夫斯基距离真有趣,搞得我有点一头雾水,废话不多,上定义: 本文从公式上表述了欧几里得距离、曼哈顿距离、切比雪夫距离记忆闵可夫斯基距离之间的关系。 一般而言,定义一个距离...
  • ____tz_zs学习笔记聚类(Clustering) 顾名思义,就是将相似样本聚合在一起,属于机器学习中的非监督学习 (unsupervised learning) 问题。聚类的目标是找到相近的数据点,并将相近的数据点聚合在一起。实现聚类的算法...
  • 聚类算法是一类非监督学习算法,在有监督学习中,学习的目标是要在两类样本中找出他们的分界,训练数据是给定标签的,要么属于正类要么属于负类。而非监督学习,它的目的是在一个没有标签的数据集中找出这个数据集的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,197
精华内容 31,278
关键字:

机器学习聚类