def testEval(self):
grid = Grid.createLinearGrid(1)
grid.getGenerator().regular(3)
gs = grid.getStorage()
# prepare surplus vector
nodalValues = DataVector(gs.getSize())
nodalValues.setAll(0.0)
# interpolation on nodal basis
p = DataVector(gs.getDimension())
for i in range(gs.getSize()):
gs.getCoordinates(gs.getPoint(i), p)
nodalValues[i] = f(p[0])
# nodalValues[i] = f(p[0], p[1])
# hierarchization
alpha = hierarchize(grid, nodalValues)
# eval the sparse grid function
x = np.linspace(0, 1, 1000)
y = [f(xi) for xi in x]
y1 = [evalSGFunction(grid, alpha, np.array([xi])) for xi in x]
y2 = evalSGFunctionMulti(grid, alpha, np.array([x]).T)
assert np.all(y1 - y2 <= 1e-13)
def __discretize(self):
"""
Discretize squared f to obtain a well suited grid for all
further computations.
"""
def f(p, val):
q = self.__T.unitToProbabilistic(p)
return val ** 2 * self.__U.pdf(q)
grid, _, _ = discretize(self.__grid, self.__alpha, f,
refnums=4, deg=1, epsilon=1e-6)
# hierarchize without pdf
gs = grid.getStorage()
nodalValues = DataVector(gs.size())
p = DataVector(gs.dim())
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
nodalValues[i] = evalSGFunction(self.__grid, self.__alpha, p)
self.__alpha = hierarchize(grid, nodalValues)
self.__grid = grid
err = checkInterpolation(self.__grid, self.__alpha, nodalValues)
if err is True:
import pdb; pdb.set_trace()
def plotSG3d(grid, alpha, n=50, f=lambda x: x):
fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.linspace(0, 1, n)
Y = np.linspace(0, 1, n)
X, Y = np.meshgrid(X, Y)
Z = np.zeros(n * n).reshape(n, n)
for i in xrange(len(X)):
for j, (x, y) in enumerate(zip(X[i], Y[i])):
Z[i, j] = f(evalSGFunction(grid, alpha, DataVector([x, y])))
# get grid points
gs = grid.getStorage()
gps = np.zeros([gs.size(), 2])
p = DataVector(2)
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
gps[i, :] = p.array()
surf = ax.plot_surface(X,
Y,
Z,
rstride=1,
cstride=1,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
ax.scatter(gps[:, 0], gps[:, 1], np.zeros(gs.size()))
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
# ax.set_zlim(0, 2)
fig.colorbar(surf, shrink=0.5, aspect=5)
return fig, ax, Z
def plotSG3d(grid, alpha, n=50, f=lambda x: x):
fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.linspace(0, 1, n)
Y = np.linspace(0, 1, n)
X, Y = np.meshgrid(X, Y)
Z = np.zeros(n * n).reshape(n, n)
for i in xrange(len(X)):
for j, (x, y) in enumerate(zip(X[i], Y[i])):
Z[i, j] = f(evalSGFunction(grid, alpha, DataVector([x, y])))
# get grid points
gs = grid.getStorage()
gps = np.zeros([gs.size(), 2])
p = DataVector(2)
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
gps[i, :] = p.array()
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
ax.scatter(gps[:, 0], gps[:, 1], np.zeros(gs.size()))
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
# ax.set_zlim(0, 2)
fig.colorbar(surf, shrink=0.5, aspect=5)
return fig, ax, Z
def __discretize(self):
"""
Discretize squared f to obtain a well suited grid for all
further computations.
"""
def f(p, val):
q = self.__T.unitToProbabilistic(p)
return val**2 * self.__U.pdf(q)
grid, _, _ = discretize(self.__grid,
self.__alpha,
f,
refnums=4,
deg=1,
epsilon=1e-6)
# hierarchize without pdf
gs = grid.getStorage()
nodalValues = DataVector(gs.size())
p = DataVector(gs.dim())
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
nodalValues[i] = evalSGFunction(self.__grid, self.__alpha, p)
self.__alpha = hierarchize(grid, nodalValues)
self.__grid = grid
err = checkInterpolation(self.__grid, self.__alpha, nodalValues)
if err is True:
import pdb
pdb.set_trace()
def __init__(self, grid,
alpha,
trainData=None,
bounds=None,
config=None,
learner=None,
unitIntegrand=True,
isPositive=True):
super(SGDEdist, self).__init__(grid.getStorage().getDimension(),
trainData, bounds)
self.grid = grid.clone()
self.alpha = alpha.copy()
self.alpha_vec = DataVector(alpha)
if trainData is not None:
self.trainData = trainData.copy()
else:
self.trainData = None
self.config = config
self.unitIntegrand = unitIntegrand
if learner is None and trainData is not None:
trainData_vec = DataMatrix(trainData)
self.learner = SparseGridDensityEstimator(self.grid, self.alpha_vec, trainData_vec)
else:
self.learner = learner
if trainData is None:
self.dim = grid.getStorage().getDimension()
elif self.dim != grid.getStorage().getDimension():
raise AttributeError("the dimensionality of the data differs from the one of the grid")
assert self.grid.getSize() == len(self.alpha)
if isPositive:
self.vol = createOperationQuadrature(self.grid).doQuadrature(self.alpha_vec)
else:
# do monte carlo quadrature to estimate the volume
n = 20000
numDims = grid.getStorage().getDimension()
generator = LatinHypercubeSampleGenerator(numDims, n)
samples = np.ndarray((n, numDims))
sample = DataVector(numDims)
for i in range(samples.shape[0]):
generator.getSample(sample)
samples[i, :] = sample.array()
values = evalSGFunction(grid, alpha, samples)
self.vol = np.mean([max(0.0, value) for value in values])
# scale the coefficients such that it has unit integrand
self.unnormalized_alpha = np.array(self.alpha / self.vol)
self.unnormalized_alpha_vec = DataVector(self.unnormalized_alpha)
self.vol *= self.trans.vol()
if unitIntegrand and self.vol > 1e-13:
self.alpha /= self.vol
self.alpha_vec.mult(1. / self.vol)
def plotNodal1d(grid, alpha):
gs = grid.getStorage()
x = np.zeros(gs.size())
nodalValues = np.zeros(gs.size())
for i in xrange(gs.size()):
x[i] = gs.get(i).getCoord(0)
nodalValues[i] = evalSGFunction(grid, alpha, DataVector([x[i]]))
plt.plot(x, nodalValues, " ", marker="o")
def plotSGNodal1d(grid, alpha):
gs = grid.getStorage()
A = np.ndarray([gs.getSize(), 2])
p = DataVector(2)
for i in range(gs.getSize()):
gs.getCoordinates(gs.getPoint(i), p)
A[i, 0] = p[0]
A[i, 1] = evalSGFunction(grid, alpha, p.array())
return plotNodal1d(A), A
def plotSGNodal3d(grid, alpha):
gs = grid.getStorage()
A = np.ndarray([gs.size(), 3])
p = DataVector(2)
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
A[i, 0] = p[0]
A[i, 1] = p[1]
A[i, 2] = evalSGFunction(grid, alpha, p)
return plotNodal3d(A), A
def plotSGNodal3d(grid, alpha):
gs = grid.getStorage()
A = np.ndarray([gs.size(), 3])
p = DataVector(2)
for i in xrange(gs.size()):
gs.get(i).getCoords(p)
A[i, 0] = p[0]
A[i, 1] = p[1]
A[i, 2] = evalSGFunction(grid, alpha, p)
return plotNodal3d(A), A
def plotSG1d(grid, alpha, n=1000, f=lambda x: x, show_grid_points=False,
**kws):
x = np.linspace(0, 1, n)
y = [f(evalSGFunction(grid, alpha, np.array([xi])))
for xi in x]
plt.plot(x, y, **kws)
if show_grid_points:
gs = grid.getStorage()
for i in range(gs.getSize()):
x = gs.getCoordinate(gs.getPoint(i), 0)
plt.scatter(x, 0, color="black")
def eval(self, samples, ts=None, dtype=KnowledgeTypes.SIMPLE):
ans = {}
if ts is None:
ts = self.__uqManager.getTimeStepsOfInterest()
qoi = self.__uqManager.getQoI()
grid = self.__knowledge.getGrid(qoi)
for t in ts:
alpha = self.__knowledge.getAlpha(qoi, t, dtype)
ans[t] = evalSGFunction(grid, alpha, samples)
if len(ts) == 1:
ans = ans[ts[0]]
return ans
def eval(self, samples, ts=None, dtype=KnowledgeTypes.SIMPLE):
ans = {}
if ts is None:
ts = self.__knowledge.getAvailableTimeSteps()
grid = self.__knowledge.getGrid(self._qoi)
for t in ts:
alpha = self.__knowledge.getAlpha(self._qoi, t, dtype)
res = evalSGFunction(grid, alpha, samples)
ans[t] = res
if len(ts) == 1:
ans = ans[ts[0]]
return ans
def eval(self, samples, ts=None, dtype=KnowledgeTypes.SIMPLE):
ans = {}
if ts is None:
ts = self.__knowledge.getAvailableTimeSteps()
grid = self.__knowledge.getGrid(self._qoi)
for t in ts:
alpha = self.__knowledge.getAlpha(self._qoi, t, dtype)
res = evalSGFunction(grid, alpha, samples)
ans[t] = res
if len(ts) == 1:
ans = ans[ts[0]]
return ans
def pdf(self, x):
# convert the parameter to the right format
x = self._convertEvalPoint(x)
# transform the samples to the unit hypercube
if self.trans is not None:
x_unit = self.trans.probabilisticToUnitMatrix(x)
else:
x_unit = x
# evaluate the sparse grid density
fx = evalSGFunction(self.grid, self.alpha, x_unit)
# if there is just one value given, extract it from the list
if len(fx) == 1:
fx = fx[0]
return max(0, fx)
def __evalHigherOrderComponent(self, fi, x):
"""
Evaluate the higher order components
@param fi: linear combination of marginalized functions
@param x: DataVector coordinate to be evaluated
"""
# constant term
sign, f0 = fi['const']
s = sign * f0
# higher order terms terms
for sign, pperm in fi['var']:
grid, alpha = self.__expectation_funcs[pperm]
p = DataVector([x[ix] for ix in pperm])
val = evalSGFunction(grid, alpha, p)
s += sign * val
return s
def __evalHigherOrderComponent(self, fi, x):
"""
Evaluate the higher order components
@param fi: linear combination of marginalized functions
@param x: DataVector coordinate to be evaluated
"""
# constant term
sign, f0 = fi['const']
s = sign * f0
# higher order terms terms
for sign, pperm in fi['var']:
grid, alpha = self.__expectation_funcs[pperm]
p = DataVector([x[ix] for ix in pperm])
val = evalSGFunction(grid, alpha, p)
s += sign * val
return s
def pdf(self, x):
# convert the parameter to the right format
if isList(x):
x = DataVector(x)
elif isNumerical(x):
return evalSGFunction(self.grid, self.alpha, DataVector([x]))
if isinstance(x, DataMatrix):
A = x
elif isinstance(x, DataVector):
A = DataMatrix(1, len(x))
A.setRow(0, x)
else:
raise AttributeError('data type "%s" is not supported in SGDEdist' % type(x))
# evaluate the sparse grid density
fx = evalSGFunctionMulti(self.grid, self.alpha, A)
# if there is just one value given, extract it from the list
if len(fx) == 1:
fx = fx[0]
return fx
def pdf(self, x):
# convert the parameter to the right format
if isList(x):
x = DataVector(x)
elif isNumerical(x):
return evalSGFunction(self.grid, self.alpha, DataVector([x]))
if isinstance(x, DataMatrix):
A = x
elif isinstance(x, DataVector):
A = DataMatrix(1, len(x))
A.setRow(0, x)
else:
raise AttributeError(
'data type "%s" is not supported in SGDEdist' % type(x))
# evaluate the sparse grid density
fx = evalSGFunctionMulti(self.grid, self.alpha, A)
# if there is just one value given, extract it from the list
if len(fx) == 1:
fx = fx[0]
return fx
def plotSG3d(grid,
alpha,
n=36,
f=lambda x: x,
grid_points_at=0,
z_min=np.Inf,
isConsistent=True,
show_grid=True,
surface_plot=False,
xoffset=0.0,
yoffset=1.0):
fig = plt.figure()
ax = fig.gca(projection='3d')
x = np.linspace(0, 1, n + 1, endpoint=True)
y = np.linspace(0, 1, n + 1, endpoint=True)
Z = np.zeros((n + 1, n + 1))
xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
for i in range(len(x)):
for j in range(len(y)):
Z[j, i] = f(
evalSGFunction(grid,
alpha,
np.array([xv[j, i], yv[j, i]]),
isConsistent=isConsistent))
if surface_plot:
cmap = load_default_color_map()
norm = colors.Normalize(vmin=Z.min(), vmax=Z.max(), clip=False)
ax.plot_surface(xv, yv, Z, rstride=1, cstride=1, norm=norm, cmap=cmap)
else:
ax.plot_wireframe(xv, yv, Z, color="black")
z_min, z_max = min(np.min(Z), z_min), np.max(Z)
ax.set_zlim(z_min, z_max)
if np.any(np.abs(alpha) > 1e-13):
cset = ax.contour(xv, yv, Z, zdir='z', offset=z_min, cmap=cm.coolwarm)
cset = ax.contour(xv,
yv,
Z,
zdir='x',
offset=xoffset,
cmap=cm.coolwarm)
cset = ax.contour(xv,
yv,
Z,
zdir='y',
offset=yoffset,
cmap=cm.coolwarm)
if show_grid:
# get grid points
gs = grid.getStorage()
gps = np.zeros([gs.getSize(), 2])
p = DataVector(2)
for i in range(gs.getSize()):
gs.getCoordinates(gs.getPoint(i), p)
p0, p1 = p.array()
color = "red" if alpha[i] < 0 else "blue"
ax.plot(np.array([p0]),
np.array([p1]),
np.array([grid_points_at]),
" ",
c=color,
marker="o",
ms=15)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
# ax.set_zlim(0, 2)
# fig.colorbar(surf, shrink=0.5, aspect=5)
return fig, ax, Z
def plotSG1d(grid, alpha, n=1000, f=lambda x: x, **kws):
x = np.linspace(0, 1, n)
y = [f(evalSGFunction(grid, alpha, DataVector([xi])))
for xi in x]
plt.plot(x, y, **kws)
def f(p):
val = evalSGFunction(grid, alpha, p)
return val ** k
def f(p):
val = evalSGFunction(grid, alpha, p)
return val ** k
