MultitaskKernelMaskPairNormalizer.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 2 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2010 Christian Widmer
 * Copyright (C) 2010 Max-Planck-Society
 */

#ifndef _MULTITASKKERNELMASKPAIRNORMALIZER_H___
#define _MULTITASKKERNELMASKPAIRNORMALIZER_H___

#include <shogun/kernel/normalizer/KernelNormalizer.h>
#include <shogun/kernel/Kernel.h>

#include <string>

namespace shogun
{


class CMultitaskKernelMaskPairNormalizer: public CKernelNormalizer
{

public:

    CMultitaskKernelMaskPairNormalizer() :
        CKernelNormalizer(), scale(1.0), normalization_constant(1.0)
    {
    }

    CMultitaskKernelMaskPairNormalizer(std::vector<int32_t> task_vector_,
                                       std::vector<std::pair<int32_t, int32_t> > active_pairs_) :
                                       scale(1.0), normalization_constant(1.0)
    {

        set_task_vector(task_vector_);
        active_pairs = active_pairs_;

    }


    virtual ~CMultitaskKernelMaskPairNormalizer()
    {
    }

    virtual bool init(CKernel* k)
    {
        ASSERT(k);
        int32_t num_lhs = k->get_num_vec_lhs();
        int32_t num_rhs = k->get_num_vec_rhs();
        ASSERT(num_lhs>0);
        ASSERT(num_rhs>0);


        //same as first-element normalizer
        CFeatures* old_lhs=k->lhs;
        CFeatures* old_rhs=k->rhs;
        k->lhs=old_lhs;
        k->rhs=old_lhs;


        if (std::string(k->get_name()) == "WeightedDegree") {
            SG_INFO("using first-element normalization\n");
            scale=k->compute(0, 0);
        } else {
            SG_INFO("no inner normalization for non-WDK kernel\n");
            scale=1.0;
        }

        k->lhs=old_lhs;
        k->rhs=old_rhs;


        return true;
    }



    inline virtual float64_t normalize(float64_t value, int32_t idx_lhs, int32_t idx_rhs)
    {

        //lookup tasks
        int32_t task_idx_lhs = task_vector_lhs[idx_lhs];
        int32_t task_idx_rhs = task_vector_rhs[idx_rhs];

        //lookup similarity
        float64_t task_similarity = get_similarity(task_idx_lhs, task_idx_rhs);

        //take task similarity into account
        float64_t similarity = (value/scale) * task_similarity;


        return similarity;

    }

    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;
    }

    std::vector<int32_t> get_task_vector_lhs() const
    {
        return task_vector_lhs;
    }


    void set_task_vector_lhs(std::vector<int32_t> vec)
    {

        task_vector_lhs.clear();

        for (int32_t i = 0; i != (int32_t)(vec.size()); ++i)
        {
            task_vector_lhs.push_back(vec[i]);
        }

    }

    std::vector<int32_t> get_task_vector_rhs() const
    {
        return task_vector_rhs;
    }


    void set_task_vector_rhs(std::vector<int32_t> vec)
    {

        task_vector_rhs.clear();

        for (int32_t i = 0; i != (int32_t)(vec.size()); ++i)
        {
            task_vector_rhs.push_back(vec[i]);
        }

    }

    void set_task_vector(std::vector<int32_t> vec)
    {
        set_task_vector_lhs(vec);
        set_task_vector_rhs(vec);
    }


    float64_t get_similarity(int32_t task_lhs, int32_t task_rhs)
    {

        float64_t similarity = 0.0;

        for (int32_t i=0; i!=static_cast<int>(active_pairs.size()); i++)
        {
            std::pair<int32_t, int32_t> block = active_pairs[i];

            // ignore order of pair
            if ((block.first==task_lhs && block.second==task_rhs) ||
                (block.first==task_rhs && block.second==task_lhs))
            {
                similarity = 1.0 / normalization_constant;
                break;
            }
        }


        return similarity;

    }

    std::vector<std::pair<int32_t, int32_t> > get_active_pairs()
    {
        return active_pairs;
    }

    float64_t get_normalization_constant () const
    {
        return normalization_constant;
    }

    float64_t set_normalization_constant(float64_t constant)
    {
        normalization_constant = constant;

        SG_NOTIMPLEMENTED;
        return 0.0;
    }


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

    CMultitaskKernelMaskPairNormalizer* KernelNormalizerToMultitaskKernelMaskPairNormalizer(CKernelNormalizer* n)
    {
           return dynamic_cast<shogun::CMultitaskKernelMaskPairNormalizer*>(n);
    }

protected:

    std::vector<std::pair<int32_t, int32_t> > active_pairs;

    std::vector<int32_t> task_vector_lhs;

    std::vector<int32_t> task_vector_rhs;

    float64_t scale;

    float64_t normalization_constant;

};
}
#endif