def update(self, grid, v, admissibleSet):
# prepare data
gpsi = list(admissibleSet.values())
# prepare list of grid points
gs = grid.getStorage()
gpsj = [None] * gs.getSize()
for i in range(gs.getSize()):
gpsj[i] = gs.getPoint(i)
# compute stiffness matrix for next run
basis = getBasis(grid)
A = self._strategy.computeBilinearFormByList(basis, gpsi, gpsj)
# compute the expectation value term for the new points
b = self._strategy.computeBilinearFormIdentity(basis, gpsi)
# estimate missing coefficients
w = np.ndarray(admissibleSet.getSize())
for i, gp in enumerate(admissibleSet.values()):
w[i] = estimateSurplus(grid, gp, v)
# w[i] = estimateConvergence(grid, gp, v)
# update the ranking
values = self.__computeRanking(v, w, A, b)
self._ranking = {}
for i, gpi in enumerate(admissibleSet.values()):
self._ranking[gpi.getHash()] = values[i]
def update(self, grid, v, gpi, params, *args, **kws):
"""
Compute ranking for variance estimation
\argmax_{i \in \A} |v_i| \sqrt{E[\varphi_i^2]}
@param grid: Grid grid
@param v: numpy array coefficients
"""
# update the quadrature operations
if not self.initialized:
self._estimationStrategy.initQuadratureStrategy(grid)
U = params.getIndependentJointDistribution()
T = params.getJointTransformation()
self.vol, self.W, self.D = self._estimationStrategy._extractPDFforMomentEstimation(
U, T)
self.initialized = True
# prepare data
gs = grid.getStorage()
basisi = getBasis(grid)
# compute the second moment for the current grid point
secondMoment, _ = self._estimationStrategy.computeSystemMatrixForVarianceList(
gs, [gpi], basisi, [gpi], basisi, self.W, self.D)
secondMoment = max(0.0, self.vol * secondMoment[0])
# update the ranking
ix = gs.getSequenceNumber(gpi)
return np.abs(v[ix]) * np.sqrt(secondMoment)
def update(self, grid, v, gpi, params, *args, **kws):
"""
Compute ranking for variance estimation
\argmax_{i \in \A} | v_i (2 A_i v_i - v_i b_i) |
@param grid: Grid grid
@param v: numpy array coefficients
@param admissibleSet: AdmissibleSet
"""
# update the quadrature operations
self._linearForm.setGridType(grid.getType())
self._bilinearForm.setGridType(grid.getType())
U = params.getDistributions()
T = params.getTransformations()
self._linearForm.setDistributionAndTransformation(U, T)
self._bilinearForm.setDistributionAndTransformation(U, T)
# prepare list of grid points
gs = grid.getStorage()
gpsi = [None] * gs.getSize()
for i in range(gs.getSize()):
gpsi[i] = gs.getPoint(i)
# compute stiffness matrix for next run
basis = getBasis(grid)
A, _ = self._bilinearForm.computeBilinearFormByList(
gs, [gpi], basis, gpsi, basis)
# update the ranking
ix = gs.getSequenceNumber(gpi)
return np.abs(v[ix] * (2 * np.dot(A, v) - v[ix] * A[0, ix]))
def update(self, grid, v, gpi, params, *args, **kws):
"""
Compute ranking for variance estimation
\argmax_{i \in \A} | |v_i| E(\varphi_i)
@param grid: Grid grid
@param v: numpy array coefficients
@param admissibleSet: AdmissibleSet
"""
# update the quadrature operations
if not self.initialized:
self._estimationStrategy.initQuadratureStrategy(grid)
U = params.getIndependentJointDistribution()
T = params.getJointTransformation()
self.vol, self.W, self.D = self._estimationStrategy._extractPDFforMomentEstimation(
U, T)
self.initialized = True
# prepare data
gs = grid.getStorage()
# compute stiffness matrix for next run
basis = getBasis(grid)
ix = gs.getSequenceNumber(gpi)
mean_phii = self.compute_mean_phii(gs, gpi, basis)
return np.abs(v[ix]) * mean_phii
def update(self, grid, v, admissibleSet):
# prepare data
gpsi = admissibleSet.values()
# prepare list of grid points
gs = grid.getStorage()
gpsj = [None] * gs.size()
for i in xrange(gs.size()):
gpsj[i] = gs.get(i)
# compute stiffness matrix for next run
basis = getBasis(grid)
A = self._strategy.computeBilinearFormByList(basis, gpsi, gpsj)
# compute the expectation value term for the new points
b = self._strategy.computeBilinearFormIdentity(basis, gpsi)
# estimate missing coefficients
w = DataVector(admissibleSet.getSize())
for i, gp in enumerate(admissibleSet.values()):
w[i] = estimateSurplus(grid, gp, v)
# w[i] = estimateConvergence(grid, gp, v)
# update the ranking
values = self.__computeRanking(v, w, A, b)
self._ranking = {}
for i, gpi in enumerate(admissibleSet.values()):
self._ranking[gpi.hash()] = values[i]
def test_laplace(grid, lmax):
resolution = 100000
grid.getGenerator().regular(lmax)
gridStorage = grid.getStorage()
size = gridStorage.getSize()
b = getBasis(grid)
op = pysgpp.createOperationLaplace(grid)
alpha = pysgpp.DataVector(size)
result = pysgpp.DataVector(size)
for point_i in range(size):
for point_j in range(size):
gp_i = gridStorage.getPoint(point_i)
gp_j = gridStorage.getPoint(point_j)
print("--------")
for i in range(0, size):
alpha[i] = 0
alpha[point_i] = 1
op.mult(alpha, result)
xs = np.linspace(0, 1, resolution)
approx = sum([
b.evalDx(gp_i.getLevel(0), gp_i.getIndex(0), x) *
b.evalDx(gp_j.getLevel(0), gp_j.getIndex(0), x) for x in xs
]) / resolution
print("i,j: {},{} result: {} approx:{}".format(
point_i, point_j, result[point_j], approx))
if (abs(result.get(point_j) - approx) > 1e-1):
print("--------")
print("points: {},{} ".format(point_i, point_j))
print("approx:{}".format(approx))
print("result:{}".format(result.get(point_j)))
# print result
print("--------")
def project(grid, dims):
"""
Project all grid points to the given dimensions
@param grid: Grid sparse grid
@param dims: list dimensions to which the grid points are projected
"""
gs = grid.getStorage()
# create a new empty grid
dim = len(dims)
gps = [None] * gs.getSize()
# run over all grid points in grid and
# project them to the dimensions dims
for i in range(gs.getSize()):
gp = gs.getPoint(i)
ngp = HashGridPoint(dim)
# copy level index to new grid point
for k, d in enumerate(dims):
ngp.set(k, gp.getLevel(d), gp.getIndex(d))
# insert it to the new grid
gps[i] = ngp
# compute new basis
ngrid = createGrid(grid, len(dims))
basis = getBasis(ngrid)
return gps, basis
def computeSystemMatrixForVariance(self, grid, W, D):
# compute the integral of the product
gs = grid.getStorage()
gps = [None] * gs.getSize()
for i in range(gs.getSize()):
gps[i] = gs.getPoint(i)
basis = getBasis(grid)
return self.computeSystemMatrixForVarianceList(gs, gps, basis, gps,
basis, W, D)
def update(self, grid, v, gpi, params, *args, **kws):
"""
Compute ranking for variance estimation
\argmax_{i \in \A} |v_i| \sqrt{E[\varphi_i^2]}
using E[\varphi_i^2] \approx \sum_{j} \varphi_i^2(x_j),
where x_j are realisations of the unknown probability density function.
@param grid: Grid
@param v: numpy array coefficients
"""
# prepare data
gs = grid.getStorage()
basisi = getBasis(grid)
self.vol = 4.0 #for the pm1d code the domain is [0,1] x [0,1] x [-0.5,3.5]
# compute the second moment for the current grid point using monte carlo estimation
key = (gpi.getLevel(0), gpi.getLevel(1), gpi.getLevel(2),
gpi.getIndex(0), gpi.getIndex(1), gpi.getIndex(2))
if key in self.moments:
secondMoment = self.moments[key]
else:
self.MCparameters = np.loadtxt(
"/home/rehmemk/git/SGpp/misc/python/UnitInputParameters_5023.txt",
dtype=np.float64,
delimiter=' ')
secondMoment = 0
for j in range(len(self.MCparameters)):
baseEval = 1
for d in range(len(self.MCparameters[0])):
baseEval *= basisi.eval(gpi.getLevel(d), gpi.getIndex(d),
self.MCparameters[j, d])
if self.refinementType == 'l2':
secondMoment += baseEval**2
elif self.refinementType == 'exp':
secondMoment += baseEval
elif self.refinementType == 'var':
sys.exit('RefinementStrategy: not implemented yet')
secondMoment = max(
0.0, self.vol * secondMoment / len(self.MCparameters))
self.moments[key] = secondMoment
with open(self.momentsFilePath, 'wb+') as f:
pickle.dump(self.moments, f, pickle.HIGHEST_PROTOCOL)
# update the ranking
ix = gs.getSequenceNumber(gpi)
if self.refinementType == 'l2':
ranking = np.abs(v[ix]) * np.sqrt(secondMoment)
elif self.refinementType == 'exp':
ranking = np.abs(v[ix] * secondMoment)
return ranking
def update(self, grid, v, gpi, params, *args, **kws):
"""
Compute ranking for variance estimation
\argmax_{i \in \A} | -v_i^2 V(\varphi_i) - 2 v_i Cov(u_indwli \varphi_i)|
@param grid: Grid grid
@param v: numpy array coefficients
@param admissibleSet: AdmissibleSet
"""
# update the quadrature operations
if not self.initialized:
self._estimationStrategy.initQuadratureStrategy(grid)
U = params.getIndependentJointDistribution()
T = params.getJointTransformation()
self.vol, self.W, self.D = self._estimationStrategy._extractPDFforMomentEstimation(
U, T)
self.initialized = True
# prepare data
gs = grid.getStorage()
basis = getBasis(grid)
# load coefficients and vectors and matrices for variance and mean
# estimation
w = np.ndarray(gs.getSize() - 1)
ix = gs.getSequenceNumber(gpi)
# prepare list of grid points
gpswi = []
jx = 0
for j in range(gs.getSize()):
gpj = gs.getPoint(j)
if gpi.getHash() != gpj.getHash():
gpswi.append(gpj)
w[jx] = v[j]
jx += 1
# compute the covariance
mean_uwi_phii = self.compute_mean_uwi_phii(gs, gpswi, w, gpi, basis)
mean_phii = self.compute_mean_phii(gs, gpi, basis)
mean_uwi = self.compute_mean_uwi(gs, gpswi, w, basis)
cov_uwi_phii = mean_uwi_phii - mean_phii * mean_uwi
# compute the variance of phi_i
var_phii = self.compute_var_phii(gs, gpi, basis, mean_phii)
# update the ranking
return np.abs(-v[ix]**2 * var_phii - 2 * v[ix] * cov_uwi_phii)
def plot_evaldx_prod(grid, lmax, i, j):
grid.getGenerator().regular(lmax)
gridStorage = grid.getStorage()
b = getBasis(grid)
gp_i = gridStorage.getPoint(i)
gp_j = gridStorage.getPoint(j)
lik = gp_i.getLevel(0)
ljk = gp_j.getLevel(0)
iik = gp_i.getIndex(0)
ijk = gp_j.getIndex(0)
xs = np.linspace(0, 1, 100000)
plt.plot(xs, [b.evalDx(lik, iik, x) * b.evalDx(ljk, ijk, x) for x in xs])
plt.show()
def computeBilinearForm(self, grid):
"""
Compute bilinear form for the current grid
@param grid: Grid
@return DataMatrix
"""
# create bilinear form of the grid
gs = grid.getStorage()
gps = [None] * gs.getSize()
for i in range(gs.getSize()):
gps[i] = gs.getPoint(i)
basis = getBasis(grid)
A, err = self.computeBilinearFormByList(gs, gps, basis, gps, basis)
return A, err
def update(self, grid, v, admissibleSet):
# prepare data
gpsi = admissibleSet.values()
# prepare list of grid points
gs = grid.getStorage()
gpsj = [None] * gs.size()
for i in xrange(gs.size()):
gpsj[i] = gs.get(i)
# compute stiffness matrix for next run
basis = getBasis(grid)
A = self._strategy.computeBilinearFormByList(basis, gpsi, gpsj)
# compute the expectation value term for the new points
b = self._strategy.computeBilinearFormIdentity(basis, gpsi)
# update the ranking
values = self.__computeRanking(v, A, b)
self._ranking = {}
for i, gpi in enumerate(admissibleSet.values()):
self._ranking[gpi.hash()] = values[i]
def test_variance_opt(self):
# parameters
level = 4
gridConfig = RegularGridConfiguration()
gridConfig.type_ = GridType_Linear
gridConfig.maxDegree_ = 2 # max(2, level + 1)
gridConfig.boundaryLevel_ = 0
gridConfig.dim_ = 2
# mu = np.ones(gridConfig.dim_) * 0.5
# cov = np.diag(np.ones(gridConfig.dim_) * 0.1 / 10.)
# dist = MultivariateNormal(mu, cov, 0, 1) # problems in 3d/l2
# f = lambda x: dist.pdf(x)
def f(x):
return np.prod(4 * x * (1 - x))
def f(x):
return np.arctan(
50 *
(x[0] - .35)) + np.pi / 2 + 4 * x[1]**3 + np.exp(x[0] * x[1] -
1)
# --------------------------------------------------------------------------
# define parameters
paramsBuilder = ParameterBuilder()
up = paramsBuilder.defineUncertainParameters()
for idim in range(gridConfig.dim_):
up.new().isCalled("x_%i" % idim).withBetaDistribution(3, 3, 0, 1)
params = paramsBuilder.andGetResult()
U = params.getIndependentJointDistribution()
T = params.getJointTransformation()
# --------------------------------------------------------------------------
grid = pysgpp.Grid.createGrid(gridConfig)
gs = grid.getStorage()
grid.getGenerator().regular(level)
nodalValues = np.ndarray(gs.getSize())
p = DataVector(gs.getDimension())
for i in range(gs.getSize()):
gp = gs.getCoordinates(gs.getPoint(i), p)
nodalValues[i] = f(p.array())
# --------------------------------------------------------------------------
alpha_vec = pysgpp.DataVector(nodalValues)
pysgpp.createOperationHierarchisation(grid).doHierarchisation(
alpha_vec)
alpha = alpha_vec.array()
checkInterpolation(grid, alpha, nodalValues, epsilon=1e-13)
# --------------------------------------------------------------------------
quad = AnalyticEstimationStrategy()
mean = quad.mean(grid, alpha, U, T)["value"]
var = quad.var(grid, alpha, U, T, mean)["value"]
if self.verbose:
print("mean: %g" % mean)
print("var : %g" % var)
print("-" * 80)
# drop arbitrary grid points and compute the mean and the variance
# -> just use leaf nodes for simplicity
bilinearForm = BilinearGaussQuadratureStrategy(grid.getType())
bilinearForm.setDistributionAndTransformation(U.getDistributions(),
T.getTransformations())
linearForm = LinearGaussQuadratureStrategy(grid.getType())
linearForm.setDistributionAndTransformation(U.getDistributions(),
T.getTransformations())
i = np.random.randint(0, gs.getSize())
gpi = gs.getPoint(i)
# --------------------------------------------------------------------------
# check refinement criterion
ranking = ExpectationValueOptRanking()
mean_rank = ranking.rank(grid, gpi, alpha, params)
if self.verbose:
print("rank mean: %g" % (mean_rank, ))
# --------------------------------------------------------------------------
# check refinement criterion
ranking = VarianceOptRanking()
var_rank = ranking.rank(grid, gpi, alpha, params)
if self.verbose:
print("rank var: %g" % (var_rank, ))
# --------------------------------------------------------------------------
# remove one grid point and update coefficients
toBeRemoved = IndexList()
toBeRemoved.push_back(i)
ixs = gs.deletePoints(toBeRemoved)
gpsj = []
new_alpha = np.ndarray(gs.getSize())
for j in range(gs.getSize()):
new_alpha[j] = alpha[ixs[j]]
gpsj.append(gs.getPoint(j))
# --------------------------------------------------------------------------
# compute the mean and the variance of the new grid
mean_trunc = quad.mean(grid, new_alpha, U, T)["value"]
var_trunc = quad.var(grid, new_alpha, U, T, mean_trunc)["value"]
basis = getBasis(grid)
# compute the covariance
A, _ = bilinearForm.computeBilinearFormByList(gs, [gpi], basis, gpsj,
basis)
b, _ = linearForm.computeLinearFormByList(gs, gpsj, basis)
mean_uwi_phii = np.dot(new_alpha, A[0, :])
mean_phii, _ = linearForm.getLinearFormEntry(gs, gpi, basis)
mean_uwi = np.dot(new_alpha, b)
cov_uwi_phii = mean_uwi_phii - mean_phii * mean_uwi
# compute the variance of phi_i
firstMoment, _ = linearForm.getLinearFormEntry(gs, gpi, basis)
secondMoment, _ = bilinearForm.getBilinearFormEntry(
gs, gpi, basis, gpi, basis)
var_phii = secondMoment - firstMoment**2
# update the ranking
var_estimated = var_trunc + alpha[i]**2 * var_phii + 2 * alpha[
i] * cov_uwi_phii
mean_diff = np.abs(mean_trunc - mean)
var_diff = np.abs(var_trunc - var)
if self.verbose:
print("-" * 80)
print("diff: |var - var_estimated| = %g" %
(np.abs(var - var_estimated), ))
print("diff: |var - var_trunc| = %g = %g = var opt ranking" %
(var_diff, var_rank))
print("diff: |mean - mean_trunc| = %g = %g = mean opt ranking" %
(mean_diff, mean_rank))
self.assertTrue(np.abs(var - var_estimated) < 1e-14)
self.assertTrue(np.abs(mean_diff - mean_rank) < 1e-14)
self.assertTrue(np.abs(var_diff - var_rank) < 1e-14)
