KernelMachine.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 _KERNEL_MACHINE_H__
#define _KERNEL_MACHINE_H__

#include "lib/common.h"
#include "lib/io.h"
#include "kernel/Kernel.h"
#include "features/Labels.h"
#include "classifier/Classifier.h"

#include <stdio.h>

namespace shogun
{
class CClassifier;
class CLabels;
class CKernel;

class CKernelMachine : public CClassifier
{
    public:
        CKernelMachine();

        virtual ~CKernelMachine();

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

        inline void set_kernel(CKernel* k)
        {
            SG_UNREF(kernel);
            SG_REF(k);
            kernel=k;
        }

        inline CKernel* get_kernel()
        {
            SG_REF(kernel);
            return kernel;
        }

        inline void set_batch_computation_enabled(bool enable)
        {
            use_batch_computation=enable;
        }

        inline bool get_batch_computation_enabled()
        {
            return use_batch_computation;
        }

        inline void set_linadd_enabled(bool enable)
        {
            use_linadd=enable;
        }

        inline bool get_linadd_enabled()
        {
            return use_linadd ;
        }

        inline void set_bias_enabled(bool enable_bias) { use_bias=enable_bias; }

        inline bool get_bias_enabled() { return use_bias; }

        inline float64_t get_bias()
        {
            return m_bias;
        }

        inline void set_bias(float64_t bias)
        {
            m_bias=bias;
        }

        inline int32_t get_support_vector(int32_t idx)
        {
            ASSERT(m_svs && idx<num_svs);
            return m_svs[idx];
        }

        inline float64_t get_alpha(int32_t idx)
        {
            ASSERT(m_alpha && idx<num_svs);
            return m_alpha[idx];
        }

        inline bool set_support_vector(int32_t idx, int32_t val)
        {
            if (m_svs && idx<num_svs)
                m_svs[idx]=val;
            else
                return false;

            return true;
        }

        inline bool set_alpha(int32_t idx, float64_t val)
        {
            if (m_alpha && idx<num_svs)
                m_alpha[idx]=val;
            else
                return false;

            return true;
        }

        inline int32_t get_num_support_vectors()
        {
            return num_svs;
        }

        void set_alphas(float64_t* alphas, int32_t d)
        {
            ASSERT(alphas);
            ASSERT(m_alpha);
            ASSERT(d==num_svs);

            for(int32_t i=0; i<d; i++)
                m_alpha[i]=alphas[i];
        }

        void set_support_vectors(int32_t* svs, int32_t d)
        {
            ASSERT(m_svs);
            ASSERT(svs);
            ASSERT(d==num_svs);

            for(int32_t i=0; i<d; i++)
                m_svs[i]=svs[i];
        }

        void get_support_vectors(int32_t** svs, int32_t* num)
        {
            int32_t nsv = get_num_support_vectors();

            ASSERT(svs && num);
            *svs=NULL;
            *num=nsv;

            if (nsv>0)
            {
                *svs = (int32_t*) malloc(sizeof(int32_t)*nsv);
                for(int32_t i=0; i<nsv; i++)
                    (*svs)[i] = get_support_vector(i);
            }
        }

        void get_alphas(float64_t** alphas, int32_t* d1)
        {
            int32_t nsv = get_num_support_vectors();

            ASSERT(alphas && d1);
            *alphas=NULL;
            *d1=nsv;

            if (nsv>0)
            {
                *alphas = (float64_t*) malloc(nsv*sizeof(float64_t));
                for(int32_t i=0; i<nsv; i++)
                    (*alphas)[i] = get_alpha(i);
            }
        }

        inline bool create_new_model(int32_t num)
        {
            delete[] m_alpha;
            delete[] m_svs;

            m_bias=0;
            num_svs=num;

            if (num>0)
            {
                m_alpha= new float64_t[num];
                m_svs= new int32_t[num];
                return (m_alpha!=NULL && m_svs!=NULL);
            }
            else
            {
                m_alpha= NULL;
                m_svs=NULL;
                return true;
            }
        }

        bool init_kernel_optimization();

        virtual CLabels* classify();

        virtual CLabels* classify(CFeatures* data);

        virtual float64_t classify_example(int32_t num);

        static void* classify_example_helper(void* p);

    protected:
        CKernel* kernel;
        bool use_batch_computation;
        bool use_linadd;
        bool use_bias;
        float64_t m_bias;
        float64_t* m_alpha;
        int32_t* m_svs;
        int32_t num_svs;
};
}
#endif /* _KERNEL_MACHINE_H__ */