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 = check_2d_array(xt, "xt") yt = check_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 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 = check_2d_array(xt, "xt") dyt_dxt = check_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 update_training_derivatives(self, dyt_dxt, kx, name=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 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") dyt_dxt = check_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 cast_to_discrete_values(xtypes, x): """ see MixedIntegerContext.cast_to_discrete_values """ ret = check_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 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 An optional label for the group of training points being set. This is only used in special situations (e.g., multi-fidelity applications). """ yt = check_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 __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 = check_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 predict_variances(self, x): xp = check_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 = check_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 predict_derivatives(self, x, kx): """ Predict the dy_dx derivatives at a set of points. Parameters ---------- x : np.ndarray[n, nx] or np.ndarray[n] 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[n, ny] Derivatives. """ check_support(self, 'derivatives') x = check_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_derivatives(self, x, kx): """ 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 = check_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_values(self, x): """ Predict the output values at a set of points. Parameters ---------- x : np.ndarray[n, nx] or np.ndarray[n] Input values for the prediction points. Returns ------- y : np.ndarray[n, ny] Output values at the prediction points. """ x = check_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_values(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.reshape((n, self.ny))
def predict_values(self, x): """ 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 = check_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_values(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.reshape((n, self.ny))