MCLDA.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2013 Kevin Hughes
 * Copyright (C) 2013 Kevin Hughes
 *
 * Thanks to Fernando José Iglesias García (shogun)
 *           and Matthieu Perrot (scikit-learn)
 */

#ifndef _MCLDA_H__
#define _MCLDA_H__

#include <shogun/lib/config.h>


#include <shogun/features/DotFeatures.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/machine/NativeMulticlassMachine.h>
#include <shogun/lib/SGNDArray.h>

namespace shogun
{

//#define DEBUG_MCLDA

class CMCLDA : public CNativeMulticlassMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_MULTICLASS)

        
        CMCLDA(float64_t tolerance = 1e-4, bool store_cov = false);

        CMCLDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab, float64_t tolerance = 1e-4, bool store_cov = false);

        virtual ~CMCLDA();

        virtual CMulticlassLabels* apply_multiclass(CFeatures* data=NULL);

        inline void set_tolerance(float64_t tolerance) { m_tolerance = tolerance; }

        inline bool get_tolerance() { return m_tolerance; }

        virtual EMachineType get_classifier_type() { return CT_LDA; } // for now add to machine typers properly later

        virtual void set_features(CDotFeatures* feat)
        {
            if (feat->get_feature_class() != C_DENSE ||
                feat->get_feature_type() != F_DREAL)
                SG_ERROR("MCLDA requires SIMPLE REAL valued features\n")

            SG_REF(feat);
            SG_UNREF(m_features);
            m_features = feat;
        }

        virtual CDotFeatures* get_features() { SG_REF(m_features); return m_features; }

        virtual const char* get_name() const { return "MCLDA"; }

        inline SGVector< float64_t > get_mean(int32_t c) const
        {
            return SGVector< float64_t >(m_means.get_column_vector(c), m_dim, false);
        }

        inline SGMatrix< float64_t > get_cov() const
        {
            return m_cov;
        }

        protected:
        virtual bool train_machine(CFeatures* data = NULL);

    private:
        void init();

        void cleanup();

        private:
        CDotFeatures* m_features;

        float64_t m_tolerance;

        bool m_store_cov;

        int32_t m_num_classes;

        int32_t m_dim;

        SGMatrix< float64_t > m_cov;

        SGMatrix< float64_t > m_means;

        SGVector< float64_t > m_xbar;

        int32_t m_rank;

        SGMatrix< float64_t > m_scalings;

        SGMatrix< float64_t > m_coef;

        SGVector< float64_t > m_intercept;

}; /* class MCLDA */
}  /* namespace shogun */

#endif /* _MCLDA_H__ */