Classifier.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 _CLASSIFIER_H__
#define _CLASSIFIER_H__

#include "lib/common.h"
#include "base/SGObject.h"
#include "lib/Mathematics.h"
#include "features/Labels.h"
#include "features/Features.h"

namespace shogun
{

class CFeatures;
class CLabels;
class CMath;

enum EClassifierType
{
    CT_NONE = 0,
    CT_LIGHT = 10,
    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
};

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

class CClassifier : public CSGObject
{
    public:
        CClassifier();
        virtual ~CClassifier();

        virtual bool train(CFeatures* data=NULL)
        {
            SG_NOTIMPLEMENTED;
            return false;
        }

        virtual CLabels* classify()=0;

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

        virtual float64_t classify_example(int32_t num)
        {
            SG_NOTIMPLEMENTED;
            return CMath::INFTY;
        }

        virtual bool load(FILE* srcfile) { ASSERT(srcfile); return false; }

        virtual bool save(FILE* dstfile) { ASSERT(dstfile); return false; }

        virtual inline void set_labels(CLabels* lab)
        {
            SG_UNREF(labels);
            SG_REF(lab);
            labels=lab;
        }

        virtual inline CLabels* get_labels() { SG_REF(labels); return labels; }

        virtual inline float64_t get_label(int32_t i)
        {
            if (!labels)
                SG_ERROR("No Labels assigned\n");

            return labels->get_label(i);
        }

        inline void set_max_train_time(float64_t t) { max_train_time=t; }

        inline float64_t get_max_train_time() { return max_train_time; }

        virtual inline EClassifierType get_classifier_type() { return CT_NONE; }

        inline void set_solver_type(ESolverType st) { solver_type=st; }

        inline ESolverType get_solver_type() { return solver_type; }

#ifdef HAVE_BOOST_SERIALIZATION
    private:

        friend class ::boost::serialization::access;
        template<class Archive>
            void serialize(Archive & ar, const unsigned int archive_version)
            {

                SG_DEBUG("archiving CClassifier\n");

                ar & ::boost::serialization::base_object<CSGObject>(*this);
                ar & max_train_time;
                ar & labels;

                SG_DEBUG("done with CClassifier\n");

            }
#endif //HAVE_BOOST_SERIALIZATION

    protected:
        float64_t max_train_time;

        CLabels* labels;

        ESolverType solver_type;
};
}
#endif // _CLASSIFIER_H__