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 <shogun/lib/common.h>
#include <shogun/io/SGIO.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/features/Labels.h>
#include <shogun/machine/Machine.h>

#include <stdio.h>

namespace shogun
{
class CMachine;
class CLabels;
class CKernel;

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

        virtual ~CKernelMachine();

        virtual const char* get_name() 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.vector && idx<m_svs.vlen);
            return m_svs.vector[idx];
        }

        inline float64_t get_alpha(int32_t idx)
        {
            if (!m_alpha.vector)
                SG_ERROR("No alphas set\n");
            if (idx>=m_alpha.vlen)
                SG_ERROR("Alphas index (%d) out of range (%d)\n", idx, m_svs.vlen);
            return m_alpha.vector[idx];
        }

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

            return true;
        }

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

            return true;
        }

        inline int32_t get_num_support_vectors()
        {
            return m_svs.vlen;
        }

        void set_alphas(SGVector<float64_t> alphas)
        {
            m_alpha = alphas;
        }

        void set_support_vectors(SGVector<int32_t> svs)
        {
            m_svs = svs;
        }

        SGVector<int32_t> get_support_vectors()
        {
            int32_t nsv = get_num_support_vectors();
            int32_t* svs = NULL;

            if (nsv>0)
            {
                svs = SG_MALLOC(int32_t, nsv);
                for(int32_t i=0; i<nsv; i++)
                    svs[i] = get_support_vector(i);
            }

            return SGVector<int32_t>(svs,nsv);
        }

        SGVector<float64_t> get_alphas()
        {
            int32_t nsv = get_num_support_vectors();
            float64_t* alphas = NULL;

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

            return SGVector<float64_t>(alphas,nsv);
        }

        inline bool create_new_model(int32_t num)
        {
            m_alpha.destroy_vector();
            m_svs.destroy_vector();

            m_bias=0;

            if (num>0)
            {
                m_alpha= SGVector<float64_t>(num);
                m_svs= SGVector<int32_t>(num);
                return (m_alpha.vector!=NULL && m_svs.vector!=NULL);
            }
            else
                return true;
        }

        bool init_kernel_optimization();

        virtual CLabels* apply();

        virtual CLabels* apply(CFeatures* data);

        virtual float64_t apply(int32_t num);

        static void* apply_helper(void* p);

    protected:
        virtual void store_model_features();

    protected:
        CKernel* kernel;
        bool use_batch_computation;
        bool use_linadd;
        bool use_bias;
        float64_t m_bias;

        SGVector<float64_t> m_alpha;

        SGVector<int32_t> m_svs;
};
}
#endif /* _KERNEL_MACHINE_H__ */