【机器学习】二分K-Means的原理以及代码实现

最新推荐文章于 2021-05-06 21:27:36 发布
最新推荐文章于 2021-05-06 21:27:36 发布
阅读量1.4k 收藏 15
点赞数 3
分类专栏： Python机器学习 文章标签： 聚类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41861700/article/details/107021392
版权

Bisecting K-Means

什么是二分K-Means

二分K-Means其实就是基于K-Means改进的算法，他的主要核心还是在于K-Means算法中，只不过它的算法思想是先从一个总簇，不断通过二分裂，直到分裂成k个簇则停止。在K-Means博文当中，我们知道经过算法后，返回了2个参数：

  • centroids：
    返回的是k质心的坐标矩阵
  • clusterAssment
    返回的是m*2的簇矩阵，其中m是dataSet里数据点的总个数。第0列储存的是数据点被归类到哪个质心簇的索引（对应centroids矩阵）， 第1列储存的是与对应质心的误差平方。

而正因为有了与质心的误差平方，通过求和算出误差平方和(SSE)，从何判断聚类的整体效果。SSE可以理解为物理热力学上的熵，熵的物理意义是体系混乱程度的度量。

二分K-Means原理

这里的二分裂并不是1 -> 2 -> 4 -> 8，而是1 -> 2 -> 1+2 -> 2+2 > 3+2 -> …
二分算法的核心：

  1. 初始化整个数据集为1个大簇
  2. 通过尝试分裂原有的质心点，找出使得SSE(熵)变小的质心点x
  3. 采取质心点 x 分裂，其他质心点不变的方案
  4. 将 x 点分裂后2个簇的数据， 更新至将原本 x 点的簇数据
  5. 更新质心点和总簇
  6. 直到分裂出 k 个质心

算法优缺点

优点：相对K-Means算法，不会掉落局部极值点，使得更精准了。
缺点：速度更慢了一点。

代码实现

实现方式写了两种

  • 代码一
    每次计算质心矩阵里的所有质心分裂后的总SSE，选取总SSE最小的方案进行分裂。
    优点：可以保证总的SSE是最小的。缺点：因为每次都要对质心进行K-Means，可能速度上会慢一点
  • 代码二
    每次计算质心矩阵里的所有质心的SSE，选取最大SSE的那簇进行分裂。
    优点：相比与代码一的方案，速度可能会快一些，因为并不需要先K-Means再计算SSE，而是直接计算summation值，省去了K-Means的那段时间消耗。
    缺点：不能保证总的SSE是最小的

代码（一）：找到最小的SSE

from numpy import mat, shape, zeros, mean, sqrt, power, sum, inf, nonzero
from numpy.random import rand
from numpy import array


def distanceEuclid(vecA, vecB):
    # 用欧几里得坐标算距离
    return sqrt(sum(power(vecA - vecB, 2)))


def randCenter(dataSet, k):
    # 生成k个随机质心
    # 获取数据的总列数
    n = shape(dataSet)[1]
    # 初始化一个质心矩阵 k * n  k行n列的0矩阵
    centroids = mat(zeros((k, n)))
    for j in range(n):
        minJ = min(dataSet[:, j])    # 计算数据集第j列的最小值
        maxJ = max(dataSet[:, j])    # 计算数据集第j列的最大值
        rangeJ = float(maxJ - minJ)  # 最大值-最小值 计算最大差值
        # 生成质心矩阵第j列的值 通过均匀分布的随机数
        centroids[:, j] = minJ + rangeJ * rand(k, 1)    # 值的范围∈[minJ, maxJ]
    return centroids


def k_means(dataSet, k, distMeas=distanceEuclid, createCent=randCenter):
    # 将数据集初始化为mat矩阵对象
    dataSet = mat(dataSet)
    # 获取数据集的总点数
    m = shape(dataSet)[0]
    # 生成数据集点数的簇矩阵并初始化为0     第一列保存该点被归类的质心索引，第二列保存该点与质心的距离
    clusterAssment = mat(zeros((m, 2)))
    # 初始化k个质心矩阵
    centroids = createCent(dataSet, k)
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False
        for i in range(m):  # 分别取出全部点 并逐一与所有质心进行距离计算 把距离第j个质心最近时，将该点归类为j
            minDist = inf   # 先初始化最小值为无限大
            minIndex = -1
            for j in range(k):      # 第i点逐一与所有质心进行距离计算
                # 算出第i点与第j个质心的距离
                distJI = distMeas(centroids[j, :], dataSet[i, :])
                # 与上次的minDist判断 如果更小则更新质心
                if distJI < minDist:
                    minDist = distJI    # 质心距离
                    minIndex = j        # 质心索引
            # 如果其中第i个点被归类的质心与上次的不一样 则继续下次的计算，否则如果全部点的质心都没有发生变化则认为收敛
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            # 并更新簇矩阵第i个点的记录[质心索引， 与该质心距离的平方]
            clusterAssment[i, :] = minIndex, minDist ** 2
        # 重新初始化质心
        for cent in range(k):   # 遍历k个质心
            ptsInClust = dataSet[nonzero(clusterAssment[:, 0].A == cent)[0]]
            # 被分类到当前第cent个点的所有点的各维度按列求平均值 生成1 * n列的矩阵并更新到质心矩阵中
            centroids[cent, :] = mean(ptsInClust, axis=0)
    # 返回  质心点      簇矩阵[质心索引， 与该质心距离的平方]
    return centroids, clusterAssment


def bisecting_k_means(dataSet, k, distMeas=distanceEuclid):
    dataSet = mat(dataSet)
    m = shape(dataSet)[0]
    # 初始化一个簇
    clusterAssment = mat(zeros((m, 2)))
    # 计算数据集每列的平均值, 生成初始质心
    centroid0 = list(mean(dataSet, axis=0).tolist())[0]
    # 质心集合
    centList = [centroid0]
    # 将数据集所有的点与初始质心进行距离计算
    for j in range(m):
        clusterAssment[j, 1] = distMeas(mat(centroid0), dataSet[j, :]) ** 2
    while len(centList) < k:
        bestClustAss, bestNewCents = zeros(1), zeros(1)
        bestCentToSplit = -1
        lowestSSE = inf
        # 遍历质心集合里的全部质心， 找到第i个质心分裂后的SSE与其他质心SSE之和最小的 i点
        for i in range(len(centList)):
            # 取出第i个质心的数据簇
            ptsIncurrCluster = dataSet[nonzero(clusterAssment[:, 0].A == i)[0], :]
            # 将第i个质心的数据簇再通过k-means一分为二
            centroidMat, splitClustAss = k_means(ptsIncurrCluster, 2, distMeas)
            # 计算一分为二的两个子簇后 总的误差平方和SSE
            sseSplit = sum(splitClustAss[:, 1])
            # 计算未一分为二之前，除了第i个质心以外的数据簇误差平方和
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:, 0].A != i)[0], 1])
            # 如果第i个点分裂后SSE + 除了i点的SSE和是最小的 则更新最好的
            print(f'center {i} sseSplit, notSplit and summation: ', sseSplit, sseNotSplit, sseSplit+sseNotSplit)
            if (sseSplit + sseNotSplit) < lowestSSE:
                # 最好的分裂点为i
                bestCentToSplit = i
                # 最好的分裂后的2个质心
                bestNewCents = centroidMat
                # 分裂后的簇
                bestClustAss = splitClustAss.copy()
                # 最小的SSE
                lowestSSE = sseSplit + sseNotSplit
        # 更新总的簇矩阵 即1分2， 2中选出最小SSE分=1+2， 3中选出最小SSE=2+2, ...
        # 将分裂后的分裂点1 更新为 质心列表长度， 因为簇矩阵第一列是质心索引由0开始递增，所以直接赋值长度正好能+1
        # 所以将分裂后的第二个质心定义为新增的质心
        bestClustAss[nonzero(bestClustAss[:, 0].A == 1)[0], 0] = len(centList)
        # 将分裂后的第一个质心定义为更新为最大SSE值质心X
        bestClustAss[nonzero(bestClustAss[:, 0].A == 0)[0], 0] = bestCentToSplit
        print('the bestCentToSplit is :', bestCentToSplit)
        print('the len of bestClustAss is :', len(bestClustAss))
        print('=========')
        print('the SSE summation of clusterAssment is :', sum(clusterAssment[:, 1]))
        print('=========')
        # 因为分裂后的第一个质心定义为更新为最大SSE值质心X， 所以放回质心X的位置
        centList[bestCentToSplit] = bestNewCents[0, :]
        # 因为将分裂后的第二个质心定义为新增的质心， 所以放到质心矩阵的最后
        centList.append(bestNewCents[1, :])
        # 更新变化后簇矩阵 属于第i个质心的数据点
        clusterAssment[nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss
    return mat(array(centList)), clusterAssment

测试算法结果（测试例子中k设置为4）

center 0 sseSplit, notSplit and summation:  792.9168565373268 0.0 792.9168565373268
the bestCentToSplit is : 0
the len of bestClustAss is : 80
=========
the SSE summation of clusterAssment is : 1465.5800234838164
=========
center 0 sseSplit, notSplit and summation:  83.5874695564185 326.2840752011824 409.87154475760093
center 1 sseSplit, notSplit and summation:  66.36683512000786 466.63278133614426 532.9996164561521
the bestCentToSplit is : 0
the len of bestClustAss is : 40
=========
the SSE summation of clusterAssment is : 792.9168565373268
=========
center 0 sseSplit, notSplit and summation:  31.62960698022571 358.8853180661336 390.51492504635934
center 1 sseSplit, notSplit and summation:  66.36683512000786 83.5874695564185 149.95430467642637
center 2 sseSplit, notSplit and summation:  18.398749985455712 377.2703018926498 395.6690518781055
the bestCentToSplit is : 1
the len of bestClustAss is : 40
=========
the SSE summation of clusterAssment is : 409.87154475760093
=========

在这里插入图片描述
代码（二）：每次分裂SSE最大的质心

from numpy import mat, shape, zeros, mean, sqrt, power, sum, inf, nonzero
from numpy.random import rand
from numpy import array


def distanceEuclid(vecA, vecB):
    # 用欧几里得坐标算距离
    return sqrt(sum(power(vecA - vecB, 2)))


def randCenter(dataSet, k):
    # 生成k个随机质心
    # 获取数据的总列数
    n = shape(dataSet)[1]
    # 初始化一个质心矩阵 k * n  k行n列的0矩阵
    centroids = mat(zeros((k, n)))
    for j in range(n):
        minJ = min(dataSet[:, j])    # 计算数据集第j列的最小值
        maxJ = max(dataSet[:, j])    # 计算数据集第j列的最大值
        rangeJ = float(maxJ - minJ)  # 最大值-最小值 计算最大差值
        # 生成质心矩阵第j列的值 通过均匀分布的随机数
        centroids[:, j] = minJ + rangeJ * rand(k, 1)    # 值的范围∈[minJ, maxJ]
    return centroids


def k_means(dataSet, k, distMeas=distanceEuclid, createCent=randCenter):
    # 将数据集初始化为mat矩阵对象
    dataSet = mat(dataSet)
    # 获取数据集的总点数
    m = shape(dataSet)[0]
    # 生成数据集点数的簇矩阵并初始化为0     第一列保存该点被归类的质心索引，第二列保存该点与质心的距离
    clusterAssment = mat(zeros((m, 2)))
    # 初始化k个质心矩阵
    centroids = createCent(dataSet, k)
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False
        for i in range(m):  # 分别取出全部点 并逐一与所有质心进行距离计算 把距离第j个质心最近时，将该点归类为j
            minDist = inf   # 先初始化最小值为无限大
            minIndex = -1
            for j in range(k):      # 第i点逐一与所有质心进行距离计算
                # 算出第i点与第j个质心的距离
                distJI = distMeas(centroids[j, :], dataSet[i, :])
                # 与上次的minDist判断 如果更小则更新质心
                if distJI < minDist:
                    minDist = distJI    # 质心距离
                    minIndex = j        # 质心索引
            # 如果其中第i个点被归类的质心与上次的不一样 则继续下次的计算，否则如果全部点的质心都没有发生变化则认为收敛
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            # 并更新簇矩阵第i个点的记录[质心索引， 与该质心距离的平方]
            clusterAssment[i, :] = minIndex, minDist ** 2
        # 重新初始化质心
        for cent in range(k):   # 遍历k个质心
            ptsInClust = dataSet[nonzero(clusterAssment[:, 0].A == cent)[0]]
            # 被分类到当前第cent个点的所有点的各维度按列求平均值 生成1 * n列的矩阵并更新到质心矩阵中
            centroids[cent, :] = mean(ptsInClust, axis=0)
    # 返回  质心点      簇矩阵[质心索引， 与该质心距离的平方]
    return centroids, clusterAssment


def bisecting_k_means(dataSet, k, distMeas=distanceEuclid):
    dataSet = mat(dataSet)
    m = shape(dataSet)[0]
    # 初始化一个簇
    clusterAssment = mat(zeros((m, 2)))
    # 计算数据集每列的平均值, 生成初始质心
    centroid0 = list(mean(dataSet, axis=0).tolist())[0]
    # 质心集合
    centList = [centroid0]
    # 将数据集所有的点与初始质心进行距离计算
    for j in range(m):
        clusterAssment[j, 1] = distMeas(mat(centroid0), dataSet[j, :]) ** 2
    while len(centList) < k:
        biggestToSplit = 0
        biggestDist = 0
        for i in range(len(centList)):
            # 计算每个簇的总SSE值
            clusterDist = sum(clusterAssment[nonzero(clusterAssment[:, 0] == i)[0], 1])
            print(f'center {i} SSE: {clusterDist}')
            # 得到最大SSE值得簇得索引
            if clusterDist > biggestDist:
                biggestDist = clusterDist
                biggestToSplit = i
        else:
            print('============')
            print(f'center {biggestToSplit} is biggest:', biggestDist)
            print('the SSE summation of clusterAssment is :', sum(clusterAssment[:, 1]))
            print('============')
            # 取出最大SSE值质心X的数据簇
            ptsIncurrCluster = dataSet[nonzero(clusterAssment[:, 0].A == biggestToSplit)[0], :]
            # 将质心X的数据簇再通过k-means一分为二
            centroidMat, splitClustAss = k_means(ptsIncurrCluster, 2, distMeas)
            # 将分裂后的分裂点1 更新为 质心列表长度， 因为簇矩阵第一列是质心索引由0开始递增，所以直接赋值长度正好能+1
            # 所以将分裂后的第二个质心定义为新增的质心
            splitClustAss[nonzero(splitClustAss[:, 0].A == 1)[0], 0] = len(centList)
            # 将分裂后的第一个质心定义为更新为最大SSE值质心X
            splitClustAss[nonzero(splitClustAss[:, 0].A == 0)[0], 0] = biggestToSplit
            # 因为分裂后的第一个质心定义为更新为最大SSE值质心X， 所以放回质心X的位置
            centList[biggestToSplit] = centroidMat[0, :]
            # 因为将分裂后的第二个质心定义为新增的质心， 所以放到质心矩阵的最后
            centList.append(centroidMat[1, :])
            # 更新变化后簇矩阵 属于第i个质心的数据点
            clusterAssment[nonzero(clusterAssment[:, 0].A == biggestToSplit)[0], :] = splitClustAss
    return mat(array(centList)), clusterAssment

测试算法结果：(测试例子中k设置为7)

center 0 SSE: 1465.5800234838164
============
center 0 is biggest: 1465.5800234838164
the SSE summation of clusterAssment is : 1465.5800234838164
============
center 0 SSE: 326.2840752011824
center 1 SSE: 466.63278133614426
============
center 1 is biggest: 466.63278133614426
the SSE summation of clusterAssment is : 792.9168565373268
============
center 0 SSE: 326.2840752011824
center 1 SSE: 50.986226691467344
center 2 SSE: 32.60124286495115
============
center 0 is biggest: 326.2840752011824
the SSE summation of clusterAssment is : 409.87154475760093
============
center 0 SSE: 30.0483491615835
center 1 SSE: 50.986226691467344
center 2 SSE: 32.60124286495115
center 3 SSE: 36.318485958424354
============
center 1 is biggest: 50.986226691467344
the SSE summation of clusterAssment is : 149.95430467642635
============
center 0 SSE: 30.0483491615835
center 1 SSE: 1.8848153078419991
center 2 SSE: 32.60124286495115
center 3 SSE: 36.318485958424354
center 4 SSE: 26.45378625997894
============
center 3 is biggest: 36.318485958424354
the SSE summation of clusterAssment is : 127.30667955277994
============
center 0 SSE: 30.0483491615835
center 1 SSE: 1.8848153078419991
center 2 SSE: 32.60124286495115
center 3 SSE: 15.838658007214358
center 4 SSE: 26.45378625997894
center 5 SSE: 5.980214281567667
============
center 2 is biggest: 32.60124286495115
the SSE summation of clusterAssment is : 112.8070658831376
============

在这里插入图片描述

Yakuho
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
K-Means算法详细介绍(SSE、轮廓分析)
修炼之路
04-29 4万+
在前面我们介绍过了很多的监督学习算法，分类和回归。这篇文章主要介绍无监督算法，通过聚类分析来处理无类标数据。我们事先并不知道数据的正确结果(类标)，通过聚类算法来发现和挖掘数据本身的结构信息，对数据进行分簇(分类)。聚类算法的目标是，簇内相似度高，簇间相似度低。有点像LDA降维算法，类内方差最小，类间方差最大。这篇文章主要包括：1、K-Means算法2、K-Means++3、硬聚类和软聚类4、聚类...
biKmeans 二分Kmeans聚类算法 Python
11-11
Python biKmeans 二分聚类算法
kmeans 算法_kmeans优化算法：二分Kmeans聚类算法
weixin_26938645的博客
01-30 588
算法的理解​ Bi这里是的意思就是Binary，二进制的意思，所以有时候叫这个算法为二进Kmeans算法。为什么我们需要用BiKmeans呢，就是为了解决初始化k个随机的质心点时其中一个或者多个点由于位置太极端而导致迭代的过程中消失的问题。BiKmeans只是Kmeans其中一个优化方案，其实还是有很多优化的方案，这里BiKmeans容易讲解和理解，并且容易用numpy, pandas实现。​ 那...
实现二分k-means算法
qq_44421796的博客
05-06 680
（1) 算法思路： 二分 k-means 算法，此算法不需要标签变量，在 k-means 算法的基础上需要通过四个特征变量将 Iris 进行聚类。目标：通过 Iris 的四个特征值进行聚类，得到每个聚类中的质心，并把聚类结果写入文件中。 （2) 算法原理基础： 在原理上跟 k-means 上差不多相同。 （3) 算法步骤： 把整个数据集看成一个簇，计算质心 将这个簇分成两个簇 选择满足条件的可以分解的簇，选择条件为簇元素的个数和 SSE 大小 使用 k-mean 算法将可分裂的簇分成两个簇 重复（2）（3）
二分K-Means算法
fu_jian_ping的博客
03-30 6720
二分K-Means算法是对K-Means算法的优化，主要优化的地方是在选取质心的时候，二分K-Means算法有效地避免了在初始选取质心时的误差，可以有效地提高算法效率。 测试数据：testSet2.txt 中间用tab分隔 3.275154 2.957587 -3.344465 2.603513 0.355083 -3.376585 1.852435 3...
聚类算法 - K-Means、二分K-Means、K-Means 、K-Means||、Canopy、Mini Batch K-Means算法
qfikh的博客
04-14 2554
K-Means 系列：K-Means，二分K-Means，K-Means++，K-Meansll，canopy算法，MiniBatchK-Means算法。 K-Means系列聚类算法原理：https://www.cnblogs.com/pinard/p/6164214.html 用scikit-learn学习K-Means聚类：https://www.cnblogs.com/pinar...
KMeans和二分KMeans
渣渣
02-06 5523
聚类算法是机器学习中的一类无监督学习方法，用于将无标签的数据进行聚类划分。最简单的也最典型的一类算法就是KMeans算法。此处的K表示划分成K个聚类。利用各个点到质心之间的距离的平方和作为将节点划分到不同类的标准。当然也可以采用其他的距离计算方法，不一定是欧式距离方法。 一、KMeans 此方法一般是在数据分析前期使用，选取适当的K，将数据聚类后，研究不同聚类下数据的特点。 算法原理： （
[机器学习]二分k-means算法详解
图解AI
02-05 1万+
二分k-means算法  二分k-means算法是分层聚类（Hierarchical clustering）的一种，分层聚类是聚类分析中常用的方法。 分层聚类的策略一般有两种： 聚合。这是一种自底向上的方法，每一个观察者初始化本身为一类，然后两两结合 分裂。这是一种自顶向下的方法，所有观察者初始化为一类，然后递归地分裂它们   二分k-means算法是分裂法的一种。1 二分k-means的步骤
机器学习之经典算法（十七）二分Kmeans算法
机器之我心的博客
06-17 3079
（1）      二分Kmeans算法简介：二分KMeans(Bisecting KMeans)是基于KMeans算法之上，KMeans聚类结果易受到初始聚类中心点选择的影响。如果不需要选取初始值呢。二分KMeans克服初始中心点影响，各簇中心点的距离较远，这就完全避免了初始聚类中心会选到一个类别上，一定程度上克服了算法陷入局部最优状态。基本思想：首先将所有点作为一个簇，然后将该簇一分为二，每次选...
机器学习（二）：二分K-means算法（进阶篇）
Auraros的博客
06-22 6025
机器学习（二）：二分K-means算法 在前一节的内容已经介绍了k-means算法的原理和代码实现，如果没有了解过K-means的同学建议先了解机器学习（二）：k-means算法（基础篇） 二分k-means是k-means算法的一种优化，二分k-means算法很好的解决了k-means算法的局部最优的问题。接下来我们来了解一下二分k-means的神奇之处 二分k-means算法 二分k-mean...
python机器学习mooc解决K-means代码无法运行的问题
12-21
‘utf-8’ codec can’t decode byte 0xb1 in position 0: invalid start byte问题原因改进方案改进代码open函数的解释 问题原因 在于’utf-8’编码无法读取信息 所以尝试使用gbk编码 改进方案 改进代码 相比于...
机器学习-K-Means算法的Python实现.zip
最新发布
02-15
机器学习 机器学习_K-Means算法的Python实现
python实现机器学习K-means聚类算法.zip
12-13
python实现机器学习K-means聚类算法.zip对数据进行聚类并绘图。原理 ​ K-means算法属于八大经典的机器学习算法中的其中一种，是一种无监督的聚类算法。其中无监督是机器学习领域中一个专业名词，和有监督是相对的，...
Python机器学习之K-Means聚类实现详解
12-24
本文为大家分享了Python机器学习之K-Means聚类的实现代码，供大家参考，具体内容如下 1.K-Means聚类原理 K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其...
机器学习+图像处理-基于k-means算法的图像分类.rar
07-22
本资源属于机器学习+数字图像处理领域，主要是基于k-means算法的图像分类，包括分类图片集和matlab实现图像分类程序。
【sklearn篇】mixture.GaussianMixture各参数详解以及代码实现
热门推荐
weixin_41861700的博客
04-29 2万+
GaussianMixture 参量 n_components 混合高斯模型个数，默认为 1 covariance_type 协方差类型，{‘full’,‘tied’, ‘diag’, ‘spherical’} full 指每个分量有各自不同的标准协方差矩阵，完全协方差矩阵（元素都不为零） tied 指所有分量有相同的标准协方差矩阵（HMM 会用到） diag 指每个分量有各自不同对角协方...
【机器学习】KNN算法及其用KNN解决字体反爬
weixin_41861700的博客
11-17 3335
KNN算法及其用KNN解决字体反爬关于KNN算法概要简介原理KNN算法Python实现KNN解决字体反爬web-font介绍例子最后 关于KNN算法 概要 K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是如果一个样本在特征空间中的k个...
【机器学习】为何要归一化和归一化，标准化的处理方法
weixin_41861700的博客
11-16 2959
为何要归一化？如何归一化和标准化？为何要归一化·提升模型的收敛速度·提升模型的精度·总结如何归一化和标准化min-max(0-1) 标准化z-score(标准差) 标准化nonlinearity(非线性) 归一化 为何要归一化 ·提升模型的收敛速度 如下图，观察x1，x2的取值范围,x1的范围比x2的范围不是一个对等的量级，得到的曲线会比较尖锐，假如只有这两个特征，对其进行优化时，会得到一个窄长的...
【机器学习】关联分析Apriori算法详解以及代码实现
weixin_41861700的博客
07-02 2188
Apriori算法以及统计学基础什么是关联分析简单的统计学基础Apriori输出频繁集从频繁项集中挖掘关联规则 什么是关联分析 从大规模数据集中寻找物品间的隐含关系被称作关联分析。而寻找物品的不同组合是一项十分耗时的任务，所需的计算代价很高。通过统计学方法，Apriori算法正可以解决这一问题。 物品之间的关系一般可以有两种形式：频繁项集和关联规则。 频繁项集：数据集中经常出现在一块的物品的集合。 关联规则：两种物品之间可能存在很强的关系。 下面借用一个在 《机器学习实战》第11章上的例子: 交
机器学习K-means聚类代码
07-16
当然，我可以为您提供一个简单的机器学习K-means聚类的代码示例。以下是一个使用Python编写的示例： ```python import numpy as np from sklearn.cluster import KMeans # 创建样本数据 X = np.array([[1, 2], [1.5, 1.8], [5, 8], [8, 8], [1, 0.6], [9, 11]]) # 创建K-means模型并进行训练 kmeans = KMeans(n_clusters=2) kmeans.fit(X) # 输出聚类的中心点和标签 centroids = kmeans.cluster_centers_ labels = kmeans.labels_ print("聚类中心点：") print(centroids) print("聚类标签：") print(labels) ``` 在上面的代码中，我们首先导入了必要的库，包括`numpy`和`sklearn.cluster`中的`KMeans`类。然后，我们创建了一个包含样本数据的二维数组`X`。接下来，我们使用`KMeans`类创建了一个K-means模型，并指定聚类数量为2。然后，我们使用`fit`方法对模型进行训练。 最后，我们可以通过`cluster_centers_`属性获取聚类的中心点坐标，通过`labels_`属性获取每个样本的聚类标签，并将它们打印出来。 请注意，这只是一个简单的示例，实际的应用可能需要更多的数据预处理和调参步骤。希望这个示例对您有所帮助！如果您有任何进一步的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值