Synthetic

.gitignore

@@ -24,3 +24,4 @@
 /benchmark/build/
 /benchmark/release/
 /cmake-*
+/debug

benchmark/src/Benchmark.cpp

@@ -20,20 +20,27 @@ int main(int argc, char **argv) {
   //Parse parameters.
   param_t cmd_params;
   BenchmarkUtils::defaultParam(cmd_params);
-  cmd_params.pointNumber = 15120;
+  cmd_params.pointNumber = 3000;
   cmd_params.seed = 10;
-  cmd_params.clusterNumber = 10;
+  cmd_params.clusterNumber = 7;
   cmd_params.dimension = 54;
-  cmd_params.coresetSize = 100;
-  cmd_params.lastArrivingNum = 60;
-  cmd_params.timeWindow = 6;
-  cmd_params.timeInterval = 4;
-  cmd_params.onlineClusterNumber = 15;
-  cmd_params.radiusFactor = 2;
-  cmd_params.initBuffer = 500;
-  cmd_params.offlineTimeWindow = 2;
+  cmd_params.coresetSize = 600;
+  cmd_params.lastArrivingNum = 5;
+  cmd_params.timeWindow = 300;
+  cmd_params.timeInterval = 8;
+  cmd_params.onlineClusterNumber = 150;
+  cmd_params.radiusFactor = 20;
+  cmd_params.initBuffer = 20;
+  cmd_params.offlineTimeWindow = 0;
+  cmd_params.maxInternalNodes = 40;
+  cmd_params.maxLeafNodes = 20;
+  cmd_params.thresholdDistance = 10;
+  cmd_params.GTClusterNumber = 7;
+  cmd_params.timeDecay = false;
+
+
   cmd_params.outputPath = "results.txt";
-  cmd_params.algoType = SESAME::CluStreamType;
+  cmd_params.algoType = SESAME::StreamKMeansType;
   BenchmarkUtils::parseArgs(argc, argv, cmd_params);
   std::vector<SESAME::PointPtr> input;
   std::vector<SESAME::PointPtr> results;

include/Algorithm/OfflineClustering/KMeans.hpp

@@ -41,6 +41,7 @@ class KMeans : public SESAME::OfflineClustering {
   void produceResult(std::vector<std::vector<PointPtr>> &groups, DataSinkPtr sinkPtr);
   void runKMeans(int numberOfCenters,
                  int numberOfInput,
+                 std::vector<PointPtr> &centers,
                  std::vector<PointPtr> &input,
                  std::vector<std::vector<PointPtr>> &oldGroups,
                  std::vector<std::vector<PointPtr>> &newGroups,

include/Evaluation/Evaluation.hpp

@@ -14,9 +14,7 @@ namespace SESAME {
 
 class Evaluation {
  public:
-  static void runEvaluation(//int numberOfPoints,
-                           // int numberOfCenters,
-                            int dimension,
+  static void runEvaluation(int dimension,int GTClusterNumber, bool decay,
                             const std::vector<PointPtr> &inputs,
                             const std::vector<PointPtr> &results);
 

include/Evaluation/Purity.hpp

@@ -12,14 +12,14 @@ class Purity {
  private:
   static void pointToGroup(const std::vector<SESAME::PointPtr> &input,
                            std::vector<std::vector<PointPtr>> &group, int number);
-  static int calculateBelongsFromTwo(std::vector<SESAME::PointPtr> &groupA,
+  static double calculateBelongsFromTwo(std::vector<SESAME::PointPtr> &groupA,
                                      std::vector<SESAME::PointPtr> &groupB);
   static double getMaxBelongs(std::vector<SESAME::PointPtr> &singleSample,
                               std::vector<std::vector<PointPtr>> &GT);
  public:
   static double purityCost(const std::vector<PointPtr> &input,
                          const std::vector<PointPtr> &result,
-                         int dimension);
+                         int dimension, int GTclusterNumber, bool decay);
 };
 
 }

include/Utils/BenchmarkUtils.hpp

@@ -23,6 +23,7 @@
 
 struct param_t {
   int pointNumber;
+  bool timeDecay;
   int clusterNumber;
   int dimension;
   int coresetSize;
@@ -36,6 +37,7 @@ struct param_t {
   int offlineTimeWindow;
   int maxInternalNodes;
   int maxLeafNodes;
+  int GTClusterNumber;
   double thresholdDistance;
   //used in DenStream(unique)
   unsigned int minPoints;

include/Utils/UtilityFunctions.hpp

@@ -26,7 +26,7 @@
 #define CMM_KNN 10
 #define CMM_A 0.998
 #define CMM_LAMDA 1
-#define CMM_THRESHOLD 1000
+#define CMM_THRESHOLD 542
 
 /*
 Determines when Lloyd terminates (should be between 0 and 1)

src/Algorithm/Birch.cpp

@@ -29,7 +29,8 @@ void SESAME::Birch::runOfflineClustering(DataSinkPtr sinkPtr) {
     sinkPtr->put(centroid->copy());
   }
   timerMeter.printTime(false,false,false,false);
-  SESAME_DEBUG( "The size of the centroid is :" << sinkPtr->getResults().size());
+  //SESAME_DEBUG( "The size of the centroid is :" << sinkPtr->getResults().size());
+
 //  std::vector<std::vector<PointPtr>> oldGroups, newGroups;
 //  this->kmeans->runKMeans((int)middleCentroids.size() / 2, (int)middleCentroids.size(),
 //                          middleCentroids,oldGroups,newGroups, true);
@@ -128,12 +129,14 @@ void SESAME::Birch::selectChild(vector<SESAME::NodePtr> &children, SESAME::Point
 
 // calculate the radius of a cluster
 double SESAME::Birch::calculateRadius(SESAME::PointPtr &point, SESAME::PointPtr &centroid) {
+  timerMeter.dataInsertAccMeasure();
   double denominator = 0;
   double radius = 0;
   for(int i = 0; i < point->getDimension(); i++) {
     denominator += pow(centroid->getFeatureItem(i) - point->getFeatureItem(i), 2);
   }
   radius = sqrt(denominator);
+  timerMeter.dataInsertEndMeasure();
   return radius;
 }
 
@@ -213,22 +216,27 @@ void SESAME::Birch::forwardInsert(SESAME::PointPtr point){
       if(curNode->getIsLeaf()) {
         timerMeter.clusterUpdateAccMeasure();
         CFPtr curCF = curNode->getCF();
+        timerMeter.dataInsertAccMeasure();
         if(curCF->getN() == 0) {
           initializeCF(curCF, point->getDimension());
         }
         PointPtr centroid = make_shared<Point>();
         calculateCentroid(curCF, centroid);
+        timerMeter.dataInsertEndMeasure();
         if(calculateRadius(point,  centroid) <= this->cfTree->getT()) { // concept drift detection
           // whether the new radius is lower than threshold T
+          timerMeter.dataInsertAccMeasure();
           updateNLS(curNode, point, true);
-          timerMeter.clusterUpdateEndMeasure();
+          timerMeter.dataInsertEndMeasure();
+
           // means this point could get included in this cluster
-          SESAME_DEBUG("No concept drift occurs(t <= T), insert tha point into the leaf node...");
+          //SESAME_DEBUG("No concept drift occurs(t <= T), insert tha point into the leaf node...");
           break;
           // Normally insert the data point into the tree leafNode without concept drift
         } else {
           // concept drift adaption
-          SESAME_DEBUG("Concept drift occurs(t > T), the current leaf node capacity reaches the threshold T");
+          // SESAME_DEBUG("Concept drift occurs(t > T), the current leaf node capacity reaches the threshold T");
+          timerMeter.clusterUpdateAccMeasure();
           backwardEvolution(curNode, point);
           timerMeter.clusterUpdateEndMeasure();
           break;
@@ -246,7 +254,7 @@ void SESAME::Birch::forwardInsert(SESAME::PointPtr point){
 // concept drift adaption
 void SESAME::Birch::backwardEvolution(SESAME::NodePtr &curNode, SESAME::PointPtr &point) {
   if(curNode->getParents().empty()) { // means current node is root node
-    SESAME_DEBUG("l <= L, create a new leaf node and insert the point into it(root change)");
+    //SESAME_DEBUG("l <= L, create a new leaf node and insert the point into it(root change)");
     NodePtr newRoot = make_shared<CFNode>();
     newRoot->setIsLeaf(false);
     newRoot->setChild(curNode);
@@ -278,13 +286,13 @@ void SESAME::Birch::backwardEvolution(SESAME::NodePtr &curNode, SESAME::PointPtr
     parent->setChild(newNode);
     if(parent->getChildren().size() <= this->cfTree->getL()){
       // whether the number of CFs(clusters) in the current leaf node is lower thant threshold L
-      SESAME_DEBUG("l <= L, create a new leaf node and insert the point into it");
+      //SESAME_DEBUG("l <= L, create a new leaf node and insert the point into it");
 
       // update the parent node
       updateNLS(parent, point, true);
     } else{
-      SESAME_DEBUG("l > L, parent node of the current leaf node capacity reaches the threshold L");
-      SESAME_DEBUG("split a new parent node from the old one ");
+     // SESAME_DEBUG("l > L, parent node of the current leaf node capacity reaches the threshold L");
+      //SESAME_DEBUG("split a new parent node from the old one ");
       bool CurNodeIsLeaf = true;
       while(true) {
         NodePtr parParent;
@@ -370,10 +378,10 @@ void SESAME::Birch::backwardEvolution(SESAME::NodePtr &curNode, SESAME::PointPtr
         }
 
         if(parParent->getChildren().size() <= this->cfTree->getB()) {
-          SESAME_DEBUG("b < B, remove the old node and insert the new nodeA and nodeB into the parent node");
+          //SESAME_DEBUG("b < B, remove the old node and insert the new nodeA and nodeB into the parent node");
           break;
         }else {
-          SESAME_DEBUG("b >= B, parent node of the current interior node capacity reaches the threshold B");
+          //SESAME_DEBUG("b >= B, parent node of the current interior node capacity reaches the threshold B");
           curNode = curNode->getParents()[0];
           parent = parParent;
           CurNodeIsLeaf = false;