ScatterKernelNormalizer.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) 2010 Soeren Sonnenburg
 * Copyright (C) 2010 Berlin Institute of Technology
 */

#ifndef _SCATTERKERNELNORMALIZER_H___
#define _SCATTERKERNELNORMALIZER_H___

#include "kernel/KernelNormalizer.h"
#include "kernel/IdentityKernelNormalizer.h"
#include "kernel/Kernel.h"
#include "features/Labels.h"
#include "lib/io.h"

namespace shogun
{
class CScatterKernelNormalizer: public CKernelNormalizer
{

public:
    CScatterKernelNormalizer() : CKernelNormalizer()
    {
        init();
    }

    CScatterKernelNormalizer(float64_t const_diag, float64_t const_offdiag,
            CLabels* labels,CKernelNormalizer* normalizer=NULL)
        : CKernelNormalizer()
    {
        init();

        m_testing_class=-1;
        m_const_diag=const_diag;
        m_const_offdiag=const_offdiag;

        ASSERT(labels)
        SG_REF(labels);
        m_labels=labels;

        if (normalizer==NULL)
            normalizer=new CIdentityKernelNormalizer();
        SG_REF(normalizer);
        m_normalizer=normalizer;

        SG_DEBUG("Constructing ScatterKernelNormalizer with const_diag=%g"
                " const_offdiag=%g num_labels=%d and normalizer='%s'\n",
                const_diag, const_offdiag, labels->get_num_labels(),
                normalizer->get_name());
    }

    virtual ~CScatterKernelNormalizer()
    {
        SG_UNREF(m_labels);
        SG_UNREF(m_normalizer);
    }

    virtual bool init(CKernel* k)
    {
        m_normalizer->init(k);
        return true;
    }

    int32_t get_testing_class()
    {
        return m_testing_class;
    }

    void set_testing_class(int32_t c)
    {
        m_testing_class=c;
    }

    inline virtual float64_t normalize(float64_t value, int32_t idx_lhs,
            int32_t idx_rhs)
    {
        value=m_normalizer->normalize(value, idx_lhs, idx_rhs);
        float64_t c=m_const_offdiag;

        if (m_testing_class>=0)
        {
            if (m_labels->get_label(idx_lhs) == m_testing_class)
                c=m_const_diag;
        }
        else
        {
            if (m_labels->get_label(idx_lhs) == m_labels->get_label(idx_rhs))
                c=m_const_diag;

        }
        return value*c;
    }

    inline virtual float64_t normalize_lhs(float64_t value, int32_t idx_lhs)
    {
        SG_ERROR("normalize_lhs not implemented");
        return 0;
    }

    inline virtual float64_t normalize_rhs(float64_t value, int32_t idx_rhs)
    {
        SG_ERROR("normalize_rhs not implemented");
        return 0;
    }

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

private:
    void init()
    {
        m_const_diag = 1.0;
        m_const_offdiag = 1.0;

        m_labels = NULL;
        m_normalizer = NULL;

        m_testing_class = -1;

        
        m_parameters->add(&m_testing_class, "m_testing_class"
                "Testing Class.");
        m_parameters->add(&m_const_diag, "m_const_diag"
                "Factor to multiply to diagonal elements.");
        m_parameters->add(&m_const_offdiag, "m_const_offdiag"
                "Factor to multiply to off-diagonal elements.");

        m_parameters->add((CSGObject**) &m_labels, "m_labels", "Labels");
        m_parameters->add((CSGObject**) &m_normalizer, "m_normalizer", "Kernel normalizer.");
    }

protected:

    float64_t m_const_diag;
    float64_t m_const_offdiag;

    CLabels* m_labels;

    CKernelNormalizer* m_normalizer;

    int32_t m_testing_class;
};
}
#endif