ZeroMeanCenterKernelNormalizer.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 Gorden Jemwa
 * Copyright (C) 2010 University of Stellenbosch
 */

#ifndef _ZEROMEANCENTERKERNELNORMALIZER_H___
#define _ZEROMEANCENTERKERNELNORMALIZER_H___

#include <shogun/lib/config.h>

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

namespace shogun
{
class CZeroMeanCenterKernelNormalizer : public CKernelNormalizer
{
    public:
        CZeroMeanCenterKernelNormalizer()
            : CKernelNormalizer(), ktrain_row_means(NULL), num_ktrain(0),
            ktest_row_means(NULL),  num_ktest(0)
        {
            m_parameters->add_vector(&ktrain_row_means, &num_ktrain,
                    "num_ktrain", "Train row means.");
            m_parameters->add_vector(&ktest_row_means, &num_ktest,
                    "num_ktest","Test row means.");
        }

        virtual ~CZeroMeanCenterKernelNormalizer()
        {
            SG_FREE(ktrain_row_means);
            SG_FREE(ktest_row_means);
        }

        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)

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

            /* compute mean for each row of the train matrix*/
            k->lhs=old_lhs;
            k->rhs=old_lhs;

            bool r1=alloc_and_compute_row_means(k, ktrain_row_means, num_lhs,num_lhs);

            /* compute mean for each row of the test matrix */
            k->lhs=old_lhs;
            k->rhs=old_rhs;

            bool r2=alloc_and_compute_row_means(k, ktest_row_means, num_lhs,num_rhs);

            /* compute train kernel matrix mean */
            ktrain_mean=0;
            for (int32_t i=0;i<num_lhs;i++)
                ktrain_mean += (ktrain_row_means[i]/num_lhs);

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

            return r1 && r2;
        }

        virtual float64_t normalize(
                float64_t value, int32_t idx_lhs, int32_t idx_rhs)
        {
            value += (-ktrain_row_means[idx_lhs] - ktest_row_means[idx_rhs] + ktrain_mean);
            return value;
        }

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

        bool alloc_and_compute_row_means(CKernel* k, float64_t* &v, int32_t num_lhs, int32_t num_rhs)
        {
            SG_FREE(v);
            v=SG_MALLOC(float64_t, num_rhs);

            for (int32_t i=0; i<num_rhs; i++)
            {
                v[i]=0;
                for (int32_t j=0; j<num_lhs; j++)
                    v[i] += ( k->compute(j,i)/num_lhs );
            }
            return (v!=NULL);
        }

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

    protected:
        float64_t* ktrain_row_means;

        int32_t num_ktrain;

        float64_t* ktest_row_means;

        int32_t num_ktest;

        float64_t ktrain_mean;
};
}
#endif