MKL.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) 2009 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
 * Copyright (C) 2010 Ryota Tomioka (University of Tokyo)
 */
#ifndef __MKL_H__
#define __MKL_H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/lib/Time.h>
#include <shogun/features/Features.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/classifier/svm/SVM.h>

namespace shogun
{
class CMKL : public CSVM
{
    public:
        CMKL(CSVM* s=NULL);

        virtual ~CMKL();

        inline void set_constraint_generator(CSVM* s)
        {
            set_svm(s);
        }

        inline void set_svm(CSVM* s)
        {
            SG_REF(s);
            SG_UNREF(svm);
            svm=s;
        }

        inline CSVM* get_svm()
        {
            SG_REF(svm);
            return svm;
        }

        inline void set_C_mkl(float64_t C) { C_mkl = C; }

        void set_mkl_norm(float64_t norm);

        void set_elasticnet_lambda(float64_t elasticnet_lambda);

        void set_mkl_block_norm(float64_t q);

        inline void set_interleaved_optimization_enabled(bool enable)
        {
            interleaved_optimization=enable;
        }

        inline bool get_interleaved_optimization_enabled()
        {
            return interleaved_optimization;
        }

        inline float64_t compute_mkl_primal_objective()
        {
            return compute_svm_primal_objective();
        }

        virtual float64_t compute_mkl_dual_objective();


        float64_t compute_elasticnet_dual_objective();

        inline void set_mkl_epsilon(float64_t eps) { mkl_epsilon=eps; }

        inline float64_t get_mkl_epsilon() { return mkl_epsilon; }

        inline int32_t get_mkl_iterations() { return mkl_iterations; }

        virtual bool perform_mkl_step(const float64_t* sumw, float64_t suma);

        static bool perform_mkl_step_helper (CMKL* mkl,
                const float64_t* sumw, const float64_t suma)
        {
            return mkl->perform_mkl_step(sumw, suma);
        }


        virtual float64_t compute_sum_alpha()=0;

        virtual void compute_sum_beta(float64_t* sumw);

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

    protected:
        virtual bool train_machine(CFeatures* data=NULL);

        virtual void init_training()=0;

        void perform_mkl_step(float64_t* beta, float64_t* old_beta, int num_kernels,
                int32_t* label, int32_t* active2dnum,
                float64_t* a, float64_t* lin, float64_t* sumw, int32_t& inner_iters);


        float64_t compute_optimal_betas_via_cplex(float64_t* beta, const float64_t* old_beta, int32_t num_kernels,
                const float64_t* sumw, float64_t suma, int32_t& inner_iters);

        float64_t compute_optimal_betas_via_glpk(float64_t* beta, const float64_t* old_beta,
                int num_kernels, const float64_t* sumw, float64_t suma, int32_t& inner_iters);

        float64_t compute_optimal_betas_elasticnet(
                float64_t* beta, const float64_t* old_beta, const int32_t num_kernels,
                const float64_t* sumw, const float64_t suma, const float64_t mkl_objective);

        inline void elasticnet_transform(float64_t *beta, float64_t lmd, int32_t len)
        {
            for (int32_t i=0;i <len;i++)
                beta[i]=beta[i]/(1.0-lmd+lmd*beta[i]);
        }

        void elasticnet_dual(float64_t *ff, float64_t *gg, float64_t *hh,
                const float64_t &del, const float64_t* nm, int32_t len,
                const float64_t &lambda);

        float64_t compute_optimal_betas_directly(
                float64_t* beta, const float64_t* old_beta, const int32_t num_kernels,
                const float64_t* sumw, const float64_t suma, const float64_t mkl_objective);

        float64_t compute_optimal_betas_block_norm(
                float64_t* beta, const float64_t* old_beta, const int32_t num_kernels,
                const float64_t* sumw, const float64_t suma, const float64_t mkl_objective);

        float64_t compute_optimal_betas_newton(float64_t* beta, const float64_t* old_beta,
                int32_t num_kernels, const float64_t* sumw, float64_t suma, float64_t mkl_objective);

        virtual bool converged()
        {
            return w_gap<mkl_epsilon;
        }

        void init_solver();

    protected:
        CSVM* svm;
        float64_t C_mkl;
        float64_t mkl_norm;
        float64_t ent_lambda;

        float64_t mkl_block_norm;

        float64_t* beta_local;
        int32_t mkl_iterations;
        float64_t mkl_epsilon;
        bool interleaved_optimization;

        float64_t* W;

        float64_t w_gap;
        float64_t rho;

        CTime training_time_clock;

        class Self;
        Unique<Self> self;

        bool lp_initialized ;
};
}
#endif //__MKL_H__