DirectorKernelMachine.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.
 *
 * Copyright (C) 2012 Evgeniy Andreev (gsomix)
 */

#ifndef _DIRECTORKERNELMACHINE_H___
#define _DIRECTORKERNELMACHINE_H___

#include <shogun/lib/config.h>

#ifdef USE_SWIG_DIRECTORS
#include <shogun/lib/common.h>
#include <shogun/lib/DataType.h>
#include <shogun/machine/Machine.h>
#include <shogun/machine/KernelMachine.h>

namespace shogun
{

#define IGNORE_IN_CLASSLIST
IGNORE_IN_CLASSLIST class CDirectorKernelMachine : public CKernelMachine
{
    public:
        /* default constructor */
        CDirectorKernelMachine()
        : CKernelMachine()
        {

        }

        CDirectorKernelMachine(CKernel* k, const SGVector<float64_t> alphas, const SGVector<int32_t> svs, float64_t b)
        : CKernelMachine(k, alphas, svs, b)
        {
        }

        /* destructor */
        virtual ~CDirectorKernelMachine()
        {

        }

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

        virtual bool train_function(CFeatures* data=NULL)
        {
            SG_ERROR("Train function of Director Kernel Machine needs to be overridden.\n")
            return false;
        }

        virtual CLabels* apply(CFeatures* data=NULL)
        {
            return CKernelMachine::apply(data);
        }

        virtual CBinaryLabels* apply_binary(CFeatures* data=NULL)
        {
            return CKernelMachine::apply_binary(data);
        }

        virtual CRegressionLabels* apply_regression(CFeatures* data=NULL)
        {
            return CKernelMachine::apply_regression(data);
        }

        using CKernelMachine::apply_multiclass;

        virtual float64_t apply_one(int32_t num)
        {
            return CKernelMachine::apply_one(num);
        }

        virtual void set_labels(CLabels* lab)
        {
            CKernelMachine::set_labels(lab);
        }

        virtual CLabels* get_labels()
        {
            return CKernelMachine::get_labels();
        }

        virtual EMachineType get_classifier_type() { return CT_DIRECTORKERNEL; }

        virtual void set_store_model_features(bool store_model)
        {
            CKernelMachine::set_store_model_features(store_model);
        }

        virtual bool train_locked(SGVector<index_t> indices)
        {
            return CKernelMachine::train_locked(indices);
        }

        virtual CLabels* apply_locked(SGVector<index_t> indices)
        {
            return CKernelMachine::apply_locked(indices);
        }

        virtual CBinaryLabels* apply_locked_binary(SGVector<index_t> indices)
        {
            return CKernelMachine::apply_locked_binary(indices);
        }

        virtual CRegressionLabels* apply_locked_regression(
                SGVector<index_t> indices)
        {
            return CKernelMachine::apply_locked_regression(indices);
        }

        using CKernelMachine::apply_locked_multiclass;

        virtual SGVector<float64_t> apply_locked_get_output(
                SGVector<index_t> indices)
        {
            return CKernelMachine::apply_locked_get_output(indices);
        }

        virtual void data_lock(CLabels* labs, CFeatures* features)
        {
            CKernelMachine::data_lock(labs, features);
        }

        virtual void data_unlock()
        {
            CKernelMachine::data_unlock();
        }

        virtual bool supports_locking() const
        {
            return CKernelMachine::supports_locking();
        }

        //TODO change to pure virtual
        virtual EProblemType get_machine_problem_type() const
        {
            return CKernelMachine::get_machine_problem_type();
        }

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

    protected:
        virtual bool train_machine(CFeatures* data=NULL)
        {
            return train_function(data);
        }
};

}

#endif /* USE_SWIG_DIRECTORS */
#endif /* _DIRECTORKERNELMACHINE_H___ */