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")