Kernel.cpp

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) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#include <shogun/lib/config.h>
#include <shogun/lib/common.h>
#include <shogun/io/SGIO.h>
#include <shogun/io/File.h>
#include <shogun/lib/Time.h>
#include <shogun/lib/Signal.h>

#include <shogun/base/Parallel.h>

#include <shogun/kernel/Kernel.h>
#include <shogun/kernel/IdentityKernelNormalizer.h>
#include <shogun/features/Features.h>
#include <shogun/base/Parameter.h>

#include <shogun/classifier/svm/SVM.h>

#include <string.h>
#include <unistd.h>
#include <math.h>

#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif

using namespace shogun;

CKernel::CKernel() : CSGObject()
{
    init();
    register_params();
}

CKernel::CKernel(int32_t size) : CSGObject()
{
    init();
    
    if (size<10)
        size=10;

    cache_size=size;
    register_params();
}


CKernel::CKernel(CFeatures* p_lhs, CFeatures* p_rhs, int32_t size) : CSGObject()
{
    init();

    if (size<10)
        size=10;

    cache_size=size;

    set_normalizer(new CIdentityKernelNormalizer());
    init(p_lhs, p_rhs);
    register_params();
}

CKernel::~CKernel()
{
    if (get_is_initialized())
        SG_ERROR("Kernel still initialized on destruction.\n");

    remove_lhs_and_rhs();
    SG_UNREF(normalizer);

    SG_INFO("Kernel deleted (%p).\n", this);
}



bool CKernel::init(CFeatures* l, CFeatures* r)
{
    //make sure features were indeed supplied
    ASSERT(l);
    ASSERT(r);

    //make sure features are compatible
    ASSERT(l->get_feature_class()==r->get_feature_class());
    ASSERT(l->get_feature_type()==r->get_feature_type());

    //remove references to previous features
    remove_lhs_and_rhs();

    //increase reference counts
    SG_REF(l);
    if (l==r)
        lhs_equals_rhs=true;
    else // l!=r
        SG_REF(r);

    lhs=l;
    rhs=r;

    ASSERT(!num_lhs || num_lhs==l->get_num_vectors());
    ASSERT(!num_rhs || num_rhs==l->get_num_vectors());

    num_lhs=l->get_num_vectors();
    num_rhs=r->get_num_vectors();

    return true;
}

bool CKernel::set_normalizer(CKernelNormalizer* n)
{
    SG_REF(n);
    if (lhs && rhs)
        n->init(this);

    SG_UNREF(normalizer);
    normalizer=n;

    return (normalizer!=NULL);
}

CKernelNormalizer* CKernel::get_normalizer()
{
    SG_REF(normalizer)
    return normalizer;
}

bool CKernel::init_normalizer()
{
    return normalizer->init(this);
}

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



void CKernel::load(CFile* loader)
{
    SG_SET_LOCALE_C;
    SG_RESET_LOCALE;
}

void CKernel::save(CFile* writer)
{
    SGMatrix<float64_t> k_matrix=get_kernel_matrix<float64_t>();
    SG_SET_LOCALE_C;
    writer->set_matrix(k_matrix.matrix, k_matrix.num_rows, k_matrix.num_cols);
    SG_FREE(k_matrix.matrix);
    SG_RESET_LOCALE;
}

void CKernel::remove_lhs_and_rhs()
{
    if (rhs!=lhs)
        SG_UNREF(rhs);
    rhs = NULL;
    num_rhs=0;

    SG_UNREF(lhs);
    lhs = NULL;
    num_lhs=0;
    lhs_equals_rhs=false;


}

void CKernel::remove_lhs()
{
    if (rhs==lhs)
        rhs=NULL;
    SG_UNREF(lhs);
    lhs = NULL;
    num_lhs=0;
    lhs_equals_rhs=false;

}

void CKernel::remove_rhs()
{
    if (rhs!=lhs)
        SG_UNREF(rhs);
    rhs = NULL;
    num_rhs=0;
    lhs_equals_rhs=false;


}

#define ENUM_CASE(n) case n: SG_INFO(#n " "); break;

void CKernel::list_kernel()
{
    SG_INFO( "%p - \"%s\" weight=%1.2f OPT:%s", this, get_name(),
            get_combined_kernel_weight(),
            get_optimization_type()==FASTBUTMEMHUNGRY ? "FASTBUTMEMHUNGRY" :
            "SLOWBUTMEMEFFICIENT");

    switch (get_kernel_type())
    {
        ENUM_CASE(K_UNKNOWN)
        ENUM_CASE(K_LINEAR)
        ENUM_CASE(K_POLY)
        ENUM_CASE(K_GAUSSIAN)
        ENUM_CASE(K_GAUSSIANSHIFT)
        ENUM_CASE(K_GAUSSIANMATCH)
        ENUM_CASE(K_HISTOGRAM)
        ENUM_CASE(K_SALZBERG)
        ENUM_CASE(K_LOCALITYIMPROVED)
        ENUM_CASE(K_SIMPLELOCALITYIMPROVED)
        ENUM_CASE(K_FIXEDDEGREE)
        ENUM_CASE(K_WEIGHTEDDEGREE)
        ENUM_CASE(K_WEIGHTEDDEGREEPOS)
        ENUM_CASE(K_WEIGHTEDDEGREERBF)
        ENUM_CASE(K_WEIGHTEDCOMMWORDSTRING)
        ENUM_CASE(K_POLYMATCH)
        ENUM_CASE(K_ALIGNMENT)
        ENUM_CASE(K_COMMWORDSTRING)
        ENUM_CASE(K_COMMULONGSTRING)
        ENUM_CASE(K_SPECTRUMRBF)
        ENUM_CASE(K_COMBINED)
        ENUM_CASE(K_AUC)
        ENUM_CASE(K_CUSTOM)
        ENUM_CASE(K_SIGMOID)
        ENUM_CASE(K_CHI2)
        ENUM_CASE(K_DIAG)
        ENUM_CASE(K_CONST)
        ENUM_CASE(K_DISTANCE)
        ENUM_CASE(K_LOCALALIGNMENT)
        ENUM_CASE(K_PYRAMIDCHI2)
        ENUM_CASE(K_OLIGO)
        ENUM_CASE(K_MATCHWORD)
        ENUM_CASE(K_TPPK)
        ENUM_CASE(K_REGULATORYMODULES)
        ENUM_CASE(K_SPARSESPATIALSAMPLE)
        ENUM_CASE(K_HISTOGRAMINTERSECTION)
        ENUM_CASE(K_WAVELET)
        ENUM_CASE(K_WAVE)
        ENUM_CASE(K_CAUCHY)
        ENUM_CASE(K_TSTUDENT)
        ENUM_CASE(K_MULTIQUADRIC)
        ENUM_CASE(K_EXPONENTIAL)
        ENUM_CASE(K_RATIONAL_QUADRATIC)
        ENUM_CASE(K_POWER)
        ENUM_CASE(K_SPHERICAL)
        ENUM_CASE(K_LOG)
        ENUM_CASE(K_SPLINE)
        ENUM_CASE(K_ANOVA)
        ENUM_CASE(K_CIRCULAR)
        ENUM_CASE(K_INVERSEMULTIQUADRIC)
        ENUM_CASE(K_SPECTRUMMISMATCHRBF)
        ENUM_CASE(K_DISTANTSEGMENTS)
        ENUM_CASE(K_BESSEL)
    }

    switch (get_feature_class())
    {
        ENUM_CASE(C_UNKNOWN)
        ENUM_CASE(C_SIMPLE)
        ENUM_CASE(C_SPARSE)
        ENUM_CASE(C_STRING)
        ENUM_CASE(C_STREAMING_SIMPLE)
        ENUM_CASE(C_STREAMING_SPARSE)
        ENUM_CASE(C_STREAMING_STRING)
        ENUM_CASE(C_STREAMING_VW)
        ENUM_CASE(C_COMBINED)
        ENUM_CASE(C_COMBINED_DOT)
        ENUM_CASE(C_WD)
        ENUM_CASE(C_SPEC)
        ENUM_CASE(C_WEIGHTEDSPEC)
        ENUM_CASE(C_POLY)
        ENUM_CASE(C_ANY)
    }

    switch (get_feature_type())
    {
        ENUM_CASE(F_UNKNOWN)
        ENUM_CASE(F_BOOL)
        ENUM_CASE(F_CHAR)
        ENUM_CASE(F_BYTE)
        ENUM_CASE(F_SHORT)
        ENUM_CASE(F_WORD)
        ENUM_CASE(F_INT)
        ENUM_CASE(F_UINT)
        ENUM_CASE(F_LONG)
        ENUM_CASE(F_ULONG)
        ENUM_CASE(F_SHORTREAL)
        ENUM_CASE(F_DREAL)
        ENUM_CASE(F_LONGREAL)
        ENUM_CASE(F_ANY)
    }
    SG_INFO( "\n");
}
#undef ENUM_CASE

bool CKernel::init_optimization(
    int32_t count, int32_t *IDX, float64_t * weights)
{
   SG_ERROR( "kernel does not support linadd optimization\n");
    return false ;
}

bool CKernel::delete_optimization()
{
   SG_ERROR( "kernel does not support linadd optimization\n");
    return false;
}

float64_t CKernel::compute_optimized(int32_t vector_idx)
{
   SG_ERROR( "kernel does not support linadd optimization\n");
    return 0;
}

void CKernel::compute_batch(
    int32_t num_vec, int32_t* vec_idx, float64_t* target, int32_t num_suppvec,
    int32_t* IDX, float64_t* weights, float64_t factor)
{
   SG_ERROR( "kernel does not support batch computation\n");
}

void CKernel::add_to_normal(int32_t vector_idx, float64_t weight)
{
   SG_ERROR( "kernel does not support linadd optimization, add_to_normal not implemented\n");
}

void CKernel::clear_normal()
{
   SG_ERROR( "kernel does not support linadd optimization, clear_normal not implemented\n");
}

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

void CKernel::compute_by_subkernel(
    int32_t vector_idx, float64_t * subkernel_contrib)
{
   SG_ERROR( "kernel compute_by_subkernel not implemented\n");
}

const float64_t* CKernel::get_subkernel_weights(int32_t &num_weights)
{
    num_weights=1 ;
    return &combined_kernel_weight ;
}

void CKernel::set_subkernel_weights(SGVector<float64_t> weights)
{
    ASSERT(weights.vector);
    if (weights.vlen!=1)
      SG_ERROR( "number of subkernel weights should be one ...\n");

    combined_kernel_weight = weights.vector[0] ;
}

bool CKernel::init_optimization_svm(CSVM * svm)
{
    int32_t num_suppvec=svm->get_num_support_vectors();
    int32_t* sv_idx=SG_MALLOC(int32_t, num_suppvec);
    float64_t* sv_weight=SG_MALLOC(float64_t, num_suppvec);

    for (int32_t i=0; i<num_suppvec; i++)
    {
        sv_idx[i]    = svm->get_support_vector(i);
        sv_weight[i] = svm->get_alpha(i);
    }
    bool ret = init_optimization(num_suppvec, sv_idx, sv_weight);

    SG_FREE(sv_idx);
    SG_FREE(sv_weight);
    return ret;
}

void CKernel::load_serializable_post() throw (ShogunException)
{
    CSGObject::load_serializable_post();
    if (lhs_equals_rhs)
        rhs=lhs;
}

void CKernel::save_serializable_pre() throw (ShogunException)
{
    CSGObject::save_serializable_pre();

    if (lhs_equals_rhs)
        rhs=NULL;
}

void CKernel::save_serializable_post() throw (ShogunException)
{
    CSGObject::save_serializable_post();

    if (lhs_equals_rhs)
        rhs=lhs;
}

void CKernel::register_params()   {
    m_parameters->add(&cache_size, "cache_size",
                      "Cache size in MB.");
    m_parameters->add((CSGObject**) &lhs, "lhs",
                      "Feature vectors to occur on left hand side.");
    m_parameters->add((CSGObject**) &rhs, "rhs",
                      "Feature vectors to occur on right hand side.");
    m_parameters->add(&lhs_equals_rhs, "lhs_equals_rhs",
                      "If features on lhs are the same as on rhs.");
    m_parameters->add(&num_lhs, "num_lhs",
                      "Number of feature vectors on left hand side.");
    m_parameters->add(&num_rhs, "num_rhs",
                      "Number of feature vectors on right hand side.");
    m_parameters->add(&combined_kernel_weight, "combined_kernel_weight",
                      "Combined kernel weight.");
    m_parameters->add(&optimization_initialized,
                      "optimization_initialized",
                      "Optimization is initialized.");
    m_parameters->add((machine_int_t*) &opt_type, "opt_type",
                      "Optimization type.");
    m_parameters->add(&properties, "properties",
                      "Kernel properties.");
    m_parameters->add((CSGObject**) &normalizer, "normalizer",
                      "Normalize the kernel.");
}


void CKernel::init()
{
    cache_size=10;
    kernel_matrix=NULL;
    lhs=NULL;
    rhs=NULL;
    num_lhs=0;
    num_rhs=0;
    combined_kernel_weight=1;
    optimization_initialized=false;
    opt_type=FASTBUTMEMHUNGRY;
    properties=KP_NONE;
    normalizer=NULL;



    set_normalizer(new CIdentityKernelNormalizer());
}