MulticlassSVM.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-2011 Soeren Sonnenburg
 * Written (W) 2012 Soeren Sonnenburg, Chiyuan Zhang
 * Copyright (C) 1999-2011 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _MULTICLASSSVM_H___
#define _MULTICLASSSVM_H___

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/features/Features.h>
#include <shogun/classifier/svm/SVM.h>
#include <shogun/machine/KernelMulticlassMachine.h>

namespace shogun
{

class CSVM;

class CMulticlassSVM : public CKernelMulticlassMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_MULTICLASS);

        CMulticlassSVM();

        CMulticlassSVM(CMulticlassStrategy *strategy);

        CMulticlassSVM(
            CMulticlassStrategy *strategy, float64_t C, CKernel* k, CLabels* lab);
        virtual ~CMulticlassSVM();

        bool create_multiclass_svm(int32_t num_classes);

        bool set_svm(int32_t num, CSVM* svm);

        CSVM* get_svm(int32_t num)
        {
            return dynamic_cast<CSVM *>(m_machines->get_element_safe(num));
        }

        bool load(FILE* svm_file);

        bool save(FILE* svm_file);

        // TODO remove if unnecessary here
        SGVector<float64_t> get_linear_term() { return svm_proto()->get_linear_term(); }
        // TODO remove if unnecessary here
        float64_t get_tube_epsilon() { return svm_proto()->get_tube_epsilon(); }
        // TODO remove if unnecessary here
        float64_t get_epsilon() { return svm_proto()->get_epsilon(); }
        // TODO remove if unnecessary here
        float64_t get_nu() { return svm_proto()->get_nu(); }
        // TODO remove if unnecessary here
        float64_t get_C() { return m_C; }
        // TODO remove if unnecessary here
        int32_t get_qpsize() { return svm_proto()->get_qpsize(); }
        // TODO remove if unnecessary here
        bool get_shrinking_enabled() { return svm_proto()->get_shrinking_enabled(); }
        // TODO remove if unnecessary here
        float64_t get_objective() { return svm_proto()->get_objective(); }

        // TODO remove if unnecessary here
        bool get_bias_enabled() { return svm_proto()->get_bias_enabled(); }
        // TODO remove if unnecessary here
        bool get_linadd_enabled() { return svm_proto()->get_linadd_enabled(); }
        // TODO remove if unnecessary here
        bool get_batch_computation_enabled() { return svm_proto()->get_batch_computation_enabled(); }

        // TODO remove if unnecessary here
        void set_defaults(int32_t num_sv=0) { svm_proto()->set_defaults(num_sv); }
        // TODO remove if unnecessary here
        void set_linear_term(SGVector<float64_t> linear_term) { svm_proto()->set_linear_term(linear_term); }
        // TODO remove if unnecessary here
        void set_C(float64_t C) { svm_proto()->set_C(C,C); m_C = C; }
        // TODO remove if unnecessary here
        void set_epsilon(float64_t eps) { svm_proto()->set_epsilon(eps); }
        // TODO remove if unnecessary here
        void set_nu(float64_t nue) { svm_proto()->set_nu(nue); }
        // TODO remove if unnecessary here
        void set_tube_epsilon(float64_t eps) { svm_proto()->set_tube_epsilon(eps); }
        // TODO remove if unnecessary here
        void set_qpsize(int32_t qps) { svm_proto()->set_qpsize(qps); }
        // TODO remove if unnecessary here
        void set_shrinking_enabled(bool enable) { svm_proto()->set_shrinking_enabled(enable); }
        // TODO remove if unnecessary here
        void set_objective(float64_t v) { svm_proto()->set_objective(v); }
        // TODO remove if unnecessary here
        void set_bias_enabled(bool enable_bias) { svm_proto()->set_bias_enabled(enable_bias); }
        // TODO remove if unnecessary here
        void set_linadd_enabled(bool enable) { svm_proto()->set_linadd_enabled(enable); }
        // TODO remove if unnecessary here
        void set_batch_computation_enabled(bool enable) { svm_proto()->set_batch_computation_enabled(enable); }

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

    protected:

        CSVM *svm_proto()
        {
            return dynamic_cast<CSVM*>(m_machine);
        }
        SGVector<int32_t> svm_svs()
        {
            return svm_proto()->m_svs;
        }

        virtual bool init_machines_for_apply(CFeatures* data);

        virtual bool is_acceptable_machine(CMachine *machine)
        {
            CSVM *svm = dynamic_cast<CSVM*>(machine);
            if (svm == NULL)
                return false;
            return true;
        }

    private:

        void init();

    protected:

        float64_t m_C;
};
}
#endif