def set_training_derivatives(self, xt, dyt_dxt, kx, name=None):
"""
Set training data (derivatives).
Parameters
----------
xt : np.ndarray[nt, nx] or np.ndarray[nt]
The input values for the nt training points.
dyt_dxt : np.ndarray[nt, ny] or np.ndarray[nt]
The derivatives values for the nt training points.
kx : int
0-based index of the derivatives being set.
name : str or None
An optional label for the group of training points being set.
This is only used in special situations (e.g., multi-fidelity applications).
"""
check_support(self, "training_derivatives")
xt = ensure_2d_array(xt, "xt")
dyt_dxt = ensure_2d_array(dyt_dxt, "dyt_dxt")
if xt.shape[0] != dyt_dxt.shape[0]:
raise ValueError(
"the first dimension of xt and dyt_dxt must have the same length"
)
if not isinstance(kx, int):
raise ValueError("kx must be an int")
self.training_points[name][kx + 1] = [np.array(xt), np.array(dyt_dxt)]
def set_training_values(self, xt, yt, name=None):
"""
Set training data (values).
Parameters
----------
xt : np.ndarray[nt, nx] or np.ndarray[nt]
The input values for the nt training points.
yt : np.ndarray[nt, ny] or np.ndarray[nt]
The output values for the nt training points.
name : str or None
An optional label for the group of training points being set.
This is only used in special situations (e.g., multi-fidelity applications).
"""
xt = ensure_2d_array(xt, "xt")
yt = ensure_2d_array(yt, "yt")
if xt.shape[0] != yt.shape[0]:
raise ValueError(
"the first dimension of xt and yt must have the same length")
self.nt = xt.shape[0]
self.nx = xt.shape[1]
self.ny = yt.shape[1]
kx = 0
self.training_points[name][kx] = [np.array(xt), np.array(yt)]
def cast_to_discrete_values(xtypes, x):
"""
see MixedIntegerContext.cast_to_discrete_values
"""
ret = ensure_2d_array(x, "x").copy()
x_col = 0
for xtyp in xtypes:
if xtyp == FLOAT:
x_col += 1
continue
elif xtyp == INT:
ret[:, x_col] = np.round(ret[:, x_col])
x_col += 1
elif isinstance(xtyp, tuple) and xtyp[0] == ENUM:
# Categorial : The biggest level is selected.
xenum = ret[:, x_col:x_col + xtyp[1]]
maxx = np.max(xenum, axis=1).reshape((-1, 1))
mask = xenum < maxx
xenum[mask] = 0
xenum[~mask] = 1
x_col = x_col + xtyp[1]
else:
_raise_value_error(xtyp)
return ret
def __call__(self, x, kx=None):
"""
Evaluate the function.
Parameters
----------
x : ndarray[n, nx] or ndarray[n]
Evaluation points where n is the number of evaluation points.
kx : int or None
Index of derivative (0-based) to return values with respect to.
None means return function value rather than derivative.
Returns
-------
ndarray[n, 1]
Functions values if kx=None or derivative values if kx is an int.
"""
x = ensure_2d_array(x, "x")
if x.shape[1] != self.options["ndim"]:
raise ValueError("The second dimension of x should be %i" %
self.options["ndim"])
if kx is not None:
if not isinstance(kx, int) or kx < 0:
raise TypeError("kx should be None or a non-negative int.")
y = self._evaluate(x, kx)
if self.options["return_complex"]:
return y
else:
return np.real(y)
def cast_to_discrete_values(xtypes, xlimits, categorical_kernel, x):
"""
see MixedIntegerContext.cast_to_discrete_values
"""
ret = ensure_2d_array(x, "x").copy()
x_col = 0
for i, xtyp in enumerate(xtypes):
if xtyp == FLOAT:
x_col += 1
continue
elif xtyp == ORD:
if isinstance(xlimits[i][0], str):
listint = list(map(float, xlimits[i]))
ret[:, x_col] = take_closest_in_list(listint, ret[:, x_col])
else:
ret[:, x_col] = np.round(ret[:, x_col])
x_col += 1
elif isinstance(xtyp, tuple) and xtyp[0] == ENUM:
if categorical_kernel is None:
# Categorial : The biggest level is selected.
xenum = ret[:, x_col:x_col + xtyp[1]]
maxx = np.max(xenum, axis=1).reshape((-1, 1))
mask = xenum < maxx
xenum[mask] = 0
xenum[~mask] = 1
x_col = x_col + xtyp[1]
else:
ret[:, x_col] = np.round(ret[:, x_col])
x_col += 1
else:
_raise_value_error(xtyp)
return ret
def update_training_values(self, yt, name=None):
"""
Update the training data (values) at the previously set input values.
Parameters
----------
yt : np.ndarray[nt, ny] or np.ndarray[nt]
The output values for the nt training points.
name : str or None, optional
An optional label for the group of training points being set.
This is only used in special situations (e.g., multi-fidelity applications). The default is None.
Raises
------
ValueError
The training points must be set first with set_training_values before calling update_training_values.
The number of training points does not agree with the earlier call of set_training_values.
"""
yt = ensure_2d_array(yt, "yt")
kx = 0
if kx not in self.training_points[name]:
raise ValueError(
"The training points must be set first with set_training_values "
+ "before calling update_training_values.")
xt = self.training_points[name][kx][0]
if xt.shape[0] != yt.shape[0]:
raise ValueError(
"The number of training points does not agree with the earlier call of "
+ "set_training_values.")
self.training_points[name][kx][1] = np.array(yt)
def predict_variances(self, x):
xp = ensure_2d_array(x, "xp")
if self._input_in_folded_space:
x2 = unfold_with_enum_mask(self._xtypes, xp)
else:
x2 = xp
return self._surrogate.predict_variances(
cast_to_discrete_values(self._xtypes, x2))
def set_training_values(self, xt, yt, name=None):
xt = ensure_2d_array(xt, "xt")
if self._input_in_folded_space:
xt2 = unfold_with_enum_mask(self._xtypes, xt)
else:
xt2 = xt
super().set_training_values(xt2, yt)
self._surrogate.set_training_values(xt2, yt, name)
def set_training_values(self, xt, yt, name=None):
xt = ensure_2d_array(xt, "xt")
if self._input_in_folded_space:
xt2 = unfold_with_enum_mask(self._xtypes, xt)
else:
xt2 = xt
xt2 = cast_to_discrete_values(self._xtypes, self._xlimits,
self._categorical_kernel, xt2)
super().set_training_values(xt2, yt)
self._surrogate.set_training_values(xt2, yt, name)
def set_training_values(self, xt, yt, name=None):
xt = ensure_2d_array(xt, "xt")
if self._use_gower_distance:
super().set_training_values(xt, yt)
self._surrogate.options["corr"] = "gower"
self._surrogate.set_training_values(xt, yt, name)
else:
if self._input_in_folded_space:
xt2 = unfold_with_enum_mask(self._xtypes, xt)
else:
xt2 = xt
super().set_training_values(xt2, yt)
self._surrogate.set_training_values(xt2, yt, name)
def predict_derivatives(self, x: np.ndarray, kx: int) -> np.ndarray:
"""
Predict the dy_dx derivatives at a set of points.
Parameters
----------
x : np.ndarray[nt, nx] or np.ndarray[nt]
Input values for the prediction points.
kx : int
The 0-based index of the input variable with respect to which derivatives are desired.
Returns
-------
dy_dx : np.ndarray[nt, ny]
Derivatives.
"""
check_support(self, "derivatives")
x = ensure_2d_array(x, "x")
check_nx(self.nx, x)
n = x.shape[0]
self.printer.active = (
self.options["print_global"] and self.options["print_prediction"]
)
if self.name == "MixExp":
# Mixture of experts model
self.printer._title("Evaluation of the Mixture of experts")
else:
self.printer._title("Evaluation")
self.printer(" %-12s : %i" % ("# eval points.", n))
self.printer()
# Evaluate the unknown points using the specified model-method
with self.printer._timed_context("Predicting", key="prediction"):
y = self._predict_derivatives(x, kx)
time_pt = self.printer._time("prediction")[-1] / n
self.printer()
self.printer("Prediction time/pt. (sec) : %10.7f" % time_pt)
self.printer()
return y.reshape((n, self.ny))
def predict_variances(self, x):
"""
Predict the variances at a set of points.
Parameters
----------
x : np.ndarray[nt, nx] or np.ndarray[nt]
Input values for the prediction points.
Returns
-------
s2 : np.ndarray[nt, ny]
Variances.
"""
check_support(self, "variances")
x = ensure_2d_array(x, "x")
check_nx(self.nx, x)
n = x.shape[0]
x2 = np.copy(x)
s2 = self._predict_variances(x2)
return s2.reshape((n, self.ny))
def predict_output_derivatives(self, x):
"""
Predict the derivatives dy_dyt at a set of points.
Parameters
----------
x : np.ndarray[nt, nx] or np.ndarray[nt]
Input values for the prediction points.
Returns
-------
dy_dyt : dict of np.ndarray[nt, nt]
Dictionary of output derivatives.
Key is None for derivatives wrt yt and kx for derivatives wrt dyt_dxt.
"""
check_support(self, "output_derivatives")
x = ensure_2d_array(x, "x")
check_nx(self.nx, x)
dy_dyt = self._predict_output_derivatives(x)
return dy_dyt
def predict_variance_derivatives(self, x):
"""
Predict the derivation of the variance at a point
Parameters:
-----------
x : np.ndarray
Input value for the prediction point.
Returns:
--------
derived_variance: np.ndarray
The jacobian of the variance
"""
x = ensure_2d_array(x, "x")
check_support(self, "variance_derivatives")
check_nx(self.nx, x)
n = x.shape[0]
self.printer.active = (
self.options["print_global"] and self.options["print_prediction"]
)
if self.name == "MixExp":
# Mixture of experts model
self.printer._title("Evaluation of the Mixture of experts")
else:
self.printer._title("Evaluation")
self.printer(" %-12s : %i" % ("# eval points.", n))
self.printer()
# Evaluate the unknown points using the specified model-method
with self.printer._timed_context("Predicting", key="prediction"):
y = self._predict_variance_derivatives(x)
time_pt = self.printer._time("prediction")[-1] / n
self.printer()
self.printer("Prediction time/pt. (sec) : %10.7f" % time_pt)
self.printer()
return y
def update_training_derivatives(
self, dyt_dxt: np.ndarray, kx: int, name: Optional[str] = None
) -> None:
"""
Update the training data (values) at the previously set input values.
Parameters
----------
dyt_dxt : np.ndarray[nt, ny] or np.ndarray[nt]
The derivatives values for the nt training points.
kx : int
0-based index of the derivatives being set.
name :str or None, optional
An optional label for the group of training points being set.
This is only used in special situations (e.g., multi-fidelity applications).
Raises
------
ValueError
The training points must be set first with set_training_values before calling update_training_values..
The number of training points does not agree with the earlier call of set_training_values.
"""
check_support(self, "training_derivatives")
dyt_dxt = ensure_2d_array(dyt_dxt, "dyt_dxt")
if kx not in self.training_points[name]:
raise ValueError(
"The training points must be set first with set_training_values "
+ "before calling update_training_values."
)
xt = self.training_points[name][kx][0]
if xt.shape[0] != dyt_dxt.shape[0]:
raise ValueError(
"The number of training points does not agree with the earlier call of "
+ "set_training_values."
)
self.training_points[name][kx + 1][1] = np.array(dyt_dxt)
def predict_values(self, x: np.ndarray) -> np.ndarray:
"""
Predict the output values at a set of points.
Parameters
----------
x : np.ndarray[nt, nx] or np.ndarray[nt]
Input values for the prediction points.
Returns
-------
y : np.ndarray[nt, ny]
Output values at the prediction points.
"""
x = ensure_2d_array(x, "x")
check_nx(self.nx, x)
n = x.shape[0]
x2 = np.copy(x)
self.printer.active = (
self.options["print_global"] and self.options["print_prediction"]
)
if self.name == "MixExp":
# Mixture of experts model
self.printer._title("Evaluation of the Mixture of experts")
else:
self.printer._title("Evaluation")
self.printer(" %-12s : %i" % ("# eval points.", n))
self.printer()
# Evaluate the unknown points using the specified model-method
with self.printer._timed_context("Predicting", key="prediction"):
y = self._predict_values(x2)
time_pt = self.printer._time("prediction")[-1] / n
self.printer()
self.printer("Prediction time/pt. (sec) : %10.7f" % time_pt)
self.printer()
return y.reshape((n, self.ny))
