MulticlassMachine.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) 1999-2011 Soeren Sonnenburg
 * Written (W) 2012 Fernando José Iglesias García and Sergey Lisitsyn
 * Written (W) 2013 Shell Hu and Heiko Strathmann
 * Copyright (C) 2012 Sergey Lisitsyn, Fernando José Iglesias Garcia
 */

#ifndef _MULTICLASSMACHINE_H___
#define _MULTICLASSMACHINE_H___

#include <shogun/machine/BaseMulticlassMachine.h>
#include <shogun/lib/DynamicObjectArray.h>
#include <shogun/multiclass/MulticlassStrategy.h>
#include <shogun/labels/MulticlassLabels.h>
#include <shogun/labels/MulticlassMultipleOutputLabels.h>

namespace shogun
{

class CFeatures;
class CLabels;

class CMulticlassMachine : public CBaseMulticlassMachine
{
    public:
        CMulticlassMachine();

        CMulticlassMachine(CMulticlassStrategy* strategy, CMachine* machine, CLabels* labels);

        virtual ~CMulticlassMachine();

        virtual void set_labels(CLabels* lab);

        inline bool set_machine(int32_t num, CMachine* machine)
        {
            ASSERT(num<m_machines->get_num_elements() && num>=0)
            if (machine != NULL && !is_acceptable_machine(machine))
                SG_ERROR("Machine %s is not acceptable by %s", machine->get_name(), this->get_name())

            m_machines->set_element(machine, num);
            return true;
        }

        inline CMachine* get_machine(int32_t num) const
        {
            return (CMachine*) m_machines->get_element_safe(num);
        }

        virtual CBinaryLabels* get_submachine_outputs(int32_t i);

        virtual float64_t get_submachine_output(int32_t i, int32_t num);

        virtual CMulticlassLabels* apply_multiclass(CFeatures* data=NULL);
        
        virtual CMulticlassMultipleOutputLabels* apply_multiclass_multiple_output(CFeatures* data=NULL, int32_t n_outputs=5);

        virtual float64_t apply_one(int32_t vec_idx);

        inline CMulticlassStrategy* get_multiclass_strategy() const
        {
            SG_REF(m_multiclass_strategy);
            return m_multiclass_strategy;
        }

        inline CRejectionStrategy* get_rejection_strategy() const
        {
            return m_multiclass_strategy->get_rejection_strategy();
        }

        inline void set_rejection_strategy(CRejectionStrategy* rejection_strategy)
        {
            m_multiclass_strategy->set_rejection_strategy(rejection_strategy);
        }

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

        inline EProbHeuristicType get_prob_heuris()
        {
            return m_multiclass_strategy->get_prob_heuris_type();
        }

        inline void set_prob_heuris(EProbHeuristicType prob_heuris)
        {
            m_multiclass_strategy->set_prob_heuris_type(prob_heuris);
        }

    protected:
        void init_strategy();

        void clear_machines();

        virtual bool train_machine(CFeatures* data = NULL);

        virtual bool init_machine_for_train(CFeatures* data) = 0;

        virtual bool init_machines_for_apply(CFeatures* data) = 0;

        virtual bool is_ready() = 0;

        virtual CMachine* get_machine_from_trained(CMachine* machine) = 0;

        virtual int32_t get_num_rhs_vectors() = 0;

        virtual void add_machine_subset(SGVector<index_t> subset) = 0;

        virtual void remove_machine_subset() = 0;

        virtual bool is_acceptable_machine(CMachine *machine)
        {
            return true;
        }

    private:

        void register_parameters();

    protected:
        CMulticlassStrategy *m_multiclass_strategy;

        CMachine* m_machine;
};
}
#endif