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 = ;
         size_t end = ;
         while (start < s.size()) {
             end = s.find_first_of(pattern, start);
             if (end == string::npos) {
                 res.push_back(s.substr(start, end - start - ));
                 return res;
             }
             res.push_back(s.substr(start, end - start));
             start = end + ;
         }
         return res;
     }

     void loadDataSet(const char* fileName) {
         ifstream dataFile(fileName);
         if (!dataFile.is_open()) {
             cerr << "open file " << fileName << "failed!\n";
             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 = ;
         for (size_t i = ; i < v1.size(); i++) {
             dist += (v1[i] - v2[i]) * (v1[i] - v2[i]);
         }
         return sqrt(dist);
     }

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

         //first:min second：max
         vector<pair<double, double>> minMaxOfFeat(numOfFeats);
         for (int i = ; i < numOfFeats; i++) {
             minMaxOfFeat[i].first = this->m_dataSet[][i];
             minMaxOfFeat[i].second = this->m_dataSet[][i];
         }
         for (size_t i = ; i < numOfSamples; i++) {
             for (int j = ; 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 = ; i < this->m_k; i++) {
             for (int j = ; 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[].size();
         cout << "iter =  " << iter;
         for (int i = ; i < m; i++) {
             cout << " {";
             for (int j = ; 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 = ; i < this->m_dataSet.size(); i++) {
             for (size_t j = ; j < this->m_dataSet[].size(); j++) {
                 fout << this->m_dataSet[i][j] << "\t";
             }
             fout << setprecision() << this->m_clusterResult[i] << "\n";
         }
         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[].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[].size()));
         generateRandCent();
     }

     //verbose = 1,printClusterCent();
     void kmeansCluster(int verbose = ) {
         int iter = ;
         bool isClusterChanged = true;
         while (isClusterChanged) {
             isClusterChanged = false;
             //step 1: find the nearest centroid of each point
             int numOfFeats = this->m_dataSet[].size();
             size_t numOfSamples = this->m_dataSet.size();
             for (size_t i = ; i < numOfSamples; i++) {
                 int minIndex = -;
                 double minDist = INT_MAX;
                 for (int j = ; 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, );
             this->m_cluserCent = vector<vector<double>>(this->m_k,
                     vector<double>(numOfFeats, 0.0));
             for (size_t i = ; i < numOfSamples; i++) {
                 for (int j = ; 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 = ; i < this->m_k; i++) {
                 for (int j = ; j < numOfFeats; j++) {
                     this->m_cluserCent[i][j] /= cnt[i];
                 }
             }
             if (verbose)
                 printClusterCent(iter++);
         }
         writeResult();
     }
 };

 };

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