/usr/include/shogun/kernel/RidgeKernelNormalizer.h is in libshogun-dev 1.1.0-4ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | /*
* 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) 2009 Soeren Sonnenburg
* Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
*/
#ifndef _RIDGEKERNELNORMALIZER_H___
#define _RIDGEKERNELNORMALIZER_H___
#include <shogun/kernel/KernelNormalizer.h>
namespace shogun
{
/** @brief Normalize the kernel by adding a constant term to its diagonal.
* This aids kernels to become positive definite (even though they are
* not - often caused by numerical problems).
*
* Formally,
*
* \f[
* k'(x,x')= \frac{k(x,x')}+ R\cdot {\bf E}
* \f]
*
* where E is a matrix with ones on the diagonal and R is the scalar
* ridge term. The ridge term R is computed as \f$R=r\dot c\f$.
*
* Typically,
*
* - r=1e-10 and c=0.0 will add mean(diag(K))*1e-10 to the diagonal
* - r=0.1 and c=1 will add 0.1 to the diagonal
*
*
* In case c <= 0, c is compute as the mean of the kernel diagonal
* \f[
* \mbox{c} = \frac{1}{N}\sum_{i=1}^N k(x_i,x_i)
* \f]
*
*/
class CRidgeKernelNormalizer : public CKernelNormalizer
{
public:
/** constructor
*
* @param r ridge parameter
* @param c scale parameter, if <= 0 scaling will be computed
* from the avg of the kernel diagonal elements
*
* the scalar r*c will be added to the kernel diagonal, typical use cases:
* - r=1e-10 and c=0.0 will add mean(diag(K))*1e-10 to the diagonal
* - r=0.1 and c=1 will add 0.1 to the diagonal
*/
CRidgeKernelNormalizer(float64_t r=1e-10, float64_t c=0.0)
: CKernelNormalizer()
{
m_parameters->add(&scale, "scale",
"Scale quotient by which kernel is scaled.");
m_parameters->add(&ridge, "ridge", "Ridge added to diagonal.");
scale=c;
ridge=r;
}
/** default destructor */
virtual ~CRidgeKernelNormalizer()
{
}
/** initialization of the normalizer (if needed)
* @param k kernel */
virtual bool init(CKernel* k)
{
if (scale<=0)
{
ASSERT(k);
int32_t num=k->get_num_vec_lhs();
ASSERT(num>0);
CFeatures* old_lhs=k->lhs;
CFeatures* old_rhs=k->rhs;
k->lhs=old_lhs;
k->rhs=old_lhs;
float64_t sum=0;
for (int32_t i=0; i<num; i++)
sum+=k->compute(i, i);
scale=sum/num;
k->lhs=old_lhs;
k->rhs=old_rhs;
}
ridge*=scale;
return true;
}
/** normalize the kernel value
* @param value kernel value
* @param idx_lhs index of left hand side vector
* @param idx_rhs index of right hand side vector
*/
inline virtual float64_t normalize(
float64_t value, int32_t idx_lhs, int32_t idx_rhs)
{
if (idx_lhs==idx_rhs)
return value+ridge;
else
return value;
}
/** normalize only the left hand side vector
* @param value value of a component of the left hand side feature vector
* @param idx_lhs index of left hand side vector
*/
inline virtual float64_t normalize_lhs(float64_t value, int32_t idx_lhs)
{
SG_ERROR("linadd not supported with Ridge normalization.\n");
return 0;
}
/** normalize only the right hand side vector
* @param value value of a component of the right hand side feature vector
* @param idx_rhs index of right hand side vector
*/
inline virtual float64_t normalize_rhs(float64_t value, int32_t idx_rhs)
{
SG_ERROR("linadd not supported with Ridge normalization.\n");
return 0;
}
/** @return object name */
inline virtual const char* get_name() const { return "RidgeKernelNormalizer"; }
protected:
/// the constant ridge to be added to the kernel diagonal
float64_t ridge;
/// scaling parameter (avg of diagonal)
float64_t scale;
};
}
#endif // _RIDGEKERNELNORMALIZER_H___
|