dlib C++ Library - sparse_kernel.h

// Copyright (C) 2009 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_SVm_SPARSE_KERNEL
#define DLIB_SVm_SPARSE_KERNEL
#include "sparse_kernel_abstract.h"
#include <cmath>
#include <limits>
#include "../algs.h"
#include "../serialize.h"
#include "sparse_vector.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
 template <
 typename T
 >
 struct sparse_radial_basis_kernel
 {
 typedef typename T::value_type::second_type scalar_type;
 typedef T sample_type;
 typedef default_memory_manager mem_manager_type;
 sparse_radial_basis_kernel(const scalar_type g) : gamma(g) {}
 sparse_radial_basis_kernel() : gamma(0.1) {}
 sparse_radial_basis_kernel(
 const sparse_radial_basis_kernel& k
 ) : gamma(k.gamma) {}
 const scalar_type gamma;
 scalar_type operator() (
 const sample_type& a,
 const sample_type& b
 ) const
 { 
 const scalar_type d = distance_squared(a,b);
 return std::exp(-gamma*d);
 }
 sparse_radial_basis_kernel& operator= (
 const sparse_radial_basis_kernel& k
 )
 {
 const_cast<scalar_type&>(gamma) = k.gamma;
 return *this;
 }
 bool operator== (
 const sparse_radial_basis_kernel& k
 ) const
 {
 return gamma == k.gamma;
 }
 };
 template <
 typename T
 >
 void serialize (
 const sparse_radial_basis_kernel<T>& item,
 std::ostream& out
 )
 {
 try
 {
 serialize(item.gamma, out);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while serializing object of type sparse_radial_basis_kernel"); 
 }
 }
 template <
 typename T
 >
 void deserialize (
 sparse_radial_basis_kernel<T>& item,
 std::istream& in 
 )
 {
 typedef typename T::value_type::second_type scalar_type;
 try
 {
 deserialize(const_cast<scalar_type&>(item.gamma), in);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while deserializing object of type sparse_radial_basis_kernel"); 
 }
 }
// ----------------------------------------------------------------------------------------
 template <
 typename T
 >
 struct sparse_polynomial_kernel
 {
 typedef typename T::value_type::second_type scalar_type;
 typedef T sample_type;
 typedef default_memory_manager mem_manager_type;
 sparse_polynomial_kernel(const scalar_type g, const scalar_type c, const scalar_type d) : gamma(g), coef(c), degree(d) {}
 sparse_polynomial_kernel() : gamma(1), coef(0), degree(1) {}
 sparse_polynomial_kernel(
 const sparse_polynomial_kernel& k
 ) : gamma(k.gamma), coef(k.coef), degree(k.degree) {}
 typedef T type;
 const scalar_type gamma;
 const scalar_type coef;
 const scalar_type degree;
 scalar_type operator() (
 const sample_type& a,
 const sample_type& b
 ) const
 { 
 return std::pow(gamma*(dot(a,b)) + coef, degree);
 }
 sparse_polynomial_kernel& operator= (
 const sparse_polynomial_kernel& k
 )
 {
 const_cast<scalar_type&>(gamma) = k.gamma;
 const_cast<scalar_type&>(coef) = k.coef;
 const_cast<scalar_type&>(degree) = k.degree;
 return *this;
 }
 bool operator== (
 const sparse_polynomial_kernel& k
 ) const
 {
 return (gamma == k.gamma) && (coef == k.coef) && (degree == k.degree);
 }
 };
 template <
 typename T
 >
 void serialize (
 const sparse_polynomial_kernel<T>& item,
 std::ostream& out
 )
 {
 try
 {
 serialize(item.gamma, out);
 serialize(item.coef, out);
 serialize(item.degree, out);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while serializing object of type sparse_polynomial_kernel"); 
 }
 }
 template <
 typename T
 >
 void deserialize (
 sparse_polynomial_kernel<T>& item,
 std::istream& in 
 )
 {
 typedef typename T::value_type::second_type scalar_type;
 try
 {
 deserialize(const_cast<scalar_type&>(item.gamma), in);
 deserialize(const_cast<scalar_type&>(item.coef), in);
 deserialize(const_cast<scalar_type&>(item.degree), in);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while deserializing object of type sparse_polynomial_kernel"); 
 }
 }
// ----------------------------------------------------------------------------------------
 template <
 typename T
 >
 struct sparse_sigmoid_kernel
 {
 typedef typename T::value_type::second_type scalar_type;
 typedef T sample_type;
 typedef default_memory_manager mem_manager_type;
 sparse_sigmoid_kernel(const scalar_type g, const scalar_type c) : gamma(g), coef(c) {}
 sparse_sigmoid_kernel() : gamma(0.1), coef(-1.0) {}
 sparse_sigmoid_kernel(
 const sparse_sigmoid_kernel& k
 ) : gamma(k.gamma), coef(k.coef) {}
 typedef T type;
 const scalar_type gamma;
 const scalar_type coef;
 scalar_type operator() (
 const sample_type& a,
 const sample_type& b
 ) const
 { 
 return std::tanh(gamma*(dot(a,b)) + coef);
 }
 sparse_sigmoid_kernel& operator= (
 const sparse_sigmoid_kernel& k
 )
 {
 const_cast<scalar_type&>(gamma) = k.gamma;
 const_cast<scalar_type&>(coef) = k.coef;
 return *this;
 }
 bool operator== (
 const sparse_sigmoid_kernel& k
 ) const
 {
 return (gamma == k.gamma) && (coef == k.coef);
 }
 };
 template <
 typename T
 >
 void serialize (
 const sparse_sigmoid_kernel<T>& item,
 std::ostream& out
 )
 {
 try
 {
 serialize(item.gamma, out);
 serialize(item.coef, out);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while serializing object of type sparse_sigmoid_kernel"); 
 }
 }
 template <
 typename T
 >
 void deserialize (
 sparse_sigmoid_kernel<T>& item,
 std::istream& in 
 )
 {
 typedef typename T::value_type::second_type scalar_type;
 try
 {
 deserialize(const_cast<scalar_type&>(item.gamma), in);
 deserialize(const_cast<scalar_type&>(item.coef), in);
 }
 catch (serialization_error& e)
 { 
 throw serialization_error(e.info + "\n while deserializing object of type sparse_sigmoid_kernel"); 
 }
 }
// ----------------------------------------------------------------------------------------
 template <typename T>
 struct sparse_linear_kernel
 {
 typedef typename T::value_type::second_type scalar_type;
 typedef T sample_type;
 typedef default_memory_manager mem_manager_type;
 scalar_type operator() (
 const sample_type& a,
 const sample_type& b
 ) const
 { 
 return dot(a,b);
 }
 bool operator== (
 const sparse_linear_kernel& 
 ) const
 {
 return true;
 }
 };
 template <
 typename T
 >
 void serialize (
 const sparse_linear_kernel<T>& ,
 std::ostream& 
 ){}
 template <
 typename T
 >
 void deserialize (
 sparse_linear_kernel<T>& ,
 std::istream& 
 ){}
// ----------------------------------------------------------------------------------------
 template <typename T>
 struct sparse_histogram_intersection_kernel
 {
 typedef typename T::value_type::second_type scalar_type;
 typedef T sample_type;
 typedef default_memory_manager mem_manager_type;
 scalar_type operator() (
 const sample_type& a,
 const sample_type& b
 ) const
 { 
 typename sample_type::const_iterator ai = a.begin();
 typename sample_type::const_iterator bi = b.begin();
 scalar_type sum = 0;
 while (ai != a.end() && bi != b.end())
 {
 if (ai->first == bi->first)
 {
 sum += std::min(ai->second , bi->second);
 ++ai;
 ++bi;
 }
 else if (ai->first < bi->first)
 {
 ++ai;
 }
 else 
 {
 ++bi;
 }
 }
 return sum;
 }
 bool operator== (
 const sparse_histogram_intersection_kernel& 
 ) const
 {
 return true;
 }
 };
 template <
 typename T
 >
 void serialize (
 const sparse_histogram_intersection_kernel<T>& ,
 std::ostream& 
 ){}
 template <
 typename T
 >
 void deserialize (
 sparse_histogram_intersection_kernel<T>& ,
 std::istream& 
 ){}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_SVm_SPARSE_KERNEL