写一段python代码：用于K-means聚类

下面是一段Python代码用于K-means聚类，使用sklearn库实现：

from sklearn.cluster import KMeans

# 假设有一组数据集X
X = [[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]]

# 定义聚类数k
k = 2

# 进行K-means聚类
kmeans = KMeans(n_clusters=k, random_state=0).fit(X)

# 输出聚类结果
print(kmeans.labels_) # 输出每个样本所属的簇
print(kmeans.cluster_centers_) # 输出每个簇的质心

在这段代码中，我们首先定义了一个数据集X，然后定义了聚类数k=2。接着，我们使用sklearn库中的KMeans函数进行K-means聚类，并将数据集X作为输入。最后，我们输出了聚类结果，包括每个样本所属的簇和每个簇的质心。

相关问题

用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个中心点，然后迭代地将每个点分配到最近的簇中，并更新每个簇的中心点。最终，我们返回每个簇的点和中心点，并绘制聚类结果。

写一段python代码：用蒙特卡罗模拟生成一系列场景，将这些场景用k-means聚类

以下是一段简单的Python代码，用于生成一些场景，然后使用k-means聚类将它们分类：

import random
import numpy as np
from sklearn.cluster import KMeans

# 生成一些场景
def generate_scenes(num_scenes):
    scenes = []
    for i in range(num_scenes):
        # 场景由4个点组成，每个点的位置随机生成
        x1, y1 = random.uniform(0, 10), random.uniform(0, 10)
        x2, y2 = random.uniform(0, 10), random.uniform(0, 10)
        x3, y3 = random.uniform(0, 10), random.uniform(0, 10)
        x4, y4 = random.uniform(0, 10), random.uniform(0, 10)
        scenes.append([(x1, y1), (x2, y2), (x3, y3), (x4, y4)])
    return scenes

# 将场景转换为特征向量
def scenes_to_features(scenes):
    features = []
    for scene in scenes:
        feature = np.array(scene).flatten()
        features.append(feature)
    return np.array(features)

# 使用k-means聚类将场景分类
def cluster_scenes(features, num_clusters):
    kmeans = KMeans(n_clusters=num_clusters)
    kmeans.fit(features)
    return kmeans.labels_

# 生成10个场景，并使用k-means聚类将它们分成3类
scenes = generate_scenes(10)
features = scenes_to_features(scenes)
labels = cluster_scenes(features, 3)

# 输出每个场景的类别
for i, label in enumerate(labels):
    print("Scene", i+1, "is in cluster", label)

这段代码首先生成一些场景，然后将它们转换为特征向量，最后使用k-means聚类将它们分成指定数量的类别。在这个例子中，我们生成了10个场景，并将它们分成3类。