def compute_partials(self, inputs, partials):
"""
Collect computed partial derivatives and return them.
Checks if the needed derivatives are cached already based on the
inputs vector. Refreshes the cache by re-computing the current point
if necessary.
Parameters
----------
inputs : Vector
unscaled, dimensional input variables read via inputs[key]
partials : Jacobian
sub-jac components written to partials[output_name, input_name]
"""
pt = np.array([inputs[pname].flatten() for pname in self.pnames]).T
if self.options['training_data_gradients']:
dy_ddata = np.zeros(self.sh)
for j in range(self.options['vec_size']):
for i, axis in enumerate(self.params):
e_i = np.eye(axis.size)
interp = _make_interp_spline(axis, e_i, k=self._ki[i], axis=0)
if i == 0:
val = interp(pt[j, i])
else:
val = np.outer(val, interp(pt[j, i]))
dy_ddata[j] = val.reshape(self.sh[1:])
for out_name in self.interps:
dval = self.interps[out_name].gradient(pt).T
for i, p in enumerate(self.pnames):
partials[out_name, p] = dval[i]
if self.options['training_data_gradients']:
partials[out_name, "%s_train" % out_name] = dy_ddata
def _do_spline_fit(self, x, y, pt, k, compute_gradients):
"""
Do a single interpolant call, and compute the gradient if needed.
Parameters
----------
x : array_like, shape (n,)
Abscissas.
y : array_like, shape (n, ...)
Ordinates.
pt : array_like
Points to evaluate the spline at.
k : float
Spline interpolation order.
compute_gradients : bool
If a spline interpolation method is chosen, this determines whether gradient
calculations should be made and cached.
Returns
-------
array_like
Value of interpolant at point of interest.
None or array_like, optional
Value of gradient of interpolant at point of interest.
"""
local_interp = _make_interp_spline(x, y, k=k, axis=0)
values = local_interp(pt)
local_derivs = None
if compute_gradients:
local_derivs = local_interp(pt, 1)
return values, local_derivs
def compute_partials(self, inputs, partials):
"""
Collect computed partial derivatives and return them.
Checks if the needed derivatives are cached already based on the
inputs vector. Refreshes the cache by re-computing the current point
if necessary.
Parameters
----------
inputs : Vector
unscaled, dimensional input variables read via inputs[key]
partials : Jacobian
sub-jac components written to partials[output_name, input_name]
"""
pt = np.array([inputs[pname].flatten() for pname in self.pnames]).T
if self.options['training_data_gradients']:
dy_ddata = np.zeros(self.sh)
for j in range(self.options['vec_size']):
for i, axis in enumerate(self.params):
e_i = np.eye(axis.size)
interp = _make_interp_spline(axis, e_i, k=self._ki[i], axis=0)
if i == 0:
val = interp(pt[j, i])
else:
val = np.outer(val, interp(pt[j, i]))
dy_ddata[j] = val.reshape(self.sh[1:])
for out_name in self.interps:
dval = self.interps[out_name].gradient(pt).T
for i, p in enumerate(self.pnames):
partials[out_name, p] = dval[i]
if self.options['training_data_gradients']:
partials[out_name, "%s_train" % out_name] = dy_ddata
def training_gradients(self, pt):
"""
Compute the training gradient for the vector of training points.
Parameters
----------
pt : ndarray
Training point values.
Returns
-------
ndarray
Gradient of output with respect to training point values.
"""
for i, axis in enumerate(self.grid):
e_i = np.eye(axis.size)
interp = _make_interp_spline(axis, e_i, k=self._ki[i], axis=0)
if i == 0:
val = interp(pt[i])
else:
val = np.outer(val, interp(pt[i]))
return val