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)