RelaxedTree.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 RELAXEDTREE_H__
#define RELAXEDTREE_H__

#include <utility>
#include <vector>

#include <shogun/features/DenseFeatures.h>
#include <shogun/classifier/svm/LibSVM.h>
#include <shogun/multiclass/tree/TreeMachine.h>
#include <shogun/multiclass/tree/RelaxedTreeNodeData.h>

namespace shogun
{

class CBaseMulticlassMachine;

class CRelaxedTree: public CTreeMachine<RelaxedTreeNodeData>
{
public:
    CRelaxedTree();

    virtual ~CRelaxedTree();

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

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

    void set_features(CDenseFeatures<float64_t> *feats)
    {
        SG_REF(feats);
        SG_UNREF(m_feats);
        m_feats = feats;
    }

    virtual void set_kernel(CKernel *kernel)
    {
        SG_REF(kernel);
        SG_UNREF(m_kernel);
        m_kernel = kernel;
    }

    virtual void set_labels(CLabels* lab)
    {
        CMulticlassLabels *mlab = dynamic_cast<CMulticlassLabels *>(lab);
        REQUIRE(lab, "requires MulticlassLabes\n");

        CMachine::set_labels(mlab);
        m_num_classes = mlab->get_num_classes();
    }

    void set_machine_for_confusion_matrix(CBaseMulticlassMachine *machine)
    {
        SG_REF(machine);
        SG_UNREF(m_machine_for_confusion_matrix);
        m_machine_for_confusion_matrix = machine;
    }

    void set_svm_C(float64_t C)
    {
        m_svm_C = C;
    }
    float64_t get_svm_C() const
    {
        return m_svm_C;
    }

    void set_svm_epsilon(float64_t epsilon)
    {
        m_svm_epsilon = epsilon;
    }
    float64_t get_svm_epsilon() const
    {
        return m_svm_epsilon;
    }

    void set_A(float64_t A)
    {
        m_A = A;
    }
    float64_t get_A() const
    {
        return m_A;
    }

    void set_B(int32_t B)
    {
        m_B = B;
    }
    int32_t get_B() const
    {
        return m_B;
    }

    void set_max_num_iter(int32_t n_iter)
    {
        m_max_num_iter = n_iter;
    }
    int32_t get_max_num_iter() const
    {
        return m_max_num_iter;
    }

    virtual bool train(CFeatures* data=NULL)
    {
        return CMachine::train(data);
    }

    typedef std::pair<std::pair<int32_t, int32_t>, float64_t> entry_t;
protected:
    float64_t apply_one(int32_t idx);

    virtual bool train_machine(CFeatures* data);

    node_t *train_node(const SGMatrix<float64_t> &conf_mat, SGVector<int32_t> classes);
    std::vector<entry_t> init_node(const SGMatrix<float64_t> &global_conf_mat, SGVector<int32_t> classes);
    SGVector<int32_t> train_node_with_initialization(const CRelaxedTree::entry_t &mu_entry, SGVector<int32_t> classes, CSVM *svm);

    float64_t compute_score(SGVector<int32_t> mu, CSVM *svm);
    SGVector<int32_t> color_label_space(CSVM *svm, SGVector<int32_t> classes);
    SGVector<float64_t> eval_binary_model_K(CSVM *svm);

    void enforce_balance_constraints_upper(SGVector<int32_t> &mu, SGVector<float64_t> &delta_neg, SGVector<float64_t> &delta_pos, int32_t B_prime, SGVector<float64_t>& xi_neg_class);
    void enforce_balance_constraints_lower(SGVector<int32_t> &mu, SGVector<float64_t> &delta_neg, SGVector<float64_t> &delta_pos, int32_t B_prime, SGVector<float64_t>& xi_neg_class);

    int32_t m_max_num_iter;
    float64_t m_A;
    int32_t m_B;
    float64_t m_svm_C;
    float64_t m_svm_epsilon;
    CKernel *m_kernel;
    CDenseFeatures<float64_t> *m_feats;
    CBaseMulticlassMachine *m_machine_for_confusion_matrix;
    int32_t m_num_classes;
};

} /* shogun */ 

#endif /* end of include guard: RELAXEDTREE_H__ */