coco
487 lines
12 KiB
C++
487 lines
12 KiB
C++
// Copyright (C) 2009 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
#undef DLIB_SVm_SPARSE_KERNEL_ABSTRACT_
|
|
#ifdef DLIB_SVm_SPARSE_KERNEL_ABSTRACT_
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include "../algs.h"
|
|
#include "../serialize.h"
|
|
#include "kernel_abstract.h"
|
|
#include "sparse_vector_abstract.h"
|
|
|
|
namespace dlib
|
|
{
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
struct sparse_radial_basis_kernel
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON T
|
|
Must be a sparse vector as defined in dlib/svm/sparse_vector_abstract.h
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a radial basis function kernel
|
|
that works with sparse vectors.
|
|
|
|
THREAD SAFETY
|
|
This kernel is threadsafe.
|
|
!*/
|
|
|
|
typedef typename T::value_type::second_type scalar_type;
|
|
typedef T sample_type;
|
|
typedef default_memory_manager mem_manager_type;
|
|
|
|
const scalar_type gamma;
|
|
|
|
sparse_radial_basis_kernel(
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == 0.1
|
|
!*/
|
|
|
|
sparse_radial_basis_kernel(
|
|
const sparse_radial_basis_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == k.gamma
|
|
!*/
|
|
|
|
sparse_radial_basis_kernel(
|
|
const scalar_type g
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == g
|
|
!*/
|
|
|
|
scalar_type operator() (
|
|
const sample_type& a,
|
|
const sample_type& b
|
|
) const;
|
|
/*!
|
|
requires
|
|
- a is a sparse vector
|
|
- b is a sparse vector
|
|
ensures
|
|
- returns exp(-gamma * distance_squared(a,b))
|
|
!*/
|
|
|
|
sparse_radial_basis_kernel& operator= (
|
|
const sparse_radial_basis_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma = k.gamma
|
|
- returns *this
|
|
!*/
|
|
|
|
bool operator== (
|
|
const sparse_radial_basis_kernel& k
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- if (k and *this are identical) then
|
|
- returns true
|
|
- else
|
|
- returns false
|
|
!*/
|
|
|
|
};
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void serialize (
|
|
const sparse_radial_basis_kernel<T>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
provides serialization support for sparse_radial_basis_kernel
|
|
!*/
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void deserialize (
|
|
sparse_radial_basis_kernel<T>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
provides deserialization support for sparse_radial_basis_kernel
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
struct sparse_sigmoid_kernel
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON T
|
|
Must be a sparse vector as defined in dlib/svm/sparse_vector_abstract.h
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a sigmoid kernel
|
|
that works with sparse vectors.
|
|
|
|
THREAD SAFETY
|
|
This kernel is threadsafe.
|
|
!*/
|
|
|
|
typedef typename T::value_type::second_type scalar_type;
|
|
typedef T sample_type;
|
|
typedef default_memory_manager mem_manager_type;
|
|
|
|
const scalar_type gamma;
|
|
const scalar_type coef;
|
|
|
|
sparse_sigmoid_kernel(
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == 0.1
|
|
- #coef == -1.0
|
|
!*/
|
|
|
|
sparse_sigmoid_kernel(
|
|
const sparse_sigmoid_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == k.gamma
|
|
- #coef == k.coef
|
|
!*/
|
|
|
|
sparse_sigmoid_kernel(
|
|
const scalar_type g,
|
|
const scalar_type c
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == g
|
|
- #coef == c
|
|
!*/
|
|
|
|
scalar_type operator() (
|
|
const sample_type& a,
|
|
const sample_type& b
|
|
) const;
|
|
/*!
|
|
requires
|
|
- a is a sparse vector
|
|
- b is a sparse vector
|
|
ensures
|
|
- returns tanh(gamma * dot(a,b) + coef)
|
|
!*/
|
|
|
|
sparse_sigmoid_kernel& operator= (
|
|
const sparse_sigmoid_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma = k.gamma
|
|
- #coef = k.coef
|
|
- returns *this
|
|
!*/
|
|
|
|
bool operator== (
|
|
const sparse_sigmoid_kernel& k
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- if (k and *this are identical) then
|
|
- returns true
|
|
- else
|
|
- returns false
|
|
!*/
|
|
};
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void serialize (
|
|
const sparse_sigmoid_kernel<T>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
provides serialization support for sparse_sigmoid_kernel
|
|
!*/
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void deserialize (
|
|
sparse_sigmoid_kernel<T>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
provides deserialization support for sparse_sigmoid_kernel
|
|
!*/
|
|
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
struct sparse_polynomial_kernel
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON T
|
|
Must be a sparse vector as defined in dlib/svm/sparse_vector_abstract.h
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a polynomial kernel
|
|
that works with sparse vectors.
|
|
|
|
THREAD SAFETY
|
|
This kernel is threadsafe.
|
|
!*/
|
|
|
|
typedef typename T::value_type::second_type scalar_type;
|
|
typedef T sample_type;
|
|
typedef default_memory_manager mem_manager_type;
|
|
|
|
const scalar_type gamma;
|
|
const scalar_type coef;
|
|
const scalar_type degree;
|
|
|
|
sparse_polynomial_kernel(
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == 1
|
|
- #coef == 0
|
|
- #degree == 1
|
|
!*/
|
|
|
|
sparse_polynomial_kernel(
|
|
const sparse_polynomial_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == k.gamma
|
|
- #coef == k.coef
|
|
- #degree == k.degree
|
|
!*/
|
|
|
|
sparse_polynomial_kernel(
|
|
const scalar_type g,
|
|
const scalar_type c,
|
|
const scalar_type d
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma == g
|
|
- #coef == c
|
|
- #degree == d
|
|
!*/
|
|
|
|
scalar_type operator() (
|
|
const sample_type& a,
|
|
const sample_type& b
|
|
) const;
|
|
/*!
|
|
requires
|
|
- a is a sparse vector
|
|
- b is a sparse vector
|
|
ensures
|
|
- returns pow(gamma * dot(a,b) + coef, degree)
|
|
!*/
|
|
|
|
sparse_polynomial_kernel& operator= (
|
|
const sparse_polynomial_kernel& k
|
|
);
|
|
/*!
|
|
ensures
|
|
- #gamma = k.gamma
|
|
- #coef = k.coef
|
|
- #degree = k.degree
|
|
- returns *this
|
|
!*/
|
|
|
|
bool operator== (
|
|
const sparse_polynomial_kernel& k
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- if (k and *this are identical) then
|
|
- returns true
|
|
- else
|
|
- returns false
|
|
!*/
|
|
};
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void serialize (
|
|
const sparse_polynomial_kernel<T>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
provides serialization support for sparse_polynomial_kernel
|
|
!*/
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void deserialize (
|
|
sparse_polynomial_kernel<T>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
provides deserialization support for sparse_polynomial_kernel
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
struct sparse_linear_kernel
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON T
|
|
Must be a sparse vector as defined in dlib/svm/sparse_vector_abstract.h
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a linear function kernel
|
|
that works with sparse vectors.
|
|
|
|
THREAD SAFETY
|
|
This kernel is threadsafe.
|
|
!*/
|
|
|
|
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;
|
|
/*!
|
|
requires
|
|
- a is a sparse vector
|
|
- b is a sparse vector
|
|
ensures
|
|
- returns dot(a,b)
|
|
!*/
|
|
|
|
bool operator== (
|
|
const sparse_linear_kernel& k
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns true
|
|
!*/
|
|
};
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void serialize (
|
|
const sparse_linear_kernel<T>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
provides serialization support for sparse_linear_kernel
|
|
!*/
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void deserialize (
|
|
sparse_linear_kernel<T>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
provides deserialization support for sparse_linear_kernel
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
struct sparse_histogram_intersection_kernel
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON T
|
|
Must be a sparse vector as defined in dlib/svm/sparse_vector_abstract.h
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a histogram intersection kernel
|
|
that works with sparse vectors.
|
|
|
|
THREAD SAFETY
|
|
This kernel is threadsafe.
|
|
!*/
|
|
|
|
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;
|
|
/*!
|
|
requires
|
|
- a is a sparse vector
|
|
- b is a sparse vector
|
|
- all the values in a and b are >= 0
|
|
ensures
|
|
- Let A(i) denote the value of the ith dimension of the a vector.
|
|
- Let B(i) denote the value of the ith dimension of the b vector.
|
|
- returns sum over all i: std::min(A(i), B(i))
|
|
!*/
|
|
|
|
bool operator== (
|
|
const sparse_histogram_intersection_kernel& k
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns true
|
|
!*/
|
|
};
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void serialize (
|
|
const sparse_histogram_intersection_kernel<T>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
provides serialization support for sparse_histogram_intersection_kernel
|
|
!*/
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void deserialize (
|
|
sparse_histogram_intersection_kernel<T>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
provides deserialization support for sparse_histogram_intersection_kernel
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
#endif // DLIB_SVm_SPARSE_KERNEL_ABSTRACT_
|
|
|
|
|