Derived approximation class for Gaussian Process implementation. More...

Inheritance diagram for GaussProcApproximation:

Public Member Functions
	GaussProcApproximation ()
	default constructor More...

	GaussProcApproximation (const SharedApproxData &shared_data)
	alternate constructor

	GaussProcApproximation (const ProblemDescDB &problem_db, const SharedApproxData &shared_data, const String &approx_label)
	standard constructor

	~GaussProcApproximation ()
	destructor

Public Member Functions inherited from Approximation
	Approximation ()
	default constructor More...

	Approximation (ProblemDescDB &problem_db, const SharedApproxData &shared_data, const String &approx_label)
	standard constructor for envelope More...

	Approximation (const SharedApproxData &shared_data)
	alternate constructor More...

	Approximation (const Approximation &approx)
	copy constructor More...

virtual	~Approximation ()
	destructor

Approximation	operator= (const Approximation &approx)
	assignment operator

virtual void	active_model_key (const Pecos::ActiveKey &sd_key)
	activate an approximation state based on its multi-index key

virtual void	clear_model_keys ()
	reset initial state by removing all model keys for an approximation

virtual void	build (int num_resp)
	overloaded build to support field-based approximations; builds from scratch More...

virtual void	export_model (const StringArray &var_labels=StringArray(), const String &fn_label="", const String &export_prefix="", const unsigned short export_format=NO_MODEL_FORMAT)
	exports the approximation; if export_format > NO_MODEL_FORMAT, uses all 3 parameters, otherwise extracts these from the Approximation's sharedDataRep to build a filename

virtual void	export_model (const Variables &vars, const String &fn_label="", const String &export_prefix="", const unsigned short export_format=NO_MODEL_FORMAT)
	approximation export that generates labels from the passed Variables, since only the derived classes know how the variables are ordered w.r.t. the surrogate build; if export_format > NO_MODEL_FORMAT, uses all 3 parameters, otherwise extracts these from the Approximation's sharedDataRep to build a filename

virtual void	rebuild ()
	rebuilds the approximation incrementally

virtual void	replace (const IntResponsePair &response_pr, size_t fn_index)
	replace the response data

virtual void	pop_coefficients (bool save_data)
	removes entries from end of SurrogateData::{vars,resp}Data (last points appended, or as specified in args)

virtual void	push_coefficients ()
	restores state prior to previous pop()

virtual void	finalize_coefficients ()
	finalize approximation by applying all remaining trial sets

virtual void	clear_current_active_data ()
	clear current build data in preparation for next build More...

virtual void	combine_coefficients ()
	combine all level approximations into a single aggregate approximation

virtual void	combined_to_active_coefficients (bool clear_combined=true)
	promote combined approximation into active approximation

virtual void	clear_inactive_coefficients ()
	prune inactive coefficients following combination and promotion to active

virtual RealVector	values (const Variables &vars)
	retrieve the approximate function values for a given parameter vector

virtual const RealSymMatrix &	hessian (const Variables &vars)
	retrieve the approximate function Hessian for a given parameter vector

virtual Real	value (const RealVector &c_vars)
	retrieve the approximate function value for a given parameter vector

virtual RealVector	values (const RealVector &c_vars)
	retrieve the approximate function value for a given parameter vector

virtual const RealVector &	gradient (const RealVector &c_vars)
	retrieve the approximate function gradient for a given parameter vector

virtual const RealSymMatrix &	hessian (const RealVector &c_vars)
	retrieve the approximate function Hessian for a given parameter vector

virtual Real	prediction_variance (const RealVector &c_vars)
	retrieve the variance of the predicted value for a given parameter vector

virtual Real	mean ()
	return the mean of the expansion, where all active vars are random

virtual Real	mean (const RealVector &x)
	return the mean of the expansion for a given parameter vector, where a subset of the active variables are random

virtual Real	combined_mean ()
	return the mean of the combined expansion, where all active vars are random

virtual Real	combined_mean (const RealVector &x)
	return the mean of the combined expansion for a given parameter vector, where a subset of the active variables are random

virtual const RealVector &	mean_gradient ()
	return the gradient of the expansion mean

virtual const RealVector &	mean_gradient (const RealVector &x, const SizetArray &dvv)
	return the gradient of the expansion mean

virtual Real	variance ()
	return the variance of the expansion, where all active vars are random

virtual Real	variance (const RealVector &x)
	return the variance of the expansion for a given parameter vector, where a subset of the active variables are random

virtual const RealVector &	variance_gradient ()

virtual const RealVector &	variance_gradient (const RealVector &x, const SizetArray &dvv)

virtual Real	covariance (Approximation &approx_2)
	return the covariance between two response expansions, treating all variables as random

virtual Real	covariance (const RealVector &x, Approximation &approx_2)
	return the covariance between two response expansions, treating a subset of the variables as random

virtual Real	combined_covariance (Approximation &approx_2)
	return the covariance between two combined response expansions, where all active variables are random

virtual Real	combined_covariance (const RealVector &x, Approximation &approx_2)
	return the covariance between two combined response expansions, where a subset of the active variables are random

virtual void	compute_moments (bool full_stats=true, bool combined_stats=false)

virtual void	compute_moments (const RealVector &x, bool full_stats=true, bool combined_stats=false)

virtual const RealVector &	moments () const

virtual const RealVector &	expansion_moments () const

virtual const RealVector &	numerical_integration_moments () const

virtual const RealVector &	combined_moments () const

virtual Real	moment (size_t i) const

virtual void	moment (Real mom, size_t i)

virtual Real	combined_moment (size_t i) const

virtual void	combined_moment (Real mom, size_t i)

virtual void	clear_component_effects ()

virtual void	compute_component_effects ()

virtual void	compute_total_effects ()

virtual const RealVector &	sobol_indices () const

virtual const RealVector &	total_sobol_indices () const

virtual ULongULongMap	sparse_sobol_index_map () const

virtual bool	advancement_available ()
	check if resolution advancement (e.g., order, rank) is available for this approximation instance

virtual bool	diagnostics_available ()
	check if diagnostics are available for this approximation type

virtual Real	diagnostic (const String &metric_type)
	retrieve a single diagnostic metric for the diagnostic type specified

virtual RealArray	cv_diagnostic (const StringArray &metric_types, unsigned num_folds)
	retrieve diagnostic metrics for the diagnostic types specified, applying

virtual void	primary_diagnostics (size_t fn_index)
	compute and print all requested diagnostics and cross-validation

virtual RealArray	challenge_diagnostic (const StringArray &metric_types, const RealMatrix &challenge_points, const RealVector &challenge_responses)
	compute requested diagnostics for user provided challenge pts

virtual void	challenge_diagnostics (size_t fn_index, const RealMatrix &challenge_points, const RealVector &challenge_responses)
	compute and print all requested diagnostics for user provided challenge pts

virtual RealVector	approximation_coefficients (bool normalized) const
	return the coefficient array computed by build()/rebuild()

virtual void	approximation_coefficients (const RealVector &approx_coeffs, bool normalized)
	set the coefficient array from external sources, rather than computing with build()/rebuild()

virtual void	coefficient_labels (std::vector< std::string > &coeff_labels) const
	print the coefficient array computed in build()/rebuild()

virtual void	print_coefficients (std::ostream &s, bool normalized)
	print the coefficient array computed in build()/rebuild()

virtual int	recommended_coefficients () const
	return the recommended number of samples (unknowns) required to build the derived class approximation type in numVars dimensions

virtual int	num_constraints () const
	return the number of constraints to be enforced via an anchor point

virtual size_t	num_components () const
	return the number of approximation components (1 for scalars)

virtual void	expansion_coefficient_flag (bool)

virtual bool	expansion_coefficient_flag () const

virtual void	expansion_gradient_flag (bool)

virtual bool	expansion_gradient_flag () const

virtual void	clear_computed_bits ()
	clear tracking of computed moments, due to (expansion) change that invalidates previous results

virtual void	map_variable_labels (const Variables &dfsm_vars)
	if needed, map passed all variable labels to approximation's labels

int	min_points (bool constraint_flag) const
	return the minimum number of points required to build the approximation type in numVars dimensions. Uses *_coefficients() and num_constraints().

int	recommended_points (bool constraint_flag) const
	return the recommended number of samples to build the approximation type in numVars dimensions (default same as min_points)

void	pop_data (bool save_data)
	removes entries from end of SurrogateData::{vars,resp}Data (last points appended, or as specified in args)

void	push_data ()
	restores SurrogateData state prior to previous pop()

void	finalize_data ()
	finalize SurrogateData by applying all remaining trial sets

const Pecos::SurrogateData &	surrogate_data () const
	return approxData

Pecos::SurrogateData &	surrogate_data ()
	return approxData

void	add (const Variables &vars, bool v_copy, const Response &response, size_t fn_index, bool r_copy, bool anchor_flag, int eval_id, size_t key_index=_NPOS)
	create SurrogateData{Vars,Resp} and append to SurrogateData:: {varsData,respData,dataIdentifiers}

void	add (const Real *c_vars, bool v_copy, const Response &response, size_t fn_index, bool r_copy, bool anchor_flag, int eval_id, size_t key_index=_NPOS)
	create SurrogateData{Vars,Resp} and append to SurrogateData:: {varsData,respData,dataIdentifiers}

void	add (const Pecos::SurrogateDataVars &sdv, bool v_copy, const Response &response, size_t fn_index, bool r_copy, bool anchor_flag, int eval_id, size_t key_index=_NPOS)
	create a SurrogateDataResp and append to SurrogateData:: {varsData,respData,dataIdentifiers}

void	add (const Pecos::SurrogateDataVars &sdv, bool v_copy, const Pecos::SurrogateDataResp &sdr, bool r_copy, bool anchor_flag, int eval_id, size_t key_index=_NPOS)
	append to SurrogateData::{varsData,respData,dataIdentifiers}

void	add_array (const RealMatrix &sample_vars, bool v_copy, const RealVector &sample_resp, bool r_copy, size_t key_index=_NPOS)
	add surrogate data from the provided sample and response data, assuming continuous variables and function values only More...

void	pop_count (size_t count, size_t key_index)
	appends to SurrogateData::popCountStack (number of entries to pop from end of SurrogateData::{vars,resp}Data, based on size of last data append)

void	clear_data ()
	clear SurrogateData::{vars,resp}Data for activeKey + embedded keys More...

void	clear_active_data ()
	clear active approximation data

void	clear_inactive_data ()
	clear inactive approximation data

void	clear_active_popped ()
	clear SurrogateData::popped{Vars,Resp}Trials,popCountStack for activeKey

void	clear_popped ()
	clear SurrogateData::popped{Vars,Resp}Trials,popCountStack for all keys

void	set_bounds (const RealVector &c_l_bnds, const RealVector &c_u_bnds, const IntVector &di_l_bnds, const IntVector &di_u_bnds, const RealVector &dr_l_bnds, const RealVector &dr_u_bnds)
	set approximation lower and upper bounds (currently only used by graphics)

std::shared_ptr< Approximation >	approx_rep () const
	returns approxRep for access to derived class member functions that are not mapped to the top Approximation level

Protected Member Functions
int	min_coefficients () const
	return the minimum number of samples (unknowns) required to build the derived class approximation type in numVars dimensions

void	build ()
	find the covariance parameters governing the Gaussian process response

Real	value (const Variables &vars)
	retrieve the function value for a given parameter set

const RealVector &	gradient (const Variables &vars)
	retrieve the function gradient at the predicted value for a given parameter set

Real	prediction_variance (const Variables &vars)
	retrieve the variance of the predicted value for a given parameter set

Protected Member Functions inherited from Approximation
	Approximation (BaseConstructor, const ProblemDescDB &problem_db, const SharedApproxData &shared_data, const String &approx_label)
	constructor initializes the base class part of letter classes (BaseConstructor overloading avoids infinite recursion in the derived class constructors - Coplien, p. 139) More...

	Approximation (NoDBBaseConstructor, const SharedApproxData &shared_data)
	constructor initializes the base class part of letter classes (BaseConstructor overloading avoids infinite recursion in the derived class constructors - Coplien, p. 139) More...

std::shared_ptr< Approximation >	get_approx (ProblemDescDB &problem_db, const SharedApproxData &shared_data, const String &approx_label)
	Used only by the standard envelope constructor to initialize approxRep to the appropriate derived type. More...

std::shared_ptr< Approximation >	get_approx (const SharedApproxData &shared_data)
	Used only by the alternate envelope constructor to initialize approxRep to the appropriate derived type. More...

Pecos::SurrogateDataVars	variables_to_sdv (const Real *sample_c_vars)
	create a SurrogateDataVars instance from a Real*

Pecos::SurrogateDataVars	variables_to_sdv (const Variables &vars)
	create a SurrogateDataVars instance by extracting data from a Variables object

Pecos::SurrogateDataResp	response_to_sdr (const Response &response, size_t fn_index)
	create a SurrogateDataResp instance by extracting data for a particular QoI from a Response object

void	add (const Pecos::SurrogateDataVars &sdv, bool v_copy, const Pecos::SurrogateDataResp &sdr, bool r_copy, bool anchor_flag)
	tracks a new data point by appending to SurrogateData::{vars,Resp}Data

void	add (int eval_id)
	tracks a new data point by appending to SurrogateData::dataIdentifiers

void	check_points (size_t num_build_pts)
	Check number of build points against minimum required.

void	assign_key_index (size_t key_index)
	extract and assign i-th embedded active key

Private Member Functions
void	GPmodel_build ()
	Function to compute hyperparameters governing the GP.

void	GPmodel_apply (const RealVector &new_x, bool variance_flag, bool gradients_flag)
	Function returns a response value using the GP surface. More...

void	normalize_training_data ()
	Normalizes the initial inputs upon which the GP surface is based.

void	get_trend ()
	Gets the trend (basis) functions for the calculation of the mean of the GP If the order = 0, the trend is a constant, if the order = 1, trend is linear, if order = 2, trend is quadratic.

void	get_beta_coefficients ()
	Gets the beta coefficients for the calculation of the mean of the GP.

int	get_cholesky_factor ()
	Gets the Cholesky factorization of the covariance matrix, with error checking.

void	get_process_variance ()
	Gets the estimate of the process variance given the values of beta and the correlation lengthscales

void	get_cov_matrix ()
	calculates the covariance matrix for a given set of input points

void	get_cov_vector ()
	calculates the covariance vector between a new point x and the set of inputs upon which the GP is based

void	optimize_theta_global ()
	sets up and performs the optimization of the negative log likelihood to determine the optimal values of the covariance parameters using NCSUDirect

void	optimize_theta_multipoint ()
	sets up and performs the optimization of the negative log likelihood to determine the optimal values of the covariance parameters using a gradient-based solver and multiple starting points

void	predict (bool variance_flag, bool gradients_flag)
	Calculates the predicted new response value for x in normalized space.

Real	calc_nll ()
	calculates the negative log likelihood function (based on covariance matrix)

void	calc_grad_nll ()
	Gets the gradient of the negative log likelihood function with respect to the correlation lengthscales, theta

void	get_grad_cov_vector ()
	Calculate the derivatives of the covariance vector, with respect to each componeent of x.

void	run_point_selection ()
	Runs the point selection algorithm, which will choose a subset of the training set with which to construct the GP model, and estimate the necessary parameters.

void	initialize_point_selection ()
	Initializes the point selection routine by choosing a small initial subset of the training points.

void	pointsel_get_errors (RealArray &delta)
	Uses the current GP model to compute predictions at all of the training points and find the errors.

int	addpoint (int, IntArray &added_index)
	Adds a point to the effective training set. Returns 1 on success.

int	pointsel_add_sel (const RealArray &delta)
	Accepts a vector of unsorted prediction errors, determines which points should be added to the effective training set, and adds them.

Real	maxval (const RealArray &) const
	Return the maximum value of the elements in a vector.

void	pointsel_write_points ()
	Writes out the training set before and after point selection.

void	lhood_2d_grid_eval ()
	For problems with 2D input, evaluates the negative log likelihood on a grid.

void	writex (const char[])
	Writes out the current training set (in original units) to a specified file.

void	writeCovMat (char[])
	Writes out the covariance matrix to a specified file.

Static Private Member Functions
static void	negloglik (int mode, int n, const Teuchos::SerialDenseVector< int, double > &X, Real &fx, Teuchos::SerialDenseVector< int, double > &grad_x, int &result_mode)
	static function used by OPT++ as the objective function to optimize the hyperparameters in the covariance of the GP by minimizing the negative log likelihood

static void	constraint_eval (int mode, int n, const Teuchos::SerialDenseVector< int, double > &X, Teuchos::SerialDenseVector< int, double > &g, Teuchos::SerialDenseMatrix< int, double > &gradC, int &result_mode)
	static function used by OPT++ as the constraint function in the optimization of the negative log likelihood. Currently this function is empty: it is an unconstrained optimization.

static double	negloglikNCSU (const RealVector &x)
	function used by NCSUOptimizer to optimize negloglik objective

Private Attributes
Real	approxValue
	value of the approximation returned by value()

Real	approxVariance
	value of the approximation returned by prediction_variance()

RealMatrix	trainPoints
	A 2-D array (num sample sites = rows, num vars = columns) used to create the Gaussian process.

RealMatrix	trainValues
	An array of response values; one response value per sample site.

RealVector	trainMeans
	The mean of the input columns of trainPoints.

RealVector	trainStdvs
	The standard deviation of the input columns of trainPoints.

RealMatrix	normTrainPoints
	Current working set of normalized points upon which the GP is based.

RealMatrix	trendFunction
	matrix to hold the trend function

RealMatrix	betaCoeffs
	matrix to hold the beta coefficients for the trend function

RealSymMatrix	covMatrix
	The covariance matrix where each element (i,j) is the covariance between points Xi and Xj in the initial set of samples.

RealMatrix	covVector
	The covariance vector where each element (j,0) is the covariance between a new point X and point Xj from the initial set of samples.

RealMatrix	approxPoint
	Point at which a prediction is requested. This is currently a single point, but it could be generalized to be a vector of points.

RealMatrix	gradNegLogLikTheta
	matrix to hold the gradient of the negative log likelihood with respect to the theta correlation terms

Teuchos::SerialSpdDenseSolver< int, Real >	covSlvr
	The global solver for all computations involving the inverse of the covariance matrix.

RealMatrix	gradCovVector
	A matrix, where each column is the derivative of the covVector with respect to a particular componenet of X.

RealMatrix	normTrainPointsAll
	Set of all original samples available.

RealMatrix	trainValuesAll
	All original samples available.

RealMatrix	trendFunctionAll
	Trend function values corresponding to all original samples.

RealMatrix	Rinv_YFb
	Matrix for storing inverse of correlation matrix Rinv*(Y-FB)

size_t	numObs
	The number of observations on which the GP surface is built.

size_t	numObsAll
	The original number of observations.

short	trendOrder
	The number of variables in each X variable (number of dimensions of the problem). More...

RealVector	thetaParams
	Theta is the vector of covariance parameters for the GP. We determine the values of theta by optimization Currently, the covariance function is theta[0]exp(-0.5sume)+deltapow(sige,2). sume is the sum squared of weighted distances; it involves a sum of theta[1](Xi(1)-Xj(1))^2 + theta[2](Xi(2)-Xj(2))^2 + ... where Xi(1) is the first dimension value of multi-dimensional variable Xi. deltapow(sige,2) is a jitter term used to improve matrix computations. delta is zero for the covariance between different points and 1 for the covariance between the same point. sige is the underlying process error.

Real	procVar
	The process variance, the multiplier of the correlation matrix.

IntArray	pointsAddedIndex
	Used by the point selection algorithm, this vector keeps track all points which have been added.

int	cholFlag
	A global indicator for success of the Cholesky factorization.

bool	usePointSelection
	a flag to indicate the use of point selection

Static Private Attributes
static GaussProcApproximation *	GPinstance
	pointer to the active object instance used within the static evaluator

Additional Inherited Members
Protected Attributes inherited from Approximation
Pecos::SurrogateData	approxData
	contains the variables/response data for constructing a single approximation model (one response function). There is only one SurrogateData instance per Approximation, although it may contain keys for different model forms/resolutions and aggregations (e.g., discrepancies) among forms/resolutions.

RealVector	approxGradient
	gradient of the approximation returned by gradient()

RealSymMatrix	approxHessian
	Hessian of the approximation returned by hessian()

String	approxLabel
	label for approximation, if applicable

std::shared_ptr< SharedApproxData >	sharedDataRep
	contains the approximation data that is shared among the response set

std::shared_ptr< Approximation >	approxRep
	pointer to the letter (initialized only for the envelope)

Detailed Description

Derived approximation class for Gaussian Process implementation.

The GaussProcApproximation class provides a global approximation (surrogate) based on a Gaussian process. The Gaussian process is built after normalizing the function values, with zero mean. Opt++ is used to determine the optimal values of the covariance parameters, those which minimize the negative log likelihood function.

Constructor & Destructor Documentation

◆ GaussProcApproximation()

GaussProcApproximation ( )

inline

default constructor

alternate constructor used by EffGlobalOptimization and NonDGlobalReliability that does not use a problem database defaults here are no point selectinn and quadratic trend function.

Member Function Documentation

◆ GPmodel_apply()

void GPmodel_apply	(	const RealVector &	new_x,
		bool	variance_flag,
		bool	gradients_flag
	)

private

Function returns a response value using the GP surface.

The response value is computed at the design point specified by the RealVector function argument.

References Dakota::abort_handler(), GaussProcApproximation::approxPoint, GaussProcApproximation::get_cov_vector(), GaussProcApproximation::predict(), Approximation::sharedDataRep, GaussProcApproximation::trainMeans, and GaussProcApproximation::trainStdvs.

Referenced by GaussProcApproximation::gradient(), GaussProcApproximation::pointsel_get_errors(), GaussProcApproximation::prediction_variance(), and GaussProcApproximation::value().

Member Data Documentation

◆ trendOrder

short trendOrder

private

The number of variables in each X variable (number of dimensions of the problem).

The order of the basis function for the mean of the GP If the order = 0, the trend is a constant, if the order = 1, trend is linear, if order = 2, trend is quadratic.

Referenced by GaussProcApproximation::GaussProcApproximation(), GaussProcApproximation::get_beta_coefficients(), GaussProcApproximation::get_trend(), GaussProcApproximation::GPmodel_build(), and GaussProcApproximation::predict().

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

GaussProcApproximation.hpp
GaussProcApproximation.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes