算法——K-means算法和算法改进

最新推荐文章于 2024-09-14 09:14:02 发布
最新推荐文章于 2024-09-14 09:14:02 发布
阅读量1.9k 收藏 24
点赞数 20
分类专栏： 算法 文章标签： 算法 kmeans 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66890670/article/details/141404892
版权

简介：个人学习分享，如有错误，欢迎批评指正。

一、什么是K-means算法？

K-means算法是一种无监督的聚类算法，用于将一组数据点分为K个簇（cluster）。其核心目标是将数据点划分到K个不同的簇中，使得每个簇内的数据点之间的相似性最大化，而不同簇之间的相似性最小化。

具体而言，K-means算法通过以下方式实现聚类：

  1. 簇中心（质心）：每个簇都有一个中心点，称为质心（centroid）。质心通常是该簇中所有数据点的平均值。
  2. 距离度量：数据点与质心之间的距离通常使用欧几里得距离度量。每个数据点被分配到与其最近的质心所在的簇中。
  3. 目标函数：K-means算法的目标是最小化所有数据点到其所属簇质心的距离平方和，这个值被称为簇内平方和误差（Within-Cluster Sum of Squares, WCSS）。

通过反复更新数据点的分配和质心的位置，K-means算法不断优化簇的划分，最终得到K个簇，使得簇内数据点之间更加相似，簇间差异更大。

在这里插入图片描述

牧师-村民模型

  • 有四个牧师去郊区布道，一开始牧师们随意选了几个布道点，并且把这几个布道点的情况公告给了郊区所有的村民，于是每个村民到离自己家最近的布道点去听课。
    听课之后，大家觉得距离太远了，于是每个牧师统计了一下自己的课上所有的村民的地址，搬到了所有地址的中心地带，并且在海报上更新了自己的布道点的位置。
    牧师每一次移动不可能离所有人都更近，有的人发现A牧师移动以后自己还不如去B牧师处听课更近，于是每个村民又去了离自己最近的布道点……
    就这样，牧师每个礼拜更新自己的位置，村民根据自己的情况选择布道点，最终稳定了下来。
    我们可以看到该牧师的目的是为了让每个村民到其最近中心点的距离和最小。

二、K-近邻算法流程

1.初始化

  • 确定K值：设定簇的数量K，这个值通常需要根据数据的特性或通过经验确定。
  • 随机选择初始质心：从数据集中随机选择K个点作为初始质心，也可以通过如K-means++等方法选择更好的初始质心，以提高聚类效果。

2.分配数据点到最近的质心

  • 计算距离：对于数据集中每个数据点，计算它与K个质心之间的距离。通常使用欧几里得距离计算，即：
    d ( x i , μ j ) = ∑ m = 1 M ( x i m − μ j m ) 2 d(x_i, \mu_j) = \sqrt{\sum_{m=1}^{M}(x_{im} - \mu_{jm})^2} d(xi​,μj​)=m=1∑M​(xim​−μjm​)2 ​

其中， x i x_i xi​ 是数据点， μ j \mu_j μj​ 是第 j j j 个质心， M M M 是数据点的维度。

  • 分配数据点：将每个数据点分配到距离其最近的质心所属的簇。

3.更新质心

  • 计算新的质心：对于每一个簇，计算其所有数据点的平均值，并将该平均值作为新的质心。计算公式为：

μ j = 1 ∣ C j ∣ ∑ x i ∈ C j x i \mu_j = \frac{1}{|C_j|} \sum_{x_i \in C_j} x_i μj​=∣Cj​∣1​xi​∈Cj​∑​xi​

其中， C j C_j Cj​ 是第 j j j 个簇中的所有数据点， μ j \mu_j μj​ 是该簇的质心。

4. 迭代
重复步骤2和3：继续将数据点分配到最近的质心，然后更新质心的位置。这个过程不断迭代，直到质心的位置不再发生显著变化，或者达到预定的迭代次数。
5. 收敛
收敛判断：当质心的位置在两次迭代间变化非常小时，或者所有数据点的分配不再变化，算法停止迭代，认为已经收敛。
6. 输出结果
输出簇和质心：算法最终输出每个数据点的簇标签，以及每个簇的质心位置。

伪代码

获取数据 n 个 m 维的数据
随机生成 K 个 m 维的点
while(t)
    for(int i=0;i < n;i++)
        for(int j=0;j < k;j++)
            计算点 i 到类 j 的距离
    for(int i=0;i < k;i++)
        1. 找出所有属于自己这一类的所有数据点
        2. 把自己的坐标修改为这些数据点的中心点坐标
end

时间复杂度： O ( t k n m ) O(tknm) O(tknm) ，其中，t 为迭代次数，k 为簇的数目，n 为样本点数，m 为样本点维度。
空间复杂度： O ( m ( n + k ) O(m(n+k) O(m(n+k) ，其中，k 为簇的数目，m 为样本点维度，n 为样本点数。

三、K-means算法的损失函数和收敛问题

1. 损失函数

K-means算法的目标是将数据点划分为K个簇，使得每个簇内的数据点到该簇中心（质心）的距离之和最小。这个优化目标可以通过一个损失函数来表示，该损失函数通常称为“簇内平方和误差”（Within-Cluster Sum of Squares, WCSS），也可以称为“惯性”（Inertia）。

损失函数的定义

对于给定的K个簇 { C 1 , C 2 , … , C K } \{C_1, C_2, \ldots, C_K\} {C1​,C2​,…,CK​}，每个簇的质心为 μ k \mu_k μk​，K-means算法的损失函数 J J J 定义为：

J = ∑ k = 1 K ∑ x i ∈ C k ∥ x i − μ k ∥ 2 J = \sum_{k=1}^{K} \sum_{x_i \in C_k} \|x_i - \mu_k\|^2 J=k=1∑K​xi​∈Ck​∑​∥xi​−μk​∥2

其中：

  • x i x_i xi​ 是数据集中的第 i i i 个数据点。
  • μ k \mu_k μk​ 是簇 C k C_k Ck​ 的质心，等于该簇中所有数据点的均值。
  • ∥ x i − μ k ∥ \|x_i - \mu_k\| ∥xi​−μk​∥ 是数据点 x i x_i xi​ 到簇中心 μ k \mu_k μk​ 的欧几里得距离。

损失函数的意义
这个损失函数衡量了数据点到其所属簇中心的距离的平方和，目标是最小化这个值，使得每个簇内的点尽可能地接近其簇中心。损失函数的最小化意味着簇内数据点的紧密性最大化，从而实现有效的聚类。

2. 收敛问题

K-means算法通过迭代来最小化损失函数，收敛性是指算法最终会停止在一个局部最优点，即簇中心和数据点的分配不再发生显著变化。K-means算法的收敛性是保证其能在有限次迭代后终止的关键。

收敛的过程
K-means算法的迭代过程可以总结为以下步骤：

  1. 初始化：随机选择K个点作为初始质心。
  2. 分配数据点：将每个数据点分配到最近的质心所属的簇。
  3. 更新质心：计算每个簇的新的质心（即所有簇内数据点的均值）。
  4. 检查收敛：如果质心的位置不再发生变化，或者变化小于设定的阈值，则认为算法收敛。

K-means算法的收敛性主要体现在以下几个方面：

  1. 有限次迭代收敛：由于每次迭代都会减少或保持损失函数的值，且可能的簇分配组合有限，K-means算法在有限次迭代后必定会收敛。
  2. 局部最优解：由于K-means是基于贪心策略的算法，它可能会收敛到局部最优解，而非全局最优解。最终的簇分配可能依赖于初始质心的选择。
  3. 初始值敏感性：K-means对初始质心的位置非常敏感。不同的初始化可能导致算法收敛到不同的局部最优点。因此，常常使用如K-means++的方法来改善初始质心选择，增加算法收敛到全局最优解的可能性。
  4. 停机条件：K-means通常设置两种停机条件：质心的变化小于某个阈值或达到最大迭代次数。两者之一满足时，算法停止。

数学解释收敛性
从数学角度看，K-means算法每次迭代都是在最小化一个分段线性但非连续的损失函数。由于每次迭代都会减少或保持损失函数的值，并且损失函数的取值是有限的，因此K-means算法在有限次迭代后必定会收敛。每次迭代后，新的簇分配和质心计算结果会维持或减小损失函数的值，直到算法停止变化，达成局部收敛。

四、k-means算法的调优与改进

K-means算法虽然简单有效，但也存在一些局限性。为了提高其性能，研究者和实践者提出了多种调优与改进方法。以下是常见的K-means算法的调优与改进策略：

1. 初始质心选择的改进

1.1.K-means++

K-means++是对传统K-means算法的一种改进，旨在解决K-means对初始质心选择敏感的问题。传统的K-means算法随机选择初始质心，这可能导致糟糕的聚类效果，尤其是当初始质心选择不佳时，可能会陷入局部最优解。K-means++通过更合理的初始质心选择策略，显著提高了K-means算法的收敛速度和聚类效果。

K-means++的核心思想是通过一种概率方法选择初始质心，使得质心能够更好地覆盖数据分布。它通过以下步骤来选择初始质心：

  1. 随机选择第一个质心：

    • 从数据集中随机选择一个点作为第一个质心。

  2. 为后续质心选择分配概率：

    • 对于数据集中每个剩余的点，计算其到最近已选择质心的距离平方，记为 D ( x ) 2 D(x)^2 D(x)2。
    • 通过距离平方 D ( x ) 2 D(x)^2 D(x)2 的值来决定点被选为下一个质心的概率。距离较远的点（与已选择的质心）有更大的概率被选为下一个质心。

  3. 选择下一个质心：

    • 根据步骤2计算出的概率分布，随机选择一个点作为下一个质心。

  4. 重复：

    • 重复步骤2和3，直到选出 K K K 个质心为止。

  5. 执行标准K-means算法：

    • 使用K-means++选出的初始质心，执行标准的K-means算法，进行数据点的分配和质心的更新，直到算法收敛。

K-means++的Python代码实现

  1. 调包实现（使用scikit-learn库）
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 生成随机数据
X = np.random.rand(100, 2)

# 使用K-means++初始化的K-means模型
kmeans = KMeans(n_clusters=3, init='k-means++', random_state=0)

# 进行聚类
kmeans.fit(X)

# 获取聚类结果
labels = kmeans.labels_
centers = kmeans.cluster_centers_

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x')
plt.title('K-means Clustering with K-means++ Initialization')
plt.show()
  1. 不调包实现
    以下是K-means++算法的手动实现版本：
import numpy as np
import matplotlib.pyplot as plt

def initialize_centroids_kmeans_plus_plus(X, k):
    # 随机选择第一个质心
    centroids = [X[np.random.choice(X.shape[0])]]
    
    for _ in range(1, k):
        # 计算每个点到最近质心的距离平方
        distances = np.array([min(np.sum((x - c) ** 2) for c in centroids) for x in X])
        # 选择概率与距离平方成正比的点作为下一个质心
        probabilities = distances / distances.sum()
        cumulative_probabilities = probabilities.cumsum()
        r = np.random.rand()
        for i, p in enumerate(cumulative_probabilities):
            if r < p:
                centroids.append(X[i])
                break
    
    return np.array(centroids)

def assign_clusters(X, centroids):
    distances = np.sqrt(((X - centroids[:, np.newaxis]) ** 2).sum(axis=2))
    return np.argmin(distances, axis=0)

def update_centroids(X, labels, k):
    return np.array([X[labels == i].mean(axis=0) for i in range(k)])

def kmeans(X, k, max_iters=100):
    centroids = initialize_centroids_kmeans_plus_plus(X, k)
    for _ in range(max_iters):
        labels = assign_clusters(X, centroids)
        new_centroids = update_centroids(X, labels, k)
        if np.all(centroids == new_centroids):
            break
        centroids = new_centroids
    return labels, centroids

# 生成随机数据
X = np.random.rand(100, 2)

# 调用自定义的k-means++算法
k = 3
labels, centroids = kmeans(X, k)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', marker='x')
plt.title('K-means Clustering with K-means++ Initialization (Without Using Libraries)')
plt.show()

K-means++的优势

  • 更好的初始质心：通过使用距离平方的概率分布，K-means++能够选择更好的初始质心，这些质心更有可能位于数据的密集区域，从而避免选择过于接近或不合理的质心。
  • 提高收敛速度：由于初始质心选择得更好，K-means++通常在更少的迭代中就能收敛，从而减少计算时间。
  • 提高聚类质量：K-means++通常能够找到更接近全局最优解的聚类结果，从而提高了聚类的质量。

2.簇的数量K的确定

2.1. 肘部法则（Elbow Method）

核心思想
肘部法则是一种直观的、常用的确定K值的方法。它通过观察不同K值下簇内平方和误差（Within-Cluster Sum of Squares, WCSS）的变化趋势，选择一个使得WCSS明显减少的K值。WCSS表示每个簇中数据点到其质心的距离平方和之和，WCSS越小，聚类效果越好。

操作步骤

  1. 对于不同的K值，计算对应的WCSS。
  2. 将K值与WCSS绘制成曲线图。
  3. 观察曲线，选择K值对应的“肘部”位置，即曲线开始趋于平缓的点作为合适的K值。

调包实现

import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的WCSS
wcss = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=0).fit(X)
    wcss.append(kmeans.inertia_)

# 绘制肘部法则图
plt.plot(range(1, 11), wcss, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('WCSS')
plt.title('Elbow Method for Optimal K')
plt.show()

不调包实现

import numpy as np
import matplotlib.pyplot as plt

def calculate_wcss(X, centroids, labels, k):
    wcss = 0
    for i in range(k):
        cluster_points = X[labels == i]
        centroid = centroids[i]
        wcss += np.sum((cluster_points - centroid) ** 2)
    return wcss

def initialize_centroids(X, k):
    np.random.seed(0)
    indices = np.random.choice(X.shape[0], k, replace=False)
    return X[indices]

def assign_clusters(X, centroids):
    distances = np.sqrt(((X - centroids[:, np.newaxis]) ** 2).sum(axis=2))
    return np.argmin(distances, axis=0)

def update_centroids(X, labels, k):
    return np.array([X[labels == i].mean(axis=0) for i in range(k)])

def kmeans_custom(X, k, max_iters=100):
    centroids = initialize_centroids(X, k)
    for _ in range(max_iters):
        labels = assign_clusters(X, centroids)
        new_centroids = update_centroids(X, labels, k)
        if np.all(centroids == new_centroids):
            break
        centroids = new_centroids
    return labels, centroids

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的WCSS
wcss = []
for k in range(1, 11):
    labels, centroids = kmeans_custom(X, k)
    wcss.append(calculate_wcss(X, centroids, labels, k))

# 绘制肘部法则图
plt.plot(range(1, 11), wcss, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('WCSS')
plt.title('Elbow Method for Optimal K (Without Using Libraries)')
plt.show()

优点

  • 简单直观，容易理解和操作。
  • 适用于大多数数据集。

缺点

  • 有时“肘部”不明显，导致K值难以确定。
  • 在某些情况下，该方法可能会对数据的噪声敏感。
2.2. 轮廓系数（Silhouette Coefficient）

核心思想
轮廓系数是一种衡量聚类效果的指标，考虑了簇内紧密度（即数据点与同簇其他点的距离）和簇间分离度（即数据点与最近的其他簇的距离）。轮廓系数的取值范围是[-1, 1]，值越大，表示聚类效果越好。

操作步骤

  1. 对于每个数据点，计算它的轮廓系数，公式为：

    s ( i ) = b ( i ) − a ( i ) max ⁡ ( a ( i ) , b ( i ) ) s(i) = \frac{b(i) - a(i)}{\max(a(i), b(i))} s(i)=max(a(i),b(i))b(i)−a(i)​

    其中：

    • a ( i ) a(i) a(i) 是数据点 i i i 到同簇内其他数据点的平均距离。
    • b ( i ) b(i) b(i) 是数据点 i i i 到最近的其他簇的平均距离。

  2. 计算所有数据点的平均轮廓系数作为整体聚类效果的指标。

  3. 选择轮廓系数最大的K值作为最佳K值。

调包实现

from sklearn.metrics import silhouette_score

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的轮廓系数
silhouette_scores = []
for k in range(2, 11):
    kmeans = KMeans(n_clusters=k, random_state=0).fit(X)
    score = silhouette_score(X, kmeans.labels_)
    silhouette_scores.append(score)

# 绘制轮廓系数图
plt.plot(range(2, 11), silhouette_scores, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Method for Optimal K')
plt.show()

不调包实现

import numpy as np

def calculate_silhouette_score(X, labels, k):
    silhouette_scores = []
    for i, point in enumerate(X):
        same_cluster = X[labels == labels[i]]
        other_cluster = X[labels != labels[i]]
        
        a = np.mean([np.linalg.norm(point - other) for other in same_cluster if not np.array_equal(point, other)])
        b = np.min([np.mean([np.linalg.norm(point - other) for other in X[labels == label]]) for label in range(k) if label != labels[i]])
        
        silhouette_score = (b - a) / max(a, b)
        silhouette_scores.append(silhouette_score)
    
    return np.mean(silhouette_scores)

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的轮廓系数
silhouette_scores = []
for k in range(2, 11):
    labels, centroids = kmeans_custom(X, k)
    score = calculate_silhouette_score(X, labels, k)
    silhouette_scores.append(score)

# 绘制轮廓系数图
plt.plot(range(2, 11), silhouette_scores, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Method for Optimal K (Without Using Libraries)')
plt.show()

优点

  • 提供了聚类效果的直接量化评估。
  • 对于不同形状的簇也能有效处理。

缺点

  • 计算复杂度较高，尤其是在处理大规模数据时。
  • 对数据的噪声和异常值敏感。
2.3. 信息准则（如AIC/BIC）

核心思想
信息准则（如AIC，Akaike Information Criterion；BIC，Bayesian Information Criterion）是一种基于模型复杂度和拟合优度的评估方法。信息准则考虑了模型的拟合优度（通常使用对数似然估计）和模型的复杂度（自由参数的数量）。AIC和BIC的值越小，表示模型平衡了复杂度和拟合优度，选择的K值越合适。

操作步骤
计算不同K值下的AIC或BIC值。
选择使得AIC或BIC值最小的K值。

调包实现

from sklearn.mixture import GaussianMixture

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的BIC
bic_scores = []
for k in range(1, 11):
    gmm = GaussianMixture(n_components=k, random_state=0).fit(X)
    bic_scores.append(gmm.bic(X))

# 绘制BIC图
plt.plot(range(1, 11), bic_scores, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('BIC')
plt.title('BIC for Optimal K')
plt.show()

不调包实现

import numpy as np

def calculate_bic(X, labels, centroids, k):
    n, d = X.shape
    m = k * d
    wcss = calculate_wcss(X, centroids, labels, k)
    bic = n * np.log(wcss / n) + m * np.log(n)
    return bic

# 生成随机数据
X = np.random.rand(100, 2)

# 计算不同K值的BIC
bic_scores = []
for k in range(1, 11):
    labels, centroids = kmeans_custom(X, k)
    bic = calculate_bic(X, labels, centroids, k)
    bic_scores.append(bic)

# 绘制BIC图
plt.plot(range(1, 11), bic_scores, 'bx-')
plt.xlabel('Number of clusters (K)')
plt.ylabel('BIC')
plt.title('BIC for Optimal K (Without Using Libraries)')
plt.show()

优点

  • 同时考虑了模型的拟合优度和复杂度，具有理论上的优越性。
  • 对复杂数据和大数据集适用性强。

缺点

  • 计算过程相对复杂。
  • 依赖于数据的具体分布假设，对于一些分布不明确的数据集，结果可能不准确。

3.算法的加速与优化

  1. Mini-Batch K-means：在大型数据集上，标准K-means可能需要较长的计算时间。Mini-Batch K-means通过使用小批量的数据点来更新质心，显著减少了计算时间，同时保持了较好的聚类效果。

  2. 并行化与分布式计算：在多核处理器或分布式系统上，并行化K-means算法可以加速计算，特别适用于大数据场景。Hadoop、Spark等框架提供了K-means的并行实现。

  3. 球状簇的检测：标准K-means假设簇是球形的，因此在处理复杂形状的簇时效果较差。可以结合层次聚类或DBSCAN等其他算法，预处理数据或分割复杂簇。

4.对异常值的处理

4.1. 均值漂移聚类（Mean Shift Clustering）

均值漂移聚类（Mean Shift Clustering）是一种非参数化的聚类方法，它通过检测数据的密度峰值来确定簇的中心。与K-means不同，均值漂移聚类不需要预设簇的数量K，而是通过算法自动找到簇的数量和簇中心。
核心思想
均值漂移聚类的核心思想是通过滑动窗口（也称为核函数）来不断更新数据点的质心，质心会沿着数据密度的梯度移动，最终收敛到数据密度最大的区域。每个数据点最终会聚集到一个密度峰值，密度峰值所在的位置就是簇的中心。

主要步骤

  1. 初始化：将所有数据点视为可能的簇中心。
  2. 计算窗口内的数据点：为每个点设置一个半径（称为带宽，bandwidth），并找到该半径范围内的所有数据点。
  3. 计算新的质心：通过这些邻近的数据点的均值来更新当前点的质心位置。质心位置向数据密集的区域移动。
  4. 重复移动质心：反复计算质心，直到所有质心收敛（即质心位置的变化小于设定的阈值）。
  5. 聚类：当所有质心收敛后，最终的质心就代表数据中的簇。那些收敛到相同质心的点被归为同一个簇。

带宽（Bandwidth）的作用
带宽参数控制滑动窗口的大小，是均值漂移聚类中的关键参数。它决定了算法搜索数据密集区域的半径。如果带宽过小，算法会产生过多的簇；如果带宽过大，则会产生较少的簇。带宽可以通过交叉验证或手动调整来选择。

公式

假设我们有一个数据点 x i x_i xi​，带宽为 h h h，则在该点周围的邻居点集合 N ( x i ) N(x_i) N(xi​) 的质心更新公式为：

m ( x i ) = ∑ x j ∈ N ( x i ) K ( x j − x i h ) x j ∑ x j ∈ N ( x i ) K ( x j − x i h ) m(x_i) = \frac{\sum_{x_j \in N(x_i)} K\left(\frac{x_j - x_i}{h}\right) x_j}{\sum_{x_j \in N(x_i)} K\left(\frac{x_j - x_i}{h}\right)} m(xi​)=∑xj​∈N(xi​)​K(hxj​−xi​​)∑xj​∈N(xi​)​K(hxj​−xi​​)xj​​

其中：

  • K ( ⋅ ) K(\cdot) K(⋅) 是核函数，通常使用高斯核函数：

    K ( x ) = e − x 2 2 K(x) = e^{-\frac{x^2}{2}} K(x)=e−2x2​

  • x j x_j xj​ 是数据集中属于点 x i x_i xi​ 的邻居点，带宽 h h h 控制着核函数的范围。

优点

  1. 不需要预设簇的数量：与K-means不同，均值漂移聚类不需要预设簇数，簇的数量是由算法自动确定的。
  2. 能够处理非球形簇：均值漂移聚类能够处理不规则形状的簇，不像K-means只能处理球形簇。
  3. 对异常值的鲁棒性强：因为质心会被数据密集区域吸引，异常值对均值漂移聚类的影响较小。

缺点

  1. 计算复杂度高：由于需要对每个点反复进行质心更新，均值漂移聚类的计算复杂度较高，特别是在大数据集上，计算成本会很大。
  2. 对带宽敏感：带宽的选择对结果影响较大，带宽过大或过小都会导致聚类效果不佳。如何选取合适的带宽是一个挑战。
  3. 可能产生空簇：如果某些区域的密度较低，均值漂移可能在这些区域不产生簇。

Python代码实现
调包实现

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt

# 生成随机数据
X = np.random.rand(100, 2)

# 均值漂移聚类
ms = MeanShift(bandwidth=0.1)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(cluster_centers[:, 0], cluster_centers[:, 1], c='red', marker='x')
plt.title('Mean Shift Clustering (Using scikit-learn)')
plt.show()

不调包实现

import numpy as np
import matplotlib.pyplot as plt

def gaussian_kernel(distance, bandwidth):
    return np.exp(-0.5 * (distance / bandwidth) ** 2)

def mean_shift(X, bandwidth=0.1, max_iter=300):
    # 初始化
    points = X.copy()
    for _ in range(max_iter):
        for i in range(points.shape[0]):
            # 计算每个点到其他所有点的距离
            distances = np.linalg.norm(points - points[i], axis=1)
            # 应用高斯核函数
            weights = gaussian_kernel(distances, bandwidth)
            # 更新质心位置
            points[i] = np.sum(points.T * weights, axis=1) / np.sum(weights)
    
    # 将点聚合为簇
    cluster_centers = []
    labels = np.zeros(points.shape[0])
    for i, point in enumerate(points):
        # 如果点接近已有的簇中心，则将其归入该簇
        for center in cluster_centers:
            if np.linalg.norm(point - center) < bandwidth:
                labels[i] = cluster_centers.index(center)
                break
        else:
            cluster_centers.append(point)
            labels[i] = len(cluster_centers) - 1
    
    return np.array(cluster_centers), labels

# 生成随机数据
X = np.random.rand(100, 2)

# 调用自定义的均值漂移聚类算法
cluster_centers, labels = mean_shift(X, bandwidth=0.1)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(cluster_centers[:, 0], cluster_centers[:, 1], c='red', marker='x')
plt.title('Mean Shift Clustering (Without Using Libraries)')
plt.show()
4.2. 内存占用优化

对于高维数据，可以通过主成分分析（PCA）或其他降维技术来减少维度，从而减小内存占用和计算复杂度。

5.混合模型

5.1. Soft K-means

Soft K-means（也称为Fuzzy K-means或模糊K-means）是K-means算法的一种变体，它通过引入模糊聚类的概念，使得每个数据点可以部分地属于多个簇，而不是像传统K-means那样硬性地分配到一个簇中。Soft K-means在处理数据点处于多个簇的边界时尤为有效，能够更好地捕捉数据的模糊性和不确定性。

核心思想
Soft K-means的核心思想是通过模糊隶属度函数（membership function）来表示每个数据点属于不同簇的概率或隶属度。这个隶属度的值介于0和1之间，表示数据点与每个簇中心的关联程度。最终的簇中心更新会考虑所有数据点的隶属度，而不是仅仅考虑距离最近的点。

主要步骤

  1. 初始化簇中心：与 K-means 类似，首先随机初始化 K 个簇中心。

  2. 计算隶属度：对于每个数据点，计算它属于每个簇的隶属度。隶属度通常与数据点到各簇中心的距离成反比，距离越近，隶属度越高。

    隶属度 u i j u_{ij} uij​ 的计算公式为：

    u i j = exp ⁡ ( − β ⋅ ∥ x i − μ j ∥ 2 ) ∑ k = 1 K exp ⁡ ( − β ⋅ ∥ x i − μ k ∥ 2 ) u_{ij} = \frac{\exp\left(-\beta \cdot \|x_i - \mu_j\|^2\right)}{\sum_{k=1}^{K} \exp\left(-\beta \cdot \|x_i - \mu_k\|^2\right)} uij​=∑k=1K​exp(−β⋅∥xi​−μk​∥2)exp(−β⋅∥xi​−μj​∥2)​

    其中：

    • u i j u_{ij} uij​ 表示数据点 x i x_i xi​ 对簇 j j j 的隶属度。
    • μ j \mu_j μj​ 是簇 j j j 的质心。
    • β \beta β 是控制隶属度分配的参数（通常与逆温度成比例）。

  3. 更新簇中心：根据所有数据点的隶属度加权更新每个簇的质心。更新公式为：

    μ j = ∑ i = 1 n u i j ⋅ x i ∑ i = 1 n u i j \mu_j = \frac{\sum_{i=1}^{n} u_{ij} \cdot x_i}{\sum_{i=1}^{n} u_{ij}} μj​=∑i=1n​uij​∑i=1n​uij​⋅xi​​

    其中， n n n 是数据点的总数。

  4. 迭代：重复计算隶属度和更新簇中心的步骤，直到簇中心的变化小于预设的阈值或达到最大迭代次数。

优点

  1. 处理模糊边界：Soft K-means能够处理数据点同时属于多个簇的情况，更适合那些簇之间没有明显边界的数据集。
  2. 更灵活的簇划分：通过隶属度，Soft K-means能够更灵活地划分数据，尤其是在处理复杂的、多模态的数据分布时表现更好。
  3. 降低局部最优的风险：由于考虑了所有簇的隶属度，Soft K-means在一定程度上降低了陷入局部最优解的风险。

缺点

  1. 计算复杂度高：由于需要计算每个数据点对每个簇的隶属度，Soft K-means的计算复杂度高于传统K-means。
  2. 对参数敏感：Soft K-means对隶属度函数中的参数（如 β ）较为敏感，参数选择不当可能影响聚类效果。
  3. 难以解释：由于每个点可以部分地属于多个簇，结果的解释性比硬性聚类更复杂。

Soft K-means的Python代码实现

import numpy as np
import matplotlib.pyplot as plt

def soft_kmeans(X, k, beta=1.0, max_iters=100):
    # 初始化簇中心
    n, d = X.shape
    centers = X[np.random.choice(n, k, replace=False)]
    
    for _ in range(max_iters):
        # 计算隶属度
        distances = np.array([[np.linalg.norm(x - center) for center in centers] for x in X])
        membership = np.exp(-beta * distances)
        membership = membership / membership.sum(axis=1, keepdims=True)
        
        # 更新簇中心
        new_centers = np.dot(membership.T, X) / membership.sum(axis=0)[:, np.newaxis]
        
        # 检查收敛性
        if np.allclose(centers, new_centers):
            break
        centers = new_centers
    
    return centers, membership

# 生成随机数据
X = np.random.rand(100, 2)

# 调用自定义的Soft K-means算法
k = 3
centers, membership = soft_kmeans(X, k, beta=1.0)

# 根据最大隶属度分配标签
labels = np.argmax(membership, axis=1)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x')
plt.title('Soft K-means Clustering (Without Using Libraries)')
plt.show()
5.2. 高斯混合模型（GMM）

高斯混合模型（Gaussian Mixture Model，简称GMM）是一种概率模型，用于表示具有多个高斯分布的数据集。与K-means算法不同，高斯混合模型通过假设数据来自于多个高斯分布（即簇），并将数据点的生成过程视为从这些高斯分布中采样，从而实现对数据的聚类。

核心思想
高斯混合模型认为数据集中的每个数据点都可以由多个高斯分布生成，并且每个数据点属于某个高斯分布的概率是未知的。通过最大化数据点在这些高斯分布下的概率，GMM可以找到最符合数据分布的参数，即每个高斯分布的均值、协方差和混合系数。

主要组成部分

  1. 混合系数：描述每个高斯分布在总体中的权重，即每个高斯分布生成数据点的概率。所有混合系数之和为1。

    ∑ k = 1 K π k = 1 \sum_{k=1}^{K} \pi_k = 1 k=1∑K​πk​=1

    其中， π k \pi_k πk​ 是第 k k k 个高斯分布的混合系数， K K K 是高斯分布的数量。

  2. 高斯分布：每个簇由一个高斯分布表示，具有自己的均值向量 μ k \mu_k μk​ 和协方差矩阵 Σ k \Sigma_k Σk​。数据点的生成假设遵循这些高斯分布。

    多维高斯分布的概率密度函数为：

    N ( x ∣ μ k , Σ k ) = 1 ( 2 π ) d / 2 ∣ Σ k ∣ 1 / 2 exp ⁡ ( − 1 2 ( x − μ k ) ⊤ Σ k − 1 ( x − μ k ) ) N(x|\mu_k, \Sigma_k) = \frac{1}{(2\pi)^{d/2} |\Sigma_k|^{1/2}} \exp \left( -\frac{1}{2} (x - \mu_k)^\top \Sigma_k^{-1} (x - \mu_k) \right) N(x∣μk​,Σk​)=(2π)d/2∣Σk​∣1/21​exp(−21​(x−μk​)⊤Σk−1​(x−μk​))

    其中， d d d 是数据的维度， ∣ Σ k ∣ |\Sigma_k| ∣Σk​∣ 是协方差矩阵的行列式。

  3. 潜在变量：表示每个数据点属于某个高斯分布的概率，这些概率值用于估计模型参数。

模型估计与期望最大化算法（EM算法）

GMM的参数估计通常使用期望最大化算法（EM算法）进行。EM算法通过迭代计算来找到最可能的参数，使得给定模型下的概率最大化。

  1. 初始化：初始化每个高斯分布的均值、协方差矩阵和混合系数，或者通过K-means算法进行初始聚类。

  2. E步（期望步）：计算每个数据点属于各个高斯分布的后验概率，即责任度 γ i k \gamma_{ik} γik​：

    γ i k = π k N ( x i ∣ μ k , Σ k ) ∑ j = 1 K π j N ( x i ∣ μ j , Σ j ) \gamma_{ik} = \frac{\pi_k N(x_i|\mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j N(x_i|\mu_j, \Sigma_j)} γik​=∑j=1K​πj​N(xi​∣μj​,Σj​)πk​N(xi​∣μk​,Σk​)​

    这里， γ i k \gamma_{ik} γik​ 表示数据点 x i x_i xi​ 属于簇 k k k 的概率。

  3. M步（最大化步）：利用E步计算得到的责任度更新模型参数（均值 μ k \mu_k μk​，协方差 Σ k \Sigma_k Σk​，混合系数 π k \pi_k πk​）：

    • 更新均值：

      μ k = ∑ i = 1 n γ i k x i ∑ i = 1 n γ i k \mu_k = \frac{\sum_{i=1}^{n} \gamma_{ik} x_i}{\sum_{i=1}^{n} \gamma_{ik}} μk​=∑i=1n​γik​∑i=1n​γik​xi​​

    • 更新协方差矩阵：

      Σ k = ∑ i = 1 n γ i k ( x i − μ k ) ( x i − μ k ) ⊤ ∑ i = 1 n γ i k \Sigma_k = \frac{\sum_{i=1}^{n} \gamma_{ik} (x_i - \mu_k)(x_i - \mu_k)^\top}{\sum_{i=1}^{n} \gamma_{ik}} Σk​=∑i=1n​γik​∑i=1n​γik​(xi​−μk​)(xi​−μk​)⊤​

    • 更新混合系数：

      π k = 1 n ∑ i = 1 n γ i k \pi_k = \frac{1}{n} \sum_{i=1}^{n} \gamma_{ik} πk​=n1​i=1∑n​γik​

  4. 迭代：重复E步和M步，直到模型参数的变化小于设定的阈值或达到最大迭代次数。

优点

  1. 柔性更强：GMM可以捕捉数据的复杂分布，适用于具有不同形状和大小的簇。
  2. 概率模型：GMM是基于概率的模型，可以提供每个数据点属于某个簇的概率，这对于后续的决策和分析非常有用。
  3. 处理多模态数据：GMM适用于具有多模态分布的数据集，能够有效地分离不同的分布模式。

缺点

  1. 计算复杂度较高：由于涉及多次迭代和复杂的矩阵运算，GMM的计算复杂度较高。
  2. 对初始值敏感：GMM对初始参数值较为敏感，可能会陷入局部最优解。
  3. 假设高斯分布：GMM假设数据服从高斯分布，因此在非高斯分布的数据上表现可能不佳。

Python代码实现
调包实现

import numpy as np
from sklearn.mixture import GaussianMixture
import matplotlib.pyplot as plt

# 生成随机数据
X = np.random.rand(100, 2)

# 定义并训练GMM模型
gmm = GaussianMixture(n_components=3, random_state=0)
gmm.fit(X)

# 获取聚类结果
labels = gmm.predict(X)
centers = gmm.means_

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x')
plt.title('Gaussian Mixture Model Clustering')
plt.show()

不调包实现
以下是一个简化的GMM手动实现，使用EM算法进行参数估计：

import numpy as np

def gaussian_pdf(x, mean, cov):
    d = len(x)
    cov_inv = np.linalg.inv(cov)
    norm_const = 1.0 / (np.sqrt((2 * np.pi) ** d * np.linalg.det(cov)))
    x_mu = np.matrix(x - mean)
    result = np.exp(-0.5 * (x_mu * cov_inv * x_mu.T))
    return norm_const * result

def gmm_em(X, k, max_iters=100):
    n, d = X.shape
    
    # 初始化参数
    np.random.seed(0)
    means = X[np.random.choice(n, k, replace=False)]
    covariances = np.array([np.eye(d)] * k)
    weights = np.ones(k) / k
    responsibilities = np.zeros((n, k))
    
    for _ in range(max_iters):
        # E步：计算责任度
        for i in range(n):
            for j in range(k):
                responsibilities[i, j] = weights[j] * gaussian_pdf(X[i], means[j], covariances[j])
            responsibilities[i] /= np.sum(responsibilities[i])
        
        # M步：更新参数
        Nk = np.sum(responsibilities, axis=0)
        for j in range(k):
            means[j] = np.sum(responsibilities[:, j][:, np.newaxis] * X, axis=0) / Nk[j]
            diff = X - means[j]
            covariances[j] = np.dot((responsibilities[:, j][:, np.newaxis] * diff).T, diff) / Nk[j]
            weights[j] = Nk[j] / n
    
    return means, covariances, weights

# 生成随机数据
X = np.random.rand(100, 2)

# 调用自定义的GMM算法
k = 3
means, covariances, weights = gmm_em(X, k)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=np.argmax(responsibilities, axis=1), cmap='viridis')
plt.scatter(means[:, 0], means[:, 1], c='red', marker='x')
plt.title('Gaussian Mixture Model Clustering (Without Using Libraries)')
plt.show()

6.距离度量的改进

  • 使用其他距离度量：在某些情况下，欧几里得距离并不是最好的选择。可以根据数据特点选择其他的距离度量，如曼哈顿距离、余弦相似度、马氏距离等，以改善聚类效果。

7.自动化调参

  • 自动化调参工具：可以使用诸如GridSearchCV或随机搜索（Random Search）等方法，自动寻找最优的K值和其他超参数组合，提高模型性能。

这些改进和调优方法能够有效地提升K-means算法的性能，使其更好地适应复杂的数据场景。然而，在选择具体的改进策略时，需要根据实际问题的特点进行综合考虑，以达到最优的聚类效果。

五、python代码实现

1. 调包实现（使用scikit-learn库）

import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 生成随机数据
X = np.random.rand(100, 2)

# 定义k-means模型，设置簇的数量为3
kmeans = KMeans(n_clusters=3, random_state=0)

# 进行聚类
kmeans.fit(X)

# 获取聚类结果
labels = kmeans.labels_
centers = kmeans.cluster_centers_

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x')
plt.title('K-means Clustering (Using scikit-learn)')
plt.show()

2. 不调包实现（手动编写K-means算法）

import numpy as np
import matplotlib.pyplot as plt

def initialize_centroids(X, k):
    # 从数据集中随机选择k个点作为初始质心
    np.random.seed(0)
    indices = np.random.choice(X.shape[0], k, replace=False)
    return X[indices]

def assign_clusters(X, centroids):
    # 分配每个点到最近的质心
    distances = np.sqrt(((X - centroids[:, np.newaxis])**2).sum(axis=2))
    return np.argmin(distances, axis=0)

def update_centroids(X, labels, k):
    # 更新质心
    return np.array([X[labels == i].mean(axis=0) for i in range(k)])

def kmeans(X, k, max_iters=100):
    centroids = initialize_centroids(X, k)
    for _ in range(max_iters):
        labels = assign_clusters(X, centroids)
        new_centroids = update_centroids(X, labels, k)
        # 检查质心是否收敛
        if np.all(centroids == new_centroids):
            break
        centroids = new_centroids
    return labels, centroids

# 生成随机数据
X = np.random.rand(100, 2)

# 调用自定义的k-means算法
k = 3
labels, centroids = kmeans(X, k)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', marker='x')
plt.title('K-means Clustering (Without Using Libraries)')
plt.show()

六、总结

优点

  1. 简单易懂：K-means算法相对简单，容易理解和实现。它基于直观的概念，即通过反复调整簇中心和数据点的分配来进行聚类。
  2. 计算效率高：对于大规模数据集，K-means的计算速度较快，特别是在K值较小的情况下。其时间复杂度为 O ( n ∗ k ∗ d ∗ t ) O(n * k * d *t) O(n∗k∗d∗t)，其中n为数据点数量，k为簇数，d为数据维度，t为迭代次数。
  3. 适用于球形簇：K-means在处理形状相对规则、大小相近的球形簇时效果较好。因为算法假设簇是由相似分布的数据点组成的。
  4. 易于解释和应用：由于K-means产生的每个簇都有明确的中心点，且数据点归属于具体的簇，因此其结果容易解释，适用于许多实际应用场景，如客户分群、图像分割等。

缺点

  1. 需要预设K值：K-means算法要求事先设定簇的数量K，这在某些情况下并不容易确定。选择不当的K值可能会导致聚类效果不佳。

  2. 对初始值敏感：K-means算法对初始质心的选择非常敏感，不同的初始质心可能导致不同的聚类结果。初始质心选择不当可能导致算法陷入局部最优解，而非全局最优解。

  3. 仅适用于球形簇：K-means假设簇是球形且具有相似大小，这限制了它处理复杂形状的簇或不均匀大小簇的能力。在面对非球形、非均匀密度的簇时，K-means表现不佳。

  4. 对异常值敏感：K-means算法对异常值和噪声较为敏感，因为异常值会拉动簇中心的位置，影响聚类效果。在数据中存在异常值时，算法的聚类效果可能会大幅下降。

  5. 簇的形状受限：K-means算法假设簇是线性可分的、圆形的，这使得它不适合处理那些形状复杂、互相嵌套的簇。

  6. 收敛速度依赖于数据分布：在某些情况下，K-means算法可能需要较多的迭代才能收敛，尤其是在数据分布较为复杂或簇之间边界模糊时。

总结
K-means算法作为一种经典的聚类算法，在处理球形簇和大规模数据时表现优秀，且计算效率高，容易实现。然而，其局限性也较为明显，特别是在处理非球形簇、异常值和初始值选择上。因此，在实际应用中，通常需要结合数据的特性，以及使用如K-means++、层次聚类等改进或辅助方法，以获得更好的聚类效果。

结~~~

ballball~~
关注
专栏目录
k-means算法课件ppt
09-28
k-means算法是一种广泛应用的无监督学习方法，主要用于数据聚类。它的主要目标是将数据集...对于k值的选择和算法的局限性，可以通过讨论实际案例来深入探讨，以帮助听众了解如何在实际问题中应用和优化k-means算法。
改进的 K-Means 聚类方法介绍
weixin_46287760的博客
02-01 1173
本文以代码的形式展现了对K-Means聚类方法的改进介绍。
详解 K-means及其改进算法
Avery123123的博客
11-05 4492
详解 K-means及其改进算法 详解 K-means及其改进算法K-means基本概念K-means ++基本概念ISODATA基本概念 详解 K-means及其改进算法 K-means 基本概念 算法步骤： Step1.给定初始质心：首先选取初始质心集合centroids 说明 A.质心数量由用户给出，记为k，k-means最终得到的簇数量也是k B.每个质心的数值由初始质心的计算算法计算...
k-means聚类算法解析：定义、优缺点及应用策略
最新发布
weixin_28913879的博客
09-14 1741
本文还有配套的精品资源，点击获取 简介：k-means是一种用于无监督学习的数据分类方法，其目的是将数据集分成k个簇。算法流程包括初始化质心、分配阶段、更新阶段以及迭代过程。该算法的优点在于其简单性、高效率和适用性，但同时存在对初始质心敏感、需要预设k值等缺点。在市场细分、图像分割、文本分类等领域有广泛的应用。针对其局限性，研究者提出了K-Means++、DBSCAN和谱聚...
K-means的改进
chbxw
04-10 9592
前言 k-means算法是数据挖掘十大经典算法之一，已出现了很多的改进或改良算法。例如 1、对k的选择可以先用一些算法，分析数据的分布，如重心和密度等，然后选择合适的k。 2、有人提出了二分k均值（bisecting k-means）算法，它对初始的k个质心的选择就不太敏感。 3、基于图划分的谱聚类算法，能够很好地解决非凸数据的聚类。 一、Canopy算法配合初始聚类 二、K-means++ ...
深入理解K-Means聚类算法
热门推荐
yqtao的博客
12-18 22万+
概述什么是聚类分析聚类分析是在数据中发现数据对象之间的关系，将数据进行分组，组内的相似性越大，组间的差别越大，则聚类效果越好。不同的簇类型聚类旨在发现有用的对象簇，在现实中我们用到很多的簇的类型，使用不同的簇类型划分数据的结果是不同的，如下的几种簇类型。明显分离的可以看到(a)中不同组中任意两点之间的距离都大于组内任意两点之间的距离，明显分离的簇不一定是球形的，可以具有任意的形状。基于原型的簇是对象
k-means聚类算法详解
magicmens的博客
04-06 1万+
K-means 是我们最常用的基于欧式距离的聚类算法，其认为两个目标的距离越近，相似度越大。
K-means算法
AGNING的博客
01-20 3543
K-means算法，也称为K-平均或者K-均值，是一种无监督的聚类算法。对于给定的样本集，按照样本之间的距离大小，将样本划分为K个簇，让簇内的点尽量紧密的连接在一起，而让簇间的距离尽量的大。K-means是一种使用广泛的最基础的聚类算法，通常作为学习聚类算法时的第一个算法。其他的聚类算法还有：K-medoids、k-modes、Clara、Clarans等：物理或抽象对象的集合分成由类似的对象组成的多个类的过程被称为聚类。
Python——K-means聚类分析及其结果可视化
12-21
K-Means算法的核心思想是通过迭代过程，不断调整样本点的所属类别，以达到每个类别内部样本点的相似度最大化，而类别之间的差异性最小化。 1. **K-Means算法原理**： K-Means算法基于距离度量样本点之间的相似度，...
聚类算法：K-means聚类图像分割
12-22
K-Means聚类是最常用的聚类算法，最初起源于信号处理，其目标是将数据点划分为K个类簇，找到每个簇的中心并使其度量最小化。该算法的最大优点是简单、便于理解，运算速度较快，缺点是只能应用于连续型数据，并且要在...
K均值聚类即K-Means算法详解PPT
04-13
K-Means聚类算法是一种常用的无监督学习方法，主要用于将数据点分组成不同的簇，以便更好地理解数据的结构和特征。在这里，我们将详细介绍K-Means聚类算法的原理、步骤和应用。 一、聚类算法概述 聚类是一种无监督...
K-means算法_k-means算法_K._
09-28
为了优化K-means算法，研究人员提出了多种改进版本，如加权K-means、层次K-means、DBSCAN（密度基空间聚类）等，以应对不同类型的聚类问题和数据特性。 通过深入理解K-means算法的工作原理和局限性，我们可以更好地...
K-means改进：基于网格的孤立点预处理算法
m0_56662453的博客
01-24 1168
本文主要针对K-means算法中易受孤立点的影响及对用户输入的k值依赖，对数据的初始化过程进行了改进：提出了基于网格化预处理数据算法，将数据集中的孤立点区分出来并滤除，避免了对聚类过程的干扰，并分别进行了实验验证了其可行性和有效性。
K-means聚类算法的三种改进(K-means++,ISODATA,Kernel K-means)介绍与对比
悠悠小船长的博客
03-25 3717
K-means聚类算法的三种改进(K-means++,ISODATA,Kernel K-means)介绍与对比
k-means算法
qq_42413820的博客
06-12 724
k-means算法 k-means算法是一种聚类算法，所谓聚类，即根据相似性原则，将具有较高相似度的数据对象划分至同一类簇，将具有较高相异度的数据对象划分至不同类簇。聚类与分类最大的区别在于，分类的目标事先已知，而聚类结果的类别没有预先定义，聚类也称无监督分类。 K-means算法原理 k-means算法中的k代表类簇个数，means代表类簇内数据对象的均值（这种均值是一种对类簇中心的描述），因此，k-means算法又称为k-均值算法。k-means算法是一种基于划分的聚类算法，以距离作为数据对象间相似性度
详解K-Means算法
Elon15的博客
11-03 2914
详解K-Means算法
k-means聚类算法及改进
m0_58485149的博客
05-16 1537
原始Kmeans算法最开始随机选取数据集中k个点作为聚类中心，k个初始化的质心的位置选择对最后的聚类结果和运行时间都有很大的影响，因此需要选择合适的k个质心。k-means在选择质心时是直接随机选取k个质心(在选择时不能重复选取)，而k-means++在选择初始质心时是根据轮盘法选择距离位置远的数据点作为下一个质心。它的原理是将数据划分为k个簇，每个簇由距离中心最近的数据点组成，基于计算样本与中心点的距离归纳各簇类下的所属样本，迭代实现样本与其归属的簇类中心的距离为最小的目标。
机器学习之K-Means（k均值）算法
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
06-20 1万+
K-Means算法又称K均值算法，属于聚类（clustering）算法的一种，是应用最广泛的聚类算法之一。所谓聚类，即根据相似性原则，将具有较高相似度的数据对象划分至同一类簇，将具有较高相异度的数据对象划分至不同类簇。聚类与分类最大的区别在于，聚类过程为无监督过程，即待处理数据对象没有任何先验知识，而分类过程为有监督过程，即存在有先验知识的训练数据集。K-Means是无监督学习的杰出代表之一。
机器学习之k-means算法详解
平原的博客
07-02 5万+
K-means算法 （无监督算法，聚类算法） 1-1 基本流程 一、概念： 二、主要特点： 三、算法流程： kmeans作用：去除奇异值 小结： 1-2 算法效果衡量标准 一、K值确定： 二、轮廓系数： 三、Canopy算法配合初始聚类： 1、Canopy简介： 2、Canopy+Kmeans： 四、Calinski-Harabasz Index： K-m...
如何使用KMeans算法改进CLAHE算法？
02-24
KMeans算法和CLAHE算法是两个不同的算，它们的目标和应用领域也不同。KMeans算法是一种聚类算法，用于将数据集划分为不同的簇，而CLAHE算法是一种图像增强算法，用于增强图像的对比度。 虽然KMeans算法和CLAHE算法本身没有直接的关联，但是可以通过结合它们来改进CLAHE算法的效果。具体的步骤如下： 1. 首先，使用CLAHE算法对图像进行增强，得到增强后的图像。 2. 将增强后的图像转换为灰度图像。 3. 使用KMeans算法对灰度图像进行聚类，将图像中的像素点划分为不同的簇。 4. 对于每个簇，计算该簇中像素点的平均灰度值。 5. 根据每个簇的平均灰度值，对图像进行分割，将每个簇中的像素点替换为对应的平均灰度值。 6. 最后，得到改进后的图像。 这种方法的思想是通过KMeans算法将图像中的像素点划分为不同的簇，并根据每个簇的平均灰度值对图像进行分割，从而改进CLAHE算法的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值