Feature/skmeans

FlucomaClients.cmake

@@ -144,6 +144,7 @@ add_client(DataSetQuery clients/nrt/DataSetQueryClient.hpp CLASS NRTThreadedData
 add_client(LabelSet clients/nrt/LabelSetClient.hpp CLASS NRTThreadedLabelSetClient GROUP MANIPULATION)
 add_client(KDTree clients/nrt/KDTreeClient.hpp CLASS NRTThreadedKDTreeClient GROUP MANIPULATION)
 add_client(KMeans clients/nrt/KMeansClient.hpp CLASS NRTThreadedKMeansClient GROUP MANIPULATION)
+add_client(SKMeans clients/nrt/SKMeansClient.hpp CLASS NRTThreadedSKMeansClient GROUP MANIPULATION)
 add_client(KNNClassifier clients/nrt/KNNClassifierClient.hpp CLASS NRTThreadedKNNClassifierClient GROUP MANIPULATION)
 add_client(KNNRegressor clients/nrt/KNNRegressorClient.hpp CLASS NRTThreadedKNNRegressorClient GROUP MANIPULATION)
 add_client(Normalize clients/nrt/NormalizeClient.hpp CLASS NRTThreadedNormalizeClient GROUP MANIPULATION)

include/algorithms/public/KMeans.hpp

@@ -109,7 +109,7 @@ class KMeans
     out <<= _impl::asFluid(mAssignments);
   }
 
-  void getDistances(RealMatrixView data, RealMatrixView out) const
+  void transform(RealMatrixView data, RealMatrixView out) const
   {
     Eigen::ArrayXXd points = _impl::asEigen<Eigen::Array>(data);
     Eigen::ArrayXXd D = fluid::algorithm::DistanceMatrix(points, 2);
@@ -118,8 +118,8 @@ class KMeans
     out <<= _impl::asFluid(D);
   }
 
-private:
-  double distance(Eigen::ArrayXd v1, Eigen::ArrayXd v2) const
+protected:
+  double distance(const Eigen::ArrayXd&  v1, const Eigen::ArrayXd& v2) const
   {
     return (v1 - v2).matrix().norm();
   }

include/algorithms/public/SKMeans.hpp

@@ -0,0 +1,121 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#pragma once
+
+#include "../public/KMeans.hpp"
+#include "../util/FluidEigenMappings.hpp"
+#include "../../data/FluidDataSet.hpp"
+#include "../../data/FluidIndex.hpp"
+#include "../../data/FluidTensor.hpp"
+#include "../../data/TensorTypes.hpp"
+#include <Eigen/Core>
+#include <queue>
+#include <string>
+
+namespace fluid {
+namespace algorithm {
+
+class SKMeans : public KMeans
+{
+
+public:
+  void train(const FluidDataSet<std::string, double, 1>& dataset, index k,
+             index maxIter)
+  {
+    using namespace Eigen;
+    using namespace _impl;
+    assert(!mTrained || (dataset.pointSize() == mDims && mK == k));
+    MatrixXd dataPoints = asEigen<Matrix>(dataset.getData());
+    MatrixXd dataPointsT = dataPoints.transpose();
+    if (mTrained) { mAssignments = assignClusters(dataPointsT);}
+    else
+    {
+      mK = k;
+      mDims = dataset.pointSize();
+      initMeans(dataPoints);
+    }
+
+    while (maxIter-- > 0)
+    {
+      mEmbedding = mMeans.matrix() * dataPointsT;
+      auto assignments = assignClusters(mEmbedding);
+      if (!changed(assignments)) { break; }
+      else
+        mAssignments = assignments;
+      updateEmbedding();
+      computeMeans(dataPoints);
+    }
+    mTrained = true;
+  }
+
+
+  void encode(RealMatrixView data, RealMatrixView out,
+                 double alpha = 0.25) const
+  {
+    using namespace Eigen;
+    MatrixXd points = _impl::asEigen<Matrix>(data).transpose();
+    MatrixXd embedding = (mMeans.matrix() * points).array() - alpha;
+    embedding = (embedding.array() > 0).select(embedding, 0).transpose();
+    out <<= _impl::asFluid(embedding);
+  }
+
+private:
+
+  void initMeans(Eigen::MatrixXd& dataPoints)
+  {
+    using namespace Eigen;
+    mMeans = ArrayXXd::Zero(mK, mDims);
+    mAssignments =
+        ((0.5 + (0.5 * ArrayXd::Random(dataPoints.rows()))) * (mK - 1))
+            .round()
+            .cast<int>();
+    mEmbedding = MatrixXd::Zero(mK, dataPoints.rows());
+    for (index i = 0; i < dataPoints.rows(); i++)
+      mEmbedding(mAssignments(i), i) = 1;
+    computeMeans(dataPoints);
+  }
+
+  void updateEmbedding()
+  {
+    for (index i = 0; i < mAssignments.cols(); i++)
+    {
+      double val = mEmbedding(mAssignments(i), i);
+      mEmbedding.col(i).setZero();
+      mEmbedding(mAssignments(i), i) = val;
+    }
+  }
+
+
+  Eigen::VectorXi assignClusters(Eigen::MatrixXd& embedding) const
+  {
+    Eigen::VectorXi assignments = Eigen::VectorXi::Zero(embedding.cols());
+    for (index i = 0; i < embedding.cols(); i++)
+    {
+      Eigen::VectorXd::Index maxIndex;
+      embedding.col(i).maxCoeff(&maxIndex);
+      assignments(i) = static_cast<int>(maxIndex);
+    }
+    return assignments;
+  }
+
+
+  void computeMeans(Eigen::MatrixXd& dataPoints)
+  {
+    mMeans = mEmbedding * dataPoints;
+    mMeans.matrix().rowwise().normalize();
+  }
+
+
+private:
+  Eigen::MatrixXd mEmbedding;
+};
+} // namespace algorithm
+} // namespace fluid

include/clients/nrt/KMeansClient.hpp

@@ -146,7 +146,7 @@ class KMeansClient : public FluidBaseClient,
 
     StringVectorView ids = srcDataSet.getIds();
     RealMatrix       output(srcDataSet.size(), mAlgorithm.size());
-    mAlgorithm.getDistances(srcDataSet.getData(), output);
+    mAlgorithm.transform(srcDataSet.getData(), output);
     FluidDataSet<string, double, 1> result(ids, output);
     destPtr->setDataSet(result);
     return OK();
@@ -224,7 +224,7 @@ class KMeansClient : public FluidBaseClient,
     RealMatrix dest(1, mAlgorithm.size());
     src.row(0) <<=
         BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
-    mAlgorithm.getDistances(src, dest);
+    mAlgorithm.transform(src, dest);
     outBuf.allFrames()(Slice(0, 1), Slice(0, mAlgorithm.size())) <<= dest;
     return OK();
   }