KernelMulticlassMachine.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-2012 Soeren Sonnenburg and Sergey Lisitsyn
 * Written (W) 2012 Heiko Strathmann
 * Copyright (C) 1999-2012 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _KERNELMULTICLASSMACHINE_H___
#define _KERNELMULTICLASSMACHINE_H___

#include <shogun/lib/common.h>
#include <shogun/features/Features.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/machine/KernelMachine.h>
#include <shogun/machine/MulticlassMachine.h>

namespace shogun
{

class CKernel;
class CKernelMachine;

class CKernelMulticlassMachine : public CMulticlassMachine
{
    public:
        CKernelMulticlassMachine() : CMulticlassMachine(), m_kernel(NULL)
        {
            SG_ADD((CSGObject**)&m_kernel,"kernel", "The kernel to be used", MS_AVAILABLE);
        }

        CKernelMulticlassMachine(CMulticlassStrategy *strategy, CKernel* kernel, CKernelMachine* machine, CLabels* labs) :
            CMulticlassMachine(strategy,(CMachine*)machine,labs), m_kernel(NULL)
        {
            set_kernel(kernel);
            SG_ADD((CSGObject**)&m_kernel,"kernel", "The kernel to be used", MS_AVAILABLE);
        }

        virtual ~CKernelMulticlassMachine()
        {
            SG_UNREF(m_kernel);
        }

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

        void set_kernel(CKernel* k)
        {
            ((CKernelMachine*)m_machine)->set_kernel(k);
            SG_REF(k);
            SG_UNREF(m_kernel);
            m_kernel=k;
        }

        CKernel* get_kernel()
        {
            SG_REF(m_kernel);
            return m_kernel;
        }

        virtual void store_model_features();

    protected:

        virtual bool init_machine_for_train(CFeatures* data)
        {
            if (data)
                m_kernel->init(data,data);

            ((CKernelMachine*)m_machine)->set_kernel(m_kernel);

            return true;
        }

        virtual bool init_machines_for_apply(CFeatures* data)
        {
            if (data)
            {
                /* set data to rhs for this kernel */
                CFeatures* lhs=m_kernel->get_lhs();
                m_kernel->init(lhs, data);
                SG_UNREF(lhs);
            }

            /* set kernel to all sub-machines */
            for (int32_t i=0; i<m_machines->get_num_elements(); i++)
            {
                CKernelMachine *machine=
                        (CKernelMachine*)m_machines->get_element(i);
                machine->set_kernel(m_kernel);
                SG_UNREF(machine);
            }

            return true;
        }

        virtual bool is_ready()
        {
            if (m_kernel && m_kernel->get_num_vec_lhs() && m_kernel->get_num_vec_rhs())
                    return true;

            return false;
        }

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

        virtual int32_t get_num_rhs_vectors()
        {
            return m_kernel->get_num_vec_rhs();
        }

        virtual void add_machine_subset(SGVector<index_t> subset)
        {
            SG_NOTIMPLEMENTED;
        }

        virtual void remove_machine_subset()
        {
            SG_NOTIMPLEMENTED;
        }

    protected:

        CKernel* m_kernel;

};
}
#endif