def uniform(self, a=0, b=1): # set distributions of the input parameters builder = ParameterBuilder() up = builder.defineUncertainParameters() for idim in range(self.numDims): up.new().isCalled("x%i" % idim).withUniformDistribution(a, b) return up.andGetResult()
def normal(self, mu=0, sigma=1, alpha=0.001): # set distributions of the input parameters builder = ParameterBuilder() up = builder.defineUncertainParameters() for idim in range(self.numDims): up.new().isCalled("x%i" % idim).withNormalDistribution( mu, sigma, 0.001) return builder.andGetResult()
def buildSin2Params(dist_type): dist = generateDistribution(dist_type, alpha=0.01) parameterBuilder = ParameterBuilder() up = parameterBuilder.defineUncertainParameters() up.new().isCalled("x1").withDistribution(dist) return parameterBuilder.andGetResult()
def buildBoreholeParams(dist_type): boreholeLimits = [[0.05, 0.15], [100, 50000], [63070, 115600], [990, 1110], [63.1, 116], [700, 820], [1120, 1680], [9855, 12045]] boreholeParamNames = ["r_w", "r", "T_u", "H_u", "T_l", "H_l", "L", "K_w"] parameterBuilder = ParameterBuilder() up = parameterBuilder.defineUncertainParameters() for k in range(8): xlim = boreholeLimits[k] dist = generateDistribution(dist_type, xlim) up.new().isCalled(boreholeParamNames[k]).withDistribution(dist) return parameterBuilder.andGetResult()
def multivariate_normal(self, mu=0, cov=None, a=0, b=1): # set distributions of the input parameters mu = np.array([mu] * numDims) if cov is None: # use standard values diag = np.eye(numDims) * 0.005 offdiag = np.abs(np.eye(numDims) - 1) * 0.001 cov = diag + offdiag # estimate the density builder = ParameterBuilder() up = builder.defineUncertainParameters() names = ", ".join(["x%i" for i in range(numDims)]) up.new().isCalled(names).withMultivariateNormalDistribution( mu, cov, 0, 1) return builder.andGetResult()
def marginalize(self): """ NOTE: just returns the marginalized active subset of params """ # marginalize the distribution margDistList = [] margTransformations = [] activeParams = self.activeParams() distributions = activeParams.getIndependentJointDistribution( ).getDistributions() transformations = activeParams.getJointTransformation( ).getTransformations() if len(distributions) == len(activeParams): return self else: for dist, trans in zip(distributions, transformations): # check if current parameter is independent if dist.getDim() == 1: margDistList.append(dist) margTransformations.append(trans) else: # marginalize the densities and update the transformations innertrans = trans.getTransformations() for idim in range(dist.getDim()): margDist = dist.marginalizeToDimX(idim) margDistList.append(margDist) # update transformations if isinstance(innertrans[idim], RosenblattTransformation): margTransformations.append( RosenblattTransformation(margDist)) else: a, b = margDist.getBounds() margTransformations.append( LinearTransformation(a, b)) assert len(margDistList) == len( margTransformations) == activeParams.getDim() # update the parameter setting from pysgpp.extensions.datadriven.uq.parameters.ParameterBuilder import ParameterBuilder builder = ParameterBuilder() up = builder.defineUncertainParameters() for name, dist, trans in zip(activeParams.getNames(), margDistList, margTransformations): up.new().isCalled(name).withDistribution(dist)\ .withTransformation(trans) return builder.andGetResult()
def refineGrid(self, grid, knowledge, params=None, qoi="_", refinets=[0]): # check if this method is used in the right context if grid.getType( ) not in polyGridTypes + bsplineGridTypes + linearGridTypes: raise AttributeError('Grid type %s is not supported' % grid.getType()) if params is None: # define standard uniform params uncertainParams = ParameterBuilder().defineUncertainParameters() for idim in range(grid.getStorage().getDimension()): uncertainParams.new().isCalled( "x_%i" % idim).withUniformDistribution(0, 1) params = uncertainParams.andGetResult() # get refinement candidates if self.verbose: print("compute ranking") B = self.candidates(grid, knowledge, params, qoi, refinets) # now do the refinement return self.__refine(grid, B, simulate=False)
def setUpClass(cls): super(MonteCarloStrategyTest, cls).setUpClass() builder = ParameterBuilder() up = builder.defineUncertainParameters() up.new().isCalled('x1').withUniformDistribution(0, 1) up.new().isCalled('x2').withUniformDistribution(0, 1) cls.params = builder.andGetResult() cls.numDims = cls.params.getStochasticDim() cls.samples = np.random.random((10000, 1)) cls.grid = Grid.createPolyGrid(cls.numDims, 2) cls.grid.getGenerator().regular(1) gs = cls.grid.getStorage() # interpolate parabola nodalValues = np.zeros(gs.getSize()) x = DataVector(cls.numDims) for i in range(gs.getSize()): gs.getCoordinates(gs.getPoint(i), x) nodalValues[i] = 16 * (1 - x[0]) * (1 - x[1]) cls.alpha = hierarchize(cls.grid, nodalValues)
from pysgpp.extensions.datadriven.uq.dists.MultivariateNormal import MultivariateNormal from pysgpp import Grid, DataVector, DataMatrix from pysgpp.extensions.datadriven.uq.operations import (hierarchize, evalSGFunctionMulti) from pysgpp.extensions.datadriven.uq.operations.forcePositivity import OperationMakePositive from pysgpp.extensions.datadriven.uq.quadrature import doQuadrature from pysgpp.extensions.datadriven.uq.parameters.ParameterBuilder import ParameterBuilder from pysgpp.extensions.datadriven.uq.dists.SGDEdist import SGDEdist mu = np.array([0.5, 0.5]) cov = np.array([[0.1, 0.04], [0.04, 0.1]]) / 5. dist = MultivariateNormal(mu, cov, 0, 1) # setup 2d case builder = ParameterBuilder() up = builder.defineUncertainParameters() up.new().isCalled("x").withLognormalDistribution(0.5, 0.2, alpha=0.001) up.new().isCalled("y").withBetaDistribution(3, 3, 0, 1) disst = builder.andGetResult().getIndependentJointDistribution() class myDist(object): def pdf(self, x): if x[0] < 0.5 and x[1] < 0.5: return 1. elif x[0] > 0.5 and x[1] > 0.5: return -1. elif x[0] > 0.5 and x[1] < 0.5: return 2. else:
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)
def tesst_squared(self): # parameters level = 3 gridConfig = RegularGridConfiguration() gridConfig.type_ = GridType_Linear gridConfig.maxDegree_ = 2 # max(2, level + 1) gridConfig.boundaryLevel_ = 0 gridConfig.dim_ = 2 def f(x): return np.prod(8 * x * (1 - x)) # -------------------------------------------------------------------------- # define parameters paramsBuilder = ParameterBuilder() up = paramsBuilder.defineUncertainParameters() for idim in range(gridConfig.dim_): up.new().isCalled("x_%i" % idim).withUniformDistribution(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()) weightedNodalValues = 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())**2 weightedNodalValues[i] = f(p.array())**2 * U.pdf( T.unitToProbabilistic(p)) # -------------------------------------------------------------------------- alpha_vec = pysgpp.DataVector(nodalValues) pysgpp.createOperationHierarchisation(grid).doHierarchisation( alpha_vec) alpha = alpha_vec.array() checkInterpolation(grid, alpha, nodalValues, epsilon=1e-13) # -------------------------------------------------------------------------- alpha_vec = pysgpp.DataVector(weightedNodalValues) pysgpp.createOperationHierarchisation(grid).doHierarchisation( alpha_vec) weightedAlpha = alpha_vec.array() checkInterpolation(grid, weightedAlpha, weightedNodalValues, epsilon=1e-13) # -------------------------------------------------------------------------- # np.random.seed(1234567) i = np.random.randint(0, gs.getSize()) gpi = gs.getPoint(i) gs.getCoordinates(gpi, p) print(evalSGFunction(grid, alpha, p.array())) print(evalSGFunctionBasedOnParents(grid, alpha, gpi)) # -------------------------------------------------------------------------- # check refinement criterion ranking = SquaredSurplusRanking() squared_surplus_rank = ranking.rank(grid, gpi, weightedAlpha, params) if self.verbose: print("rank squared surplus: %g" % (squared_surplus_rank, )) # -------------------------------------------------------------------------- # check refinement criterion ranking = AnchoredMeanSquaredOptRanking() anchored_mean_squared_rank = ranking.rank(grid, gpi, alpha, params) if self.verbose: print("rank mean squared : %g" % (anchored_mean_squared_rank, ))
def test_anchored_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) # -------------------------------------------------------------------------- i = np.random.randint(0, gs.getSize()) gpi = gs.getPoint(i) # -------------------------------------------------------------------------- # check refinement criterion ranking = AnchoredVarianceOptRanking() var_rank = ranking.rank(grid, gpi, alpha, params) if self.verbose: print("rank anchored var: %g" % (var_rank, )) # -------------------------------------------------------------------------- # compute the mean and the variance of the new grid x = DataVector(gs.getDimension()) gs.getCoordinates(gpi, x) x = x.array() uwxi = evalSGFunction(grid, alpha, x) - alpha[i] fx = U.pdf(T.unitToProbabilistic(x)) var_rank_estimated = np.abs( (fx - fx**2) * (-alpha[i]**2 - 2 * alpha[i] * uwxi)) if self.verbose: print("rank anchored var: %g" % (var_rank_estimated, )) if self.verbose: print("-" * 80) print("diff: |var - var_estimated| = %g" % (np.abs(var_rank - var_rank_estimated), ))
# Copyright (C) 2008-today The SG++ project # This file is part of the SG++ project. For conditions of distribution and # use, please see the copyright notice provided with SG++ or at # sgpp.sparsegrids.org import matplotlib.pyplot as plt import numpy as np from scipy import fftpack from pysgpp.extensions.datadriven.uq.parameters.ParameterBuilder import ParameterBuilder from pysgpp.extensions.datadriven.uq.plot.plot1d import plotFunction1d builder = ParameterBuilder() up = builder.defineUncertainParameters() up.new().isCalled('x').withUniformDistribution(-np.pi, np.pi) params = builder.andGetResult() def f(x): return np.arctan(x) # np.arctan(50 * (x - .35)) # + np.exp(x - 1) class FourierSeries(object): def __init__(self, x, y, x_steps=256): self.n = y.size // 2 ut = np.fft.rfft(y) * np.array([(1. / (2. * self.n))] + [(1. / self.n) for i in range(1, self.n)] + [(1. / (2. * self.n))]) self.f, self.g = (ut.real, -ut.imag[1:-1])