k-means聚类算法python实现

k-means聚类算法是一种基于类中心的聚类方法。在python中，可以使用Scikit-learn库中的KMeans类来实现k-means聚类。下面是一个简单的示例代码：

from sklearn.cluster import KMeans
import numpy as np

# 创建样本数据
X = np.array([[1, 2], [1, 4], [1, 0],
              [4, 2], [4, 4], [4, 0]])

# 创建k-means模型，并设置聚类中心数量为2
kmeans = KMeans(n_clusters=2)

# 训练模型
kmeans.fit(X)

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

# 获取聚类中心
cluster_centers = kmeans.cluster_centers_

# 打印结果
print("Labels:", labels)
print("Cluster Centers:", cluster_centers)

在这个示例中，我们创建了一个样本数据，并使用KMeans类训练了一个k-means模型。然后我们使用labels_属性获取每个样本的聚类结果，并使用cluster_centers_属性获取聚类中心。

相关问题

k-means聚类算法python实现方法

k-means聚类算法是一种无监督学习方法，用于将数据集分成k个类。其基本思想是将数据集划分为k个簇，每个簇对应一个聚类中心，使得簇内数据点到聚类中心的距离最小，而簇间数据点的距离最大。下面介绍k-means聚类算法的python实现方法。

1.导入相关库和数据集

首先需要导入相关库和数据集，本例使用sklearn库中的make_blobs模块生成一个随机数据集。

from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np

# 生成随机数据集
X, y = make_blobs(n_samples=200, centers=4, random_state=42)

2.初始化聚类中心

k-means算法需要对聚类中心进行初始化，可以随机选择k个数据点作为初始聚类中心。下面使用numpy库中的random模块随机选择k个数据点。

# 初始化聚类中心
k = 4
init_index = np.random.choice(X.shape[0], k, replace=False)
centroids = X[init_index]

3.迭代更新聚类中心和簇分配

k-means算法迭代更新聚类中心和簇分配，直到聚类中心不再变化或达到最大迭代次数。下面是完整的k-means聚类算法python实现代码。

def k_means(X, k, max_iter=100):
    # 初始化聚类中心
    init_index = np.random.choice(X.shape[0], k, replace=False)
    centroids = X[init_index]
    # 迭代更新聚类中心和簇分配
    for i in range(max_iter):
        # 计算每个数据点到聚类中心的距离
        distances = np.sqrt(np.sum((X - centroids[:, np.newaxis])**2, axis=2))
        # 簇分配
        cluster = np.argmin(distances, axis=0)
        # 更新聚类中心
        for j in range(k):
            centroids[j] = np.mean(X[cluster==j], axis=0)
    return centroids, cluster

# 调用k_means函数进行聚类
centroids, cluster = k_means(X, 4)

# 可视化聚类结果
colors = ['r', 'g', 'b', 'y']
for i in range(4):
    plt.scatter(X[cluster==i][:, 0], X[cluster==i][:, 1], c=colors[i])
plt.scatter(centroids[:, 0], centroids[:, 1], marker='*', s=300, c='black')
plt.show()

运行结果如下图所示，其中四个颜色代表四个簇，黑色星号代表聚类中心。


K-Means聚类算法python实现代码

### 回答1：

K-Means聚类算法是一种用于对数据进行分组的机器学习算法，它可以帮助我们根据数据特征将相似的数据分为几类。Python实现K-Means聚类算法的代码大致如下：import numpy as np
from sklearn.cluster import KMeans# 加载数据
data = np.loadtxt("data.txt", delimiter=",")# 创建KMeans模型
kmeans = KMeans(n_clusters=3)# 训练模型
kmeans.fit(data)# 聚类中心
centers = kmeans.cluster_centers_# 结果标签
labels = kmeans.labels_

### 回答2：
K-Means是一种常用的聚类算法，用于将数据集中的元素划分为K个不同的组或类。以下是K-Means聚类算法的Python实现代码示例：

import numpy as np

class KMeans:
    def __init__(self, k=2, max_iters=100):
        self.k = k
        self.max_iters = max_iters
        
    def fit(self, X):
        self.centroids = self._initialize_centroids(X)
        
        for _ in range(self.max_iters):
            clusters = [[] for _ in range(self.k)]
            
            # Assign each data point to the nearest centroid
            for xi in X:
                distances = [np.linalg.norm(xi - centroid) for centroid in self.centroids]
                cluster_index = np.argmin(distances)
                clusters[cluster_index].append(xi)
            
            # Update centroids
            prev_centroids = np.copy(self.centroids)
            for i in range(self.k):
                self.centroids[i] = np.mean(clusters[i], axis=0)
            
            # Break loop if centroids do not change
            if np.allclose(prev_centroids, self.centroids):
                break
        
    def predict(self, X):
        return [np.argmin([np.linalg.norm(xi - centroid) for centroid in self.centroids]) for xi in X]
    
    def _initialize_centroids(self, X):
        indices = np.random.choice(range(len(X)), size=self.k, replace=False)
        return X[indices]

以上代码实现了一个简单的K-Means聚类算法。`fit`方法用于训练模型，`predict`方法用于进行预测。在训练过程中，首先随机选择K个初始质心，然后迭代更新每个样本的簇分配，直到达到最大迭代次数或质心不再发生变化。最后，预测时根据最近的质心将新的样本点分配到对应的簇中。

请注意，这只是一个简单的K-Means实现，它可能不具有较强的鲁棒性和效率。实际应用中，可以考虑使用成熟的机器学习库中的K-Means实现，如Scikit-learn等。

### 回答3：
K-Means聚类算法是一种常用的无监督学习算法，用于将数据集划分为K个不同的簇。下面是Python中实现K-Means聚类算法的代码示例：

import numpy as np

def kmeans(data, K, max_iters=100):
    # 随机初始化K个中心点
    centers = data[np.random.choice(range(len(data)), K, replace=False)]
    
    for _ in range(max_iters):
        # 计算每个样本与中心点的欧式距离
        dists = np.linalg.norm(data[:,:,np.newaxis] - centers.T[np.newaxis,:,:], axis=1)
        
        # 根据距离将样本分配到最近的簇
        labels = np.argmin(dists, axis=1)
        
        # 更新每个簇的中心点为该簇所有样本的平均值
        centers_new = np.array([data[labels == k].mean(axis=0) for k in range(K)])
        
        # 判断中心点是否稳定不变，若不变则停止迭代
        if np.all(centers == centers_new):
            break
        
        centers = centers_new
    
    return labels, centers

# 测试数据
data = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])

# 调用K-Means算法进行聚类
labels, centers = kmeans(data, K=2)

# 打印聚类结果
print("聚类结果：", labels)
print("聚类中心点：", centers)

上述代码实现了K-Means聚类算法，其中`data`表示输入的数据集，`K`表示要划分的簇的数量。`kmeans`函数使用随机初始化的中心点，迭代计算样本与中心点的距离，并将样本分配到最近的簇。然后更新每个簇的中心点为该簇所有样本的平均值，直到中心点不再改变或达到最大迭代次数为止。最后返回每个样本所属的簇以及最终的中心点。