DirectorKernel.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.
 *
 * Copyright (C) 2012 Soeren Sonnenburg
 * Copyright (C) 2012 Evgeniy Andreev (gsomix)
 */

#ifndef _DIRECTORKERNEL_H___
#define _DIRECTORKERNEL_H___

#include <shogun/lib/config.h>

#ifdef USE_SWIG_DIRECTORS
#include <shogun/lib/common.h>
#include <shogun/lib/DataType.h>
#include <shogun/kernel/Kernel.h>

namespace shogun
{
#define IGNORE_IN_CLASSLIST
IGNORE_IN_CLASSLIST class CDirectorKernel: public CKernel
{
    public:
        CDirectorKernel() 
        : CKernel(), external_features(false)
        {
        }

        CDirectorKernel(bool is_external_features) 
        : CKernel(), external_features(is_external_features)
        {
        }

        CDirectorKernel(int32_t size, bool is_external_features) 
        : CKernel(size), external_features(is_external_features)
        {
        }

        virtual ~CDirectorKernel()  
        {
            cleanup();
        }

        virtual bool init(CFeatures* l, CFeatures* r)
        {
            if (this->parallel->get_num_threads()!=1)
            {
                SG_WARNING("Enforcing to use only one thread due to restrictions of directors\n")
                this->parallel->set_num_threads(1);
            }
            return CKernel::init(l, r);
        }

        virtual bool set_normalizer(CKernelNormalizer* normalizer)
        {
            return CKernel::set_normalizer(normalizer);
        }

        virtual CKernelNormalizer* get_normalizer()
        {
            return CKernel::get_normalizer();
        }

        virtual bool init_normalizer()
        {
            return CKernel::init_normalizer();
        }

        virtual void cleanup()
        {
            CKernel::cleanup();
        }

        virtual float64_t kernel_function(int32_t idx_a, int32_t idx_b)
        {
            SG_ERROR("Kernel function of Director Kernel needs to be overridden.\n")
            return 0;
        }

        virtual SGVector<float64_t> get_kernel_col(int32_t j)
        {
            return CKernel::get_kernel_col(j);
        }

        virtual SGVector<float64_t> get_kernel_row(int32_t i)
        {
            return CKernel::get_kernel_row(i);
        }

        virtual int32_t get_num_vec_lhs()
        {
            return CKernel::get_num_vec_lhs();
        }

        virtual int32_t get_num_vec_rhs()
        {
            return CKernel::get_num_vec_rhs();
        }

        virtual void set_num_vec_lhs(int32_t num)
        {
            num_lhs=num;
        }

        virtual void set_num_vec_rhs(int32_t num)
        {
            num_rhs=num;
        }
        
        virtual bool has_features()
        {
            if (!external_features)
                return CKernel::has_features();
            else
                return true;
        }

        virtual void remove_lhs_and_rhs()
        {
            CKernel::remove_lhs_and_rhs();
        }

        virtual void remove_lhs()
        {
            CKernel::remove_lhs();
        }

        virtual void remove_rhs()
        {
            CKernel::remove_rhs();
        }

        virtual EKernelType get_kernel_type() { return K_DIRECTOR; }

        virtual EFeatureType get_feature_type() { return F_ANY; }

        virtual EFeatureClass get_feature_class() { return C_ANY; }

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

        virtual void clear_normal()
        {
            CKernel::clear_normal();
        }

        virtual void add_to_normal(int32_t vector_idx, float64_t weight)
        {
            CKernel::add_to_normal(vector_idx, weight);
        }

        virtual void set_optimization_type(EOptimizationType t)
        {
            CKernel::set_optimization_type(t);
        }

        virtual bool init_optimization(
            int32_t count, int32_t *IDX, float64_t *weights)
        {
            return CKernel::init_optimization(count, IDX, weights);
        }

        virtual bool delete_optimization()
        {
            return CKernel::delete_optimization();
        }

        virtual float64_t compute_optimized(int32_t vector_idx)
        {
            return CKernel::compute_optimized(vector_idx);
        }

        virtual void compute_batch(
            int32_t num_vec, int32_t* vec_idx, float64_t* target,
            int32_t num_suppvec, int32_t* IDX, float64_t* alphas,
            float64_t factor=1.0)
        {
            CKernel::compute_batch(num_vec, vec_idx, target, num_suppvec, IDX, alphas, factor);
        }

        virtual int32_t get_num_subkernels()
        {
            return CKernel::get_num_subkernels();
        }

        virtual void compute_by_subkernel(
            int32_t vector_idx, float64_t * subkernel_contrib)
        {
            CKernel::compute_by_subkernel(vector_idx, subkernel_contrib);
        }

        virtual const float64_t* get_subkernel_weights(int32_t& num_weights)
        {
            return CKernel::get_subkernel_weights(num_weights);
        }

        virtual void set_subkernel_weights(SGVector<float64_t> weights)
        {
            CKernel::set_subkernel_weights(weights);
        }

    protected:
        virtual TParameter* migrate(DynArray<TParameter*>* param_base,
                const SGParamInfo* target)
        {
            return CSGObject::migrate(param_base, target);
        }

        virtual void one_to_one_migration_prepare(DynArray<TParameter*>* param_base,
                const SGParamInfo* target, TParameter*& replacement,
                TParameter*& to_migrate, char* old_name=NULL)
        {
            return CSGObject::one_to_one_migration_prepare(param_base, target,
                    replacement, to_migrate, old_name);
        }
        virtual void load_serializable_pre() throw (ShogunException)
        {
            CKernel::load_serializable_pre();
        }

        virtual void load_serializable_post() throw (ShogunException)
        {
            CKernel::load_serializable_post();
        }

        virtual void save_serializable_pre() throw (ShogunException)
        {
            CKernel::save_serializable_pre();
        }

        virtual void save_serializable_post() throw (ShogunException)
        {
            CKernel::save_serializable_post();
        }

        virtual float64_t compute(int32_t idx_a, int32_t idx_b)
        {
            return kernel_function(idx_a, idx_b);
        }

        virtual void register_params()
        {
            CKernel::register_params();
        }

    protected:
        /* is external features */
        bool external_features;
};
}
#endif /* USE_SWIG_DIRECTORS */
#endif /* _DIRECTORKERNEL_H__ */