MetaParametersLWR Class Reference

Meta-parameters for the Locally Weighted Regression (LWR) function approximator. More...

#include <MetaParametersLWR.hpp>

Inheritance diagram for MetaParametersLWR:

Collaboration diagram for MetaParametersLWR:

Public Member Functions
	MetaParametersLWR (int expected_input_dim, const std::vector< Eigen::VectorXd > &centers_per_dim, double intersection_height=0.5, double regularization=0.0, bool asymmetric_kernels=false)
	Constructor for the algorithmic meta-parameters of the LWR function approximator. More...
	MetaParametersLWR (int expected_input_dim, const Eigen::VectorXi &n_basis_functions_per_dim, double intersection_height=0.5, double regularization=0.0, bool asymmetric_kernels=false)
	Constructor for the algorithmic meta-parameters of the LWR function approximator. More...
	MetaParametersLWR (int expected_input_dim, int n_basis_functions=10, double intersection_height=0.5, double regularization=0.0, bool asymmetric_kernels=false)
	Constructor for the algorithmic meta-parameters of the LWR function approximator. 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...
double	regularization (void) const
	Accessor function for regularization. More...
bool	asymmetric_kernels (void) const
	Accessor function for asymmetric_kernels. More...
MetaParametersLWR *	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 Locally Weighted Regression (LWR) function approximator.

Definition at line 39 of file MetaParametersLWR.hpp.

Constructor & Destructor Documentation

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

Constructor for the algorithmic meta-parameters of the LWR 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
[in]	asymmetric_kernels	Whether to use asymmetric kernels or not (to be documented, default is false)

Definition at line 52 of file MetaParametersLWR.cpp.

:
  MetaParameters(expected_input_dim),
  n_bfs_per_dim_(VectorXi::Zero(0)),
  centers_per_dim_(centers_per_dim),
  intersection_height_(intersection_height),
  regularization_(regularization),
  asymmetric_kernels_(asymmetric_kernels)
{
  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);
}

MetaParametersLWR	(	int	expected_input_dim,
		const Eigen::VectorXi &	n_basis_functions_per_dim,
		double	intersection_height = 0.5,
		double	regularization = 0.0,
		bool	asymmetric_kernels = false
	)

Constructor for the algorithmic meta-parameters of the LWR 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
[in]	asymmetric_kernels	Whether to use asymmetric kernels or not (to be documented, default is false)

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 68 of file MetaParametersLWR.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),
  asymmetric_kernels_(asymmetric_kernels)
{
  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);
};

MetaParametersLWR	(	int	expected_input_dim,
		int	n_basis_functions = 10,
		double	intersection_height = 0.5,
		double	regularization = 0.0,
		bool	asymmetric_kernels = false
	)

Constructor for the algorithmic meta-parameters of the LWR 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
[in]	asymmetric_kernels	Whether to use asymmetric kernels or not (to be documented, default is false)

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 84 of file MetaParametersLWR.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),
  asymmetric_kernels_(asymmetric_kernels)
{
  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

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 112 of file MetaParametersLWR.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:

double regularization ( void  ) const

inline

Accessor function for regularization.

Returns

Regularization parameter.

Definition at line 93 of file MetaParametersLWR.hpp.

  {
    return regularization_;
  }

bool asymmetric_kernels ( void  ) const

inline

Accessor function for asymmetric_kernels.

Returns

true if asymmetric kernels are used, false if symmetric kernels are used.

Todo:

Document this. In the literature, only symmetric kernels are used.

Definition at line 102 of file MetaParametersLWR.hpp.

  {
    return asymmetric_kernels_;
  }

Here is the call graph for this function:

MetaParametersLWR * 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 100 of file MetaParametersLWR.cpp.

{
  MetaParametersLWR* cloned;
  if (centers_per_dim_.size()>0)
    cloned =  new MetaParametersLWR(getExpectedInputDim(),centers_per_dim_,intersection_height_,regularization_,asymmetric_kernels_);
  else
    cloned =  new MetaParametersLWR(getExpectedInputDim(),n_bfs_per_dim_,intersection_height_,regularization_,asymmetric_kernels_);
  
  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 213 of file MetaParametersLWR.cpp.

{
  RETURN_STRING_FROM_BOOST_SERIALIZATION_XML("MetaParametersLWR");
}

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Give boost serialization access to private members.

Definition at line 124 of file MetaParametersLWR.hpp.

---

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

• MetaParametersLWR.hpp
• MetaParametersLWR.cpp