ModelParametersGMR Class Reference

Model parameters for the GMR function approximator. More...

#include <ModelParametersGMR.hpp>

Inheritance diagram for ModelParametersGMR:

Collaboration diagram for ModelParametersGMR:

Public Member Functions
	ModelParametersGMR (std::vector< double > priors, std::vector< Eigen::VectorXd > means, std::vector< Eigen::MatrixXd > covars, int n_output_dims=1)
	Constructor for the model parameters of the GMR function approximator.
	ModelParametersGMR (std::vector< double > priors, std::vector< Eigen::VectorXd > mu_xs, std::vector< Eigen::VectorXd > mu_ys, std::vector< Eigen::MatrixXd > sigma_xs, std::vector< Eigen::MatrixXd > sigma_ys, std::vector< Eigen::MatrixXd > sigma_x_ys)
	Constructor for the model parameters of the GMR function approximator.
	ModelParametersGMR (int n_observations, std::vector< double > priors, std::vector< Eigen::VectorXd > means, std::vector< Eigen::MatrixXd > covars, int n_output_dims=1)
	Constructor for the model parameters of the GMR function approximator (Used by the incremental training).
	ModelParametersGMR (int n_observations, std::vector< double > priors, std::vector< Eigen::VectorXd > mu_xs, std::vector< Eigen::VectorXd > mu_ys, std::vector< Eigen::MatrixXd > sigma_xs, std::vector< Eigen::MatrixXd > sigma_ys, std::vector< Eigen::MatrixXd > sigma_x_ys)
	Constructor for the model parameters of the GMR function approximator (Used by the incremental training).
unsigned int	getNumberOfGaussians (void) const
	Get the number of Gaussians in the GMM. More...
virtual int	getExpectedOutputDim (void) const
	The expected dimensionality of the output data. More...
virtual int	getExpectedInputDim (void) const
	The expected dimensionality of the input data. 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...
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...
bool	saveGMM (std::string directory, bool overwrite=false) const
	Save a Gaussian mixture model to a directory; useful for debugging. More...
void	toMatrix (Eigen::MatrixXd &gmm_as_matrix) const
	This function represents the Gaussian Mixture Model as one big matrix. More...
bool	saveGMMToMatrix (std::string filename, bool overwrite=false) const
	Save the GMM as a matrix in an ASCII file. More...
UnifiedModel *	toUnifiedModel (void) const
	Convert these model parameters to unified model parameters. More...
Public Member Functions inherited from ModelParameters
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...

Static Public Member Functions
static bool	saveGMM (std::string directory, const std::vector< Eigen::VectorXd > &centers, const std::vector< Eigen::MatrixXd > &covars, bool overwrite=false, int iter=-1)
	Save a Gaussian mixture model to a directory; useful for debugging. More...
static ModelParametersGMR *	fromMatrix (const Eigen::MatrixXd &gmm_matrix)
	Initialize a GMM from a matrix. More...
static ModelParametersGMR *	loadGMMFromMatrix (std::string filename)
	Load the GMM from a matrix in an ASCII file. More...

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

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

Detailed Description

Model parameters for the GMR function approximator.

Definition at line 38 of file ModelParametersGMR.hpp.

Member Function Documentation

unsigned int getNumberOfGaussians ( void  ) const

inline

Get the number of Gaussians in the GMM.

Returns

The number of Gaussians in the GMM.

Definition at line 73 of file ModelParametersGMR.hpp.

  {
    return priors_.size();
  }

virtual int getExpectedOutputDim ( void  ) const

inlinevirtual

The expected dimensionality of the output data.

For now, we only consider 1-dimensional output by default.

Returns

Expected dimensionality of the output data

Reimplemented from ModelParameters.

Definition at line 78 of file ModelParametersGMR.hpp.

  {
          assert(means_y_.size()>0); // This is also checked in the constructor
    return means_y_[0].size();
  }

virtual int getExpectedInputDim ( void  ) const

inlinevirtual

The expected dimensionality of the input data.

Returns

Expected dimensionality of the input data

Implements ModelParameters.

Definition at line 84 of file ModelParametersGMR.hpp.

        {
          assert(means_x_.size()>0); // This is also checked in the constructor
          return means_x_[0].size();
        };

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 ModelParameters.

Definition at line 236 of file ModelParametersGMR.cpp.

{
  RETURN_STRING_FROM_BOOST_SERIALIZATION_XML("ModelParametersGMR");
};

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 196 of file ModelParametersGMR.cpp.

{
  std::vector<double> priors;
  std::vector<VectorXd> means_x;
  std::vector<VectorXd> means_y;
  std::vector<MatrixXd> covars_x;
  std::vector<MatrixXd> covars_y;
  std::vector<MatrixXd> covars_y_x;
  int n_observations = n_observations_;

  for (size_t i = 0; i < priors_.size(); i++)
  {
    priors.push_back(priors_[i]);
    means_x.push_back(VectorXd(means_x_[i]));
    means_y.push_back(VectorXd(means_y_[i]));
    covars_x.push_back(MatrixXd(covars_x_[i]));
    covars_y.push_back(MatrixXd(covars_y_[i]));
    covars_y_x.push_back(MatrixXd(covars_y_x_[i]));
  }

  return new ModelParametersGMR(n_observations, priors, means_x, means_y, covars_x, covars_y, covars_y_x);
}

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

Todo:

Determine which parameters should be modifiable in GMR.

Implements Parameterizable.

Definition at line 403 of file ModelParametersGMR.cpp.

{
  selected_values_labels = set<string>();
  // selected_values_labels.insert("centers");
  // selected_values_labels.insert("priors");
  // selected_values_labels.insert("slopes");
  // selected_values_labels.insert("biases");
  // selected_values_labels.insert("inverse_covars_l");
}

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 413 of file ModelParametersGMR.cpp.

{
  // selected_mask.resize(getParameterVectorAllSize());
  // selected_mask.fill(0);
  
  // int offset = 0;
  // int size;

  // size = centers_.size() * centers_[0].size();
  // if (selected_values_labels.find("centers")!=selected_values_labels.end())
  //   selected_mask.segment(offset,size).fill(1);
  // offset += size;
  
  // size = priors_.size();
  // if (selected_values_labels.find("priors")!=selected_values_labels.end())
  //   selected_mask.segment(offset,size).fill(2);
  // offset += size;

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

    
  // size = biases_.size() * biases_[0].size();
  // if (selected_values_labels.find("biases")!=selected_values_labels.end())
  //   selected_mask.segment(offset,size).fill(4);
  // offset += size;

  // size = inverseCovarsL_.size() * (inverseCovarsL_[0].rows() * (inverseCovarsL_[0].cols() + 1))/2;
  // if (selected_values_labels.find("inverse_covars_l")!=selected_values_labels.end())
  //   selected_mask.segment(offset,size).fill(5);
  // offset += size;
    
  // assert(offset == getParameterVectorAllSize());   
}

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 451 of file ModelParametersGMR.cpp.

{
  // values.resize(getParameterVectorAllSize());
  // int offset = 0;

  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   values.segment(offset, centers_[i].size()) = centers_[i];
  //   offset += centers_[i].size();
  // }

  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   values[offset] = priors_[i];
  //   offset += 1;
  // }

  // for (size_t i = 0; i < slopes_.size(); i++)
  // {
  //   for (int col = 0; col < slopes_[i].cols(); col++)
  //   {
  //     values.segment(offset, slopes_[i].rows()) = slopes_[i].col(col);
  //     offset += slopes_[i].rows();
  //   }
  // }

  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   values.segment(offset, biases_[i].size()) = biases_[i];
  //   offset += biases_[i].size();
  // }

  // for (size_t i = 0; i < inverseCovarsL_.size(); i++)
  // {
  //   for (int row = 0; row < inverseCovarsL_[i].rows(); row++)
  //     for (int col = 0; col < row + 1; col++)
  //     {
  //       values[offset] = inverseCovarsL_[i](row, col);
  //       offset += 1;
  //     }
  // }
  
  // assert(offset == getParameterVectorAllSize());   

};

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 ModelParametersGMR.hpp.

  {
    return all_values_vector_size_;
  }

Here is the call graph for this function:

bool saveGMM ( std::string  directory, const std::vector< Eigen::VectorXd > &  centers, const std::vector< Eigen::MatrixXd > &  covars, bool  overwrite = false, int  iter = -1  )

static

Save a Gaussian mixture model to a directory; useful for debugging.

Parameters

[in]	directory	Directory to save to
[in]	centers	Centers of the Gaussians
[in]	covars	Covariance matrices of the Gaussians
[in]	overwrite	Whether to overwrite existing files or not.
[in]	iter	Iteration number when running Expectation-Maximization. Allows the GMM to be stored with a different filename (in the same directory) at each iteration.

Returns

true if successful, false otherwise

Definition at line 241 of file ModelParametersGMR.cpp.

{
  for (size_t i_gau = 0; i_gau < centers.size(); i_gau++)
  {
    stringstream stream;
    stream << "gmm";
    if (iter>=0)
      stream << "_iter" << setw(2) << setfill('0') << iter;
    stream  << "_mu" << setw(3) << setfill('0') << i_gau << ".txt";
    string filename = stream.str();
    if (!saveMatrix(directory, filename,  centers[i_gau],  overwrite))
      return false;
    //cout << "  filename=" << filename << endl;
    
    stringstream stream2;
    stream2 << "gmm";
    if (iter>=0)
      stream2 << "_iter" << setw(2) << setfill('0') << iter;
    stream2  << "_covar" << setw(3) << setfill('0') << i_gau << ".txt";
    filename = stream2.str();
    //cout << "  filename=" << filename << endl;
    if (!saveMatrix(directory, filename,  covars[i_gau],  overwrite))
      return false;    
  }
  return true;
}

Here is the call graph for this function:

bool saveGMM	(	std::string	directory,
		bool	overwrite = false
	)		const

Save a Gaussian mixture model to a directory; useful for debugging.

Parameters

[in]	directory	Directory to save to
[in]	overwrite	Whether to overwrite existing files or not.

Returns

true if successful, false otherwise

Definition at line 268 of file ModelParametersGMR.cpp.

{
  if (save_directory.empty())
    return true;
  
  //MatrixXd inputs;
  //FunctionApproximator::generateInputsGrid(min, max, n_samples_per_dim, inputs);
  //saveMatrix(save_directory,"n_samples_per_dim.txt",n_samples_per_dim,overwrite);

  int n_gaussians = means_x_.size();
  int n_dims_in = means_x_[0].size();
  int n_dims_out = means_y_[0].size();
  int n_dims_gmm = n_dims_in + n_dims_out;
  
  
  std::vector<VectorXd> means(n_gaussians);
  std::vector<MatrixXd> covars(n_gaussians);
  for (int i_gau = 0; i_gau < n_gaussians; i_gau++)
  {
    means[i_gau] = VectorXd(n_dims_gmm);
    means[i_gau].segment(0, n_dims_in) = means_x_[i_gau];
    means[i_gau].segment(n_dims_in, n_dims_out) = means_y_[i_gau];

    covars[i_gau] = MatrixXd(n_dims_gmm,n_dims_gmm);
    covars[i_gau].fill(0);
    covars[i_gau].block(0, 0, n_dims_in, n_dims_in) = covars_x_[i_gau]; 
    covars[i_gau].block(n_dims_in, n_dims_in, n_dims_out, n_dims_out) = covars_y_[i_gau]; 
    covars[i_gau].block(n_dims_in, 0, n_dims_out, n_dims_in) = covars_y_x_[i_gau];
    covars[i_gau].block(0, n_dims_in, n_dims_in, n_dims_out) = covars_y_x_[i_gau].transpose();
  }
  
  saveGMM(save_directory,means,covars,overwrite);
 
  
  return true;  
}

Here is the call graph for this function:

void toMatrix

(

Eigen::MatrixXd &

gmm_as_matrix

)

const

This function represents the Gaussian Mixture Model as one big matrix.

Parameters

[out]

gmm_as_matrix

The Gaussian Mixture Model as one big matrix

In combination with ModelParametersGMR::saveGMMToMatrix() and ModelParametersGMR::loadGMMFromMatrix(), this hacky function allowed for easier exchange with some Matlab code we wrote.

This matrix contains the following rows (example for two Gaussians, with dimensionality 3)

 0. meta_data  (n_gaussians and n_output_dims)
 1. meta_data  (n_observations)
__________________________
 2. prior1 and E1
 3. mean1      (size: 3)
 4. covar1     (row1 of covar matrix)
 5. covar1     (row2 of covar matrix)
 6. covar1     (row3 of covar matrix)
 __________________________
 7. prior2 and E2
 8. mean2      (size: 3)
 9. covar2     (row1 of covar matrix)
 10. covar2     (row2 of covar matrix)
 11. covar2     (row3 of covar matrix)

 Thus, the number of rows in the Matrix is 2 (for meta-data) + n_gaussians * (1+1+n_dims)

Definition at line 305 of file ModelParametersGMR.cpp.

{
  int n_gaussians = means_x_.size();
  assert(n_gaussians>0);
  int n_dims_in = means_x_[0].size();
  int n_dims_out = means_y_[0].size();
  int n_dims_gmm = n_dims_in + n_dims_out;
  
  int n_rows = 2; // First row contains n_gaussians, n_output_dims, second row contains n_observations and responsability
  for (int i_gau = 0; i_gau < n_gaussians; i_gau++)
  {
    n_rows += 1; // Add one row for the prior
    n_rows += 1; // Add one row for the mean
    n_rows += n_dims_gmm; // For the covariance matrix 
  }
  
  gmm_as_matrix = MatrixXd::Zero(n_rows,n_dims_gmm);
  
  gmm_as_matrix(0,0) = n_gaussians;
  gmm_as_matrix(0,1) = n_dims_out;
  gmm_as_matrix(1,0) = n_observations_;
  
  VectorXd mean = VectorXd(n_dims_gmm);
  MatrixXd covar = MatrixXd(n_dims_gmm,n_dims_gmm);
  int cur_row = 2;
  for (int i_gau = 0; i_gau < n_gaussians; i_gau++)
  {
    mean.segment(0, n_dims_in) = means_x_[i_gau];
    mean.segment(n_dims_in, n_dims_out) = means_y_[i_gau];

    covar.block(0, 0, n_dims_in, n_dims_in) = covars_x_[i_gau]; 
    covar.block(n_dims_in, n_dims_in, n_dims_out, n_dims_out) = covars_y_[i_gau]; 
    covar.block(n_dims_in, 0, n_dims_out, n_dims_in) = covars_y_x_[i_gau];
    covar.block(0, n_dims_in, n_dims_in, n_dims_out) = covars_y_x_[i_gau].transpose();
    
    gmm_as_matrix(cur_row,0) = priors_[i_gau];
    gmm_as_matrix.row(cur_row+1) = mean;
    gmm_as_matrix.block(cur_row+2,0,n_dims_gmm,n_dims_gmm) = covar;
    
    cur_row += 1 + 1 + n_dims_gmm;
  }  
}

ModelParametersGMR * fromMatrix ( const Eigen::MatrixXd &  gmm_matrix )

static

Initialize a GMM from a matrix.

See also

toMatrix() for the format of the file

Parameters

[in]

gmm_matrix

The GMM, represented as a matrix.

Returns

The model parameters of the GMM.

Definition at line 348 of file ModelParametersGMR.cpp.

{
  int n_dims_gmm = gmm_matrix.cols();
  int n_rows = gmm_matrix.rows();
  assert(n_dims_gmm>1);
  assert(n_rows>0);
  
  int n_gaussians = gmm_matrix(0,0);
  int n_dims_out = gmm_matrix(0,1); 
  int n_observations = gmm_matrix(1,0);

  assert(n_rows == (2+ (n_gaussians*(1+1+n_dims_gmm))));
  
  vector<double> priors(n_gaussians);
  vector<VectorXd> means(n_gaussians);
  vector<MatrixXd> covars(n_gaussians);
  
  int cur_row = 2;
  for (int i_gau = 0; i_gau < n_gaussians; i_gau++)
  {
    priors[i_gau] = gmm_matrix(cur_row,0);
    
    means[i_gau] = gmm_matrix.row(cur_row+1);
   
    covars[i_gau] = gmm_matrix.block(cur_row+2,0,n_dims_gmm,n_dims_gmm);
    
    cur_row += 1 + 1 + n_dims_gmm;
  }
    
  return new ModelParametersGMR(n_observations,priors,means,covars,n_dims_out);
}

bool saveGMMToMatrix	(	std::string	filename,
		bool	overwrite = false
	)		const

Save the GMM as a matrix in an ASCII file.

See also

toMatrix() for the format of the file

Parameters

[in]	filename	The name of the file to save the GMM to.
[in]	overwrite	Whether to overwrite the file if it already exists.

Returns

true if saving was successful, false otherwise.

Definition at line 380 of file ModelParametersGMR.cpp.

{
  if (filename.empty())
    return true;

  MatrixXd gmm_as_matrix;
  toMatrix(gmm_as_matrix);
  
  if (!saveMatrix(filename, gmm_as_matrix,  overwrite))
    return false;    
    
  return true;  
}

Here is the call graph for this function:

ModelParametersGMR * loadGMMFromMatrix ( std::string  filename )

static

Load the GMM from a matrix in an ASCII file.

See also

toMatrix() for the format of the file

Parameters

[in]

filename

The name of the file to load the GMM from.

Returns

The model parameters of the GMM.

Definition at line 394 of file ModelParametersGMR.cpp.

{
  MatrixXd gmm_matrix;
  if (!loadMatrix(filename, gmm_matrix))
    return NULL;
  
  return ModelParametersGMR::fromMatrix(gmm_matrix);
}

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 548 of file ModelParametersGMR.cpp.

{
  int n_gaussians = means_x_.size();
    
  // This copying is not necessary. It is just done to show which variable in GMR relates to which
  // variable in the unified model. 
  vector<VectorXd> centers = means_x_;
  vector<MatrixXd> covars  = covars_x_;

  vector<VectorXd> slopes(n_gaussians);
  vector<double> offsets(n_gaussians);
  VectorXd rest;
  for (int i_gau=0; i_gau<n_gaussians; i_gau++)
  {
    slopes[i_gau] = (covars_y_x_[i_gau] * covars_x_inv_[i_gau]).transpose();
    
    assert(means_y_[i_gau].size()==1); // Only works for 1D y output for now
    offsets[i_gau] = means_y_[i_gau][0] - slopes[i_gau].dot(means_x_[i_gau]);
  }
  

  bool normalized_basis_functions = true;
  bool lines_pivot_at_max_activation = false;

  return new UnifiedModel(centers, covars, slopes, offsets, priors_,  normalized_basis_functions,lines_pivot_at_max_activation); 
  
}

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 497 of file ModelParametersGMR.cpp.

{
  // if (all_values_vector_size_ != values.size())
  // {
  //   cerr << __FILE__ << ":" << __LINE__ << ": values is of wrong size." << endl;
  //   return;
  // }
  
  // int offset = 0;

  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   centers_[i] = values.segment(offset, centers_[i].size());
  //   offset += centers_[i].size();
  // }
  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   priors_[i] = values[offset];
  //   offset += 1;
  // }

  // for (size_t i = 0; i < slopes_.size(); i++)
  // {
  //   for (int col = 0; col < slopes_[i].cols(); col++)
  //   {
  //     slopes_[i].col(col) = values.segment(offset, slopes_[i].rows());
  //     offset += slopes_[i].rows();
  //   }
  // }

  // for (size_t i = 0; i < centers_.size(); i++)
  // {
  //   biases_[i] = values.segment(offset, biases_[i].size());
  //   offset += biases_[i].size();
  // }

  // for (size_t i = 0; i < inverseCovarsL_.size(); i++)
  // {
  //   for (int row = 0; row < inverseCovarsL_[i].rows(); row++)
  //     for (int col = 0; col < row + 1; col++)
  //     {
  //       inverseCovarsL_[i](row, col) = values[offset];
  //       offset += 1;
  //     }
  // }
  
  // assert(offset == getParameterVectorAllSize());

};

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Give boost serialization access to private members.

Definition at line 214 of file ModelParametersGMR.hpp.

---

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

• ModelParametersGMR.hpp
• ModelParametersGMR.cpp