def defineUQManager(self):
builder = ASGCUQManagerBuilder()
builder.withParameters(self.params)\
.withTypesOfKnowledge([KnowledgeTypes.SIMPLE,
KnowledgeTypes.SQUARED])\
.withQoI(self.qoi)\
.withTimeStepsOfInterest(self.toi)\
.useInterpolation()\
.withTestSet(self.uqSettings["ref"])\
.learnWithTest()
# define uq setting
self.defineUQSetting(builder.defineUQSetting())
samplerSpec = builder.defineSampler()
samplerSpec.withGrid().withLevel(4)
# define refinement
samplerSpec.withRefinement().withAdaptThreshold(1e-10)\
.withAdaptPoints(5)\
.withBalancing()\
.refineMostPromisingNodes().withSquaredSurplusRanking()\
.createAllChildrenOnRefinement()
# ref.withBalancing()\
# .addMostPromisingChildren().withLinearSurplusEstimationRanking()
samplerSpec.withStopPolicy().withAdaptiveIterationLimit(0)
return builder
def testSettings(self):
# set distributions of the input parameters
builder = ParameterBuilder()
up = builder.defineUncertainParameters()
up.new().isCalled('x').withUniformDistribution(0, 1)
up.new().isCalled('y').withUniformDistribution(0, 1)
params = builder.andGetResult()
def postprocessor(x, *args, **kws):
return {'x': np.array([x[0], -x[0]]), 'time': list(range(len(x)))}
f = lambda x, **kws: [x[0], 2 * x[0], 4 * x[0], 8 * x[0]]
toi = [0, 1]
# set up uq setting
builder = ASGCUQManagerBuilder().withParameters(params)\
.withTypesOfKnowledge([KnowledgeTypes.SIMPLE,
KnowledgeTypes.SQUARED])\
.withQoI("x")\
.withTimeStepsOfInterest(toi)\
.useInterpolation()
builder.defineUQSetting().withSimulation(f)\
.withPostprocessor(postprocessor)
builder.defineSampler().withGrid().withLevel(3)\
.hasType(GridType_Poly)\
.withDegree(2)\
.withBoundaryLevel(1)
uqManager = builder.andGetResult()
uqManager.runNextSamples()
# define analysis
uqAnalysis = ASGCAnalysisBuilder().withUQManager(uqManager)\
.withAnalyticEstimationStrategy()\
.andGetResult()
# plot result
ans = {}
for t in uqManager.getTimeStepsOfInterest():
grid, alpha = uqManager.getKnowledge().getSparseGridFunction(
t=t, qoi="x")
fig = plt.figure()
ans[t] = plotSG2d(grid,
alpha,
show_grid_points=True,
show_numbers=True)
fig.show()
assert all(ans[0] == -ans[1])
plt.show()
def buildSetting(self,
params,
f=None,
level=None,
gridType=None,
grid=None,
deg=1,
maxGridSize=1000,
isFull=False,
boundaryLevel=1,
balancing=True,
epsilon=1e-15,
adaptive=None,
refinementTechnique="refinement",
adaptPoints=3,
saveAfterN=-1,
adaptRate=None,
uqSetting=None,
uqSettingRef=None,
knowledgeFilename=None,
knowledgeTypes=[
KnowledgeTypes.SIMPLE, KnowledgeTypes.SQUARED,
KnowledgeTypes.EXPECTATIONVALUE
],
qoi=None,
toi=None):
builder = ASGCUQManagerBuilder()
builder.withParameters(params)\
.withTypesOfKnowledge(knowledgeTypes)\
.useInterpolation()
if qoi is not None:
builder.withQoI(qoi)
if toi is not None:
builder.withTimeStepsOfInterest(toi)
if uqSetting is not None:
builder.useUQSetting(uqSetting)
else:
builder.defineUQSetting().withSimulation(f).saveAfterEachRun(
saveAfterN)
if uqSettingRef is not None and len(uqSettingRef) > 0:
builder.withTestSet(uqSettingRef)\
.learnWithTest()
if knowledgeFilename is not None:
builder.withKnowledge(knowledgeFilename)
samplerSpec = builder.defineSampler()
gridSpec = samplerSpec.withGrid()
if grid is not None:
gridSpec.fromGrid(grid)
else:
assert level is not None
assert gridType is not None
gridSpec.withLevel(level).hasType(gridType)
if deg > 1:
gridSpec.withDegree(deg)
if isFull:
gridSpec.isFull()
if hasBorder(gridType) and boundaryLevel is not None:
gridSpec.withBoundaryLevel(boundaryLevel)
if adaptive is not None:
# specify the refinement
refinement = samplerSpec.withRefinement()
refinement.withAdaptThreshold(epsilon)\
.withAdaptPoints(adaptPoints)
if balancing:
refinement.withBalancing()
if adaptRate is not None:
refinement.withAdaptRate(adaptRate)
if refinementTechnique == "refinement":
refineNodes = refinement.refineMostPromisingNodes()
refineNodes.createAllChildrenOnRefinement()
if adaptive == "simple":
refineNodes.withSurplusRanking()
elif adaptive == "weighted":
refineNodes.withWeightedSurplusRanking()
elif adaptive == "l2":
refineNodes.withWeightedL2OptimizationRanking()
elif adaptive == "exp":
refineNodes.withExpectationValueOptimizationRanking()
elif adaptive == "var":
refineNodes.withVarianceOptimizationRanking()
elif adaptive == "mean_squared":
refineNodes.withMeanSquaredOptRanking()
elif adaptive == "squared":
refineNodes.withSquaredSurplusRanking()
elif adaptive == "anchored_exp":
refineNodes.withAnchoredExpectationValueOptimizationRanking(
)
elif adaptive == "anchored_var":
refineNodes.withAnchoredVarianceOptimizationRanking()
elif adaptive == "anchored_l2":
refineNodes.withAnchoredWeightedL2OptimizationRanking()
elif adaptive == "anchored_mean_squared":
refineNodes.withAnchoredMeanSquaredOptRanking()
elif adaptive == "l2_mc_pm1d":
refineNodes.withPM1D_MC_Ranking(deg, gridType, 'l2')
elif adaptive == "exp_mc_pm1d":
refineNodes.withPM1D_MC_Ranking(deg, gridType, 'exp')
elif adaptive == "var_mc_pm1d":
refineNodes.withPM1D_MC_Ranking(deg, gridType, 'var')
else:
raise AttributeError(
"unknown ranking method: refinement, %s" % adaptive)
else:
addNodes = refinement.addMostPromisingChildren()
if adaptive == "weighted":
addNodes.withWeightedSurplusOptimizationRanking()
elif adaptive == "l2":
addNodes.withWeightedL2OptimizationRanking()
else:
raise AttributeError(
"unknown ranking method: predictive, %s" % adaptive)
if toi is not None:
refinement.withAverageWeightening()
samplerSpec.withStopPolicy().withGridSizeLimit(maxGridSize)
uqManager = builder.andGetResult()
# update the stats, which are not stored with the knowledge
if knowledgeFilename is not None:
uqManager.recomputeStats()
return uqManager
def testAnova(self):
# ----------------------------------------------------------
# define the learner
# ----------------------------------------------------------
# define UQ setting
builder = ASGCUQManagerBuilder()
builder.withParameters(self.params)\
.withTypesOfKnowledge([KnowledgeTypes.SIMPLE,
KnowledgeTypes.SQUARED,
KnowledgeTypes.EXPECTATIONVALUE])\
.useInterpolation()
builder.defineUQSetting().withSimulation(self.simulation)
samplerSpec = builder.defineSampler()
samplerSpec.withGrid().hasType(GridType_PolyBoundary)\
.withLevel(4)\
.withDegree(5)\
.withBoundaryLevel(1)
# ----------------------------------------------------------
# discretize the stochastic space with the ASGC method
# ----------------------------------------------------------
uqManager = builder.andGetResult()
# ----------------------------------------------
# first run
while uqManager.hasMoreSamples():
uqManager.runNextSamples()
# ----------------------------------------------------------
# specify ASGC estimator
# ----------------------------------------------------------
analysis = ASGCAnalysisBuilder().withUQManager(uqManager)\
.withAnalyticEstimationStrategy()\
.andGetResult()
# ----------------------------------------------------------
# expectation values and variances
_, _ = analysis.mean(), analysis.var()
# ----------------------------------------------------------
# estimated anova decomposition
anova = analysis.getAnovaDecomposition(nk=len(self.params))
# ----------------------------------------------------------
# check interpolation and decomposition
m = np.random.rand(100, self.params.getDim())
for i in range(m.shape[0]):
self.assertTrue(abs(analysis.eval(m[i, :]) - anova.eval(m[i, :])) < 1e-14)
# ----------------------------------------------------------
# main effects
me = anova.getSobolIndices()
print("-------------- Sobol Indices (t = %i) ------------------" % 1)
for (key, val) in sorted(me.items()):
print("%s: %s" % (key, val))
print(sum([val for val in list(me.values())]), "==", 1)
# ----------------------------------------------------------
# total effects
te = anova.getTotalEffects()
print("-------------- Total Effects (t = %i) -----------------" % 1)
for key, val in sorted(te.items()):
print("%s: %s" % (key, val))
print("---------------------------------------------")
print()
names = anova.getSortedPermutations(list(me.keys()))
values = [me[name] for name in names]
fig, _ = plotSobolIndices(values, legend=True, names=names)
fig.show()
plt.show()
rc('text', usetex=True)
# define random variables
builder = ParameterBuilder()
up = builder.defineUncertainParameters()
up.new().isCalled('x_0').withTNormalDistribution(0.0, 0.5, -2, 1)
up.new().isCalled('x_1').withTNormalDistribution(
0.5, 0.2, 0, 1).withInverseCDFTransformation()
up.new().isCalled('x_2,x_3,x_4,...').withSGDEDistribution(
dist).withInverseCDFTransformation()
params = builder.andGetResult()
# define UQ setting
builder = ASGCUQManagerBuilder()
builder.withParameters(params)\
.withTypesOfKnowledge([KnowledgeTypes.SIMPLE,
KnowledgeTypes.SQUARED])\
.useInterpolation()
# define model function
def g(x, **kws):
return np.arctan(
50 *
(x[0] - .35)) + np.pi / 2 + 4 * x[1]**3 + 10 * np.exp(x[0] * x[1] - 1)
builder.defineUQSetting().withSimulation(g)
def buildSetting(self,
label,
level,
gridType,
deg=1,
nsamples=1000,
isFull=False,
epsilon=1e-15,
adaptive=None,
knowledgeFilename=None):
builder = ASGCUQManagerBuilder()
builder.withParameters(self.params)\
.useUQSetting(self.uqSettings[label])\
.withTypesOfKnowledge([KnowledgeTypes.SIMPLE,
KnowledgeTypes.SQUARED])\
.useInterpolation()
if 'ref' in self.uqSettings and len(self.uqSettings['ref']) > 0:
builder.withTestSet(self.uqSettings['ref'])\
.learnWithTest()\
if knowledgeFilename is not None:
builder.withKnowledge(knowledgeFilename)
samplerSpec = builder.defineSampler()
gridSpec = samplerSpec.withGrid()
gridSpec.withLevel(level).hasType(gridType)
if deg > 1:
gridSpec.withDegree(deg)
if isFull:
gridSpec.isFull()
if adaptive is not None:
# specify the refinement
samplerSpec.withRefinement()\
.withAdaptThreshold(epsilon)\
.withAdaptPoints(2)\
.withBalancing()
refinement = samplerSpec.refineMostPromisingNodes()
if adaptive == "simple":
refinement.withSurplusRanking()
elif adaptive == "exp":
refinement.withExpectationValueOptimizationRanking()
elif adaptive == "var":
refinement.withVarianceOptimizationRanking()
elif adaptive == "squared":
refinement.withSquaredSurplusRanking()
refinement.createAllChildrenOnRefinement()
samplerSpec.withStopPolicy().withGridSizeLimit(nsamples)
uqManager = builder.andGetResult()
# update the stats, which are not stored with the knowledge
if knowledgeFilename is not None:
uqManager.recomputeStats()
return uqManager