【大数据】聚类算法

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define N 100 // 假设有100个数据点
#define K 3   // 假设我们要分成3个簇
 
// 生成随机数据点的函数
void generate_data(float *data) {
    for (int i = 0; i < N; ++i) {
        data[i] = rand() % 100; // 生成0到99之间的随机整数
    }
}
 
// 计算平方和的函数
float calculate_squared_error(float *centroids, int *clusters, int data_points, int k) {
    float squared_error = 0.0f;
    int *counts = (int *)calloc(k, sizeof(int));
    float *sums = (float *)calloc(k, sizeof(float));
 
    for (int i = 0; i < data_points; ++i) {
        int cluster = clusters[i];
        sums[cluster] += centroids[cluster];
        counts[cluster]++;
    }
 
    for (int i = 0; i < k; ++i) {
        if (counts[i] > 0) {
            sums[i] /= counts[i];
            squared_error += (counts[i] * (centroids[i] - sums[i]) * (centroids[i] - sums[i]));
        }
    }
 
    free(counts);
    free(sums);
    return squared_error;
}
 
int main() {
    srand(time(0)); // 初始化随机数生成器
    float data[N];
    generate_data(data); // 生成数据点
 
    // 聚类算法的实现部分（此处省略）
 
    // 计算并输出平方误差
    float centroids[K]; // 假设我们已经更新了K个簇的质心
    int clusters[N]; // 假设我们已经对数据点进行了分类
    float squared_error = calculate_squared_error(centroids, clusters, N, K);
    printf("Squared error: %f\n", squared_error);
 
    return 0;
}

这个代码实例提供了一个简化的数据生成、聚类算法核心步骤的实现和主函数示例。在主函数中，我们假设已经完成了聚类和计算新的质心的步骤，并计算了最终的平方误差。这个例子旨在展示如何在C语言中实现聚类算法的一部分，并提供了一个基本框架。

3.2 聚类算法JAVA实现

在Java中，实现聚类算法可以通过多种方式。以下是一个简单的示例，使用K-means算法对数据点进行聚类：

import java.util.ArrayList;
import java.util.List;
 
public class KMeansClustering {
 
    public static class Cluster {
        public List<double[]> points;
        public double[] center;
 
        public Cluster(double[] center) {
            this.center = center;
            this.points = new ArrayList<>();
        }
    }
 
    public static double[] calculateCenter(List<double[]> points) {
        int dimensions = points.get(0).length;
        double[] center = new double[dimensions];
        for (double[] point : points) {
            for (int i = 0; i < dimensions; i++) {
                center[i] += point[i];
            }
        }
        for (int i = 0; i < dimensions; i++) {
            center[i] /= points.size();
        }
        return center;
    }
 
    public static List<Cluster> kMeans(List<double[]> dataPoints, int k) {
        List<Cluster> clusters = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            clusters.add(new Cluster(dataPoints.get(i)));
        }
 
        boolean convergence = false;
        while (!convergence) {
            convergence = true;
            for (Cluster cluster : clusters) {
                List<double[]> newPoints = new ArrayList<>();
                for (double[] point : dataPoints) {
                    if (isCloserToCenter(point, cluster.center, clusters)) {
                        newPoints.add(point);
                        convergence = false;
                    }
                }
                cluster.points = newPoints;
                cluster.center = calculateCenter(cluster.points);
            }
        }
        return clusters;
    }
 
    public static boolean isCloserToCenter(double[] point, double[] center1, List<Cluster> clusters) {
        double minDistance = Double.POSITIVE_INFINITY;
        for (Cluster cluster : clusters) {
            double distance = calculateDistance(point, cluster.center);
            if (distance < minDistance) {
                minDistance = distance;
            }
        }
        return minDistance > calculateDistance(point, center1);
    }
 
    public static double calculateDistance(double[] point1, double[] point2) {
        double sum = 0.0;
        for (int i = 0; i < point1.length; i++) {
            sum += Math.pow(point1[i] - point2[i], 2);
        }
        return Math.sqrt(sum);
    }
 
    public static void main(String[] args) {
        List<double[]> dataPoints = new ArrayList<>();
        // 添加数据点
        dataPoints.add(new double[]{1, 2});
        dataPoints.add(new double[]{1, 4});
        dataPoints.add(new double[]{0, 5});
        dataPoints.add(new double[]{3, 1});
        dataPoints.add(new double[]{3, 6});
 
        int k = 2; // 要形成的簇的数量
        List<Cluster> clusters = kMeans(dataPoints, k);
 
        // 输出聚类结果
        for (Cluster cluster : clusters) {
            System.out.println("Cluster center: " + java.util.Arrays.toString(cluster.center));
            for (double[] point : cluster.points) {
                System.out.println("Cluster point: " + java.util.Arrays.toString(point));
            }
        }
    }
}

这段代码定义了一个简单的Cluster类来存储簇中心和点集，并实现了K-means聚类算法。在main方法中，我们创建了一些数据点并调用kMeans方法进行聚类。

3.3 聚类算法python实现

在Python中，可以使用scikit-learn库中的KMeans算法来实现聚类。以下是一个简单的例子：

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
 
# 生成聚类数据
X, y = make_blobs(n_samples=300, centers=4, cluster_std=[1.0, 2.5, 0.5, 3.0])
 
# 初始化KMeans算法
kmeans = KMeans(n_clusters=4)
 
# 训练模型
kmeans.fit(X)
 
# 获取聚类中心
centers = kmeans.cluster_centers_
 
# 绘制聚类结果
plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, s=50, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='black', s=100, marker='*')
plt.show()

这段代码首先使用make_blobs函数生成一个包含300个样本、4个聚类中心的数据集，每个聚类的标准差不同。然后使用KMeans算法进行训练，设置聚类数为4。训练完成后，获取每个聚类的中心并绘制出聚类结果。每个点的颜色代表其所属的聚类，星形标记代表聚类中心。