LinearMulticlassMachine.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 _LINEARMULTICLASSMACHINE_H___
#define _LINEARMULTICLASSMACHINE_H___

#include <shogun/lib/common.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/machine/LinearMachine.h>
#include <shogun/machine/MulticlassMachine.h>

namespace shogun
{

class CDotFeatures;
class CLinearMachine;
class CMulticlassStrategy;

class CLinearMulticlassMachine : public CMulticlassMachine
{
    public:
        CLinearMulticlassMachine() : CMulticlassMachine(), m_features(NULL)
        {
            SG_ADD((CSGObject**)&m_features, "m_features", "Feature object.",
                MS_NOT_AVAILABLE);
        }

        CLinearMulticlassMachine(CMulticlassStrategy *strategy, CDotFeatures* features, CLinearMachine* machine, CLabels* labs) :
            CMulticlassMachine(strategy,(CMachine*)machine,labs), m_features(NULL)
        {
            set_features(features);
            SG_ADD((CSGObject**)&m_features, "m_features", "Feature object.",
                MS_NOT_AVAILABLE);
        }

        virtual ~CLinearMulticlassMachine()
        {
            SG_UNREF(m_features);
        }

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

        void set_features(CDotFeatures* f)
        {
            SG_REF(f);
            SG_UNREF(m_features);
            m_features = f;
        }

        CDotFeatures* get_features() const
        {
            SG_REF(m_features);
            return m_features;
        }

    protected:

        virtual bool init_machine_for_train(CFeatures* data)
        {
            if (!m_machine)
                SG_ERROR("No machine given in Multiclass constructor\n");

            if (data)
                set_features((CDotFeatures*)data);

            ((CLinearMachine*)m_machine)->set_features(m_features);

            return true;
        }

        virtual bool init_machines_for_apply(CFeatures* data)
        {
            if (data)
                set_features((CDotFeatures*)data);

            for (int32_t i=0; i<m_machines->get_num_elements(); i++)
            {
                CLinearMachine* machine = (CLinearMachine*)m_machines->get_element(i);
                ASSERT(m_features);
                ASSERT(machine);
                machine->set_features(m_features);
                SG_UNREF(machine);
            }

            return true;
        }

        virtual bool is_ready()
        {
            if (m_features)
                return true;

            return false;
        }

        virtual CMachine* get_machine_from_trained(CMachine* machine)
        {
            return new CLinearMachine((CLinearMachine*)machine);
        }

        virtual int32_t get_num_rhs_vectors()
        {
            return m_features->get_num_vectors();
        }

        virtual void add_machine_subset(SGVector<index_t> subset)
        {
            /* changing the subset structure to use subset stacks. This might
             * have to be revised. Heiko Strathmann */
            m_features->add_subset(subset);
        }

        virtual void remove_machine_subset()
        {
            /* changing the subset structure to use subset stacks. This might
             * have to be revised. Heiko Strathmann */
            m_features->remove_subset();
        }

        virtual void store_model_features() {}

    protected:

        CDotFeatures* m_features;
};
}
#endif