K-均值聚类算法对未标注数据分组（1）

最新推荐文章于 2022-10-05 15:01:08 发布
最新推荐文章于 2022-10-05 15:01:08 发布
阅读量690 收藏 3
点赞数 2
分类专栏： 机器学习实战 文章标签： k-均值 聚类 后处理 二分-k-均值算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lilong117194/article/details/78469476
版权

1. K-均值聚类算法

优点：容易实现。
缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢。
适用数据类型：数值型数据。

K-均值算法的工作流程是这样的。首先，随机确定&个初始点作为质心。然后将数据集中的每个点分配到一个簇中，具体来讲，为每个点找距其最近的质心，并将其分配给该质心所对应的簇。这一步完成之后，每个簇的质心更新为该簇所有点的平均值。

上述过程的伪代码表示如下：

创建k个点作为起始质心（经常是随机选择）
当任意一个点的簇分配结果发生改变时
对养据集中的每个数据点
对每个质心
计算质心与数据点之间的距离
将数据点分配到距其最近的簇
对每一个簇，计算簇中所有点的均值并将均值作为质心

k均值聚类算法：

# -*- coding: utf-8 -*-
from numpy import *

# K-均值聚类支持函数
def loadDataSet(fileName):      
    dataMat = []                
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        fltLine = 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] = mat(minJ + rangeJ * random.rand(k,1)) # 生成随机值
        #print centroids[:,j]
    return centroids  # 返回随机质心,是和数据点相同的结构

# k--均值聚类算法(计算质心--分配--重新计算)
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent): # k是簇的数目
    m = shape(dataSet)[0]  # 得到样本的数目
    clusterAssment = mat(zeros((m,2))) #  创建矩阵来存储每个点的簇分配结果
                                       #  第一列：记录簇索引值，第二列：存储误差，欧式距离的平方
    centroids = createCent(dataSet, k)  # 创建k个随机质心
    clusterChanged = True
    while clusterChanged:  # 迭代使用while循环来实现
        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
            if clusterAssment[i,0] != minIndex: # 更新停止的条件
                clusterChanged = True
            clusterAssment[i,:] = minIndex,minDist**2 # minDist**2就去掉了根号         
        for cent in range(k):  # 更新质心的位置
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]] 
            centroids[cent,:] = mean(ptsInClust, axis=0) # 然后计算均值，axis=0:沿列方向 
    print 'centroids:',centroids
    return centroids, clusterAssment # 返回簇和每个簇的误差值，误差值是当前点到该簇的质心的距离


# 主函数
datMat=mat(loadDataSet('testSet.txt'))
rand_centroids=randCent(datMat, 2)
print 'Random centroids:',rand_centroids
myCentroids,clustAssing=kMeans(datMat,4)
print 'myCentroids：',myCentroids
#centList,myNewAssments=biKmeans(datMat, 3)

运行结果：

Random centroids: [[ 0.47004012 -0.70046073]
 [ 4.59776536  2.61143197]]
centroids: [[-3.38237045 -2.9473363 ]
 [-2.46154315  2.78737555]
 [ 2.80293085 -2.7315146 ]
 [ 2.6265299   3.10868015]]
myCentroids： [[-3.38237045 -2.9473363 ]
 [-2.46154315  2.78737555]
 [ 2.80293085 -2.7315146 ]
 [ 2.6265299   3.10868015]]

上面的结果可以看出得到了4个质心

2. 二分k-均值算法

在K-均值聚类中簇的数目k是一个用户预先定义的参数，那么用户如何才能知道乂的选择是否正确？如何才能知道生成的簇比较好呢？在包含簇分配结果的矩阵中保存着每个点的误差，即该点到簇质心的距离平方值。

使用后处理来提高聚类性能：

  • K-均值算法收敛到了局部最小值，而非全局最小值（局部最小值指结果还可以但并非最好结果，全局最小值是可能的最好结果)。
  • 一种用于度量聚类效果的指标是SSE(Sum of Squared Error,误差平方和。SSE值越小表示数据点越接近于它们的质心，聚类效果也越好。因为对误差取了平方，因此更加重视那些远离中心的点。一种肯定可以降低SSE值的方法是增加簇的个数，但这违背了聚类的目标。聚类的目标是在保持族数目不变的情况下提高簇的质量。那么如何进行改进？可以对生成的簇进行后处理，一种方法是将具有最大SSE值的簇划分成两个簇。具体实现时可以将最大簇包含的点过滤出来并在这些点上运行尺-均值算法，其中的K设为2。

为克服k-均值算法收敛于局部最小值的问题：

  • 二分k-均值（bisecting K-means)算法，该算法首先将所有点作为一个簇，然后将该簇一分为二。之后选择其中一个簇继续进行划分，选择哪一个簇进行划分取决于对”其划分是否可以最大程度降低SSE的值。上述基于SSE的划分过程不断重复，直到得到用户指定的簇数目为止。
  • 另一种做法是选择SSE最大的簇进行划分，直到簇数目达到用户指定的数目为止。这个做法听起来并不难实现。

下面就来看一下该算法的实际效果。

# -*- coding: utf-8 -*-
from numpy import *

# K-均值聚类支持函数
def loadDataSet(fileName):      
    dataMat = []                
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        fltLine = 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] = mat(minJ + rangeJ * random.rand(k,1)) # 生成随机值
        #print centroids[:,j]
    return centroids  # 返回随机质心,是和数据点相同的结构

# k--均值聚类算法(计算质心--分配--重新计算)
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent): # k是簇的数目
    m = shape(dataSet)[0]  # 得到样本的数目
    clusterAssment = mat(zeros((m,2))) #  创建矩阵来存储每个点的簇分配结果
                                       #  第一列：记录簇索引值，第二列：存储误差，欧式距离的平方
    centroids = createCent(dataSet, k)  # 创建k个随机质心
    clusterChanged = True
    while clusterChanged:  # 迭代使用while循环来实现
        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
            if clusterAssment[i,0] != minIndex: # 更新停止的条件
                clusterChanged = True
            clusterAssment[i,:] = minIndex,minDist**2 # minDist**2就去掉了根号         
        for cent in range(k):  # 更新质心的位置
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]] 
            centroids[cent,:] = mean(ptsInClust, axis=0) # 然后计算均值，axis=0:沿列方向 
    print 'centroids:',centroids
    return centroids, clusterAssment # 返回簇和每个簇的误差值，误差值是当前点到该簇的质心的距离

# 二分k--均值聚类算法
def biKmeans(dataSet, k, distMeas=distEclud):
    m = shape(dataSet)[0] 
    clusterAssment = mat(zeros((m,2))) # 存储数据集中每个点的簇分配结果及平方误差
    centroid0 = mean(dataSet, axis=0).tolist()[0] # 计算整个数据集的质心：1*2的向量
    centList =[centroid0] # []的意思是使用一个列表保存所有的质心,簇列表,[]的作用很大
    for j in range(m):  # 遍历所有的数据点，计算到初始质心的误差值，存储在第1列
        clusterAssment[j,1] = distMeas(mat(centroid0), dataSet[j,:])**2
    while (len(centList) < k):  # 不断对簇进行划分，直到k
        lowestSSE = inf  # 初始化SSE为无穷大
        for i in range(len(centList)): # 遍历每一个簇
            print 'i:',i               # 数组过滤得到所有的类别簇等于i的数据集
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:,0].A==i)[0],:]
            # 得到2个簇和每个簇的误差，centroidMat：簇矩阵  splitClustAss：[索引值,误差]
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas) # centroidMat是矩阵
            sseSplit = sum(splitClustAss[:,1])  # 求二分k划分后所有数据点的误差和     
                                             # 数组过滤得到整个数据点集的簇中不等于i的点集
            print nonzero(clusterAssment[:,0].A!=i)[0]
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:,0].A!=i)[0],1])# 所有剩余数据集的误差之和
            print "sseSplit and notSplit: ",sseSplit,',',sseNotSplit
            if (sseSplit + sseNotSplit) < lowestSSE: # 划分后的误差和小于当前的误差，本次划分被保存
                print 'here..........'
                bestCentToSplit = i  # i代表簇数
                bestNewCents = centroidMat  # 保存簇矩阵
                print 'bestNewCents',bestNewCents
                bestClustAss = splitClustAss.copy() # 拷贝所有数据点的簇索引和误差
                lowestSSE = sseSplit + sseNotSplit  # 保存当前误差和
        # centList是原划分的簇向量，bestCentToSplit是i值
        print 'len(centList) and  bestCentToSplit ',len(centList),',',bestCentToSplit
                  # 数组过滤得到的是新划分的簇类别是1的数据集的类别簇重新划为新的类别值为最大的类别数
        bestClustAss[nonzero(bestClustAss[:,0].A == 1)[0],0] = len(centList) 
                  # 数组过滤得到的是新划分的簇类别是0的数据集的类别簇重新划为新的类别值为i
        bestClustAss[nonzero(bestClustAss[:,0].A == 0)[0],0] = bestCentToSplit
        print 'the bestCentToSplit is: ',bestCentToSplit   # 代表的是划分的簇个数-1
        print 'the len of bestClustAss is: ', len(bestClustAss) # 数据簇的数据点个数
                                   # 新划分簇矩阵的第0簇向量新增到当前的簇列表中
        centList[bestCentToSplit] = bestNewCents[0,:].tolist()[0] 
        print 'centList[bestCentToSplit]:',centList[bestCentToSplit]
                        # 新划分簇矩阵的第1簇向量添加到当前的簇列表中
        centList.append(bestNewCents[1,:].tolist()[0]) # centList是列表的格式
        print 'centList',centList
                    # 数组过滤得到所有数据集中簇类别是新簇的数据点
        clusterAssment[nonzero(clusterAssment[:,0].A == bestCentToSplit)[0],:]= bestClustAss
    return mat(centList), clusterAssment # 返回质心列表和簇分配结果


# 主函数
datMat=mat(loadDataSet('testSet.txt'))
centList,myNewAssments=biKmeans(datMat, 3)

运行结果：

i: 0
centroids: [[-1.12630774  1.13042276]
 [ 2.59258145 -2.78274655]]
[]
sseSplit and notSplit:  1000.74868136 , 0.0
here..........
bestNewCents [[-1.12630774  1.13042276]
 [ 2.59258145 -2.78274655]]
len(centList) and  bestCentToSplit  1 , 0
the bestCentToSplit is:  0
the len of bestClustAss is:  80
centList[bestCentToSplit]: [-1.1263077413793101, 1.13042275862069]
centList [[-1.1263077413793101, 1.13042275862069], [2.592581454545454, -2.782746545454545]]
i: 0
centroids: [[ 1.88660209  3.23434291]
 [-3.10621991 -0.25215334]]
[ 2  6 10 ..., 72 74 78]
sseSplit and notSplit:  390.512447704 , 95.5368926046
here..........
bestNewCents [[ 1.88660209  3.23434291]
 [-3.10621991 -0.25215334]]
i: 1
centroids: [[ 4.5110462  -1.0349174 ]
 [ 2.02832712 -3.29681394]]
[ 0  1  3 ..., 76 77 79]
sseSplit and notSplit:  51.9548039494 , 905.211788759
len(centList) and  bestCentToSplit  2 , 0
the bestCentToSplit is:  0
the len of bestClustAss is:  58
centList[bestCentToSplit]: [1.8866020869565217, 3.2343429130434784]
centList [[1.8866020869565217, 3.2343429130434784], [2.592581454545454, -2.782746545454545], [-3.1062199142857145, -0.2521533428571429]]

可以看出算法运行的中间过程，其中最容易迷惑的地方就是数组过滤器。可参考：
tolist()的用法
nonzero()

要注意的几点：

（1）centList =[centroid0] # []的意思是使用一个列表保存所有的质心,簇列表,[]的作用很大

In [12]: mean(datMat, axis=0).tolist()[0]
Out[12]: [-0.10361321250000004, 0.05430119999999998]

In [13]: centroid0=mean(datMat, axis=0).tolist()[0]

In [14]: centList =[centroid0]

In [15]: centList
Out[15]: [[-0.10361321250000004, 0.05430119999999998]]

（2）dataSet[nonzero(clusterAssment[:,0].A==i)[0],:]

>>> from numpy import *
>>> clusterAssment = mat(zeros((5,2)))
>>> clusterAssment[:,0].A==0
array([[ True],
       [ True],
       [ True],
       [ True],
       [ True]], dtype=bool)
>>> clusterAssment[:,0]==0
matrix([[ True],
        [ True],
        [ True],
        [ True],
        [ True]], dtype=bool)
>>> clusterAssment[:,0].A==1
array([[False],
       [False],
       [False],
       [False],
       [False]], dtype=bool)
>>> clusterAssment
matrix([[ 0.,  0.],
        [ 0.,  0.],
        [ 0.,  0.],
        [ 0.,  0.],
        [ 0.,  0.]])
>>> mm=transpose(nonzero(clusterAssment[:,0]==0))
>>> mm
array([[0, 0],
       [1, 0],
       [2, 0],
       [3, 0],
       [4, 0]], dtype=int64)
>>> nonzero(clusterAssment[:,0].A==0)[0]
array([0, 1, 2, 3, 4], dtype=int64)
>>> transpose(nonzero(clusterAssment[:,0].A==0))
array([[0, 0],
       [1, 0],
       [2, 0],
       [3, 0],
       [4, 0]], dtype=int64)
>>> nonzero(clusterAssment[:,0].A==0)
(array([0, 1, 2, 3, 4], dtype=int64), array([0, 0, 0, 0, 0], dtype=int64))
>>> dataSet=mat([[1,2],[2,3],[3,4],[4,5],[5,6]])
>>> dataSet[nonzero(clusterAssment[:,0].A==0)[0],:]
matrix([[1, 2],
        [2, 3],
        [3, 4],
        [4, 5],
        [5, 6]])
>>>

（3）bestNewCents[0,:].tolist()[0]

In [17]:a=mat([[1,2],[2,3]])

In [18]:a
Out[18]: 
matrix([[1, 2],
        [2, 3]])

In [19]:a[0,:]
Out[19]: matrix([[1, 2]])

In [20]:a[0,:].tolist()
Out[20]: [[1, 2]]

In [21]:a[0,:].tolist()[0]
Out[21]: [1, 2]
lilong117194
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
机器学习实战学习笔记（九）K-均值聚类算法
The wind of freedom blows
11-03 625
PS：该系列数据都可以在图灵社区（点击此链接）中随书下载中下载（如下）   聚类是一种无监督的学习，它将相似的对象归到同一个簇中。它有点像全自动分类，聚类方法几乎可以应用于所有对象，簇内的对象越相似，聚类的效果越好。K-均值（K-means） 聚类算法，之所以称之为K-均值是因为它可以发现k个不同的簇，且每个簇的中心采用簇中所含值的均值计算而成。   簇识别（cluster identifica...
『ML』利用K-Means聚类算法对未标注数据分组——《机器学习实战》学习笔记（Ch10）
12-21
K-Means聚类算法是机器学习领域中最基础且广泛应用的无监督学习方法之一，用于对未标注数据进行分组。它的核心思想是通过迭代优化，使得每个数据点尽可能地归属于与其最近的类中心（也称为质心）所在的簇。算法的...
机器学习——利用K-均值聚类算法对未标注数据分组
weixin_34007291的博客
12-26 196
聚类是一种无监督的学习，它将相似的对象归到同一簇中。它有点像全自动分类。聚类方法几乎可以应用到所有对象，簇内的对象越相似，聚类的效果越好。 K-均值（K-means）聚类算法，之所以称之为K-均值是因为它可以发现k个不同的簇，且每个簇的中心采用簇中所含值的均值计算而成。 簇识别（cluster identification）给出簇类结果的含义。假定有一些数据，现在将相似数据归到一起，簇识别会告诉我...
利用K-均值聚类算法对未标注数据分组
新博客：https://aping-dev.com/
06-14 795
kMean.py#!/usr/bin/python # -*- coding: utf-8 -*- #coding=utf-8from numpy import *#导入数据 def loadDataSet(fileName): dataMat = [] fr = open(fileName) for line in fr.readlines(): c
第十章 利用K-均值聚类算法对未标注数据分组
u012730092的专栏
11-15 616
第 10 章 利用K-均值聚类算法对未标注数据分组第 10 章 利用K-均值聚类算法对未标注数据分组 1 K-均值聚类算法 2 使用后处理来提高聚类性能 3 二分K-均值算法10.1 K-均值聚类算法 K-均值聚类 优点：容易实现 缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢 适用数据类型：数值型数据​ K-均值聚类伪代码：创建k个点作为起始质心(经
机器学习实战 第十章 利用k-均值聚类算法对未标注数据分组
qq_59026468的博客
09-20 714
k-均值聚类、二分k-均值聚类
大数据应用基础-聚类算法.pptx
09-23
总之，聚类算法是大数据分析的重要工具，它能帮助我们发现数据的隐含结构，对数据进行有效的组织和理解。无论是市场分析、图像处理还是异常检测，聚类算法都能发挥重要作用，为决策提供有力支持。通过深入理解和熟练...
Kmeans聚类算法入门.pdf
09-13
K-Means聚类算法是一种广泛应用的无监督学习方法，主要用于发现数据集中的自然分组或类别。在没有预先定义的标签的情况下，K-Means通过寻找数据点之间的相似性来形成不同的簇。以下是关于K-Means算法的详细介绍： 1...
C均值中国城市聚类分析
10-15
这里提到的"C均值"是指K-Means聚类算法，这是一种广泛应用的无监督学习方法，用于将数据集分成K个不同的类别。在本案例中，我们有625个中国城市的经纬度作为特征值，这些数据可能是从Google Earth获取的，提供了精确...
机器学习算法——k-均值聚类算法对未标注数据分组
weixin_45709671的博客
09-03 946
k-均值聚类算法对未标注数据分组0、前言1、k-均值聚类算法2、对于k-means的算法优化2.1对聚类得到的簇进行二次处理2.2二分k-均值聚类算法3、对纽波兰的地理位置进行聚类3.1我们按照以下几个流程完成项目：3.2具体代码实现4、小结学习永无止境，后续还会有更多的算法学习及实例尝试。 0、前言 聚类是一种无监督的学习，它将相似的对象归到同一簇中。它有点像全自动分了。聚类方法几乎可以应用到所有对象，簇内的对象越相似，聚类的效果越好。本章要学习一种称为K-均值（K-means）聚类的算法。之所以称之为K
机器学习实战第十章——利用k-均值聚类算法对未标注数据分组
jgq1466693的博客
10-05 422
函数有4个输入参数。缺点，K-均值聚类中簇的数目k是用户预先定义的，而用户并不能提前预知k的选择是否正确。创建矩阵存储数据集中的每一个点的簇分配结果以及平方误差，然后计算整个数据集的质心，使用列表保留所有的质心。我们可以很容易的对二维数据上的聚类进行可视化，但面对40维数据时，就不是那么容易了，两种量化方法：合并最近的质心，或者合并两个使得SSE增幅最小的质心。可以通过对生成的簇进行后处理，一种是将具有最大SSE值的簇划分成两个簇，具体实现时将最大簇包含的点过滤出来并在这些点上运行K-均值算法，记k=2.
机器学习实战笔记-利用K均值聚类算法对未标注数据分组
fighting!
11-20 1344
聚类是一种无监督的学习，它将相似的对象归到同一个簇中。它有点像全自动分类。聚类方法几乎可以应用于所有对象，簇内的对象越相似，聚类的效果越好 簇识别给出聚类结果的含义。假定有一些数据，现在将相似数据归到一起，簇识别会告诉我们这些簇到底都是些什么。聚类与分类的最大不同在于，分类的目标事先巳知，而聚类则不一样。因为其产生 的结果与分类相同，而只是类别没有预先定义，聚类有时也被称为无监督分类（unsup
《机器学习实战》之十——利用K-均值聚类算法对未标注数据分组
潘多拉星系的专栏
04-09 1308
K-均值目录一、前言二、K-均值聚类算法三、使用后处理来提高聚类性能四、二分K-均值算法五、示例：对地图上的点进行聚类六、总结参考资料 一、前言   聚类是一种无监督的学习，它将相似的对象归到同一簇中。它有点像全自动分了。聚类方法几乎可以应用到所有对象，簇内的对象越相似，聚类的效果越好。本章要学习一种称为K-均值（K-means）聚类的算法。之所以称之为K-均值是因为它可以发现k个不同的簇，且每个...
【机器学习实战】 利用K-均值聚类算法对未标注数据分组
欢迎来到无尾君的小窝
03-27 753
转载请注明作者和出处： https://blog.csdn.net/weixin_37392582 代码地址： https://gitee.com/wuweijun 开发平台： Win10 + Python3.6 + Anaconda3 编  者： 无尾 一、前言 二、K-均值聚类算法 1、工作流程　　 2、伪代码 3、流程图 4、核心代码解释 （１）euclidentDist...
第十章 利用k-均值聚类算法对未标注数据分组
大卫DrDavidS的博客
12-24 748
本章内容： 1. K-均值聚类算法。 2. 对聚类得到的簇进行后处理。 3. 二分K-均值聚类算法。 4.  对地理位置进行聚类。 ======================================================================== K-聚类算法是一种无监督学习算法。首先明白什么是无监督学习：输入数据有标签，则为有监督学习，没标签则为无监督学
第10章 利用K-均值聚类算法对未标注数据分组
lingan_Hong的博客
12-05 686
写在前面关于无监督学习： 在无监督学习中，类似分类和回归的目标变量事先是不存在的。与前面的“对于输入数据X能预测变量Y”的不同是，这个要回答的问题是：“从数据X能发现什么？构成X的最佳6个数据簇都是哪些？”或者“X中哪三个特征是最频繁共现的？”本章内容： ● K-均值聚类算法 ● 对聚类得到的簇进行后处理 ● 二分K-均值聚类算法 ● 对地理位置进行聚类聚类是一种无监督的学
利用K-均值聚类算法对未标注数据进行分组
weixin_43871178的博客
12-14 728
利用K-均值聚类算法对未标注数据进行分组 实验数据： testSet.txt，每行包含两个数值型数据 实验要求： 利用K-均值聚类算法对数据进行分组，由于是无标注数据，实验结果为误差平方和，这里的误差是一个点到簇中心的距离。 实验步骤： 1.处理数据：将数据转化为矩阵形式,函数为loadDataSet(fileName)，注释：fileName为文件名称，输出为数据集的矩阵形式； 2.距离计算：计...
机器学习（八）：寻找数据的分组——k均值聚类
乘风破浪2014
04-30 2541
理解聚类聚类是一种无监督的机器学习任务，可以将数据自动分成类，或具有类类似的分组。我们可能都不知道我们在寻找什么，聚类是用来知识发现而不是预测。简单地说，就是对无标签的数据进行分类k均值聚类涉及将n个案例分配到k个类中的一个，其中k是一个提前定义好的数，目标是最小化每个类内部的差异，最大化类之间的差异。该算法使用了一个可以找到局部最优解的启发式过程。两个阶段：将案例分配到初始的k个类中，其次，根据落
K-均值聚类算法及其优缺点
最新发布
07-11
1. 对初始质心敏感：K-均值聚类算法对初始质心的选择非常敏感，不同的初始质心可能导致不同的聚类结果。 2. 对异常值敏感：异常值的存在可能会对聚类结果产生较大影响。 3. 需要指定簇的个数：在使用K-均值聚类算法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值