C++聚類算法中的自適應距離度量

在C++中實現聚類算法時，自適應距離度量是一種根據數據點之間的距離進行加權的方法，它可以提高聚類效果

首先，我們需要包含必要的頭文件并定義一些輔助函數：

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

// 計算兩點之間的歐幾里得距離
double euclidean_distance(const std::vector<double>& a, const std::vector<double>& b) {
    double sum = 0;
    for (size_t i = 0; i < a.size(); ++i) {
        sum += pow(a[i] - b[i], 2);
    }
    return sqrt(sum);
}

// 自適應距離度量
double adaptive_distance(const std::vector<double>& a, const std::vector<double>& b, double alpha) {
    double distance = euclidean_distance(a, b);
    return alpha * distance + (1 - alpha) * 1; // 使用1作為最小距離閾值
}

接下來，我們可以實現一個簡單的聚類算法，如K-means：

// K-means聚類算法
void kmeans(std::vector<std::vector<double>>& data, int k, int max_iterations) {
    // 初始化質心
    std::vector<std::vector<double>> centroids(k);
    for (int i = 0; i < k; ++i) {
        centroids[i] = data[i];
    }

    // 聚類過程
    for (int iteration = 0; iteration < max_iterations; ++iteration) {
        std::vector<std::vector<int>> clusters(k);
        std::vector<double> distances(data.size());

        // 計算每個點到質心的距離并分配到最近的質心
        for (size_t i = 0; i < data.size(); ++i) {
            double min_distance = DBL_MAX;
            int closest_centroid = 0;
            for (int j = 0; j < k; ++j) {
                double distance = adaptive_distance(data[i], centroids[j]);
                if (distance < min_distance) {
                    min_distance = distance;
                    closest_centroid = j;
                }
            }
            clusters[closest_centroid].push_back(i);
            distances[i] = min_distance;
        }

        // 更新質心
        std::vector<std::vector<double>> new_centroids(k);
        for (int i = 0; i < k; ++i) {
            if (!clusters[i].empty()) {
                std::vector<double> cluster_mean(data[0].size(), 0);
                for (int index : clusters[i]) {
                    for (size_t j = 0; j < data[0].size(); ++j) {
                        cluster_mean[j] += data[index][j];
                    }
                }
                for (size_t j = 0; j < cluster_mean.size(); ++j) {
                    cluster_mean[j] /= clusters[i].size();
                }
                new_centroids[i] = cluster_mean;
            }
        }

        // 檢查質心是否收斂
        bool converged = true;
        for (int i = 0; i < k; ++i) {
            if (euclidean_distance(centroids[i], new_centroids[i]) > 1e-6) {
                converged = false;
                break;
            }
        }

        if (converged) {
            break;
        }

        centroids = new_centroids;
    }
}

最后，我們可以使用以下代碼測試我們的K-means聚類算法：

int main() {
    std::vector<std::vector<double>> data = {{1, 2}, {1.5, 1.8}, {5, 8}, {8, 8}, {1, 0.6}, {9, 11}};
    int k = 2;
    int max_iterations = 100;

    kmeans(data, k, max_iterations);

    std::cout << "質心：" << std::endl;
    for (const auto& centroid : centroids) {
        std::cout << "[" << centroid[0] << ", " << centroid[1] << "]" << std::endl;
    }

    return 0;
}

這個例子中，我們使用了自適應距離度量來計算數據點到質心的距離。adaptive_distance函數接受一個參數alpha，用于控制距離度量的權重。當alpha接近1時，距離度量將更依賴于歐幾里得距離；當alpha接近0時，距離度量將更依賴于最小距離閾值（這里設為1）。