Changeset 163

Timestamp:

Sep 22, 2004, 7:14:06 PM (19 years ago)

Author:

Peter

Message:

Design of Kernel class modified

Location:

trunk/src

Files:

• GaussianKernelFunction.cc (modified) (2 diffs)
• GaussianKernelFunction.h (modified) (3 diffs)
• Kernel.cc (modified) (1 diff)
• KernelFunction.h (modified) (3 diffs)
• PolynomialKernelFunction.cc (modified) (3 diffs)
• PolynomialKernelFunction.h (modified) (5 diffs)

trunk/src/GaussianKernelFunction.cc

@@ -7 +7 @@
 // Thep C++ Tools
 #include "GaussianKernelFunction.h"
+#include "matrix.h"
 #include "vector.h"
 
@@ -33 +34 @@
 }
 
+
+const theplu::gslapi::matrix& 
+GaussianKernelFunction::operator()(theplu::gslapi::matrix& k,
+                                   const theplu::gslapi::matrix& data) const
+{
+  theplu::gslapi::matrix data_transposed(data);
+  data_transposed.transpose();
+  k = data_transposed*data;
+  // Working with the linear linear kernel in order to avoid copying
+  // row vectors from data matrix (many times) and calculate the
+  // kernel element in a more transparent way.
+  for (size_t i=0; i<k.rows()-1; i++)
+    for (size_t j=i+1; j<k.columns(); j++)
+      k(i,j)=k(j,i)=exp(-(k(i,i)+k(j,j)-2*k(i,j))/(2*sigma_));
+  for (size_t i=0; i<k.rows(); i++)
+    k(i,i)=1;
+  return k;
+}
+
 }} // of namespace cpptools and namespace theplu

trunk/src/GaussianKernelFunction.h

@@ -15 +15 @@
 namespace cpptools {
 
-  /**
-     Class calculating one element in the kernel matrix using the 
-     Gaussian kernel.
-  */
+  ///
+  /// Class for Gaussian kernel calculations.
+  ///
 
  
@@ -25 +24 @@
     
   public:
-    ///Constructor taking the sigma_ , i.e. the width of the Gaussian,as
+    ///
+    ///Constructor taking the sigma_ , i.e. the width of the Gaussian,as
     ///input. Default is sigma_ = 1.
     ///
     GaussianKernelFunction(double = 1);
     
-    ///Destructor
+    ///
+    ///Destructor
     ///
        virtual ~GaussianKernelFunction(void) {};
     
-    ///returning the scalar product of two vectors in feature space using the
-    ///Gaussian kernel. @return \f$ exp((x - y)^{2}/\sigma^2) \f$ \n
+    ///
+    /// returning the scalar product of two vectors in feature space using the
+    /// Gaussian kernel. @return \f$ exp((x - y)^{2}/\sigma^2) \f$ \n
     ///
     inline double operator()(const gslapi::vector& a1,
@@ -49 +51 @@
                       const gslapi::vector& w2) const;
           
-  private:
+    ///
+    /// @kernel matrix
+    ///
+    const gslapi::matrix& operator()(theplu::gslapi::matrix& kernel,
+                                     const theplu::gslapi::matrix& data) const;
+  
+  private:
     double sigma_;
 

trunk/src/Kernel.cc

@@ -11 +11 @@
 
 Kernel::Kernel(const gslapi::matrix& data, const KernelFunction& kf)
-  : k_(data.rows(),data.rows())
+  : k_(data.columns(),data.columns())
 {
-  for(u_int i=0;i<data.rows();i++)
-    for(u_int j=0;j<i+1;j++)
-      k_(i,j)=kf(data[i],data[j]);
-  
-  // Copy lower triangle to upper triangle of Kernel matrix
-  for(u_int i=0;i<data.rows()-1;i++)
-    for(u_int j=i+1;j<data.rows();j++) 
-      k_(i,j)=k_(j,i);
+  k_ = kf(k_,data);
 }
 
 Kernel::Kernel(const gslapi::matrix& data, const KernelFunction& kf, 
                const gslapi::matrix& weight)
-  : k_(data.rows(),data.rows())
+  : k_(data.columns(),data.columns())
 {
-  for(u_int i=0;i<data.rows();i++)
-    for(u_int j=0;j<i+1;j++)
-      k_(i,j)=kf(data[i],data[j],weight[i],weight[j]);
+  for(u_int i=0;i<data.columns();i++)
+    for(u_int j=i;j<data.columns();j++)
+      k_(i,j)=k_(j,i)=kf(data[i],data[j],weight[i],weight[j]);
   
-  // Copy lower triangle to upper triangle of Kernel matrix
-  for(u_int i=0;i<data.rows()-1;i++)
-    for(u_int j=i+1;j<data.rows();j++) 
-      k_(i,j)=k_(j,i);
 }
 

trunk/src/KernelFunction.h

@@ -8 +8 @@
 namespace gslapi {
   class vector;
+  class matrix;
 }
 
@@ -13 +14 @@
 
   ///
-  ///   Virtual Class calculating one element in the kernel matrix
-  ///   (i.e. the scalar product in feature space) from the two
-  ///   corresponding vector in the data matrix.
+  ///   Virtual Class calculating kernel matrix.
   ///
   class KernelFunction 
@@ -39 +38 @@
                               const gslapi::vector&) const = 0; 
     
-  }; // class KernelFunction
+    virtual const theplu::gslapi::matrix& operator()
+      (theplu::gslapi::matrix& k, const gslapi::matrix& data) const = 0;
+  
+  }; // class KernelFunction
 
 }} // of namespace cpptools and namespace theplu

trunk/src/PolynomialKernelFunction.cc

@@ -6 +6 @@
 // Thep C++ Tools
 #include "PolynomialKernelFunction.h"
+#include "matrix.h"
 #include "vector.h"
 
@@ -21 +22 @@
 {
   if(order_>1) 
-    return pow(a1*a2,order_);
+    return pow(1+a1*a2,order_);
   return a1*a2;
 }
@@ -43 +44 @@
 }
 
+const theplu::gslapi::matrix& 
+PolynomialKernelFunction::operator()(theplu::gslapi::matrix& kernel,
+                                     const theplu::gslapi::matrix& data) const
+{
+  theplu::gslapi::matrix data_transposed(data.transpose());
+  kernel = data_transposed*data;
+  if (order_>1)
+    for (size_t i=0; i<kernel.rows(); i++)
+      for (size_t j=i; j<kernel.rows(); j++)
+        kernel(i,j)=kernel(j,i)=pow(1+kernel(i,j),order_);
+  return kernel;
+}
 }} // of namespace cpptools and namespace theplu

trunk/src/PolynomialKernelFunction.h

@@ -14 +14 @@
 namespace cpptools {
 
-  ///Class calculating one element in the kernel matrix using the polynomial
-  ///kernel.
+  ///
+  /// Class for polynomial kernel calculations
   ///
 
@@ -23 +23 @@
     
   public:
-    ///Constructor taking the order of the polynomial as input. Default is
+    ///
+    ///Constructor taking the order of the polynomial as input. Default is
     ///order=1 yielding the linear kernel function.
     ///
@@ -33 +34 @@
     virtual ~PolynomialKernelFunction(void) {};
     
+    ///
     ///returning the scalar product of two vectors in feature space using the
     ///polynomial kernel. @return If order is larger than one: \f$ (1+x \cdot
@@ -39 +41 @@
     double operator()(const gslapi::vector&, const gslapi::vector&) const;
 
+    ///
     ///returning the scalar product of two vectors in feature space using the
     ///polynomial kernel with weights.
@@ -45 +48 @@
                       const gslapi::vector&, const gslapi::vector&) const;
     
+    ///
+    /// @kernel matrix
+    ///
+    const gslapi::matrix& operator()(theplu::gslapi::matrix& kernel,
+                                     const theplu::gslapi::matrix& data) const;
+
   private:
     int order_;