class LinearSolver(object): def __init__(self, **kwargs): self.mtx = None self.rhs = None self.options = OptionsDictionary() self.options.declare("print_init", True, types=bool) self.options.declare("print_solve", True, types=bool) self._initialize() self.options.update(kwargs) def _initialize(self): pass def _setup(self, mtx, printer, mg_matrices=[]): pass def _solve(self, rhs, sol=None, ind_y=0): pass def _clone(self): clone = self.__class__() clone.options.update(clone.options._dict) return clone @contextlib.contextmanager def _active(self, active): orig_active = self.printer.active self.printer.active = self.printer.active and active yield self.printer self.printer.active = orig_active
def globalSurrogateModel(data, pr): pr.callingFunction = "globalSurrogate" data["prediction"] = pr.predict(data) ttdE = testTrainData(data, pr, encoded=True) ttdNE = testTrainData(data, pr, encoded=False) options = OptionsDictionary() options.declare("ndim", 1.0, types=float) options.declare("return_complex", False, types=bool) xlimits = np.zeros((int(options["ndim"]), 4)) xlimits[:, 0] = -2.0 xlimits[:, 1] = 2.0 funXLimits = xlimits ndim = 4 # models retrieved from https://github.com/SMTorg/smt/blob/master/tutorial/SMT_Tutorial.ipynb models = pd.Series() models["linear"] = Model(linearModel, ttdE) models["quadratic"] = Model(quadraticModel, ttdE) # models["kriging"] = Model(kriging, ttdE, ndim=ndim) # models["KPLSK"] = Model(kPLSK, ttdE) models["IDW"] = Model(iDW, ttdE) models["RBF"] = Model(rBF, ttdE) #models["RMTBSimba"] = Model(rMTBSimba, ttdNE, xL = funXLimits) #models["GEKPLS"] = Model(gEKPLS, ttdNE, xL = funXLimits, ndim = ndim) #models["DEKPLS"] = Model(dEKPLS, ttdNE, xL = funXLimits, ndim = ndim) for model in models: compareToOrig(model.t, model.title, model.xtest, model.ytest)
class Sampling(object): def __init__(self, **kwargs): self.options = OptionsDictionary() self.options.declare('xlimits', types=np.ndarray) self._declare_options() self.options.update(kwargs) def _declare_options(self): pass def __call__(self, n): """ Compute the requested number of sampling points. Arguments --------- n : int Number of points requested. Returns ------- ndarray[n, nx] The sampling locations in the input space. """ xlimits = self.options['xlimits'] nx = xlimits.shape[0] x = self._compute(n) for kx in range(nx): x[:, kx] = xlimits[kx, 0] + x[:, kx] * (xlimits[kx, 1] - xlimits[kx, 0]) return x
class NdimRosenbrock(Problem): def __init__(self, ndim=1, w=0.2): self.problem = ReducedProblem(Rosenbrock(ndim=ndim + 1), np.arange(1, ndim + 1), w=w) self.options = OptionsDictionary() self.options.declare("ndim", ndim, types=int) self.options.declare("return_complex", False, types=bool) self.options.declare("name", "NdimRosenbrock", types=str) self.xlimits = self.problem.xlimits def _evaluate(self, x, kx): return self.problem._evaluate(x, kx)
class Problem(object): def __init__(self, **kwargs): self.options = OptionsDictionary() self.options.declare('ndim', 1, types=int) self._declare_options() self.options.update(kwargs) self.xlimits = np.zeros((self.options['ndim'], 2)) self._initialize() def _declare_options(self): pass def _initialize(self): pass def __call__(self, x, kx=None): """ Arguments --------- x : ndarray[ne, nx] 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[ne, 1] Functions values if kx=None or derivative values if kx is an int. """ if not isinstance(x, np.ndarray) or len(x.shape) != 2: raise TypeError('x should be a rank-2 array.') elif 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.') return self._evaluate(x, kx)
class NdimStepFunction(Problem): def __init__(self, ndim=1, width=10.0): self.problem = TensorProduct(ndim=ndim, func="tanh", width=width) self.options = OptionsDictionary() self.options.declare("ndim", ndim, types=int) self.options.declare("return_complex", False, types=bool) self.options.declare("name", "NdimStepFunction", types=str) self.xlimits = self.problem.xlimits def _evaluate(self, x, kx): return self.problem._evaluate(x, kx)
class NdimCantileverBeam(Problem): def __init__(self, ndim=1, w=0.2): self.problem = ReducedProblem(CantileverBeam(ndim=3*ndim), np.arange(1, 3*ndim, 3), w=w) self.options = OptionsDictionary() self.options.declare('ndim', ndim, types=int) self.options.declare('return_complex', False, types=bool) self.options.declare('name', 'NdimCantileverBeam', types=str) self.xlimits = self.problem.xlimits def _evaluate(self, x, kx): return self.problem._evaluate(x, kx)
class NdimStepFunction(Problem): def __init__(self, ndim=1, width=10.0): self.problem = TensorProduct(ndim=ndim, func='tanh', width=width) self.options = OptionsDictionary() self.options.declare('ndim', ndim, types=int) self.options.declare('return_complex', False, types=bool) self.options.declare('name', 'NdimStepFunction', types=str) self.xlimits = self.problem.xlimits def _evaluate(self, x, kx): return self.problem._evaluate(x, kx)
class NdimRobotArm(Problem): def __init__(self, ndim=1, w=0.2): self.problem = ReducedProblem(RobotArm(ndim=2 * (ndim + 1)), np.arange(3, 2 * (ndim + 1), 2), w=w) self.options = OptionsDictionary() self.options.declare('ndim', ndim, types=int) self.options.declare('return_complex', False, types=bool) self.options.declare('name', 'NdimRobotArm', types=str) self.xlimits = self.problem.xlimits def _evaluate(self, x, kx): return self.problem._evaluate(x, kx)
class ReducedProblem(Problem): def __init__(self, problem, dims, w=0.2): """ Arguments --------- problem : Problem Pointer to the Problem object being wrapped. dims : int or list/tuple of ints Either the number of dimensions or a list of the dimension indices that this problem uses. w : float The value to use for all unaccounted for inputs where 0/1 is lower/upper bound. """ self.problem = problem self.w = w if isinstance(dims, int): self.dims = np.arange(dims) assert dims <= problem.options["ndim"] elif isinstance(dims, (list, tuple, np.ndarray)): self.dims = np.array(dims, int) assert np.max(dims) < problem.options["ndim"] else: raise ValueError("dims is invalid") self.options = OptionsDictionary() self.options.declare("ndim", len(self.dims), types=int) self.options.declare("return_complex", False, types=bool) self.options.declare("name", "R_" + self.problem.options["name"], types=str) self.xlimits = np.zeros((self.options["ndim"], 2)) for idim, idim_reduced in enumerate(self.dims): self.xlimits[idim, :] = problem.xlimits[idim_reduced, :] def _evaluate(self, x, kx): """ Arguments --------- x : ndarray[ne, nx] 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[ne, 1] Functions values if kx=None or derivative values if kx is an int. """ ne, nx = x.shape nx_prob = self.problem.options["ndim"] x_prob = np.zeros((ne, nx_prob), complex) for ix in range(nx_prob): x_prob[:, ix] = (1 - self.w) * self.problem.xlimits[ ix, 0] + self.w * self.problem.xlimits[ix, 1] for ix in range(nx): x_prob[:, self.dims[ix]] = x[:, ix] if kx is None: y = self.problem._evaluate(x_prob, None) else: y = self.problem._evaluate(x_prob, self.dims[kx]) return y
class Problem(object): def __init__(self, **kwargs): """ Constructor where values of options can be passed in. For the list of options, see the documentation for the problem being used. Parameters ---------- **kwargs : named arguments Set of options that can be optionally set; each option must have been declared. Examples -------- >>> from smt.problems import Sphere >>> prob = Sphere(ndim=3) """ self.options = OptionsDictionary() self.options.declare("ndim", 1, types=int) self.options.declare("return_complex", False, types=bool) self._initialize() self.options.update(kwargs) self.xlimits = np.zeros((self.options["ndim"], 2)) self._setup() def _initialize(self): """ Implemented by problem to declare options (optional). Examples -------- self.options.declare('option_name', default_value, types=(bool, int), desc='description') """ pass def _setup(self): pass 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 _evaluate(self, x, kx=None): """ Implemented by surrogate models to evaluate the function. Parameters ---------- x : ndarray[n, nx] 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. """ raise Exception("This problem has not been implemented correctly")
class SamplingMethod(object): def __init__(self, **kwargs): """ Constructor where values of options can be passed in. For the list of options, see the documentation for the problem being used. Parameters ---------- **kwargs : named arguments Set of options that can be optionally set; each option must have been declared. Examples -------- >>> import numpy as np >>> from smt.sampling_methods import Random >>> sampling = Random(xlimits=np.arange(2).reshape((1, 2))) """ self.options = OptionsDictionary() self.options.declare( "xlimits", types=np.ndarray, desc= "The interval of the domain in each dimension with shape nx x 2 (required)", ) self._initialize() self.options.update(kwargs) def _initialize(self): """ Implemented by sampling methods to declare options (optional). Examples -------- self.options.declare('option_name', default_value, types=(bool, int), desc='description') """ pass def __call__(self, nt): """ Compute the requested number of sampling points. The number of dimensions (nx) is determined based on `xlimits.shape[0]`. Arguments --------- nt : int Number of points requested. Returns ------- ndarray[nt, nx] The sampling locations in the input space. """ xlimits = self.options["xlimits"] nx = xlimits.shape[0] x = self._compute(nt) for kx in range(nx): x[:, kx] = xlimits[kx, 0] + x[:, kx] * (xlimits[kx, 1] - xlimits[kx, 0]) return x def _compute(self, nt): """ Implemented by sampling methods to compute the requested number of sampling points. The number of dimensions (nx) is determined based on `xlimits.shape[0]`. Arguments --------- nt : int Number of points requested. Returns ------- ndarray[nt, nx] The sampling locations in the input space. """ raise Exception( "This sampling method has not been implemented correctly")