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
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _MACHINE_H__
#define _MACHINE_H__

#include <shogun/lib/common.h>
#include <shogun/base/SGObject.h>
#include <shogun/features/Labels.h>
#include <shogun/features/Features.h>

namespace shogun
{

class CFeatures;
class CLabels;
class CMath;

enum EClassifierType
{
    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_KRR = 150,
    CT_GNPPSVM = 160,
    CT_GMNPSVM = 170,
    CT_SUBGRADIENTSVM = 180,
    CT_SUBGRADIENTLPM = 190,
    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,

};

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

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

        virtual ~CMachine();

        virtual bool train(CFeatures* data=NULL);

        virtual CLabels* apply()=0;

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

        virtual float64_t apply(int32_t num);

        virtual bool load(FILE* srcfile);

        virtual bool save(FILE* dstfile); 

        virtual void set_labels(CLabels* lab);

        virtual CLabels* get_labels();

        virtual float64_t get_label(int32_t i);

        void set_max_train_time(float64_t t);

        float64_t get_max_train_time();

        virtual EClassifierType get_classifier_type();

        void set_solver_type(ESolverType st);

        ESolverType get_solver_type();

        virtual void set_store_model_features(bool store_model);

    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 Cross-Validation and "
                    "Model-Selection is not supported for %s\n", get_name());
        }

    protected:
        float64_t max_train_time;

        CLabels* labels;

        ESolverType solver_type;

        bool m_store_model_features;
};
}
#endif // _MACHINE_H__