kmeans.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef KMEANS_H
#define KMEANS_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "math_global.h"
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <random>
#include <string>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// DEFINE NAMESPACE UTILSLIB
//=============================================================================================================
 
namespace UTILSLIB
{
 
//=============================================================================================================
// ENUMS
//=============================================================================================================

enum class KMeansDistance
{
    SquaredEuclidean,   
    CityBlock,          
    Cosine,             
    Correlation,        
    Hamming             
};

enum class KMeansStart
{
    Sample,             
    Uniform,            
    Cluster             
};

enum class KMeansEmptyAction
{
    Error,              
    Drop,               
    Singleton           
};
 
//=============================================================================================================
class MATHSHARED_EXPORT KMeans
{
public:
    typedef QSharedPointer<KMeans> SPtr;            
    typedef QSharedPointer<const KMeans> ConstSPtr; 
 
    //=========================================================================================================
    explicit KMeans(QString distance = QString("sqeuclidean"),
                    QString start = QString("sample"),
                    qint32 replicates = 1,
                    QString emptyact = QString("error"),
                    bool online = true,
                    qint32 maxit = 100);
 
    //=========================================================================================================
    explicit KMeans(KMeansDistance distance,
                    KMeansStart start = KMeansStart::Sample,
                    qint32 replicates = 1,
                    KMeansEmptyAction emptyact = KMeansEmptyAction::Error,
                    bool online = true,
                    qint32 maxit = 100);
 
    //=========================================================================================================
    bool calculate(const Eigen::MatrixXd& X,
                   qint32 kClusters,
                   Eigen::VectorXi& idx,
                   Eigen::MatrixXd& C,
                   Eigen::VectorXd& sumD,
                   Eigen::MatrixXd& D);
 
private:
    //=========================================================================================================
    Eigen::MatrixXd distfun(const Eigen::MatrixXd& X,
                            const Eigen::MatrixXd& C);
 
    //=========================================================================================================
    bool batchUpdate(const Eigen::MatrixXd& X,
                     Eigen::MatrixXd& C,
                     Eigen::VectorXi& idx);
 
    //=========================================================================================================
    void gcentroids(const Eigen::MatrixXd& X,
                    const Eigen::VectorXi& index,
                    const Eigen::VectorXi& clusts,
                    Eigen::MatrixXd& centroids,
                    Eigen::VectorXi& counts);
 
    //=========================================================================================================
    bool onlineUpdate(const Eigen::MatrixXd& X,
                      Eigen::MatrixXd& C,
                      Eigen::VectorXi& idx);
 
    //=========================================================================================================
    static KMeansDistance distanceFromString(const std::string& name);
 
    //=========================================================================================================
    static KMeansStart startFromString(const std::string& name);
 
    //=========================================================================================================
    static KMeansEmptyAction emptyactFromString(const std::string& name);
 
    KMeansDistance     m_distance;    
    KMeansStart        m_start;       
    KMeansEmptyAction  m_emptyact;    
    qint32 m_iReps;                   
    qint32 m_iMaxit;                  
    bool   m_bOnline;                 
 
    std::mt19937 m_rng;               
 
    qint32 emptyErrCnt;               
    qint32 iter;                      
    qint32 k;                         
    qint32 n;                         
    qint32 p;                         
 
    Eigen::MatrixXd Del;              
    Eigen::VectorXd d;                
    Eigen::VectorXi m;                
 
    double totsumD;                   
    double prevtotsumD;               
    Eigen::VectorXi previdx;          
};
} // NAMESPACE
 
#endif // KMEANS_H