MeLOn
kernel.h
Go to the documentation of this file.
1 /***********************************************************************************
2 * Copyright (c) 2020 Process Systems Engineering (AVT.SVT), RWTH Aachen University
3 *
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License 2.0 which is available at
6 * http://www.eclipse.org/legal/epl-2.0.
7 *
8 * SPDX-License-Identifier: EPL-2.0
9 *
10 * @file kernel.h
11 *
12 * @brief File containing declaration of kernel classes
13 *
14 **********************************************************************************/
15 
16 #pragma once
17 
18 #include <vector>
19 #include <memory>
20 
21 namespace melon {
22  namespace kernel {
23 
28  template <typename T, typename V>
29  class Kernel {
30  public:
31 
32  // Deduces kernel return type, depending on template parameters
33  using RET = decltype(std::declval<T>() + std::declval<V>());
34 
38  virtual ~Kernel() = default;
39 
49  virtual RET evaluate_kernel(std::vector<T> x1, std::vector<V> x2) = 0;
50  };
51 
52 
57  template <typename T, typename V>
58  class StationaryKernel : public Kernel<T, V> {
59  public:
60 
61  using typename Kernel<T, V> ::RET;
62 
70  virtual RET _quadratic_distance(std::vector<T> x1, std::vector<V> x2) {
71  RET distance = 0;
72 
73  for (size_t i = 0; i < x1.size(); i++) { // i the demension of X and X_test
74  distance += pow(x1.at(i) - x2.at(i), 2);
75  }
76 
77  return distance;
78  };
79 
87  virtual RET evaluate_kernel(RET distance) = 0; // works only for stationary kernels
88 
98  virtual RET calculate_distance(std::vector<T> x1, std::vector<V> x2) = 0;
99  };
100 
101 
106  template <typename T, typename V>
107  class KernelCompositeAdd : public Kernel<T, V> {
108  public:
109 
110  using typename Kernel<T, V> ::RET;
111 
117  void add(std::shared_ptr<Kernel<T, V>> kernel) { children.push_back(kernel); }
118 
128  RET evaluate_kernel(std::vector<T> x1, std::vector<V> x2) {
129  RET value = 0;
130  for (auto kernel : children) {
131  value += kernel->evaluate_kernel(x1, x2);
132  }
133  return value;
134  }
135 
136  private:
137  std::vector<std::shared_ptr<Kernel<T, V>>> children;
138  };
139 
144  template <typename T, typename V>
145  class KernelCompositeMultiply : public Kernel<T, V> {
146  public:
147 
148  using typename Kernel<T, V> ::RET;
149 
155  void add(std::shared_ptr<Kernel<T, V>> kernel) { children.push_back(kernel); }
156 
166  RET evaluate_kernel(std::vector<T> x1, std::vector<V> x2) {
167  RET value = 1;
168  for (auto kernel : children) {
169  value *= kernel->k(x1, x2);
170  }
171  return value;
172  }
173 
174  private:
175  std::vector<std::shared_ptr<Kernel<T, V>>> children;
176  };
177 
182  template <typename T, typename V>
183  class KernelConstant : public Kernel<T, V> {
184  public:
185 
186  using typename Kernel<T, V> ::RET;
187 
191  KernelConstant() : _f(1) {};
192 
198  KernelConstant(const T f) : _f(f) {};
199 
205  KernelConstant(const V f) : _f(f) {};
206 
216  RET evaluate_kernel(std::vector<T> x1, std::vector<V> x2) {
217  return _f;
218  }
219 
220  private:
221  const RET _f;
222  };
223 
224 
229  template <typename T, typename V>
230  class KernelRBF : public StationaryKernel<T, V> {
231  public:
232 
233  using typename Kernel<T, V> ::RET;
234 
240  KernelRBF(const double gamma) : _gamma(gamma) {};
241 
242 
252  RET evaluate_kernel(std::vector<T> x1, std::vector<V> x2) override {
253 
254  RET distance = calculate_distance(x1, x2);
255  return evaluate_kernel(distance);
256  }
257 
267  RET calculate_distance(std::vector<T> x1, std::vector<V> x2) override {
268  return this->_quadratic_distance(x1, x2);
269  }
270 
278  RET evaluate_kernel(RET distance) override {
279 
280  return exp(-_gamma * distance);
281 
282  }
283 
284  private:
285  const double _gamma;
286  };
287 
288  }
289 
290 }
melon::kernel::KernelRBF::calculate_distance
RET calculate_distance(std::vector< T > x1, std::vector< V > x2) override
Function for calculating the distance used in the kernel (type of distance used can vary among kernel...
Definition: kernel.h:293
melon::kernel::KernelCompositeMultiply::children
std::vector< std::shared_ptr< Kernel< T, V > > > children
Definition: kernel.h:201
melon::kernel::KernelCompositeAdd::children
std::vector< std::shared_ptr< Kernel< T, V > > > children
Definition: kernel.h:163
melon::kernel::KernelConstant::evaluate_kernel
RET evaluate_kernel(std::vector< T > x1, std::vector< V > x2)
Function for evalualting the kernel.
Definition: kernel.h:242
melon::kernel::StationaryKernel
Definition: kernel.h:84
melon::kernel::Kernel::evaluate_kernel
virtual RET evaluate_kernel(std::vector< T > x1, std::vector< V > x2)=0
Function for evalualting the kernel for the points x1 and x2.
melon::kernel::KernelConstant::KernelConstant
KernelConstant()
Constructor. Initializes the kernels return value to 1.
Definition: kernel.h:217
melon::kernel::StationaryKernel::calculate_distance
virtual RET calculate_distance(std::vector< T > x1, std::vector< V > x2)=0
Function for calculating the distance used in the kernel (type of distance used can vary among kernel...
melon::kernel::KernelRBF::KernelRBF
KernelRBF(const double gamma)
Constructor.
Definition: kernel.h:266
melon::kernel::KernelCompositeAdd::add
void add(std::shared_ptr< Kernel< T, V >> kernel)
Function for adding another subkernel to the composite kernel.
Definition: kernel.h:143
melon::kernel::KernelRBF::evaluate_kernel
RET evaluate_kernel(std::vector< T > x1, std::vector< V > x2) override
Function for evalualting the kernel.
Definition: kernel.h:278
melon::kernel::KernelCompositeMultiply::evaluate_kernel
RET evaluate_kernel(std::vector< T > x1, std::vector< V > x2)
Function for evalualting the kernel.
Definition: kernel.h:192
melon::kernel::Kernel
Abstract parent class for kernel implementations.
Definition: kernel.h:55
melon::kernel::KernelCompositeAdd::evaluate_kernel
RET evaluate_kernel(std::vector< T > x1, std::vector< V > x2)
Function for evalualting the kernel.
Definition: kernel.h:154
melon::kernel::StationaryKernel::evaluate_kernel
virtual RET evaluate_kernel(RET distance)=0
Function for evalualting the kernel for a given distance.
melon::kernel::KernelRBF::_gamma
const double _gamma
Definition: kernel.h:311
melon::kernel::Kernel::RET
decltype(std::declval< T >()+std::declval< V >()) RET
Definition: kernel.h:59
melon::kernel::KernelRBF
Implementation of Radial Basis Function kernel.
Definition: kernel.h:256
melon::kernel::Kernel::~Kernel
virtual ~Kernel()=default
Destructor.
melon::kernel::KernelCompositeMultiply::add
void add(std::shared_ptr< Kernel< T, V >> kernel)
Function for adding another subkernel to the composite kernel.
Definition: kernel.h:181
melon::kernel::KernelConstant::_f
const RET _f
Definition: kernel.h:247
melon
Definition: kernel.h:21
melon::kernel::StationaryKernel::_quadratic_distance
virtual RET _quadratic_distance(std::vector< T > x1, std::vector< V > x2)
Calculates the quadratic distance between two points x1 and x2.
Definition: kernel.h:96