C++聚类算法与网格搜索的参数优化

在C++中，聚类算法和网格搜索是机器学习中两个重要的概念

1. 聚类算法：

聚类是一种无监督学习方法，用于将数据集中的样本分成不同的组或簇。常用的C++聚类算法有K-means、DBSCAN等。以下是K-means算法的简单实现：

#include <iostream>
#include <vector>
#include <cmath>
#include <random>

using namespace std;

struct Point {
    double x, y;
};

double distance(const Point& a, const Point& b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

vector<Point> kmeans(const vector<Point>& points, int k, int max_iterations = 100) {
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(0, points.size() - 1);

    vector<Point> centroids(k);
    vector<int> labels(points.size(), -1);

    for (int i = 0; i < max_iterations; ++i) {
        vector<Point> clusters[k];

        for (int j = 0; j < points.size(); ++j) {
            int closest_centroid = dis(gen);
            clusters[closest_centroid].push_back(points[j]);
            labels[j] = closest_centroid;
        }

        bool converged = true;
        for (int j = 0; j < k; ++j) {
            if (clusters[j].size() == 0) {
                // Find the largest cluster and take its centroid as the new centroid
                int max_cluster_index = 0;
                for (int l = 1; l < k; ++l) {
                    if (clusters[l].size() > clusters[max_cluster_index].size()) {
                        max_cluster_index = l;
                    }
                }
                centroids[j] = clusters[max_cluster_index][0];
                clusters[max_cluster_index].clear();
            } else {
                Point new_centroid = {0, 0};
                for (const auto& point : clusters[j]) {
                    new_centroid.x += point.x;
                    new_centroid.y += point.y;
                }
                new_centroid.x /= clusters[j].size();
                new_centroid.y /= clusters[j].size();
                centroids[j] = new_centroid;
            }

            for (int j = 0; j < points.size(); ++j) {
                double min_distance = DBL_MAX;
                int closest_centroid = -1;
                for (int l = 0; l < k; ++l) {
                    double dist = distance(points[j], centroids[l]);
                    if (dist < min_distance) {
                        min_distance = dist;
                        closest_centroid = l;
                    }
                }
                if (closest_centroid != labels[j]) {
                    converged = false;
                    break;
                }
            }

            if (!converged) break;
        }

        if (converged) break;
    }

    return centroids;
}

2. 网格搜索：

网格搜索是一种参数优化方法，用于在给定的参数空间中搜索最佳参数组合。常用的C++网格搜索库有GridSearchCV（基于Scikit-learn）和mlpack等。以下是使用Scikit-learn的GridSearchCV进行参数优化的示例：

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <chrono>
#include <sklearn/model_selection/grid_search.hpp>
#include <sklearn/svm/svc.hpp>

using namespace std;
using namespace sklearn::model_selection;
using namespace sklearn::svm;

int main() {
    // 生成随机数据集
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(0, 100);
    vector<vector<double>> X(100, vector<double>(2));
    vector<double> y(100);
    for (int i = 0; i < 100; ++i) {
        X[i][0] = dis(gen);
        X[i][1] = dis(gen);
        y[i] = dis(gen) % 2;
    }

    // 定义参数网格
    param_grid grid = {{0, 1}, {1, 2}, {2, 3}};

    // 创建SVM分类器
    SVC classifier;

    // 创建网格搜索对象
    GridSearchCV grid_search(classifier, grid, cv::evaluate_classification, vector<double>());

    // 开始网格搜索
    auto start = chrono::high_resolution_clock::now();
    grid_search.fit(X, y);
    auto end = chrono::high_resolution_clock::now();

    // 输出最佳参数组合和对应的得分
    cout << "Best parameters: " << grid_search.best_params_ << endl;
    cout << "Best score: " << grid_search.best_score_ << endl;
    cout << "Time taken: " << chrono::duration<double, milli>(end - start).count() << " ms" << endl;

    return 0;
}

这个示例使用了Scikit-learn的GridSearchCV类来进行SVM分类器的参数优化。首先，我们生成了一个随机数据集，然后定义了参数网格，接着创建了一个SVM分类器和一个网格搜索对象。最后，我们调用fit方法开始网格搜索，并输出了最佳参数组合和对应的得分。