LeastAngleRegression.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 Chiyuan Zhang
 * Copyright (C) 2012 Chiyuan Zhang
 */

#ifndef LEASTANGLEREGRESSION_H__
#define LEASTANGLEREGRESSION_H__

#include <shogun/lib/config.h>

#include <vector>
#include <shogun/machine/LinearMachine.h>

namespace shogun
{

class CFeatures;

class CLeastAngleRegression: public CLinearMachine
{
public:

    MACHINE_PROBLEM_TYPE(PT_REGRESSION);

    CLeastAngleRegression(bool lasso = true);

    virtual ~CLeastAngleRegression();

    void set_max_non_zero(int32_t n)
    {
        m_max_nonz = n;
    }

    int32_t get_max_non_zero() const
    {
        return m_max_nonz;
    }

    void set_max_l1_norm(float64_t norm)
    {
        m_max_l1_norm = norm;
    }

    float64_t get_max_l1_norm() const
    {
        return m_max_l1_norm;
    }

    void switch_w(int32_t num_variable)
    {
        REQUIRE(w.vlen > 0,"Please train the model (i.e. run the model's train() method) before updating its weights.\n")
        REQUIRE(size_t(num_variable) < m_beta_idx.size() && num_variable >= 0,
            "Cannot switch to an estimator of %d non-zero coefficients.\n", num_variable)
        if (w.vector == NULL)
            w = SGVector<float64_t>(w.vlen);

        std::copy(m_beta_path[m_beta_idx[num_variable]].begin(),
            m_beta_path[m_beta_idx[num_variable]].end(), w.vector);
    }

    int32_t get_path_size() const
    {
        return m_beta_idx.size();
    }

    SGVector<float64_t> get_w_for_var(int32_t num_var)
    {
        return SGVector<float64_t>(&m_beta_path[m_beta_idx[num_var]][0], w.vlen, false);
    }

    virtual EMachineType get_classifier_type()
    {
        return CT_LARS;
    }

    void set_epsilon(float64_t epsilon)
    {
        m_epsilon = epsilon;
    }

    float64_t get_epsilon()
    {
        return m_epsilon;
    }

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

protected:
    bool train_machine(CFeatures * data);

    template <typename ST>
    SGMatrix<ST> cholesky_insert(const SGMatrix<ST>& X, 
            const SGMatrix<ST>& X_active, SGMatrix<ST>& R, int32_t i_max_corr, int32_t num_active);

    template <typename ST>
    SGMatrix<ST> cholesky_delete(SGMatrix<ST>& R, int32_t i_kick);

    template <typename ST>
    static void plane_rot(ST x0, ST x1,
        ST &y0, ST &y1, SGMatrix<ST> &G);

    #ifndef SWIG
    template <typename ST>
    static void find_max_abs(const std::vector<ST> &vec, const std::vector<bool> &ignore_mask,
        int32_t &imax, ST& vmax);
    #endif

private:
    template <typename ST>
    bool train_machine_templated(CDenseFeatures<ST> * data);

    void activate_variable(int32_t v)
    {
        m_num_active++;
        m_active_set.push_back(v);
        m_is_active[v] = true;
    }

    void deactivate_variable(int32_t v_idx)
    {
        m_num_active--;
        m_is_active[m_active_set[v_idx]] = false;
        m_active_set.erase(m_active_set.begin() + v_idx);
    }
    
    bool m_lasso; 

    int32_t m_max_nonz;  
    float64_t m_max_l1_norm; 

    std::vector<std::vector<float64_t> > m_beta_path;
    std::vector<int32_t> m_beta_idx;
    std::vector<int32_t> m_active_set;
    std::vector<bool> m_is_active;
    int32_t m_num_active;
    float64_t m_epsilon;
}; // class LARS

} // namespace shogun

#endif // LEASTANGLEREGRESSION_H__