CustomKernel.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
 * Written (W) 2012 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _CUSTOMKERNEL_H___
#define _CUSTOMKERNEL_H___

#include <shogun/mathematics/Math.h>
#include <shogun/lib/common.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/features/Features.h>

namespace shogun
{
class CCustomKernel: public CKernel
{
    void init();

    public:
        CCustomKernel();

        CCustomKernel(CKernel* k);

        CCustomKernel(SGMatrix<float64_t> km);

        CCustomKernel(SGMatrix<float32_t> km);

        virtual ~CCustomKernel();

        virtual bool dummy_init(int32_t rows, int32_t cols);

        virtual bool init(CFeatures* l, CFeatures* r);

        virtual void cleanup();

        void cleanup_custom();

        virtual EKernelType get_kernel_type() { return K_CUSTOM; }

        virtual EFeatureType get_feature_type() { return F_ANY; }

        virtual EFeatureClass get_feature_class() { return C_ANY; }

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

        bool set_triangle_kernel_matrix_from_triangle(
            SGVector<float64_t> tri_kernel_matrix)
        {
            if (m_row_subset_stack->has_subsets() || m_col_subset_stack->has_subsets())
            {
                SG_ERROR("%s::set_triangle_kernel_matrix_from_triangle not"
                        " possible with subset. Remove first\n", get_name());
            }
            return set_triangle_kernel_matrix_from_triangle_generic(tri_kernel_matrix);
        }

        template <class T>
        bool set_triangle_kernel_matrix_from_triangle_generic(
            SGVector<T> tri_kernel_matrix)
        {
            if (m_row_subset_stack->has_subsets() || m_col_subset_stack->has_subsets())
            {
                SG_ERROR("%s::set_triangle_kernel_matrix_from_triangle_generic "
                        "not possible with subset. Remove first\n", get_name());
            }
            ASSERT(tri_kernel_matrix.vector);

            int64_t len = tri_kernel_matrix.vlen;
            int64_t cols = (int64_t) floor(-0.5 + CMath::sqrt(0.25+2*len));

            if (cols*(cols+1)/2 != len)
            {
                SG_ERROR("km should be a vector containing a lower triangle matrix, with len=cols*(cols+1)/2 elements\n");
                return false;
            }

            cleanup_custom();
            SG_DEBUG( "using custom kernel of size %dx%d\n", cols,cols);

            kmatrix=SGMatrix<float32_t>(SG_MALLOC(float32_t, len), cols, cols);
            upper_diagonal=true;

            for (int64_t i=0; i<len; i++)
                kmatrix.matrix[i]=tri_kernel_matrix.vector[i];

            dummy_init(cols,cols);
            return true;
        }

        inline bool set_triangle_kernel_matrix_from_full(
            SGMatrix<float64_t> full_kernel_matrix)
        {
            return set_triangle_kernel_matrix_from_full_generic(full_kernel_matrix);
        }

        template <class T>
        bool set_triangle_kernel_matrix_from_full_generic(
            SGMatrix<T> full_kernel_matrix)
        {
            if (m_row_subset_stack->has_subsets() || m_col_subset_stack->has_subsets())
            {
                SG_ERROR("%s::set_triangle_kernel_matrix_from_full_generic "
                        "not possible with subset. Remove first\n", get_name());
            }

            int32_t rows = full_kernel_matrix.num_rows;
            int32_t cols = full_kernel_matrix.num_cols;
            ASSERT(rows==cols);

            cleanup_custom();
            SG_DEBUG( "using custom kernel of size %dx%d\n", cols,cols);

            kmatrix=SGMatrix<float32_t>(SG_MALLOC(float32_t, cols*(cols+1)/2), rows, cols);
            upper_diagonal = true;

            for (int64_t row=0; row<rows; row++)
            {
                for (int64_t col=row; col<cols; col++)
                {
                    int64_t idx=row * cols - row*(row+1)/2 + col;
                    kmatrix.matrix[idx] = full_kernel_matrix.matrix[col*rows+row];
                }
            }

            dummy_init(rows, cols);
            return true;
        }

        bool set_full_kernel_matrix_from_full(
            SGMatrix<float32_t> full_kernel_matrix)
        {
            if (m_row_subset_stack->has_subsets() || m_col_subset_stack->has_subsets())
            {
                SG_ERROR("%s::set_full_kernel_matrix_from_full "
                        "not possible with subset. Remove first\n", get_name());
            }

            cleanup_custom();
            kmatrix=full_kernel_matrix;
            dummy_init(kmatrix.num_rows, kmatrix.num_cols);
            return true;
        }

        bool set_full_kernel_matrix_from_full(
            SGMatrix<float64_t> full_kernel_matrix)
        {
            if (m_row_subset_stack->has_subsets() || m_col_subset_stack->has_subsets())
            {
                SG_ERROR("%s::set_full_kernel_matrix_from_full "
                        "not possible with subset. Remove first\n", get_name());
            }

            cleanup_custom();
            int32_t rows=full_kernel_matrix.num_rows;
            int32_t cols=full_kernel_matrix.num_cols;
            SG_DEBUG( "using custom kernel of size %dx%d\n", rows,cols);

            kmatrix=SGMatrix<float32_t>(rows,cols);
            upper_diagonal = false;

            for (int64_t i=0; i<int64_t(rows) * cols; i++)
                kmatrix.matrix[i]=full_kernel_matrix.matrix[i];

            dummy_init(kmatrix.num_rows, kmatrix.num_cols);
            return true;
        }

        virtual void add_row_subset(SGVector<index_t> subset);

        virtual void remove_row_subset();

        virtual void remove_all_row_subsets();

        virtual void row_subset_changed_post();

        virtual void add_col_subset(SGVector<index_t> subset);

        virtual void remove_col_subset();

        virtual void remove_all_col_subsets();

        virtual void col_subset_changed_post();

        virtual int32_t get_num_vec_lhs()
        {
            return m_row_subset_stack->has_subsets()
                    ? m_row_subset_stack->get_size() : num_lhs;
        }

        virtual int32_t get_num_vec_rhs()
        {
            return m_col_subset_stack->has_subsets()
                    ? m_col_subset_stack->get_size() : num_rhs;
        }

        virtual bool has_features()
        {
            return (get_num_vec_lhs()>0) && (get_num_vec_rhs()>0);
        }

        void print_kernel_matrix(const char* prefix="") const;

        SGMatrix<float32_t> get_float32_kernel_matrix()
        {
            return kmatrix;
        }

    protected:

        virtual float64_t compute(int32_t row, int32_t col)
        {
            ASSERT(kmatrix.matrix);

            index_t real_row=m_row_subset_stack->subset_idx_conversion(row);
            index_t real_col=m_col_subset_stack->subset_idx_conversion(col);

            if (upper_diagonal)
            {
                if (real_row <= real_col)
                {
                    int64_t r=real_row;
                    return kmatrix.matrix[r*kmatrix.num_rows - r*(r+1)/2 + real_col];
                }
                else
                {
                    int64_t c=real_col;
                    return kmatrix.matrix[c*kmatrix.num_cols - c*(c+1)/2 + real_row];
                }
            }
            else
            {
                int64_t r=real_row;
                return kmatrix.matrix[r*kmatrix.num_cols+real_col];
            }
        }

    protected:

        SGMatrix<float32_t> kmatrix;

        bool upper_diagonal;

        CSubsetStack* m_row_subset_stack;
        CSubsetStack* m_col_subset_stack;

        bool m_free_km;
};

}
#endif /* _CUSTOMKERNEL_H__ */