kmeans 平均质心距离代码

以下是一个简单的 kmeans 平均质心距离的代码示例：

from sklearn.cluster import KMeans
import numpy as np

# 生成一些随机数据
X = np.random.rand(100, 2)

# 使用 kmeans 进行聚类
kmeans = KMeans(n_clusters=3, random_state=0).fit(X)

# 计算平均质心距离
distances = []
for i in range(3):
    cluster_points = X[kmeans.labels_ == i]
    centroid = kmeans.cluster_centers_[i]
    distances.append(np.mean(np.linalg.norm(cluster_points - centroid, axis=1)))
mean_distance = np.mean(distances)

print("平均质心距离为：", mean_distance)

希望这个代码能够帮到你！

相关问题

c++ Kmeans图像压缩底层代码

以下是使用 C++ 底层实现 Kmeans 图像压缩的示例代码：

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

// 计算两个像素点的欧几里得距离
float euclideanDistance(const Vec3b& a, const Vec3b& b)
{
    float sum = 0.0;
    for (int i = 0; i < 3; i++) {
        float diff = a[i] - b[i];
        sum += diff * diff;
    }
    return sqrt(sum);
}

int main()
{
    // 读取原始图像
    Mat img = imread("lena.jpg");

    // 将图像转为一维数组
    Mat samples = img.reshape(1, img.cols * img.rows);

    // 设置 Kmeans 参数
    int K = 16; // 分为 16 类
    int max_iter = 10;
    float epsilon = 1.0;
    int attempts = 3;

    // 随机初始化 K 个质心
    vector<Vec3b> centers(K);
    for (int i = 0; i < K; i++) {
        centers[i] = samples.at<Vec3b>(rand() % samples.rows);
    }

    // 运行 Kmeans 算法
    for (int iter = 0; iter < max_iter; iter++) {
        // 计算每个像素点到质心的距离，并将其分配到距离最近的质心所在的类别
        vector<vector<int>> clusters(K);
        for (int i = 0; i < samples.rows; i++) {
            float min_dist = FLT_MAX;
            int min_idx = -1;
            for (int j = 0; j < K; j++) {
                float dist = euclideanDistance(samples.at<Vec3b>(i), centers[j]);
                if (dist < min_dist) {
                    min_dist = dist;
                    min_idx = j;
                }
            }
            clusters[min_idx].push_back(i);
        }

        // 更新质心的值为其所在类别的所有像素点的平均值
        for (int j = 0; j < K; j++) {
            Vec3f sum(0.0, 0.0, 0.0);
            for (int i : clusters[j]) {
                sum += samples.at<Vec3b>(i);
            }
            if (!clusters[j].empty()) {
                centers[j] = sum / (float)clusters[j].size();
            }
        }
    }

    // 将每个像素点的值替换为其所属质心值
    Mat new_img(img.size(), img.type());
    for (int i = 0; i < img.rows; i++) {
        for (int j = 0; j < img.cols; j++) {
            float min_dist = FLT_MAX;
            int min_idx = -1;
            for (int k = 0; k < K; k++) {
                float dist = euclideanDistance(img.at<Vec3b>(i, j), centers[k]);
                if (dist < min_dist) {
                    min_dist = dist;
                    min_idx = k;
                }
            }
            new_img.at<Vec3b>(i, j) = centers[min_idx];
        }
    }

    // 显示压缩后的图像
    imshow("compressed image", new_img);
    waitKey(0);

    return 0;
}

需要注意的是，由于使用了随机初始化，每次运行的结果可能不同。因此，为了得到更好的压缩效果，可以多次运行 Kmeans 算法，选择最优的结果。此外，为了提高计算效率，可以考虑使用并行计算或 GPU 加速。

kmeans聚类算法 代码

K-means聚类算法是一种常用的无监督学习算法，用于将数据集划分为K个不同的类别。它的基本思想是通过迭代的方式将数据点分配到K个簇中，使得每个数据点与所属簇的质心之间的距离最小化。

以下是K-means聚类算法的基本步骤：
1. 随机选择K个初始质心（簇中心）。
2. 将每个数据点分配到与其最近的质心所属的簇。
3. 更新每个簇的质心，计算每个簇中所有数据点的平均值作为新的质心。
4. 重复步骤2和步骤3，直到质心不再发生变化或达到预定的迭代次数。

K-means聚类算法的代码示例（Python）：

import numpy as np

def kmeans(data, k, max_iterations):
    # 随机选择K个初始质心
    centroids = data[np.random.choice(range(len(data)), k, replace=False)]
    
    for _ in range(max_iterations):
        # 分配数据点到最近的质心所属的簇
        clusters = [[] for _ in range(k)]
        for point in data:
            distances = [np.linalg.norm(point - centroid) for centroid in centroids]
            cluster_index = np.argmin(distances)
            clusters[cluster_index].append(point)
        
        # 更新每个簇的质心
        new_centroids = []
        for cluster in clusters:
            new_centroids.append(np.mean(cluster, axis=0))
        
        # 判断质心是否发生变化
        if np.allclose(centroids, new_centroids):
            break
        
        centroids = new_centroids
    
    return clusters, centroids

# 示例用法
data = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])
k = 2
max_iterations = 10

clusters, centroids = kmeans(data, k, max_iterations)
print("Clusters:")
for i, cluster in enumerate(clusters):
    print(f"Cluster {i+1}: {cluster}")
print("Centroids:")
for i, centroid in enumerate(centroids):
    print(f"Centroid {i+1}: {centroid}")