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("singleton"),
                    bool online = true,
                    qint32 maxit = 100);
 
    //=========================================================================================================
    explicit KMeans(KMeansDistance distance,
                    KMeansStart start = KMeansStart::Sample,
                    qint32 replicates = 1,
                    KMeansEmptyAction emptyact = KMeansEmptyAction::Singleton,
                    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);
 
    //=========================================================================================================
    bool calculate(const Eigen::MatrixXd& X,
                   const Eigen::MatrixXd& start,
                   Eigen::VectorXi& idx,
                   Eigen::MatrixXd& C,
                   Eigen::VectorXd& sumD,
                   Eigen::MatrixXd& D);
 
private:
    //=========================================================================================================
    Eigen::MatrixXd normalizedRows(const Eigen::MatrixXd& X) const;
 
    //=========================================================================================================
    bool runReplicate(const Eigen::MatrixXd& X,
                      Eigen::MatrixXd& C,
                      Eigen::VectorXi& idx,
                      Eigen::VectorXd& sumD,
                      Eigen::MatrixXd& D,
                      qint32 rep);
 
    //=========================================================================================================
    Eigen::MatrixXd distfun(const Eigen::MatrixXd& X,
                            const Eigen::MatrixXd& C);
 
    //=========================================================================================================
    bool batchUpdate(const Eigen::MatrixXd& X,
                     Eigen::MatrixXd& C,
                     Eigen::VectorXi& idx,
                     bool& converged);
 
    //=========================================================================================================
    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