DualLibQPBMSOSVM.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) 2012 Michal Uricar
 * Copyright (C) 2012 Michal Uricar
 */

#ifndef _DUALLIBQPBMSOSVM__H__
#define _DUALLIBQPBMSOSVM__H__

#include <shogun/lib/config.h>
#ifdef USE_GPL_SHOGUN

#include <shogun/machine/LinearStructuredOutputMachine.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/structure/BmrmStatistics.h>

namespace shogun
{

enum ESolver
{
    BMRM=1,     
    PPBMRM=2,   
    P3BMRM=3,   
    NCBM=4
};

class CDualLibQPBMSOSVM : public CLinearStructuredOutputMachine
{
    public:
        CDualLibQPBMSOSVM();

        CDualLibQPBMSOSVM(
                CStructuredModel*       model,
                CStructuredLabels*      labs,
                float64_t               _lambda,
                SGVector< float64_t >   W=0);

        virtual ~CDualLibQPBMSOSVM();

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

        inline void set_lambda(float64_t _lambda) { m_lambda=_lambda; }

        inline float64_t get_lambda() { return m_lambda; }

        inline void set_TolRel(float64_t TolRel) { m_TolRel=TolRel; }

        inline float64_t get_TolRel() { return m_TolRel; }

        inline void set_TolAbs(float64_t TolAbs) { m_TolAbs=TolAbs; }

        inline float64_t get_TolAbs() { return m_TolAbs; }

        inline void set_BufSize(uint32_t BufSize) { m_BufSize=BufSize; }

        inline uint32_t get_BufSize() { return m_BufSize; }

        inline void set_cleanICP(bool cleanICP) { m_cleanICP=cleanICP; }

        inline bool get_cleanICP() { return m_cleanICP; }

        inline void set_cleanAfter(uint32_t cleanAfter) { m_cleanAfter=cleanAfter; }

        inline uint32_t get_cleanAfter() { return m_cleanAfter; }

        inline void set_K(float64_t K) { m_K=K; }

        inline float64_t get_K() { return m_K; }

        inline void set_Tmax(uint32_t Tmax) { m_Tmax=Tmax; }

        inline uint32_t get_Tmax() { return m_Tmax; }

        inline void set_cp_models(uint32_t cp_models) { m_cp_models=cp_models; }

        inline uint32_t get_cp_models() { return m_cp_models; }

        inline BmrmStatistics get_result() { return m_result; }

        inline ESolver get_solver() { return m_solver; }

        inline void set_solver(ESolver solver) { m_solver=solver; }

        inline void set_w(SGVector< float64_t > W)
        {
            REQUIRE(W.vlen == m_model->get_dim(), "Dimension of the initial "
                    "solution must match the model's dimension!\n");
            m_w=W;
        }

        inline void set_store_train_info(bool store_train_info)
        {
            m_store_train_info=store_train_info;
        }

        virtual EMachineType get_classifier_type();

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

    private:
        void init();

    private:

        float64_t m_lambda;

        float64_t m_TolRel;

        float64_t m_TolAbs;

        uint32_t m_BufSize;

        bool m_cleanICP;

        uint32_t m_cleanAfter;

        float64_t m_K;

        uint32_t m_Tmax;

        uint32_t m_cp_models;

        BmrmStatistics m_result;

        ESolver m_solver;

        bool m_store_train_info;

}; /* class CDualLibQPBMSOSVM */

} /* namespace shogun */

#endif //USE_GPL_SHOGUN
#endif /* _DUALLIBQPBMSOSVM__H__ */