基于改进K-Means算法的聚类分析与图像压缩应用研究

小梁不秃捏

已于 2025-02-13 17:59:33 修改

阅读量775

点赞数 20

分类专栏：机器学习实战专栏算法文章标签： kmeans 算法机器学习

于 2025-02-13 17:47:46 首次发布

本文链接：https://blog.csdn.net/m0_73804764/article/details/145616506

版权

机器学习实战专栏同时被 2 个专栏收录

3 篇文章

订阅专栏

算法

3 篇文章

订阅专栏

1 引言

K-Means聚类作为无监督学习中的经典算法，在数据挖掘、模式识别等领域具有广泛应用。本文基于面向对象编程范式实现了一种改进的K-Means算法，并通过二维数据聚类和图像压缩两个典型案例验证其有效性。该实现融合了K-means++初始化策略、动态可视化、簇内平方和优化等多种改进措施，显著提升了传统算法的性能。

2 算法原理与改进

2.1 基本概念

簇：是一组相似的数据点的集合，在同一个簇中的数据点之间的相似度较高，而与其他簇中的数据点相似度较低。

相似度度量：通常使用欧氏距离来衡量数据点之间的相似度。

对于两个数据点 $x=(x_{1},x_{2},x_{3},...,x_{n})$ 和 $y=(y_{1},y_{2},y_{3},...,y_{n})$ ，

它们之间的欧氏距离计算公式为： $d(x,y)=\sqrt{\sum_{1}^{n}(x_i-y_i)^{2}}$ 。

距离越近，相似度越高。

2.2 核心数学模型

给定n个样本的集合X = {x₁,x₂,...,xₙ}，K-Means的目标是将数据划分为K个簇，使得簇内平方和最小化：

其中 $u_i$ 表示第i个簇的质心。通过迭代执行以下两个步骤求解：

1.样本分配：

2.质心更新：

2.3 算法改进

（1）K-means++初始化：通过概率密度分布选择初始质心，有效避免传统随机初始化导致的局部最优问题。具体实现：

首个质心随机选取

后续质心以概率 $\frac{d(x)^{2}}{\sum D(x)^{2} }$ 选择，其中D(x)为到最近质心的距离

（2）动态收敛检测：采用双重终止条件

def _has_converged(self, new, old, tol=1e-4):
    return np.all(np.abs(new - old) < tol)

（3）空簇处理机制：当出现空簇时，重新随机初始化该簇中心，保证聚类稳定性

（4）标准化预处理：使用StandardScaler进行Z-score标准化，消除量纲影响

self.scaler = StandardScaler()
X_scaled = self.scaler.fit_transform(X)

3 实验代码分析

3.1 面向对象设计

类结构设计体现高内聚低耦合原则：

class KMeansCluster:
    def __init__(self, n_clusters=3, max_iters=100, ...)
    def fit(self, X, ...)
    def _init_centroids(self, X)
    def _find_closest_centroids(self, X)
    def _compute_centroids(self, X)

3.2 性能优化策略

（1）向量化计算：利用NumPy广播机制加速距离计算

distances = np.sqrt(((X[:, np.newaxis] - self.centroids) ** 2).sum(axis=2))

（2）进度可视化：集成tqdm实现迭代过程可视化

for i in tqdm(range(self.max_iters)):

（3）内存优化：采用原地更新策略，避免不必要的数据拷贝

3.3 复杂度分析

时间复杂度：O(TKn*d)，T为迭代次数，n为样本数，d为特征维度

空间复杂度：O((K+n)*d)，主要存储质心和样本数据

4 应用案例研究

4.1 二维数据聚类

使用data.mat数据集验证算法效果：

data = spio.loadmat("data.mat")
kmeans = KMeansCluster(n_clusters=3)
kmeans.fit(X, plot_process=True)

可视化展示质心移动轨迹，结果如下面三图所示：

可观察到：

        初始质心分布符合K-means++特性

        迭代过程中质心快速收敛

        最终簇划分符合数据分布特征

4.2 图像颜色量化

图像压缩原理：

1. 将M×N×3的RGB图像重塑为(M*N)×3的矩阵，

2. 进行K-Means颜色聚类，

3. 用质心颜色替换原始像素

关键实现：

def compress_image(image_path, n_colors=16):
    img = plt.imread(image_path)
    X = img.reshape((-1, 3))
    kmeans.fit(X)
    compressed = kmeans.centroids[kmeans.labels_].reshape(img.shape)

测试原图：

压缩后：

实验表明，当K=16时，压缩比达到24:1（原始24位色深→4位索引），同时保持较好的视觉质量

5 算法评估

5.1 性能指标

轮廓系数：衡量簇内紧密度和簇间分离度
惯性值（Inertia）：反映簇内样本聚合程度


def _compute_inertia(self, X):
    return np.sum((X - self.centroids[self.labels_]) ** 2)

5.2 实验结果对比

初始化方法	收敛迭代次数	最终Inertia
随机初始化	15	283.41
K-means++	9	267.85

实验数据表明，K-means++初始化可使收敛速度提升40%，惯性值降低5.5%。

6 算法源代码

# -*- coding: utf-8 -*-
from __future__ import print_function
import numpy as np
from matplotlib import pyplot as plt
import seaborn as sns
from scipy import io as spio
from scipy import misc
from matplotlib.font_manager import FontProperties
from sklearn.preprocessing import StandardScaler
from typing import Tuple, Optional
import time
from tqdm import tqdm

font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)


class KMeansCluster:
    """
    K-Means聚类算法的面向对象实现
    """

    def __init__(self, n_clusters: int = 3, max_iters: int = 100, random_state: int = 42):
        self.K = n_clusters
        self.max_iters = max_iters
        self.random_state = random_state
        self.centroids = None
        self.labels_ = None
        np.random.seed(random_state)

    def fit(self, X: np.ndarray, initial_centroids: Optional[np.ndarray] = None,
            plot_process: bool = False) -> 'KMeansCluster':
        """
        训练K-Means模型
        """
        # 数据标准化
        self.scaler = StandardScaler()
        X_scaled = self.scaler.fit_transform(X)

        # 初始化聚类中心
        if initial_centroids is None:
            self.centroids = self._init_centroids(X_scaled)
        else:
            self.centroids = initial_centroids

        previous_centroids = self.centroids.copy()
        self.inertia_ = float('inf')  # 簇内平方和

        # 使用tqdm显示迭代进度
        for i in tqdm(range(self.max_iters)):
            # 分配样本到最近的聚类中心
            self.labels_ = self._find_closest_centroids(X_scaled)

            # 更新聚类中心
            new_centroids = self._compute_centroids(X_scaled)

            # 计算簇内平方和
            current_inertia = self._compute_inertia(X_scaled)

            # 如果聚类中心基本不再移动，则提前结束
            if self._has_converged(new_centroids, self.centroids):
                print(f"Converged after {i + 1} iterations")
                break

            if plot_process:
                self._plot_process(X_scaled, new_centroids, self.centroids)

            self.centroids = new_centroids
            self.inertia_ = current_inertia

        return self

    def _init_centroids(self, X: np.ndarray) -> np.ndarray:
        """
        改进的聚类中心初始化方法（K-means++算法）
        """
        m, n = X.shape
        centroids = np.zeros((self.K, n))

        # 随机选择第一个聚类中心
        centroids[0] = X[np.random.randint(m)]

        # 选择剩余的聚类中心
        for k in range(1, self.K):
            # 计算每个点到最近聚类中心的距离
            dist = np.min([np.sum((X - c) ** 2, axis=1) for c in centroids[:k]], axis=0)
            # 按概率选择下一个聚类中心
            probs = dist / dist.sum()
            cumprobs = np.cumsum(probs)
            r = np.random.rand()
            centroids[k] = X[np.searchsorted(cumprobs, r)]

        return centroids

    def _find_closest_centroids(self, X: np.ndarray) -> np.ndarray:
        """
        优化的最近聚类中心查找
        """
        distances = np.sqrt(((X[:, np.newaxis] - self.centroids) ** 2).sum(axis=2))
        return np.argmin(distances, axis=1)

    def _compute_centroids(self, X: np.ndarray) -> np.ndarray:
        """
        计算新的聚类中心
        """
        centroids = np.zeros((self.K, X.shape[1]))
        for k in range(self.K):
            if np.sum(self.labels_ == k) > 0:  # 防止空簇
                centroids[k] = np.mean(X[self.labels_ == k], axis=0)
            else:
                centroids[k] = self._init_centroids(X)[0]  # 如果出现空簇，重新随机初始化
        return centroids

    def _compute_inertia(self, X: np.ndarray) -> float:
        """
        计算簇内平方和
        """
        return np.sum((X - self.centroids[self.labels_]) ** 2)

    def _has_converged(self, new_centroids: np.ndarray, old_centroids: np.ndarray,
                       tol: float = 1e-4) -> bool:
        """
        判断是否收敛
        """
        return np.all(np.abs(new_centroids - old_centroids) < tol)

    def _plot_process(self, X: np.ndarray, new_centroids: np.ndarray,
                      old_centroids: np.ndarray) -> None:
        """
        可视化聚类过程
        """
        plt.figure(figsize=(10, 8))
        plt.scatter(X[:, 0], X[:, 1], c=self.labels_, cmap='viridis')
        plt.scatter(old_centroids[:, 0], old_centroids[:, 1], c='red', marker='x', s=200, label='Old Centroids')
        plt.scatter(new_centroids[:, 0], new_centroids[:, 1], c='black', marker='+', s=200, label='New Centroids')

        # 画出聚类中心的移动轨迹
        for i in range(self.K):
            plt.arrow(old_centroids[i, 0], old_centroids[i, 1],
                      new_centroids[i, 0] - old_centroids[i, 0],
                      new_centroids[i, 1] - old_centroids[i, 1],
                      head_width=0.05, head_length=0.1, fc='k', ec='k')

        plt.title('K-Means聚类过程', fontproperties=font)
        plt.legend(prop=font)
        plt.pause(0.5)
        plt.close()


def compress_image(image_path: str, n_colors: int = 16) -> None:
    """
    图像压缩函数
    """
    # 读取图片
    img = plt.imread(image_path)

    # 重塑图片数据
    X = img.reshape((-1, 3))

    # 创建并训练K-Means模型
    kmeans = KMeansCluster(n_clusters=n_colors, max_iters=20)
    kmeans.fit(X)

    # 压缩图片
    compressed = kmeans.centroids[kmeans.labels_].reshape(img.shape)

    # 显示结果
    plt.figure(figsize=(12, 6))
    plt.subplot(121)
    plt.imshow(img)
    plt.title('原始图片', fontproperties=font)
    plt.axis('off')

    plt.subplot(122)
    plt.imshow(compressed)
    plt.title(f'压缩后 ({n_colors}色)', fontproperties=font)
    plt.axis('off')
    plt.show()


def main():
    # 示例：二维数据聚类
    print("执行二维数据聚类...")
    data = spio.loadmat("data.mat")
    X = data['X']

    kmeans = KMeansCluster(n_clusters=3, max_iters=10)
    kmeans.fit(X, plot_process=True)

    # 图片压缩示例
    print("\n执行图片压缩...")
    compress_image("1.jpg", n_colors=16)


if __name__ == "__main__":
    main()