ModelParametersLWR Class Reference

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

#include <ModelParametersLWR.hpp>

Inheritance diagram for ModelParametersLWR:

Collaboration diagram for ModelParametersLWR:

Public Member Functions
	ModelParametersLWR (const Eigen::MatrixXd &centers, const Eigen::MatrixXd &widths, const Eigen::MatrixXd &slopes, const Eigen::MatrixXd &offsets, bool asymmetric_kernels=false, bool lines_pivot_at_max_activation=false)
	Constructor for the model parameters of the LWPR function approximator. More...
std::string	toString (void) const
	Returns a string representation of the object. More...
ModelParameters *	clone (void) const
	Return a pointer to a deep copy of the ModelParameters object. More...
int	getExpectedInputDim (void) const
	The expected dimensionality of the input data. More...
void	unnormalizedKernelActivations (const Eigen::Ref< const Eigen::MatrixXd > &inputs, Eigen::MatrixXd &kernel_activations) const
	Get the unnormalized kernel activations for given inputs. More...
void	kernelActivations (const Eigen::Ref< const Eigen::MatrixXd > &inputs, Eigen::MatrixXd &kernel_activations) const
	Get the normalized kernel activations for given inputs. More...
void	getLines (const Eigen::Ref< const Eigen::MatrixXd > &inputs, Eigen::MatrixXd &lines) const
	Get the output of each linear model (unweighted) for the given inputs. More...
void	setParameterVectorModifierPrivate (std::string modifier, bool new_value)
	Turn certain modifiers on or off, see Parameterizable::setParameterVectorModifier(). More...
void	set_lines_pivot_at_max_activation (bool lines_pivot_at_max_activation)
	Set whether the offsets should be adapted so that the line segments pivot around the mode of the basis function, rather than the intersection with the y-axis. More...
void	set_slopes_as_angles (bool slopes_as_angles)
	Whether to return slopes as angles or slopes in ModelParametersLWR::getParameterVectorAll() More...
void	getSelectableParameters (std::set< std::string > &selected_values_labels) const
	Return all the names of the parameter types that can be selected. More...
void	getParameterVectorMask (const std::set< std::string > selected_values_labels, Eigen::VectorXi &selected_mask) const
	Get a mask for selecting parameters. More...
void	getParameterVectorAll (Eigen::VectorXd &all_values) const
	Return a vector that returns all available parameter values. More...
int	getParameterVectorAllSize (void) const
	Get the size of the parameter values vector when it contains all available parameter values. More...
unsigned int	getNumberOfBasisFunctions () const
	Get the number of basis functions in this model. More...
UnifiedModel *	toUnifiedModel (void) const
	Convert these model parameters to unified model parameters. More...
void	set_caching (bool caching)
	Turn caching for the function normalizedKernelActivations() on or off. More...
Public Member Functions inherited from ModelParameters
virtual int	getExpectedOutputDim (void) const
	The expected dimensionality of the output data. More...
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)
	Serialize class data members to boost archive. More...
Public Member Functions inherited from Parameterizable
virtual	~Parameterizable (void)
	Destructor.
virtual int	getParameterVectorSelectedSize (void) const
	Get the size of the vector of selected parameters, as returned by getParameterVectorSelected(. More...
virtual void	getParameterVectorSelected (Eigen::VectorXd &values, bool normalized=false) const
	Get the values of the selected parameters in one vector. More...
virtual void	getParameterVectorSelectedNormalized (Eigen::VectorXd &values) const
	Get the normalized values of the selected parameters in one vector. More...
void	getParameterVectorSelectedMinMax (Eigen::VectorXd &min, Eigen::VectorXd &max) const
	Get the minimum and maximum of the selected parameters in one vector. More...
void	getParameterVectorAllMinMax (Eigen::VectorXd &min, Eigen::VectorXd &max) const
	Get the minimum and maximum values of the current parameter vector. More...
void	getParameterVectorSelectedRanges (Eigen::VectorXd &ranges) const
	Get the ranges of the selected parameters, i.e. More...
virtual void	setParameterVectorSelected (const Eigen::VectorXd &values, bool normalized=false)
	Set all the values of the selected parameters with one vector. More...
virtual void	setParameterVectorSelectedNormalized (const Eigen::VectorXd &values)
	Set all the values of the selected parameters with one vector of normalized values. More...
virtual void	setSelectedParameters (const std::set< std::string > &selected_values_labels)
	Determine which subset of parameters is represented in the vector returned by Parameterizable::getParameterVectorSelected. More...
void	setSelectedParametersOne (std::string selected)
	Set the parameters that are currently selected. More...
void	setParameterVectorModifier (std::string modifier, bool new_value)
	Turn certain modifiers on or off. More...
void	setVectorLengthsPerDimension (const Eigen::VectorXi &lengths_per_dimension)
	The vector (VectorXd) with parameter values can be split into different parts (as vector<VectorXd>; this function specifices the length of each sub-vector. More...
Eigen::VectorXi	getVectorLengthsPerDimension (void) const
	Get the specified length of each vector in each dimension. More...
void	getParameterVectorSelected (std::vector< Eigen::VectorXd > &values, bool normalized=false) const
	Get the values of the selected parameters in one vector. More...
void	setParameterVectorSelected (const std::vector< Eigen::VectorXd > &values, bool normalized=false)
	Set all the values of the selected parameters with a vector of vectors. More...

Protected Member Functions
void	setParameterVectorAll (const Eigen::VectorXd &values)
	Set all available parameter values with one vector. More...

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

Detailed Description

Model parameters for the Locally Weighted Regression (LWR) function approximator.

Definition at line 40 of file ModelParametersLWR.hpp.

Constructor & Destructor Documentation

ModelParametersLWR	(	const Eigen::MatrixXd &	centers,
		const Eigen::MatrixXd &	widths,
		const Eigen::MatrixXd &	slopes,
		const Eigen::MatrixXd &	offsets,
		bool	asymmetric_kernels = false,
		bool	lines_pivot_at_max_activation = false
	)

Constructor for the model parameters of the LWPR function approximator.

Parameters

[in]	centers	Centers of the basis functions
[in]	widths	Widths of the basis functions.
[in]	slopes	Slopes of the line segments.
[in]	offsets	Offsets of the line segments, i.e. the value of the line segment at its intersection with the y-axis.
[in]	asymmetric_kernels	Whether to use asymmetric kernels or not, cf MetaParametersLWR::asymmetric_kernels()
[in]	lines_pivot_at_max_activation	Whether line models should pivot at x=0 (false), or at the center of the kernel (x=x_c)

Definition at line 54 of file ModelParametersLWR.cpp.

:
  centers_(centers),
  widths_(widths),
  slopes_(slopes), 
  offsets_(offsets),
  asymmetric_kernels_(asymmetric_kernels),
  lines_pivot_at_max_activation_(lines_pivot_at_max_activation),
  slopes_as_angles_(false),
  caching_(false)
{
#ifndef NDEBUG // Variables below are only required for asserts; check for NDEBUG to avoid warnings.
  int n_basis_functions = centers.rows();
  int n_dims = centers.cols();
#endif  
  assert(n_basis_functions==widths_.rows());
  assert(n_dims           ==widths_.cols());
  assert(n_basis_functions==slopes_.rows());
  assert(n_dims           ==slopes_.cols());
  assert(n_basis_functions==offsets_.rows());
  assert(1                ==offsets_.cols());
  
  all_values_vector_size_ = 0;
  all_values_vector_size_ += centers_.rows()*centers_.cols();
  all_values_vector_size_ += widths_.rows() *widths_.cols();
  all_values_vector_size_ += offsets_.rows()*offsets_.cols();
  all_values_vector_size_ += slopes_.rows() *slopes_.cols();

};

Member Function Documentation

string toString ( void  ) const

virtual

Returns a string representation of the object.

Returns

A string representation of the object.

Implements ModelParameters.

Definition at line 308 of file ModelParametersLWR.cpp.

{
  RETURN_STRING_FROM_BOOST_SERIALIZATION_XML("ModelParametersLWR");
}

ModelParameters * clone ( void  ) const

virtual

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

Returns

Pointer to a deep copy

Implements ModelParameters.

Definition at line 84 of file ModelParametersLWR.cpp.

                                                     {
  return new ModelParametersLWR(centers_,widths_,slopes_,offsets_,asymmetric_kernels_,lines_pivot_at_max_activation_); 
}

int getExpectedInputDim ( void  ) const

inlinevirtual

The expected dimensionality of the input data.

Returns

Expected dimensionality of the input data

Implements ModelParameters.

Definition at line 59 of file ModelParametersLWR.hpp.

                                       {
    return centers_.cols();
  };

Here is the call graph for this function:

void unnormalizedKernelActivations	(	const Eigen::Ref< const Eigen::MatrixXd > &	inputs,
		Eigen::MatrixXd &	kernel_activations
	)		const

Get the unnormalized kernel activations for given inputs.

Parameters

[in]	inputs	The input data (size: n_samples X n_dims)
[out]	kernel_activations	The kernel activations, computed for each of the samples in the input data (size: n_samples X n_basis_functions)

Definition at line 88 of file ModelParametersLWR.cpp.

{
  ENTERING_REAL_TIME_CRITICAL_CODE
  bool normalized_basis_functions=false;  
  BasisFunction::Gaussian::activations(centers_,widths_,inputs,kernel_activations,
    normalized_basis_functions,asymmetric_kernels_);  
  EXITING_REAL_TIME_CRITICAL_CODE
}

void kernelActivations	(	const Eigen::Ref< const Eigen::MatrixXd > &	inputs,
		Eigen::MatrixXd &	kernel_activations
	)		const

Get the normalized kernel activations for given inputs.

Parameters

[in]	inputs	The input data (size: n_samples X n_dims)
[out]	kernel_activations	The normalized kernel activations, computed for each of the sampels in the input data (size: n_samples X n_basis_functions)

Definition at line 97 of file ModelParametersLWR.cpp.

{
  if (caching_)
  {
    // If the cached inputs matrix has the same size as the one now requested
    //     (this also takes care of the case when inputs_cached is empty and need to be initialized)
    if ( inputs.rows()==inputs_cached_.rows() && inputs.cols()==inputs_cached_.cols() )
    {
      // And they have the same values
      if ( (inputs.array()==inputs_cached_.array()).all() )
      {
        // Then you can return the cached values
        kernel_activations = kernel_activations_cached_;
        return;
      }
    }
  }

  ENTERING_REAL_TIME_CRITICAL_CODE
  
  // Cache could not be used, actually do the work
  bool normalize_activations = true;
  BasisFunction::Gaussian::activations(centers_,widths_,inputs,kernel_activations,normalize_activations,asymmetric_kernels_);

  EXITING_REAL_TIME_CRITICAL_CODE
  
  if (caching_)
  {
    // Cache the current results now.  
    inputs_cached_ = inputs;
    kernel_activations_cached_ = kernel_activations;
  }
  
}

void getLines	(	const Eigen::Ref< const Eigen::MatrixXd > &	inputs,
		Eigen::MatrixXd &	lines
	)		const

Get the output of each linear model (unweighted) for the given inputs.

Parameters

[in]	inputs	The inputs for which to compute the output of the lines models (size: n_samples X n_input_dims)
[out]	lines	The output of the linear models (size: n_samples X n_basis_functions)

If "lines" is passed as a Matrix of correct size (n_samples X n_basis_functions), this function will not allocate any memory, and is real-time.

Definition at line 216 of file ModelParametersLWR.cpp.

{
  ENTERING_REAL_TIME_CRITICAL_CODE
  
  //cout  << endl << "========================" << endl;
  //cout << "lines = " << lines.rows() << "X" << lines.cols() << endl;
  //cout << "centers_ = " << centers_.rows() << "X" << centers_.cols() << endl;
  //cout << "slopes_ = " << slopes_.rows() << "X" << slopes_.cols() << endl;
  //cout << "offsets_ = " << offsets_.rows() << "X" << offsets_.cols() << endl;
  //cout << "inputs = " << inputs.rows() << "X" << inputs.cols() << endl;
  
  int n_time_steps = inputs.rows();
  int n_lines = centers_.rows();
  lines.resize(n_time_steps,n_lines);
  //cout << "lines = " << lines.rows() << "X" << lines.cols() << endl;


  // Compute values along lines for each time step  
  // Line representation is "y = ax + b"
  for (int i_line=0; i_line<n_lines; i_line++)
  {
    lines.col(i_line).noalias() = inputs*slopes_.row(i_line).transpose();
    lines.col(i_line).array() += offsets_(i_line);
  
    if (lines_pivot_at_max_activation_)
    {
      // Line representation is "y = a(x-c) + b", which is  "y = ax - ac + b"
      // Therefore, we still have to subtract "ac"
      double ac = slopes_.row(i_line).dot(centers_.row(i_line));
      lines.col(i_line).array() -= ac;
    }
  }
  
  EXITING_REAL_TIME_CRITICAL_CODE
}

void setParameterVectorModifierPrivate ( std::string  modifier, bool  new_value  )

virtual

Turn certain modifiers on or off, see Parameterizable::setParameterVectorModifier().

Parameterizable::setParameterVectorModifierPrivate(), This function may (but must not be) overridden by subclasses of Parameterizable, depending on whether the subclass has modifiers (or not)

Parameters

[in]	modifier	The name of the modifier
[in]	new_value	Whether to turn the modifier on (true) or off (false)

Reimplemented from Parameterizable.

Definition at line 445 of file ModelParametersLWR.cpp.

{
  if (modifier.compare("lines_pivot_at_max_activation")==0)
    set_lines_pivot_at_max_activation(new_value);
  
  if (modifier.compare("slopes_as_angles")==0)
    set_slopes_as_angles(new_value);
  
}

Here is the call graph for this function:

void set_lines_pivot_at_max_activation

(

bool

lines_pivot_at_max_activation

)

Set whether the offsets should be adapted so that the line segments pivot around the mode of the basis function, rather than the intersection with the y-axis.

Parameters

[in]

lines_pivot_at_max_activation

Whether to pivot around the mode or not.

Definition at line 132 of file ModelParametersLWR.cpp.

{
  // If no change, just return
  if (lines_pivot_at_max_activation_ == lines_pivot_at_max_activation)
    return;

  //cout << "________________" << endl;
  //cout << centers_.transpose() << endl;  
  //cout << slopes_.transpose() << endl;  
  //cout << offsets_.transpose() << endl;  
  //cout << "centers_ = " << centers_.rows() << "X" << centers_.cols() << endl;
  //cout << "slopes_ = " << slopes_.rows() << "X" << slopes_.cols() << endl;
  //cout << "offsets_ = " << offsets_.rows() << "X" << offsets_.cols() << endl;

  // If you pivot lines around the point when the basis function has maximum activation (i.e.
  // at the center of the Gaussian), you must compute the new offset corresponding to this
  // slope, and vice versa    
  int n_lines = centers_.rows();
  VectorXd ac(n_lines); // slopes*centers
  for (int i_line=0; i_line<n_lines; i_line++)
  {
    ac[i_line] = slopes_.row(i_line) * centers_.row(i_line).transpose();
  }
    
  if (lines_pivot_at_max_activation)
  {
    // Representation was "y = ax + b", now it will be "y = a(x-c) + b^new" 
    // Since "y = ax + b" can be rewritten as "y = a(x-c) + (b+ac)", we know that "b^new = (ac+b)"
    offsets_ = offsets_ + ac;
  }
  else
  {
    // Representation was "y = a(x-c) + b", now it will be "y = ax + b^new" 
    // Since "y = a(x-c) + b" can be rewritten as "y = ax + (b-ac)", we know that "b^new = (b-ac)"
    offsets_ = offsets_ - ac;
  } 
  // Remark, the above could have been done as a one-liner, but I prefer the more legible version.
  
  //cout << offsets_.transpose() << endl;  
  //cout << "offsets_ = " << offsets_.rows() << "X" << offsets_.cols() << endl;
  
  lines_pivot_at_max_activation_ = lines_pivot_at_max_activation;
}

void set_slopes_as_angles

(

bool

slopes_as_angles

)

Whether to return slopes as angles or slopes in ModelParametersLWR::getParameterVectorAll()

Parameters

[in]

slopes_as_angles

Whether to return as slopes (true) or angles (false)

Todo:

Implement and document

Definition at line 176 of file ModelParametersLWR.cpp.

{
  slopes_as_angles_ = slopes_as_angles;
  cerr << __FILE__ << ":" << __LINE__ << ":";
  cerr << "Not implemented yet!!!" << endl;
  slopes_as_angles_ = false;
}

void getSelectableParameters ( std::set< std::string > &  selected_values_labels ) const

virtual

Return all the names of the parameter types that can be selected.

Parameters

[out]

selected_values_labels

Names of the parameter types that can be selected

Implements Parameterizable.

Definition at line 313 of file ModelParametersLWR.cpp.

{
  selected_values_labels = set<string>();
  selected_values_labels.insert("centers");
  selected_values_labels.insert("widths");
  selected_values_labels.insert("offsets");
  selected_values_labels.insert("slopes");
}

void getParameterVectorMask ( const std::set< std::string >  selected_values_labels, Eigen::VectorXi &  selected_mask  ) const

virtual

Get a mask for selecting parameters.

Parameters

[in]	selected_values_labels	Labels of the selected parameter values
[out]	selected_mask	A mask indicating indices of selected parameters. 0 indicates not selected, >0 indicates selected.

For instance, if the parameters consists of centers, widths and slopes the parameter values vector will be something like

    centers     widths    slopes
[ 100 110 120 10 10 10 0.4 0.7 0.4 ]

In this case, if selected_values_labels contains "centers" and "slopes", the mask will be:

    centers     widths    slopes
[   1   1   1  0  0  0   3   3   3 ]

The '0' indicates that these parameters are not selected. The other ones have different numbers so that they may be discerned from one another (as required in Parameterizable::getParameterVectorSelectedMinMax for instance.

Implements Parameterizable.

Definition at line 323 of file ModelParametersLWR.cpp.

{

  selected_mask.resize(getParameterVectorAllSize());
  selected_mask.fill(0);
  
  int offset = 0;
  int size;
  
  // Centers
  size = centers_.rows()*centers_.cols();
  if (selected_values_labels.find("centers")!=selected_values_labels.end())
    selected_mask.segment(offset,size).fill(1);
  offset += size;
  
  // Widths
  size = widths_.rows()*widths_.cols();
  if (selected_values_labels.find("widths")!=selected_values_labels.end())
    selected_mask.segment(offset,size).fill(2);
  offset += size;
  
  // Offsets
  size = offsets_.rows()*offsets_.cols();
  if (selected_values_labels.find("offsets")!=selected_values_labels.end())
    selected_mask.segment(offset,size).fill(3);
  offset += size;

  // Slopes
  size = slopes_.rows()*slopes_.cols();
  if (selected_values_labels.find("slopes")!=selected_values_labels.end())
    selected_mask.segment(offset,size).fill(4);
  offset += size;

  assert(offset == getParameterVectorAllSize());   
}

Here is the call graph for this function:

void getParameterVectorAll ( Eigen::VectorXd &  values ) const

virtual

Return a vector that returns all available parameter values.

Parameters

[out]

values

All available parameter values in one vector.

Remarks

Contrast this with Parameterizable::getParameterVectorSelected, which return only the SELECTED parameter values. Selecting parameters is done with Parameterizable::setSelectedParameters

Implements Parameterizable.

Definition at line 359 of file ModelParametersLWR.cpp.

{
  values.resize(getParameterVectorAllSize());
  int offset = 0;
  
  for (int i_dim=0; i_dim<centers_.cols(); i_dim++)
  {
    values.segment(offset,centers_.rows()) = centers_.col(i_dim);
    offset += centers_.rows();
  }
  
  for (int i_dim=0; i_dim<widths_.cols(); i_dim++)
  {
    values.segment(offset,widths_.rows()) = widths_.col(i_dim);
    offset += widths_.rows();
  }
  
  values.segment(offset,offsets_.rows()) = offsets_;
  offset += offsets_.rows();
  
  VectorXd cur_slopes;
  for (int i_dim=0; i_dim<slopes_.cols(); i_dim++)
  {
    cur_slopes = slopes_.col(i_dim);
    if (slopes_as_angles_)
    {
      // cur_slopes is a slope, but the values vector expects the angle with the x-axis. Do the 
      // conversion here.
      for (int ii=0; ii<cur_slopes.size(); ii++)
        cur_slopes[ii] = atan2(cur_slopes[ii],1.0);
    }
    
    values.segment(offset,slopes_.rows()) = cur_slopes;
    offset += slopes_.rows();
  }
  
  assert(offset == getParameterVectorAllSize());   
};

Here is the call graph for this function:

int getParameterVectorAllSize ( void  ) const

inlinevirtual

Get the size of the parameter values vector when it contains all available parameter values.

Returns

The size of the parameter vector

For instance, if the parameters consists of centers, widths and slopes the parameter values vector will be something like

    centers     widths    slopes
[ 100 110 120 10 10 10 0.4 0.7 0.4 ]

then getParameterVectorAllSize() will return 9

Implements Parameterizable.

Definition at line 102 of file ModelParametersLWR.hpp.

  {
    return all_values_vector_size_;
  }

unsigned int getNumberOfBasisFunctions ( ) const

inline

Get the number of basis functions in this model.

Returns

The number of basis functions.

Definition at line 110 of file ModelParametersLWR.hpp.

  {
    return centers_.rows();
  }

Here is the call graph for this function:

UnifiedModel * toUnifiedModel ( void  ) const

virtual

Convert these model parameters to unified model parameters.

Returns

Unified model parameter representation (NULL if not implemented for a particular subclass)

Implements ModelParameters.

Definition at line 455 of file ModelParametersLWR.cpp.

{

  // LWR uses normalized basis functions
  bool normalized_basis_functions = true;
  return new UnifiedModel(centers_, widths_, slopes_, offsets_, normalized_basis_functions); 
  
}

void setParameterVectorAll ( const Eigen::VectorXd &  values )

protectedvirtual

Set all available parameter values with one vector.

Parameters

[in]

values

All available parameter values in one vector.

Remarks

Contrast this with Parameterizable::setParameterVectorSelected, which sets only the SELECTED parameter values. Selecting parameters is done with Parameterizable::setSelectedParameters

Implements Parameterizable.

Definition at line 398 of file ModelParametersLWR.cpp.

                                                                     {

  if (all_values_vector_size_ != values.size())
  {
    cerr << __FILE__ << ":" << __LINE__ << ": values is of wrong size." << endl;
    return;
  }
  
  int offset = 0;
  int size = centers_.rows();
  int n_dims = centers_.cols();
  for (int i_dim=0; i_dim<n_dims; i_dim++)
  {
    // If the centers change, the cache for normalizedKernelActivations() must be cleared,
    // because this function will return different values for different centers
    if ( !(centers_.col(i_dim).array() == values.segment(offset,size).array()).all() )
      clearCache();
    
    centers_.col(i_dim) = values.segment(offset,size);
    offset += size;
  }
  for (int i_dim=0; i_dim<n_dims; i_dim++)
  {
    // If the centers change, the cache for normalizedKernelActivations() must be cleared,
    // because this function will return different values for different centers
    if ( !(widths_.col(i_dim).array() == values.segment(offset,size).array()).all() )
      clearCache();
    
    widths_.col(i_dim) = values.segment(offset,size);
    offset += size;
  }

  offsets_ = values.segment(offset,size);
  offset += size;
  // Cache must not be cleared, because normalizedKernelActivations() returns the same values.

  MatrixXd old_slopes = slopes_;
  for (int i_dim=0; i_dim<n_dims; i_dim++)
  {
    slopes_.col(i_dim) = values.segment(offset,size);
    offset += size;
    // Cache must not be cleared, because normalizedKernelActivations() returns the same values.
  }

  assert(offset == getParameterVectorAllSize());   
};

Here is the call graph for this function:

void set_caching ( bool  caching )

inline

Turn caching for the function normalizedKernelActivations() on or off.

Turning this on should lead to substantial improvements in execution time if the centers and widths of the kernels do not change often AND you call normalizedKernelActivations with the same inputs over and over again.

Parameters

[in]

caching

Whether to turn caching on or off

Remarks

In the constructor, caching is set to true, so by default it is on.

Definition at line 139 of file ModelParametersLWR.hpp.

        {
          caching_ = caching;
          if (!caching_) clearCache();
        }

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Give boost serialization access to private members.

Definition at line 162 of file ModelParametersLWR.hpp.

---

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

• ModelParametersLWR.hpp
• ModelParametersLWR.cpp