机器学习实战第十章 k均值聚类

已于 2023-06-29 19:10:27 修改
阅读量264 收藏 1
点赞数
分类专栏： 机器学习 文章标签： 机器学习 均值算法 聚类
于 2023-06-29 17:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68784427/article/details/131456263
版权
本文详细介绍了k均值聚类算法的原理和实现过程，包括如何初始化质心、如何迭代更新簇分配，以及Python代码示例。同时，文章探讨了k均值算法的局限性，并提出了二分k均值聚类作为改进方案，通过不断划分簇以优化结果。实验结果显示，二分k均值聚类在某些情况下能提供更好的聚类效果。
摘要由CSDN通过智能技术生成

k均值聚类

文章目录

什么是k均值聚类

试想一下，如果给一张图如下，要求对这张图中的点分类，你会怎么进行呢？请添加图片描述
我们当然可以认为所有的点都只有一个种类，毕竟他们本身只有坐标不同，也可以左右分成两个大类，也可以四个角落划分成四类，这一切都取决于最初定的分类个数，而这就是k均值聚类。

所谓k，就是我们的目标要把数据划分为k个类。
所谓聚类，就是向上面的例子一样，实现不给任何标签，让我们自己区随意分类
均值则是代表了一种方法，本文后面会介绍到

具体实现

前面我们已经了解了我们的目的是什么。下面我们来讲解如何实现。

我们要分类的话，肯定是在同一类中相似度越高越好。也就是说，在特征空间中，他们的距离（欧氏距离或者随便什么距离）整体而言是最近的。k均值聚类正是采取了这种思想，其执行步骤如下：

  1. 由于要划分k个类，因此首先随机选取k个点（算法结束后这k个点会成为各自类的质点）
  2. 遍历所有的点，把这些点分类给距离其最近的质点（就是1中的点）
  3. 更新质点的位置，使其成为所在类的质点（也就是同类所有点的坐标取平均值）
  4. 重复2和3直至点的分类不变

这里的均值便是k均值聚类中的来源了。现在步骤清楚了，下面可以开始用代码去实现了，同样的，所有需要注意的点已均在代码中注释：

from numpy import *

# 加载数据集
def loadDataSet(fileName):
    dataMat = []
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        # 这里要注意一下，map函数返回的是一个迭代器，需要用list函数转换成列表，原本的书上没有这个list函数，但是在python3中需要加上这个函数
        fltLine = list(map(float, curLine))
        dataMat.append(fltLine)
    return dataMat

# 计算欧式距离
def distEclud(vecA, vecB):
    return sqrt(sum(power(vecA - vecB, 2)))

# 为给定数据集构建一个包含k个随机质心的集合
def randCent(dataSet, k):
    n = shape(dataSet)[1]
    centroids = mat(zeros((k, n)))
    for j in range(n):
        # 计算最小值，最大值，保证随机点在数据集的边界之内
        minJ = min(dataSet[:, j])
        rangeJ = float(max(dataSet[:, j]) - minJ)
        centroids[:, j] = minJ + rangeJ * random.rand(k, 1)
    # 返回质心
    return centroids

# k均值聚类算法本体
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    # 数据集的行数
    m = shape(dataSet)[0]
    # 每个点的簇分配结果矩阵，第一列记录簇索引值，第二列存储误差
    clusterAssment = mat(zeros((m, 2)))
    # 创建质心
    centroids = createCent(dataSet, k)
    clusterChanged = True
    # 只要簇分配结果改变就一直迭代
    while clusterChanged:
        clusterChanged = False
        # 计算每个点到质心的距离
        for i in range(m):
            minDist = inf
            minIndex = -1
            for j in range(k):
                distJI = distMeas(centroids[j, :], dataSet[i, :])
                # 寻找最近的质心
                if distJI < minDist:
                    minDist = distJI
                    minIndex = j
            # 若任一点的簇分配结果发生改变，则更新clusterChanged标志
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            # 更新簇分配结果
            clusterAssment[i, :] = minIndex, minDist ** 2
        # 更新质心的位置
        for cent in range(k):
            ptsInClust = dataSet[nonzero(clusterAssment[:, 0].A == cent)[0]]
            centroids[cent, :] = mean(ptsInClust, axis=0)
    return centroids, clusterAssment


def main():
    # test kMeans
    dataMat = mat(loadDataSet('testSet.txt'))
    myCentroids, clustAssing = kMeans(dataMat, 4)
    # 画图，画出聚类结果
    fig = plt.figure()
    # 将dataMat中的点画出来
    ax = fig.add_subplot(111)
    
    ax.scatter(dataMat[:, 0].flatten().A[0], dataMat[:, 1].flatten().A[0], s=50, c='blue')
    # 将聚类中心画出来
    ax.scatter(myCentroids[:, 0].flatten().A[0], myCentroids[:, 1].flatten().A[0], s=300, c='red', marker='+')
    plt.show()
    
if __name__ == '__main__':
    main()

最终得到的结果如下图：请添加图片描述

可以看到分类的结果很棒，基本上每个质心都处于其类别的中心，每个的分类也较为合理，但是这个代码其实是有问题的，那就是它极其依赖于初始的质心分布，比方说有质心有可能会陷入到局部最优解的困境之中，如下图：
在这里插入图片描述
下面我们将会学习一种解决方案

二分k均值聚类

二分k均值聚类的主要思想：二分K均值聚类首先将所有数据划分为一个初始簇，然后逐步对簇进行二分，直到达到指定的簇的数量。

具体实现步骤：

  1. 初始化：将所有数据样本划分为一个初始簇。
  2. 循环：
    a. 对当前的簇进行K均值聚类操作，将其分成两个子簇。这可以通过应用K均值聚类算法一次来实现。
    b. 对刚刚分割得到的两个子簇计算聚类质量度量，例如误差平方和（SSE）或轮廓系数等。
    c. 选择具有较低质量度量的子簇进行进一步的分割操作，这意味着选择该子簇进行新一轮的K均值聚类分割。
    d. 如果达到所需的簇的数量，或者无法选择更多的子簇进行分割，则结束循环。
  3. 输出结果：最终得到所需数量的簇，每个簇包含一组数据样本。

值得一提的是，二分K均值聚类相对于传统的K均值聚类具有更好的聚类结果的机会，但无法完全避免局部最小值问题，不过不管怎么样，也算是一种解决方案。

具体实现代码如下，其中有一部分与前文提到的代码重复了，就略去不表：

def biKmeans(dataSet, k, distMeas=distEclud):
    # 数据集的行数
    m = shape(dataSet)[0]
    # 每个点的簇分配结果矩阵，第一列记录簇索引值，第二列存储误差
    clusterAssment = mat(zeros((m, 2)))
    # 创建一个初始簇，值为数据集的均值，即整个数据集作为一个簇
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    centList = [centroid0]
    # 计算每个点到质心的距离
    for j in range(m):
        clusterAssment[j, 1] = distMeas(mat(centroid0), dataSet[j, :]) ** 2
    # 对簇进行划分，直到簇的数目达到k
    while (len(centList) < k):
        lowestSSE = inf
        # 对每一个簇进行划分
        for i in range(len(centList)):
            # 获取当前簇的数据集
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:, 0].A == i)[0], :]
            # 对当前簇进行k均值聚类
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            # 计算划分后的SSE
            sseSplit = sum(splitClustAss[:, 1])
            # 计算其他簇的SSE
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:, 0].A != i)[0], 1])
            # 比较划分前后的SSE，选择最佳划分
            print ("sseSplit, and notSplit: ", sseSplit, sseNotSplit)
            if (sseSplit + sseNotSplit) < lowestSSE:
                # 将最佳划分的簇的索引值改为当前簇的索引值
                bestCentToSplit = i
                # 保存最佳划分的质心
                bestNewCents = centroidMat
                # 保存最佳划分的簇分配结果
                bestClustAss = splitClustAss.copy()
                # 保存最佳划分的SSE
                lowestSSE = sseSplit + sseNotSplit
        # 更新簇的分配结果
        bestClustAss[nonzero(bestClustAss[:, 0].A == 1)[0], 0] = len(centList)
        bestClustAss[nonzero(bestClustAss[:, 0].A == 0)[0], 0] = bestCentToSplit
        centList[bestCentToSplit] = bestNewCents[0, :].tolist()[0]
        centList.append(bestNewCents[1, :].tolist()[0])
        clusterAssment[nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss
    return mat(centList), clusterAssment

def main():
    # test bikMeans
    dataMat = mat(loadDataSet('testSet.txt'))
    centList, myNewAssments = biKmeans(dataMat, 4)
    
    # 画图，画出聚类结果
    fig = plt.figure()
    # 将dataMat中的点画出来
    ax = fig.add_subplot(111)
    
    # 画出聚类结果，每一类用一种颜色
    for i in range(shape(dataMat)[0]):
        if int(myNewAssments[i, 0]) == 0:
            ax.scatter(dataMat[i, 0], dataMat[i, 1], c='red')
        elif int(myNewAssments[i, 0]) == 1:
            ax.scatter(dataMat[i, 0], dataMat[i, 1], c='blue')
        elif int(myNewAssments[i, 0]) == 2:
            ax.scatter(dataMat[i, 0], dataMat[i, 1], c='green')
        elif int(myNewAssments[i, 0]) == 3:
            ax.scatter(dataMat[i, 0], dataMat[i, 1], c='yellow')
        elif int(myNewAssments[i, 0]) == 4:
            ax.scatter(dataMat[i, 0], dataMat[i, 1], c='black')
            
    # 画出质心
    ax.scatter(centList[:, 0].tolist(), centList[:, 1].tolist(), c='orange', marker='+', s=300)
    plt.show()

下面看一下运行结果：
请添加图片描述
结果看起来很美好对不对？但是如果我们将分类个数改为3呢？
请添加图片描述
我们可以看到红色这个区域的划分明显是不够好的，但是由于我们划设定了只划分3个类别，因此算法也只能够这样子了，所以我认为k均值聚类算法其实是还有改进的空间的，不过如果真能该了的话，算法名字里的k也就应该不复存在了吧。

实验

最后我们来跑一下书上的小实验。包含爬虫的部分我们不做，直接做后面的部分。
就理论而言，并没有什么新的内容，多了一个计算距离的函数也并非是本书的重点，因此此处还是直接给出完整的代码，感兴趣的读者可以自己拿来跑一下：

from numpy import *

# 加载数据集
def loadDataSet(fileName):
    dataMat = []
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        # 这里要注意一下，map函数返回的是一个迭代器，需要用list函数转换成列表，原本的书上没有这个list函数，但是在python3中需要加上这个函数
        fltLine = list(map(float, curLine))
        dataMat.append(fltLine)
    return dataMat

# 计算欧式距离
def distEclud(vecA, vecB):
    return sqrt(sum(power(vecA - vecB, 2)))

# 为给定数据集构建一个包含k个随机质心的集合
def randCent(dataSet, k):
    n = shape(dataSet)[1]
    centroids = mat(zeros((k, n)))
    for j in range(n):
        # 计算最小值，最大值，保证随机点在数据集的边界之内
        minJ = min(dataSet[:, j])
        rangeJ = float(max(dataSet[:, j]) - minJ)
        centroids[:, j] = minJ + rangeJ * random.rand(k, 1)
    # 返回质心
    return centroids

# k均值聚类算法本体
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    # 数据集的行数
    m = shape(dataSet)[0]
    # 每个点的簇分配结果矩阵，第一列记录簇索引值，第二列存储误差
    clusterAssment = mat(zeros((m, 2)))
    # 创建质心
    centroids = createCent(dataSet, k)
    clusterChanged = True
    # 只要簇分配结果改变就一直迭代
    while clusterChanged:
        clusterChanged = False
        # 计算每个点到质心的距离
        for i in range(m):
            minDist = inf
            minIndex = -1
            for j in range(k):
                distJI = distMeas(centroids[j, :], dataSet[i, :])
                # 寻找最近的质心
                if distJI < minDist:
                    minDist = distJI
                    minIndex = j
            # 若任一点的簇分配结果发生改变，则更新clusterChanged标志
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            # 更新簇分配结果
            clusterAssment[i, :] = minIndex, minDist ** 2
        # 更新质心的位置
        for cent in range(k):
            ptsInClust = dataSet[nonzero(clusterAssment[:, 0].A == cent)[0]]
            centroids[cent, :] = mean(ptsInClust, axis=0)
    return centroids, clusterAssment

def biKmeans(dataSet, k, distMeas=distEclud):
    # 数据集的行数
    m = shape(dataSet)[0]
    # 每个点的簇分配结果矩阵，第一列记录簇索引值，第二列存储误差
    clusterAssment = mat(zeros((m, 2)))
    # 创建一个初始簇，值为数据集的均值，即整个数据集作为一个簇
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    centList = [centroid0]
    # 计算每个点到质心的距离
    for j in range(m):
        clusterAssment[j, 1] = distMeas(mat(centroid0), dataSet[j, :]) ** 2
    # 对簇进行划分，直到簇的数目达到k
    while (len(centList) < k):
        lowestSSE = inf
        # 对每一个簇进行划分
        for i in range(len(centList)):
            # 获取当前簇的数据集
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:, 0].A == i)[0], :]
            # 对当前簇进行k均值聚类
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            # 计算划分后的SSE
            sseSplit = sum(splitClustAss[:, 1])
            # 计算其他簇的SSE
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:, 0].A != i)[0], 1])
            # 比较划分前后的SSE，选择最佳划分
            print ("sseSplit, and notSplit: ", sseSplit, sseNotSplit)
            if (sseSplit + sseNotSplit) < lowestSSE:
                # 将最佳划分的簇的索引值改为当前簇的索引值
                bestCentToSplit = i
                # 保存最佳划分的质心
                bestNewCents = centroidMat
                # 保存最佳划分的簇分配结果
                bestClustAss = splitClustAss.copy()
                # 保存最佳划分的SSE
                lowestSSE = sseSplit + sseNotSplit
        # 更新簇的分配结果
        bestClustAss[nonzero(bestClustAss[:, 0].A == 1)[0], 0] = len(centList)
        bestClustAss[nonzero(bestClustAss[:, 0].A == 0)[0], 0] = bestCentToSplit
        centList[bestCentToSplit] = bestNewCents[0, :].tolist()[0]
        centList.append(bestNewCents[1, :].tolist()[0])
        clusterAssment[nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss
    return mat(centList), clusterAssment

def distSLC(vecA, vecB):
    # calculate spherical distance
    a = sin(vecA[0, 1] * pi / 180) * sin(vecB[0, 1] * pi / 180)
    # calculate spherical distance
    b = cos(vecA[0, 1] * pi / 180) * cos(vecB[0, 1] * pi / 180) * \
        cos(pi * (vecB[0, 0] - vecA[0, 0]) / 180)
    # calculate spherical distance
    return arccos(a + b) * 6371.0

import matplotlib.pyplot as plt

def clusterClubs(numClust=5):
    # create mat to assign data points
    datList = []
    # get data points
    for line in open('places.txt').readlines():
        lineArr = line.split('\t')
        # get data points
        datList.append([float(lineArr[4]), float(lineArr[3])])
    # get data points
    datMat = mat(datList)
    # calculate cluster centers
    myCentroids, clustAssing = biKmeans(datMat, numClust, distMeas=distSLC)
    fig = plt.figure()
    # create plot
    rect = [0.1, 0.1, 0.8, 0.8]
    # create plot
    scatterMarkers = ['s', 'o', '^', '8', 'p', \
                      'd', 'v', 'h', '>', '<']
    # create plot
    axprops = dict(xticks=[], yticks=[])
    # create plot
    ax0 = fig.add_axes(rect, label='ax0', **axprops)
    # create plot
    imgP = plt.imread('Portland.png')
    # create plot
    ax0.imshow(imgP)
    # create plot
    ax1 = fig.add_axes(rect, label='ax1', frameon=False)
    # create plot
    for i in range(numClust):
        # get all data points in this cluster
        ptsInCurrCluster = datMat[nonzero(clustAssing[:, 0].A == i)[0], :]
        # plot data points
        markerStyle = scatterMarkers[i % len(scatterMarkers)]
        # plot data points
        ax1.scatter(ptsInCurrCluster[:, 0].flatten().A[0], \
                    ptsInCurrCluster[:, 1].flatten().A[0], \
                    marker=markerStyle, s=90)
    # plot cluster centers
    ax1.scatter(myCentroids[:, 0].flatten().A[0], \
                myCentroids[:, 1].flatten().A[0], \
                marker='+', s=300)
    # plot cluster centers
    plt.show()
    
def main():
    clusterClubs(5)
    
    
if __name__ == '__main__':
    main()

实验结果与书上基本一致，如下图所示：
请添加图片描述

小结

我感觉k均值聚类可能是聚类算法中最简单的一种了，由于要人工设定分类的个数，因此一些情况下效果应该会非常差，后续可能会有更高级的聚类算法，但是应该没有机会接触到了。不过了解了聚类算法的基本原理，后面上手应该也会很快。
最后总结一下k均值聚类算法的基本思想：
随机选择质心，通过不断迭代最后使得质心到各个点的距离最短。

别来这个网址
关注
专栏目录
机器学习实验3-K均值聚类.docx
11-29
《机器学习实验3-K均值聚类》 K均值聚类是一种广泛应用的无监督学习方法，主要用于将数据集中的对象自动分成不同的类别，而无需预先知道类别信息。在机器学习领域，聚类是数据预处理的重要步骤，有助于发现数据的...
机器学习算法与Python实践之（六）二分k均值聚类
modabobo
12-26 821
机器学习算法与Python实践之（六）二分k均值聚类 zouxy09@qq.com http://blog.csdn.net/zouxy09 机器学习算法与Python实践这个系列主要是参考《机器学习实战》这本书。因为自己想学习Python，然后也想对一些机器学习算法加深下了解，所以就想通过Python来实现几个比较常用的机器学习算法。恰好遇见这本同样定位的书籍，所以就参考这本书的过程来学...
二分K-均值聚类
birdguan
03-21 1930
K-均值算法算法可以实现收敛，但是存在一个问题是，K-均值算法会收敛到局部最优解而不是全局最优。 一种用于度量聚类效果的指标是SSE（sum of Squared Error，误差平方和）。SSE值越小表示数据点越接近它们的质心，聚类效果也就越好。应为误差取了平方，因此更加重视那些远离中心的点。一种肯定可以降低SSE值的方法是增加簇的个数，但这违背了聚类的目标。聚类的目标是在簇数目不变的情况下提...
k均值聚类和二分k均值聚类
yue_wu_yi的博客
09-21 2070
一、参考《机器学习与实践》 K均值聚类是一种通过距离公式把属性相近对象划分到同一类的算法，此算法对异常点和质心的选取较为敏感。二分k均值聚类是K均值聚类改进(还有一种是K中值聚类),是一种层次聚类方法，以K均值聚类为基础，通过比较和方差得到最好的分法。 K均值聚类步骤 1.得到K个数据范围类的随机质心 2.把数据划分给最近的质心得到K个簇 3.通过每个簇的平均值算出新的质点 4.重复2...
《机器学习实战》二分-kMeans算法（二分K均值聚类）
weixin_34133829的博客
10-07 1007
===================================================================== 《机器学习实战》系列博客是博主阅读《机器学习实战》这本书的笔记也包含一些其他python实现的机器学习算法 算法实现均采用pyth...
【Python机器学习】K-均值聚类算法——二分K-均值算法
最新发布
weixin_39407597的博客
08-13 367
为了克服K-均值算法收敛于局部最小值的问题，还有一种方法是二分K-均值的算法。
二分K-均值聚类算法
fu_jian_ping的博客
04-07 2236
原始数据：testSet2.txt 3.275154 2.957587 -3.344465 2.603513 0.355083 -3.376585 1.852435 3.547351 -2.078973 2.552013 -0.993756 -0.884433 2.682252 4.007573 -3.087776 2.878713 -1.5659...
吴恩达《机器学习》第十章：应用机器学习的建议
CodeLuweir 的博客
11-26 475
文章目录十、应用机器学习的建议10.1 决定下一步做什么10.2 评估假设10.3 模型选择和交叉验证集10.4 诊断偏差与方差10.5 正则化和偏差、方差10.6 学习曲线10.7 决定下一步做什么 十、应用机器学习的建议 10.1 决定下一步做什么 以房价预测为例，当预测时遇到很多无法接受的错误时，下一步该怎么做？ 获得更多的训练样本； 减少特征数； 觉得目前的特征信息量不够，要获得更多的特征； 加入高次项系数（x12，x22，x1x2，etc） 减小λ； 增大λ；   &nbsp
【一起啃书】《机器学习》第十章 降维与度量学习
xtcc的博客
06-19 3086
主成分分析（PCA）是一种使用最广泛的数据降维算法，它的主要思想是将nnn维特征映射到kkk维上，这kkk维是全新的正交特征，也被称为主成分，是在原有nnn维特征的基础上重新构造出来的kkk维特征。PCA的数学定义是：一个正交化线性变换，把数据变换到一个新的坐标系统中，使得这一数据的任何投影的第一大方差在第一个坐标（称为第一主成分）上，第二大方差在第二个坐标（第二主成分）上，依次类推。PCA的工作就是从原始的空间中顺序地找一组相互正交的坐标轴，新的坐标轴的选择与数据本身是密切相关的。
机器学习（周志华） 第十章降维与度量学习
YJY131248的博客
03-26 1918
关于周志华老师的《机器学习》这本书的学习笔记 记录学习过程 本博客记录Chapter10
数据分析之二分K均值聚类算法
mobiusvision的博客
11-13 1674
一、介绍 在聚类问题中，我们会给定一组未加标签的数据集，同时希望有一个算法能够自动将这些数据分成有紧密关系的子集或者是簇。K均值算法现在是最火热也是最为广泛应用的聚类算法。 二、K均值聚类算法原理 假设有一个无标签数据集图(a),现在想将其分为两个簇，使用K均值算法来进行操作，操作步骤： 1.首先随机生成两个点，这两点叫做聚类中心(图b)。K均值算法是一个迭代算法，它会做两件事，第一个是簇分配，第二个是移动聚类中心。 2.簇分配：K均值算法中每次内循环的第一步要进行簇分配，也就是说，遍历每个样本点，根据每个
聚类分析（二）——二分K均值
weixin_44467105的博客
02-10 2886
一般的K均值，所分成的簇往往是局部最优，而不是全局最优，比如下图，簇也不会再更新了，但显然没达到我们的要求。 算法思想： 顾名思义，二分k均值就是每次将数据集一分为二，即k均值算法中的k值为2，第一次是在整个数据集上划分，这里没什么异议，从第二次开始，每次划分的时候就要选取使整个数据集误差平方和最小的一个类进行一分为二了，以此进行下去直到分成我们想要的k类。 二分k均值的伪代码如下： 将所有点看...
coursera-斯坦福-机器学习-吴恩达-应用机器学习的建议
w3071206219的博客
12-27 315
10.1 决定下一步做什么 参考视频: 10 - 1 - Deciding What to Try Next (6 min).mkv 到目前为止，我们已经介绍了许多不同的学习算法，如果你一直跟着这些视频的进度学习，你会发现自己已经不知不觉地成为一个了解许多先进机器学习技术的专家了。 然而，在懂机器学习的人当中依然存在着很大的差距，一部分人确实掌握了怎样高效有力地运用这些学习算法。而另一些人他们...
ML入门6.0 手写K-Means 聚类 （K-Means Clustering）
weixin_39956363的博客
06-14 966
ML入门6.0 手写K-Means 聚类 （K-Means Clustering）K-Means 简介原理简介聚类指标—距离K-Means算法步骤实现代码运行结果优缺点优点缺点完整代码见GitHub K-Means 简介 聚类算法通常被归类于无监督学习中，由于训练样本是未知的，目标是通过对无对无标记训练样本的学习来揭示数据的内在规律和性质，为进一步的数据分析提供基础。聚类试图将数据集中的样本划分为若干个不相交的子集，每个子集被称为一个簇，通过这样的划分，每个簇内的样本可能拥有相同或者类似的特征，从而对应于
k均值2维数据聚类
qq_41881095的博客
07-05 971
根据《机器学习》k均值聚类的学习与认识，以西瓜数据集4.0为数据样本，对k均值matlab代码进行编程，与书本结果进行验证。 % 利用K-均值聚类的原理，实现对一组数据的分类。这里以一组二维的点为例。 clc;clear; X_2WEI=[0.697 0.774 0.634 0.608 0.556 0.403 0.481 0.437 0.666 0.243 0.245 0.343 0.639 0.657 0.36 0.593 0.719 0.359 0.339 0.282 0.748 0.714 0.4
《机器学习实战》学习笔记（十）
书生的博客
08-28 584
聚类与分类的最大不同在于，分类的目标事先巳知，而聚类则不一样。每个点会被分配到距其最近的簇质心，然后紧接着基于新分配到簇的点更新簇质心。一种肯定可以降低SSE值的方法是增加簇的个数，但这违背了聚类的目标。而且由于质心最初是随机分布的，得到的最后的聚类效果也不相同。簇识别给出聚类结果的含义。在包含簇分配结果的矩阵中保存着每个点的误差，即该点到簇质心的距离平方值。聚类的算法，之所以称之为K-均值是因为它可以发现K个不同的簇，且每个簇的中心采用簇中所含值的。聚类是一种无监督的学习，它将相似的对象归到同一个簇中。.
K均值算法（K-means）聚类
热门推荐
PyRookie
08-21 10万+
1. K-means算法 2. KMeans(n_clusters=3) 3. K-means的中心点 4. centers = kmeans.cluster_centers_ 5. 坐标轴中文显示问题 6. 坐标轴字体、负号还原问题 7. 3D绘图 8. from mpl_toolkits.mplot3d import Axes3D 9. 建立坐标系 10. ax = plt.subplot(projection='3d') 8. make_blobs生成有中心点的数据
机器学习(2): K-means (k均值) 聚类算法 小结
TechArtisan6的博客
04-24 1万+
目录 1 聚类简介 2 k-means算法流程 3 利用k-means 对数据进行聚类 4利用K-means进行图像分割 5 小结 参考资料 1 聚类简介 在无监督学习中，训练样本的标记信息是未知的，我们的目标是通过对无标记训练样本的学习来解释数据的内在性质及规律，为了进一步的数据分析提供基础，此类学习应用最多的就是“聚类”(clustering)。 聚类(clusteri...
周志华《机器学习》第十章复习（带例题）
Fitz的博客
06-23 1329
老师让我帮他出卷，就自己做了细纲出了点题。可以参考着复习。
Matlab环境下K均值聚类算法实践与K近邻对比
在机器学习领域，K均值聚类算法（K-means clustering）是一种广泛应用的无监督学习方法，用于将数据集划分到K个预定义的类别中。该算法的核心思想是通过迭代找到数据的最佳分组，使得每个簇内的数据点尽可能相似，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值