MultitaskKernelMaskNormalizer.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 _MULTITASKKERNELMASKNORMALIZER_H___
#define _MULTITASKKERNELMASKNORMALIZER_H___

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

namespace shogun
{


class CMultitaskKernelMaskNormalizer: public CKernelNormalizer
{

public:

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

    CMultitaskKernelMaskNormalizer(std::vector<int32_t> task_lhs,
                                   std::vector<int32_t> task_rhs,
                                   std::vector<int32_t> active_tasks_vec)
        : CKernelNormalizer(), scale(1.0), normalization_constant(1.0)
    {


        set_task_vector_lhs(task_lhs);
        set_task_vector_rhs(task_rhs);

        // set active tasks
        for (int32_t i = 0; i != (int32_t)(active_tasks_vec.size()); ++i)
        {
            active_tasks.insert(active_tasks_vec[i]);
        }

    }


    virtual ~CMultitaskKernelMaskNormalizer()
    {
    }

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



    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;

    }

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

    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)
    {

        const bool lhs_is_in = active_tasks.find(task_lhs) != active_tasks.end();
        const bool rhs_is_in = active_tasks.find(task_rhs) != active_tasks.end();

        float64_t similarity = 0.0;

        if (lhs_is_in && rhs_is_in)
        {
            similarity = 1.0 / normalization_constant;
        }

        return similarity;

    }

    std::vector<int32_t> get_active_tasks()
    {

        std::vector<int32_t> active_tasks_vec;

        // set active tasks
        for (std::set<int32_t>::const_iterator it=active_tasks.begin(); it!=active_tasks.end(); it++)
        {
            active_tasks_vec.push_back(*it);
        }

        return active_tasks_vec;
    }

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

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

    CMultitaskKernelMaskNormalizer* KernelNormalizerToMultitaskKernelMaskNormalizer(CKernelNormalizer* n)
    {
           return dynamic_cast<CMultitaskKernelMaskNormalizer*>(n);
    }

protected:
    std::set<int32_t> active_tasks;

    std::vector<int32_t> task_vector_lhs;

    std::vector<int32_t> task_vector_rhs;

    float64_t scale;

    float64_t normalization_constant;

};
}
#endif