kmean算法C++实现

kmean均值算法是一种最常见的聚类算法。算法实现简单，效果也比较好。kmean算法把n个对象划分成指定的k个簇，每个簇中所有对象的均值的平均值为该簇的聚点（中心）。

k均值算法有如下五个步骤：

1. 随机生成最初始k个簇心。可以从样本中随机选择，也可以根据样本中每个特征的取值特点随机生成。
2. 对每个样本计算到每个簇心的欧式距离，将样本划分到欧氏距离最小的簇心（聚点）。
3. 对划分到同一个簇心（聚点）的样本计算平均值，用均值更新簇心（聚点）
4. 若某些簇心（聚点）发生变化，转到2；若所有的聚点都没有变化，转5
5. 输出划分结果

#include <vector>
#include <cassert>
#include <iostream>
#include <cmath>
#include <fstream>
#include <climits>
#include <ctime>
#include <iomanip>

using namespace std;
namespace terse {
class Kmeans {
private:
    vector<vector<double>> m_dataSet;
    int m_k;
    vector<int> m_clusterResult;         // result of cluster
    vector<vector<double>> m_cluserCent; //center of k clusters

private:
    vector<string> split(const string& s, string pattern) {
        vector<string> res;
        size_t start = 0;
        size_t end = 0;
        while (start < s.size()) {
            end = s.find_first_of(pattern, start);
            if (end == string::npos) {
                res.push_back(s.substr(start, end - start - 1));
                return res;
            }
            res.push_back(s.substr(start, end - start));
            start = end + 1;
        }
        return res;
    }

    void loadDataSet(const char* fileName) {
        ifstream dataFile(fileName);
        if (!dataFile.is_open()) {
            cerr << "open file " << fileName << "failed!
";
            return;
        }
        string tmpstr;
        vector<double> data;
        while (!dataFile.eof()) {
            data.clear();
            tmpstr.clear();
            getline(dataFile, tmpstr);
            vector<string> tmp = split(tmpstr, ",");
            for (string str : tmp) {
                data.push_back(stod(str));
            }
            this->m_dataSet.push_back(data);
        }
        dataFile.close();
    }

    //compute Euclidean distance of two vector
    double distEclud(vector<double>& v1, vector<double>& v2) {
        assert(v1.size() == v2.size());
        double dist = 0;
        for (size_t i = 0; i < v1.size(); i++) {
            dist += (v1[i] - v2[i]) * (v1[i] - v2[i]);
        }
        return sqrt(dist);
    }

    void generateRandCent() {
        int numOfFeats = this->m_dataSet[0].size();
        size_t numOfSamples = this->m_dataSet.size();

        //first:min second：max
        vector<pair<double, double>> minMaxOfFeat(numOfFeats);
        for (int i = 0; i < numOfFeats; i++) {
            minMaxOfFeat[i].first = this->m_dataSet[0][i];
            minMaxOfFeat[i].second = this->m_dataSet[0][i];
        }
        for (size_t i = 1; i < numOfSamples; i++) {
            for (int j = 0; j < numOfFeats; j++) {
                if (this->m_dataSet[i][j] > minMaxOfFeat[j].second) {
                    minMaxOfFeat[j].second = this->m_dataSet[i][j];
                }
                if (this->m_dataSet[i][j] < minMaxOfFeat[j].first) {
                    minMaxOfFeat[j].first = this->m_dataSet[i][j];
                }
            }
        }
        srand(time(NULL));
        for (int i = 0; i < this->m_k; i++) {
            for (int j = 0; j < numOfFeats; j++) {
                this->m_cluserCent[i][j] = minMaxOfFeat[j].first
                        + (minMaxOfFeat[j].second - minMaxOfFeat[j].first)
                                * (rand() / (double) RAND_MAX);
            }
        }

    }

    void printClusterCent(int iter) {
        int m = this->m_cluserCent.size();
        int n = this->m_cluserCent[0].size();
        cout << "iter =  " << iter;
        for (int i = 0; i < m; i++) {
            cout << " {";
            for (int j = 0; j < n; j++) {
                cout << this->m_cluserCent[i][j] << ",";
            }
            cout << "};";
        }
        cout << endl;
    }

    void writeResult(const char* fileName = "res.txt") {
        ofstream fout(fileName);
        if (!fout.is_open()) {
            cerr << "open file " << fileName << "failed!";
            return;
        }
        for (size_t i = 0; i < this->m_dataSet.size(); i++) {
            for (size_t j = 0; j < this->m_dataSet[0].size(); j++) {
                fout << this->m_dataSet[i][j] << "	";
            }
            fout << setprecision(5) << this->m_clusterResult[i] << "
";
        }
        fout.close();
    }

public:
    Kmeans(int k, const char* fileName) {
        this->m_k = k;
        this->loadDataSet(fileName);
        this->m_clusterResult.reserve(this->m_dataSet.size());
        this->m_cluserCent = vector<vector<double>>(k,
                vector<double>(this->m_dataSet[0].size()));
        generateRandCent();
    }

    Kmeans(int k, vector<vector<double>>& data) {
        this->m_k = k;
        this->m_dataSet = data;
        this->m_clusterResult.reserve(this->m_dataSet.size());
        this->m_cluserCent = vector<vector<double>>(k,
                vector<double>(this->m_dataSet[0].size()));
        generateRandCent();
    }

    //verbose = 1,printClusterCent();
    void kmeansCluster(int verbose = 1) {
        int iter = 0;
        bool isClusterChanged = true;
        while (isClusterChanged) {
            isClusterChanged = false;
            //step 1: find the nearest centroid of each point
            int numOfFeats = this->m_dataSet[0].size();
            size_t numOfSamples = this->m_dataSet.size();
            for (size_t i = 0; i < numOfSamples; i++) {
                int minIndex = -1;
                double minDist = INT_MAX;
                for (int j = 0; j < this->m_k; j++) {
                    double dist = distEclud(this->m_cluserCent[j],
                            m_dataSet[i]);
                    if (dist < minDist) {
                        minDist = dist;
                        minIndex = j;
                    }
                }
                if (m_clusterResult[i] != minIndex) {
                    isClusterChanged = true;
                    m_clusterResult[i] = minIndex;
                }
            }

            //step 2: update cluster center
            vector<size_t> cnt(this->m_k, 0);
            this->m_cluserCent = vector<vector<double>>(this->m_k,
                    vector<double>(numOfFeats, 0.0));
            for (size_t i = 0; i < numOfSamples; i++) {
                for (int j = 0; j < numOfFeats; j++) {
                    this->m_cluserCent[this->m_clusterResult[i]][j] +=
                            this->m_dataSet[i][j];
                }
                cnt[this->m_clusterResult[i]]++;
            }
            // mean of the vector belong to a cluster
            for (int i = 0; i < this->m_k; i++) {
                for (int j = 0; j < numOfFeats; j++) {
                    this->m_cluserCent[i][j] /= cnt[i];
                }
            }
            if (verbose)
                printClusterCent(iter++);
        }
        writeResult();
    }
};

};

int main(){
    terse::Kmeans kmeans(4,"datafile.txt");
    kmeans.kmeansCluster();
    return 0;
}
/*namespace terse*/