LibLinearRegression.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.
 *
 * Copyright (C) 2012 Soeren Sonnenburg
 */

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

namespace shogun
{
    enum LIBLINEAR_REGRESSION_TYPE
    {
        L2R_L2LOSS_SVR,
        L2R_L1LOSS_SVR_DUAL,
        L2R_L2LOSS_SVR_DUAL
    };

class CLibLinearRegression : public CLinearMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_REGRESSION)

        
        CLibLinearRegression();

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

        virtual ~CLibLinearRegression();

        inline LIBLINEAR_REGRESSION_TYPE get_liblinear_regression_type()
        {
            return m_liblinear_regression_type;
        }

        inline void set_liblinear_regression_type(LIBLINEAR_REGRESSION_TYPE st)
        {
            m_liblinear_regression_type=st;
        }

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

        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_tube_epsilon(float64_t eps) { m_tube_epsilon=eps; }

        inline float64_t get_tube_epsilon() { return m_tube_epsilon; }


        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_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; }

protected:

        virtual bool train_machine(CFeatures* data = NULL);

private:
        void solve_l2r_l1l2_svr(const problem *prob);

        void init_defaults();

        void register_parameters();

protected:

        float64_t m_C;

        float64_t m_epsilon;

        float64_t m_tube_epsilon;

        int32_t m_max_iter;

        bool m_use_bias;

        LIBLINEAR_REGRESSION_TYPE m_liblinear_regression_type;
};
}
#endif /* HAVE_LAPACK */
#endif