MetaParametersRBFN Class Reference

Meta-parameters for the Radial Basis Function Network (RBFN) function approximator. More...

#include <MetaParametersRBFN.hpp>

Inheritance diagram for MetaParametersRBFN:

Collaboration diagram for MetaParametersRBFN:

Public Member Functions
	MetaParametersRBFN (int expected_input_dim, const std::vector< Eigen::VectorXd > &centers_per_dim, double intersection_height=0.5, double regularization=0.0)
	Constructor for the algorithmic meta-parameters of the RBFN function approximator. More...
	MetaParametersRBFN (int expected_input_dim, const Eigen::VectorXi &n_basis_functions_per_dim, double intersection_height=0.5, double regularization=0.0)
	Constructor for the algorithmic meta-parameters of the RBFN function approximator. More...
	MetaParametersRBFN (int expected_input_dim, int n_basis_functions=10, double intersection_height=0.5, double regularization=0.0)
	Constructor for the algorithmic meta-parameters of the RBFN function approximator. More...
double	regularization (void) const
	Accessor function for regularization. More...
void	getCentersAndWidths (const Eigen::VectorXd &min, const Eigen::VectorXd &max, Eigen::MatrixXd &centers, Eigen::MatrixXd &widths) const
	Get the centers and widths of the basis functions. More...
MetaParametersRBFN *	clone (void) const
	Return a pointer to a deep copy of the MetaParameters object. More...
std::string	toString (void) const
	Returns a string representation of the object. More...
Public Member Functions inherited from MetaParameters
	MetaParameters (int expected_input_dim)
	Constructor. More...
virtual	~MetaParameters (void)
	Virtual destructor, because this is a base class.
int	getExpectedInputDim (void) const
	The expected dimensionality of the input data. More...
virtual int	getExpectedOutputDim (void) const
	The expected dimensionality of the output data. More...

Friends
class	boost::serialization::access
	Give boost serialization access to private members. More...

Additional Inherited Members
Protected Member Functions inherited from MetaParameters
	MetaParameters (void)
	Default constructor. More...

Detailed Description

Meta-parameters for the Radial Basis Function Network (RBFN) function approximator.

Definition at line 39 of file MetaParametersRBFN.hpp.

Constructor & Destructor Documentation

MetaParametersRBFN	(	int	expected_input_dim,
		const std::vector< Eigen::VectorXd > &	centers_per_dim,
		double	intersection_height = 0.5,
		double	regularization = 0.0
	)

Constructor for the algorithmic meta-parameters of the RBFN function approximator.

Parameters

[in]	expected_input_dim	The dimensionality of the data this function approximator expects. Although this information is already contained in the 'centers_per_dim' argument, we ask the user to pass it explicitly so that various checks on the arguments may be conducted.
[in]	centers_per_dim	Centers of the basis functions, one VectorXd for each dimension.
[in]	intersection_height	The value at which two neighbouring basis functions will intersect.
[in]	regularization	Regularization parameter

Definition at line 52 of file MetaParametersRBFN.cpp.

:
  MetaParameters(expected_input_dim),
  n_bfs_per_dim_(VectorXi::Zero(0)),
  centers_per_dim_(centers_per_dim),
  intersection_height_(intersection_height),
  regularization_(regularization)
{
  assert(expected_input_dim==(int)centers_per_dim_.size());
  for (unsigned int dd=0; dd<centers_per_dim_.size(); dd++)
    assert(centers_per_dim_[dd].size()>0);
  assert(intersection_height_>0 && intersection_height_<1);
  assert(regularization>=0.0);
}

MetaParametersRBFN	(	int	expected_input_dim,
		const Eigen::VectorXi &	n_basis_functions_per_dim,
		double	intersection_height = 0.5,
		double	regularization = 0.0
	)

Constructor for the algorithmic meta-parameters of the RBFN function approximator.

Parameters

[in]	expected_input_dim	The dimensionality of the data this function approximator expects. Although this information is already contained in the 'centers' argument, we ask the user to pass it explicitly so that various checks on the arguments may be conducted.
[in]	n_basis_functions_per_dim	Number of basis functions
[in]	intersection_height	The value at which two neighbouring basis functions will intersect.
[in]	regularization	Regularization parameter

The centers and widths of the basis functions are determined from these parameters once the range of the input data is known, see also setInputMinMax()

Definition at line 67 of file MetaParametersRBFN.cpp.

:
  MetaParameters(expected_input_dim),
  n_bfs_per_dim_(n_bfs_per_dim),
  centers_per_dim_(std::vector<Eigen::VectorXd>(0)),
  intersection_height_(intersection_height),
  regularization_(regularization)  
{
  assert(expected_input_dim==n_bfs_per_dim_.size());
  for (int dd=0; dd<n_bfs_per_dim_.size(); dd++)
    assert(n_bfs_per_dim_[dd]>0);
  assert(intersection_height_>0 && intersection_height_<1);
  assert(regularization>=0.0);
};

MetaParametersRBFN	(	int	expected_input_dim,
		int	n_basis_functions = 10,
		double	intersection_height = 0.5,
		double	regularization = 0.0
	)

Constructor for the algorithmic meta-parameters of the RBFN function approximator.

This is for the special case when the dimensionality of the input data is 1.

Parameters

[in]	expected_input_dim	The dimensionality of the data this function approximator expects. Since this constructor is for 1-D input data only, we simply check if this argument is equal to 1.
[in]	n_basis_functions	Number of basis functions for the one dimension
[in]	intersection_height	The value at which two neighbouring basis functions will intersect.
[in]	regularization	Regularization parameter

The centers and widths of the basis functions are determined from these parameters once the range of the input data is known, see also setInputMinMax()

Definition at line 82 of file MetaParametersRBFN.cpp.

:
  MetaParameters(expected_input_dim),
  n_bfs_per_dim_(VectorXi::Constant(1,n_bfs)),
  centers_per_dim_(std::vector<Eigen::VectorXd>(0)),
  intersection_height_(intersection_height),
  regularization_(regularization)
{
  assert(expected_input_dim==n_bfs_per_dim_.size());
  for (int dd=0; dd<n_bfs_per_dim_.size(); dd++)
    assert(n_bfs_per_dim_[dd]>0);
  assert(intersection_height_>0 && intersection_height_<1);
  assert(regularization>=0.0);
};

Member Function Documentation

double regularization ( void  ) const

inline

Accessor function for regularization.

Returns

Regularization parameter.

Definition at line 79 of file MetaParametersRBFN.hpp.

  {
    return regularization_;
  }

Here is the call graph for this function:

void getCentersAndWidths	(	const Eigen::VectorXd &	min,
		const Eigen::VectorXd &	max,
		Eigen::MatrixXd &	centers,
		Eigen::MatrixXd &	widths
	)		const

Get the centers and widths of the basis functions.

Parameters

[in]	min	Minimum values of input data (one value for each dimension).
[in]	max	Maximum values of input data (one value for each dimension).
[out]	centers	Centers of the basis functions (matrix of size n_basis_functions X n_input_dims
[out]	widths	Widths of the basis functions (matrix of size n_basis_functions X n_input_dims

The reason why there are not two functions getCenters and getWidths is that it is much easier to compute both at the same time, and usually you will need both at the same time anyway.

Todo:

Document this rather complex function

Definition at line 109 of file MetaParametersRBFN.cpp.

{
  int n_dims = getExpectedInputDim();
  assert(min.size()==n_dims);
  assert(max.size()==n_dims);
    
  vector<VectorXd> centers_per_dim_local(n_dims); 
  if (!centers_per_dim_.empty())
  {
    centers_per_dim_local = centers_per_dim_;
  }
  else
  {
    // Centers are not know yet, compute them based on min and max
    for (int i_dim=0; i_dim<n_dims; i_dim++)
      centers_per_dim_local[i_dim] = VectorXd::LinSpaced(n_bfs_per_dim_[i_dim],min[i_dim],max[i_dim]);
  }
  
  // Determine the widths from the centers (separately for each dimension)
  vector<VectorXd> widths_per_dim_local(n_dims); 
  for (int i_dim=0; i_dim<n_dims; i_dim++)
  {
    VectorXd cur_centers = centers_per_dim_local[i_dim]; // Abbreviation for convenience
    int n_centers = cur_centers.size();
    VectorXd cur_widths(n_centers);

    if (n_centers==1)
    {
      cur_widths[0] = 1.0;
    }
    else
    {
      // Consider two neighbouring basis functions, exp(-0.5(x-c0)^2/w^2) and exp(-0.5(x-c1)^2/w^2)
      // Assuming the widths are the same for both, they are certain to intersect at x = 0.5(c0+c1)
      // And we want the activation at x to be 'intersection'. So
      //            y = exp(-0.5(x-c0)^2/w^2)
      // intersection = exp(-0.5((0.5(c0+c1))-c0)^2/w^2)
      // intersection = exp(-0.5((0.5*c1-0.5*c0)^2/w^2))
      // intersection = exp(-0.5((0.5*(c1-c0))^2/w^2))
      // intersection = exp(-0.5(0.25*(c1-c0)^2/w^2))
      // intersection = exp(-0.125((c1-c0)^2/w^2))
      //            w = sqrt((c1-c0)^2/-8*ln(intersection))
      for (int cc=0; cc<n_centers-1; cc++)
      {
        double w = sqrt(pow(cur_centers[cc+1]-cur_centers[cc],2)/(-8*log(intersection_height_)));
        cur_widths[cc] = w;
      }
      cur_widths[n_centers-1] = cur_widths[n_centers-2];
    }
    widths_per_dim_local[i_dim] = cur_widths;
  }

  VectorXd digit_max(n_dims);
  int n_centers = 1;
  for (int i_dim=0; i_dim<n_dims; i_dim++)
  {
    n_centers = n_centers*centers_per_dim_local[i_dim].size();
    digit_max[i_dim] = centers_per_dim_local[i_dim].size();
  }
  VectorXi digit = VectorXi::Zero(n_dims);
  
  centers.resize(n_centers,n_dims);
  widths.resize(n_centers,n_dims);
  int i_center=0;

  while (digit[0]<digit_max(0))
  {
    for (int i_dim=0; i_dim<n_dims; i_dim++)
    {
      centers(i_center,i_dim) = centers_per_dim_local[i_dim][digit[i_dim]];
      widths(i_center,i_dim) = widths_per_dim_local[i_dim][digit[i_dim]];
    }
    i_center++;
  
    // Increment last digit by one
    digit[n_dims-1]++;
    for (int i_dim=n_dims-1; i_dim>0; i_dim--)
    {
      if (digit[i_dim]>=digit_max[i_dim])
      {
        digit[i_dim] = 0;
        digit[i_dim-1]++;
      }
    }
  }
  
}

Here is the call graph for this function:

MetaParametersRBFN * clone ( void  ) const

virtual

Return a pointer to a deep copy of the MetaParameters object.

Returns

Pointer to a deep copy

Implements MetaParameters.

Definition at line 97 of file MetaParametersRBFN.cpp.

{
  MetaParametersRBFN* cloned;
  if (centers_per_dim_.size()>0)
    cloned =  new MetaParametersRBFN(getExpectedInputDim(),centers_per_dim_,intersection_height_,regularization_);
  else
    cloned =  new MetaParametersRBFN(getExpectedInputDim(),n_bfs_per_dim_,intersection_height_,regularization_);
  
  return cloned;
}

Here is the call graph for this function:

string toString ( void  ) const

virtual

Returns a string representation of the object.

Returns

A string representation of the object.

Implements MetaParameters.

Definition at line 209 of file MetaParametersRBFN.cpp.

{
  RETURN_STRING_FROM_BOOST_SERIALIZATION_XML("MetaParametersRBFN");
}

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Give boost serialization access to private members.

Definition at line 111 of file MetaParametersRBFN.hpp.

---

The documentation for this class was generated from the following files:

• MetaParametersRBFN.hpp
• MetaParametersRBFN.cpp