利用Python写出K-means聚类算法的代码

当然，我可以回答这个问题。以下是简单的Python代码示例：

import numpy as np
 
def k_means(data, k=3, centroids=None, eps=1e-6):
    n = data.shape[0]
    if centroids is None:
        centroids = data[np.random.choice(n, k)]
    old_centroids = np.zeros((k, data.shape[1]))
    while np.linalg.norm(centroids - old_centroids) > eps:
        old_centroids = centroids
        dists = np.linalg.norm(data[:, np.newaxis, :] - centroids, axis=2)
        clusters = np.argmin(dists, axis=1)
        for i in range(k):
            centroids[i] = np.mean(data[clusters == i], axis=0)
    return clusters, centroids

这是一个基本的K-means聚类算法的实现，接受数据数组和聚类数作为输入，并返回每个数据点的聚类和最终质心。

相关问题

使用Python代码实现K-means聚类算法

K-means聚类算法是一种常见的无监督机器学习算法，可用于将数据点分为不同的群组。以下是使用Python代码实现K-means聚类算法的步骤：

1. 导入必要的库

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

2. 生成随机数据

X = -2 * np.random.rand(100, 2)
X1 = 1 + 2 * np.random.rand(50, 2)
X[50:100, :] = X1

3. 初始化K-means模型

kmeans = KMeans(n_clusters=2)

4. 拟合数据

kmeans.fit(X)

5. 预测类别

y_pred = kmeans.predict(X)

6. 可视化结果

plt.scatter(X[y_pred == 0, 0], X[y_pred == 0, 1], s = 50, c = 'red', label = 'Cluster 1')
plt.scatter(X[y_pred == 1, 0], X[y_pred == 1, 1], s = 50, c = 'blue', label = 'Cluster 2')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s = 100, c = 'black', label = 'Centroids')
plt.title('K-means Clustering')
plt.legend()
plt.show()

以上就是使用Python代码实现K-means聚类算法的步骤。

用python写一段k-means聚类算法代码

好的，以下是一段基于Python的K-Means聚类算法代码：

import random
import numpy as np
import matplotlib.pyplot as plt

# 生成测试数据
def generate_data(n, k):
    data = []
    for i in range(k):
        center = np.random.uniform(-10, 10, size=2)
        for j in range(n):
            x = np.random.normal(center[0], 1)
            y = np.random.normal(center[1], 1)
            data.append([x, y, i])
    return np.array(data)

# 计算两点之间的距离
def distance(point1, point2):
    return np.sqrt(np.sum((point1 - point2) ** 2))

# K-Means算法
def k_means(data, k, max_iter=100):
    # 随机选择k个中心点
    centers = data[random.sample(range(len(data)), k)][:, :-1]
    
    for i in range(max_iter):
        # 初始化每个簇的点
        clusters = [[] for _ in range(k)]
        
        # 分配每个点到最近的簇
        for point in data:
            distances = [distance(point[:-1], center) for center in centers]
            cluster_index = np.argmin(distances)
            clusters[cluster_index].append(point)
        
        # 更新每个簇的中心点
        for j in range(k):
            centers[j] = np.mean(clusters[j], axis=0)[:-1]
        
    return clusters, centers

# 绘制聚类结果
def plot_clusters(clusters, centers):
    plt.figure(figsize=(8, 6))
    colors = ['r', 'g', 'b', 'c', 'm', 'y', 'k']
    
    for i in range(len(clusters)):
        cluster = np.array(clusters[i])
        plt.scatter(cluster[:, 0], cluster[:, 1], c=colors[i], alpha=0.5)
        
    plt.scatter(centers[:, 0], centers[:, 1], s=100, marker='*', c='black')
    plt.show()

# 测试
data = generate_data(100, 3)
clusters, centers = k_means(data, 3)
plot_clusters(clusters, centers)

在此代码中，我们首先生成了一些测试数据，然后使用K-Means算法将其聚类成k个簇，并绘制聚类结果。在该算法中，我们首先随机选择k个中心点，然后迭代地将每个点分配到最近的簇中，并更新每个簇的中心点。最终，我们返回每个簇的点和中心点，并绘制聚类结果。