MulticlassLibLinear.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 Sergey Lisitsyn
 * Copyright (C) 2012 Sergey Lisitsyn
 */

#ifndef _MULTICLASSLIBLINEAR_H___
#define _MULTICLASSLIBLINEAR_H___
#include <shogun/lib/config.h>
#ifdef HAVE_LAPACK
#include <shogun/lib/common.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/machine/LinearMulticlassMachine.h>
#include <shogun/optimization/liblinear/shogun_liblinear.h>

namespace shogun
{

class CMulticlassLibLinear : public CLinearMulticlassMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_MULTICLASS)

        
        CMulticlassLibLinear();

        CMulticlassLibLinear(float64_t C, CDotFeatures* features, CLabels* labs);

        virtual ~CMulticlassLibLinear();

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

        inline void set_C(float64_t C)
        {
            ASSERT(C>0);
            m_C = C;
        }
        inline float64_t get_C() const { return m_C; }

        inline void set_epsilon(float64_t epsilon)
        {
            ASSERT(epsilon>0);
            m_epsilon = epsilon;
        }
        inline float64_t get_epsilon() const { return m_epsilon; }

        inline void set_use_bias(bool use_bias)
        {
            m_use_bias = use_bias;
        }
        inline bool get_use_bias() const
        {
            return m_use_bias;
        }

        inline void set_save_train_state(bool save_train_state)
        {
            m_save_train_state = save_train_state;
        }
        inline bool get_save_train_state() const
        {
            return m_save_train_state;
        }

        inline void set_max_iter(int32_t max_iter)
        {
            ASSERT(max_iter>0);
            m_max_iter = max_iter;
        }
        inline int32_t get_max_iter() const { return m_max_iter; }

        void reset_train_state()
        {
            if (m_train_state)
            {
                delete m_train_state;
                m_train_state = NULL;
            }
        }

        SGVector<int32_t> get_support_vectors() const;

protected:

        virtual bool train_machine(CFeatures* data = NULL);

        virtual SGMatrix<float64_t> obtain_regularizer_matrix() const;

private:

        void init_defaults();

        void register_parameters();

protected:

        float64_t m_C;

        float64_t m_epsilon;

        int32_t m_max_iter;

        bool m_use_bias;

        bool m_save_train_state;

        mcsvm_state* m_train_state;
};
}
#endif /* HAVE_LAPACK */
#endif