python sklearn k-means 代码示例

好的，以下是用 sklearn 库中的 KMeans 模型实现 K 均值聚类的代码示例：

from sklearn.cluster import KMeans
import numpy as np

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

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

# 训练模型
kmeans.fit(X)

# 预测每个样本所属的聚类
predictions = kmeans.predict(X)

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

# 获取每个样本到聚类中心的距离
labels = kmeans.labels_

希望这个代码示例对您有所帮助！

相关问题

python的K-means代码

以下是Python实现K-means算法的基本代码：

import numpy as np
import random

# 计算两个向量之间的欧几里得距离
def euclidean_distance(x1, x2):
    return np.sqrt(np.sum((x1 - x2)**2))

class KMeans:
    def __init__(self, K=2, max_iters=100, plot_steps=False):
        self.K = K
        self.max_iters = max_iters
        self.plot_steps = plot_steps

        # 初始化聚类中心
        self.centroids = []

        # 每个数据点所属的簇
        self.clusters = [[] for _ in range(self.K)]

    def predict(self, X):
        self.X = X
        self.n_samples, self.n_features = X.shape

        # 随机选择K个样本作为初始聚类中心
        random_sample_idxs = random.sample(range(self.n_samples), self.K)
        self.centroids = [self.X[idx] for idx in random_sample_idxs]

        # 开始迭代
        for _ in range(self.max_iters):
            self.clusters = self._create_clusters(self.centroids)
            
            if self.plot_steps:
                self._plot()

            old_centroids = self.centroids
            self.centroids = self._get_centroids(self.clusters)
            
            # 如果聚类中心不再变化，停止迭代
            if self._is_converged(old_centroids, self.centroids):
                break

            if self.plot_steps:
                self._plot()

        # 返回每个数据点所属的簇
        return self._get_cluster_labels(self.clusters)

    def _create_clusters(self, centroids):
        clusters = [[] for _ in range(self.K)]
        for idx, sample in enumerate(self.X):
            centroid_idx = self._closest_centroid(sample, centroids)
            clusters[centroid_idx].append(idx)
        return clusters

    def _closest_centroid(self, sample, centroids):
        distances = [euclidean_distance(sample, point) for point in centroids]
        closest_idx = np.argmin(distances)
        return closest_idx

    def _get_centroids(self, clusters):
        centroids = np.zeros((self.K, self.n_features))
        for idx, cluster in enumerate(clusters):
            cluster_mean = np.mean(self.X[cluster], axis=0)
            centroids[idx] = cluster_mean
        return centroids

    def _is_converged(self, old_centroids, centroids):
        distances = [euclidean_distance(old_centroids[i], centroids[i]) for i in range(self.K)]
        return sum(distances) == 0

    def _get_cluster_labels(self, clusters):
        labels = np.empty(self.n_samples)
        for cluster_idx, cluster in enumerate(clusters):
            for sample_idx in cluster:
                labels[sample_idx] = cluster_idx
        return labels

    def _plot(self):
        fig, ax = plt.subplots(figsize=(12, 8))

        for i, index in enumerate(self.clusters):
            point = self.X[index].T
            ax.scatter(*point)

        for point in self.centroids:
            ax.scatter(*point, marker="x", color="black", linewidth=2)

        plt.show()

使用示例：

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

X, y = make_blobs(centers=3, n_samples=500, random_state=42)

kmeans = KMeans(K=3, max_iters=150, plot_steps=True)
y_pred = kmeans.predict(X)

fig, ax = plt.subplots(figsize=(12, 8))
for i in range(len(X)):
    ax.scatter(X[i][0], X[i][1], color='C{}'.format(y_pred[i]))
plt.show()

python的K-means算法代码

### 回答1：
以下是Python实现的K-means算法代码：

import numpy as np
import matplotlib.pyplot as plt

def kmeans(X, K, max_iters=20):
    centroids = X[np.random.choice(np.arange(len(X)), K), :]
    for i in range(max_iters):
        C = np.zeros(len(X))
        for j in range(len(X)):
            distances = np.linalg.norm(X[j] - centroids, axis=1)
            cluster = np.argmin(distances)
            C[j] = cluster
        for k in range(K):
            centroids[k] = X[C == k].mean(axis=0)
    return C, centroids

# 生成数据
np.random.seed(0)
X1 = np.random.randn(100, 2) + np.array([2, 2])
X2 = np.random.randn(100, 2) + np.array([-2, -2])
X3 = np.random.randn(100, 2) + np.array([2, -2])
X4 = np.random.randn(100, 2) + np.array([-2, 2])
X = np.vstack([X1, X2, X3, X4])

# 调用kmeans函数
C, centroids = kmeans(X, 4)

# 绘制结果
plt.scatter(X[:, 0], X[:, 1], c=C)
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.show()

其中，`X`是一个$n\times m$的矩阵，其中$n$是数据点的数量，$m$是每个数据点的维度。`K`是聚类的数量，`max_iters`是最大迭代次数。函数返回一个长度为$n$的向量`C`，其中的每个元素表示该数据点所属的聚类编号，以及一个$K\times m$的矩阵`centroids`，其中的每行表示一个聚类的中心点。

### 回答2：
K-means算法是一种常用的聚类算法，在Python中可以使用scikit-learn库中的KMeans模块进行实现。以下是K-means算法的Python代码示例：

# 导入所需的库
from sklearn.cluster import KMeans
import numpy as np

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

# 创建并拟合K-means模型
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)

# 获取每个样本所属的簇
labels = kmeans.labels_

# 获取每个簇的中心点坐标
centroids = kmeans.cluster_centers_

# 输出结果
print("每个样本所属的簇：", labels)
print("簇的中心点坐标：", centroids)

以上代码将创建一个包含6个样本的数据集X，其中每个样本有2个特征。接下来，使用KMeans函数创建一个K-means模型，并使用fit函数拟合数据。通过调整n_clusters参数的值可以指定需要聚类的簇的数量。然后，可以使用labels_属性获取每个样本所属的簇，并使用cluster_centers_属性获取每个簇的中心点坐标。最后，输出每个样本所属的簇和簇的中心点坐标。

需要注意的是，K-means算法的结果可能受到初始聚类中心的影响。可以通过设置random_state参数来固定随机种子，以使结果可重复。

### 回答3：
K-means算法是一种常用的聚类算法，可以将数据集分为k个不同的簇。下面是一个用Python实现K-means算法的示例代码：

import numpy as np

def k_means(data, k, max_iters):
    # 随机选择k个样本作为初始聚类中心
    centers = data[np.random.choice(data.shape[0], k, replace=False)]
    
    for _ in range(max_iters):
        # 计算每个样本与聚类中心的距离
        distances = np.linalg.norm(data[:, np.newaxis] - centers, axis=-1)
        
        # 分配每个样本到离其最近的聚类中心
        labels = np.argmin(distances, axis=-1)
        
        # 更新聚类中心为每个簇的平均值
        centers = np.array([data[labels == i].mean(axis=0) for i in range(k)])
        
    return centers, labels

# 测试
data = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
k = 2
max_iters = 10

centers, labels = k_means(data, k, max_iters)

print("聚类中心：")
print(centers)
print("样本标签：")
print(labels)

该代码实现了K-means算法，首先随机选择k个样本作为初始聚类中心，然后迭代更新聚类中心和样本标签，直到达到最大迭代次数。最终输出聚类中心和样本标签。在给定的数据集中，将数据分为2个簇，并输出了每个簇的聚类中心和样本标签。