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

#ifndef _MACHINE_H__
#define _MACHINE_H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/base/SGObject.h>
#include <shogun/labels/BinaryLabels.h>
#include <shogun/labels/RegressionLabels.h>
#include <shogun/labels/MulticlassLabels.h>
#include <shogun/labels/StructuredLabels.h>
#include <shogun/labels/LatentLabels.h>
#include <shogun/features/Features.h>

namespace shogun
{

class CFeatures;
class CLabels;

enum EMachineType
{
    CT_NONE = 0,
    CT_LIGHT = 10,
    CT_LIGHTONECLASS = 11,
    CT_LIBSVM = 20,
    CT_LIBSVMONECLASS=30,
    CT_LIBSVMMULTICLASS=40,
    CT_MPD = 50,
    CT_GPBT = 60,
    CT_CPLEXSVM = 70,
    CT_PERCEPTRON = 80,
    CT_KERNELPERCEPTRON = 90,
    CT_LDA = 100,
    CT_LPM = 110,
    CT_LPBOOST = 120,
    CT_KNN = 130,
    CT_SVMLIN=140,
    CT_KERNELRIDGEREGRESSION = 150,
    CT_GNPPSVM = 160,
    CT_GMNPSVM = 170,
    CT_SVMPERF = 200,
    CT_LIBSVR = 210,
    CT_SVRLIGHT = 220,
    CT_LIBLINEAR = 230,
    CT_KMEANS = 240,
    CT_HIERARCHICAL = 250,
    CT_SVMOCAS = 260,
    CT_WDSVMOCAS = 270,
    CT_SVMSGD = 280,
    CT_MKLMULTICLASS = 290,
    CT_MKLCLASSIFICATION = 300,
    CT_MKLONECLASS = 310,
    CT_MKLREGRESSION = 320,
    CT_SCATTERSVM = 330,
    CT_DASVM = 340,
    CT_LARANK = 350,
    CT_DASVMLINEAR = 360,
    CT_GAUSSIANNAIVEBAYES = 370,
    CT_AVERAGEDPERCEPTRON = 380,
    CT_SGDQN = 390,
    CT_CONJUGATEINDEX = 400,
    CT_LINEARRIDGEREGRESSION = 410,
    CT_LEASTSQUARESREGRESSION = 420,
    CT_QDA = 430,
    CT_NEWTONSVM = 440,
    CT_GAUSSIANPROCESSREGRESSION = 450,
    CT_LARS = 460,
    CT_MULTICLASS = 470,
    CT_DIRECTORLINEAR = 480,
    CT_DIRECTORKERNEL = 490,
    CT_LIBQPSOSVM = 500,
    CT_PRIMALMOSEKSOSVM = 510,
    CT_CCSOSVM = 520,
    CT_GAUSSIANPROCESSBINARY = 530,
    CT_GAUSSIANPROCESSMULTICLASS = 540,
    CT_STOCHASTICSOSVM = 550,
    CT_NEURALNETWORK = 560,
    CT_BAGGING = 570,
    CT_FWSOSVM = 580,
    CT_BCFWSOSVM = 590,
    CT_GAUSSIANPROCESSCLASS
};

enum ESolverType
{
    ST_AUTO=0,
    ST_CPLEX=1,
    ST_GLPK=2,
    ST_NEWTON=3,
    ST_DIRECT=4,
    ST_ELASTICNET=5,
    ST_BLOCK_NORM=6
};

enum EProblemType
{
    PT_BINARY = 0,
    PT_REGRESSION = 1,
    PT_MULTICLASS = 2,
    PT_STRUCTURED = 3,
    PT_LATENT = 4,
    PT_CLASS = 5
};

#define MACHINE_PROBLEM_TYPE(PT) \
 \
    virtual EProblemType get_machine_problem_type() const { return PT; }

class CMachine : public CSGObject
{
    public:
        CMachine();

        virtual ~CMachine();

        virtual bool train(CFeatures* data=NULL);

        virtual CLabels* apply(CFeatures* data=NULL);

        virtual CBinaryLabels* apply_binary(CFeatures* data=NULL);
        virtual CRegressionLabels* apply_regression(CFeatures* data=NULL);
        virtual CMulticlassLabels* apply_multiclass(CFeatures* data=NULL);
        virtual CStructuredLabels* apply_structured(CFeatures* data=NULL);
        virtual CLatentLabels* apply_latent(CFeatures* data=NULL);

        virtual void set_labels(CLabels* lab);

        virtual CLabels* get_labels();

        void set_max_train_time(float64_t t);

        float64_t get_max_train_time();

        virtual EMachineType get_classifier_type();

        void set_solver_type(ESolverType st);

        ESolverType get_solver_type();

        virtual void set_store_model_features(bool store_model);

        virtual bool train_locked(SGVector<index_t> indices)
        {
            SG_ERROR("train_locked(SGVector<index_t>) is not yet implemented "
                    "for %s\n", get_name());
            return false;
        }

        virtual float64_t apply_one(int32_t i)
        {
            SG_NOTIMPLEMENTED
            return 0.0;
        }

        virtual CLabels* apply_locked(SGVector<index_t> indices);

        virtual CBinaryLabels* apply_locked_binary(
                SGVector<index_t> indices);
        virtual CRegressionLabels* apply_locked_regression(
                SGVector<index_t> indices);
        virtual CMulticlassLabels* apply_locked_multiclass(
                SGVector<index_t> indices);
        virtual CStructuredLabels* apply_locked_structured(
                SGVector<index_t> indices);
        virtual CLatentLabels* apply_locked_latent(
                SGVector<index_t> indices);

        virtual void data_lock(CLabels* labs, CFeatures* features);

        virtual void post_lock(CLabels* labs, CFeatures* features) { };

        virtual void data_unlock();

        virtual bool supports_locking() const { return false; }

        bool is_data_locked() const { return m_data_locked; }

        virtual EProblemType get_machine_problem_type() const
        {
            SG_NOTIMPLEMENTED
            return PT_BINARY;
        }

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

    protected:
        virtual bool train_machine(CFeatures* data=NULL)
        {
            SG_ERROR("train_machine is not yet implemented for %s!\n",
                    get_name());
            return false;
        }

        virtual void store_model_features()
        {
            SG_ERROR("Model storage and therefore unlocked Cross-Validation and"
                    " Model-Selection is not supported for %s. Locked may"
                    " work though.\n", get_name());
        }

        virtual bool is_label_valid(CLabels *lab) const
        {
            return true;
        }

        virtual bool train_require_labels() const { return true; }

    protected:
        float64_t m_max_train_time;

        CLabels* m_labels;

        ESolverType m_solver_type;

        bool m_store_model_features;

        bool m_data_locked;
};
}
#endif // _MACHINE_H__