def run_mc(self, N, minExp=4, maxExp=12, out=False, plot=False):
# ----------------------------------------------------------
# dicretize the stochastic space with Monte Carlo
# ----------------------------------------------------------
np.random.seed(1234567)
print("-" * 60)
print("Latin Hypercube Sampling")
print("-" * 60)
mcSampler, mcUQSetting = TestEnvironmentMC().buildSetting(
self.params, self.simulation, 2**maxExp)
# ----------------------------------------------------------
# Monte Carlo Estimator
# ----------------------------------------------------------
samples = mcSampler.nextSamples(N)
mcUQSetting.runSamples(samples)
samples = mcUQSetting.getResults()[0]
stats = {}
for iN in np.logspace(minExp, maxExp, maxExp - minExp + 1, base=2):
# split the results into chunk of Ni samples
num_samples = int(iN)
isamples = {0: dict(list(samples.items())[:num_samples])}
analysis = MCAnalysis(self.params, isamples)
analysis.setVerbose(False)
stats[iN] = {
"num_model_evaluations": num_samples,
"mean_estimated": analysis.mean(),
"var_estimated": analysis.var()
}
print("-" * 60)
print("#samples = %i" % (num_samples, ))
print("E[x] = %g ~ %g (err=%g)" %
(self.E_ana[0], analysis.mean()[0],
np.abs(self.E_ana[0] - analysis.mean()[0])))
print("V[x] = %g ~ %g (err=%g)" %
(self.V_ana[0], analysis.var()[0],
np.abs(self.V_ana[0] - analysis.var()[0])))
if out:
# store results
filename = os.path.join(
self.pathResults, "%s_mc_d%i_%s_N%i.pkl" %
(self.radix, self.numDims, "latinHypercube", N))
fd = open(filename, "w")
pkl.dump(
{
'surrogate': 'mc',
'num_dims': self.numDims,
'sampling_strategy': "latin_hypercube",
'num_model_evaluations': N,
'mean_analytic': self.E_ana[0],
'var_analytic': self.V_ana[0],
'results': stats
}, fd)
fd.close()
def run_mc(self, N=10, out=False, plot=False):
# ----------------------------------------------------------
# dicretize the stochastic space with Monte Carlo
# ----------------------------------------------------------
np.random.seed(1234567)
print("-" * 60)
print("Latin Hypercube Sampling")
print("-" * 60)
mcSampler = MCSampler.withLatinHypercubeSampleGenerator(self.params, N)
mcUQSettingBuilder = UQBuilder()
self.defineUQSetting(mcUQSettingBuilder)
mcUQSetting = mcUQSettingBuilder.andGetResult()
# ----------------------------------------------------------
# Monte Carlo Estimator
# ----------------------------------------------------------
samples = mcSampler.nextSamples(N)
mcUQSetting.runSamples(samples)
samples = mcUQSetting.getTimeDependentResults(self.toi, qoi=self.qoi)
# split the results into chunk of Ni samples
num_samples = len(next(iter(samples.values())))
analysis = MCAnalysis(self.params, samples)
analysis.setVerbose(False)
stats = {"num_model_evaluations": num_samples,
"mean_estimated": analysis.mean(),
"var_estimated": analysis.var()}
if out:
# store results
filename = os.path.join(self.pathResults,
"%s-qoi%s_%s.pkl" % (self.radix,
self.qoi,
"mc"))
fd = open(filename, "w")
pkl.dump({'surrogate': 'mc',
'num_dims': self.numDims,
'sampling_strategy': "latin_hypercube",
'num_model_evaluations': num_samples,
'time_steps': self.toi,
'setting': self.setting,
'qoi': self.qoi,
'results': stats},
fd)
fd.close()
def runASGCAnalysis(self, analysis, label, alabel, blabel):
# ----------------------------------------------
# write stats
# ----------------------------------------------
pathResults = os.path.join(self.pathResults, alabel, blabel)
analysisMC = None
if 'ref' in self.uqSettings:
res = self.uqSettings['ref'].getResults()
analysisMC = MCAnalysis(self.params, res)
# print "sobol indices"
# analysis.writeSensitivityValues(os.path.join(pathResults, label))
print("surpluses")
analysis.writeSurplusesLevelWise(os.path.join(pathResults, label))
print("stats")
analysis.writeStats(os.path.join(pathResults, label))
print("moments")
analysis.writeMoments(os.path.join(pathResults, label))
print("sampling")
analysis.sampleGrids(os.path.join(pathResults, "samples", label))
print("checkpoints")
analysis.writeCheckpoints(
os.path.join(pathResults, "checkpoints", label))
print("density")
kde = analysis.estimateDensity(dtype="kde")
sgde = analysis.estimateDensity(dtype="sgde")
kdeMC = None
if analysisMC is not None:
kdeMC = analysisMC.estimateDensity(dtype="kde")
fig = plt.figure()
plotDensity1d(kde, label="kde")
plotDensity1d(sgde, label="sgde")
if kdeMC is not None:
plotDensity1d(kdeMC, label="kde (ref)")
plt.legend()
plt.savefig(os.path.join(pathResults, "scc.pdf.png"))
plt.close(fig)
fig = plt.figure()
plotCDF1d(kde, label="kde")
plotCDF1d(sgde, label="sgde")
if kdeMC is not None:
plotCDF1d(kdeMC, label="kde (ref)")
plt.legend()
plt.savefig(os.path.join(pathResults, "scc.cdf.png"))
plt.close(fig)
# ----------------------------------------------
# do some plotting
# ----------------------------------------------
uqManager = analysis.getUQManager()
# scatter plot of surpluses level wise
for t in uqManager.getTimeStepsOfInterest():
for dtype in uqManager.getKnowledgeTypes():
surpluses = analysis.computeSurplusesLevelWise(t, dtype)
maxLevel = uqManager.getKnowledge().getGrid(uqManager.getQoI())\
.getStorage().getMaxLevel()
fig = plotSurplusLevelWise(surpluses, maxLevel)
fig.savefig(
os.path.join(
pathResults, "surpluses.%s.t%g.png" %
(KnowledgeTypes.toString(dtype), t)))
def computeReferenceValues(cls, uqSetting, n=100):
# ----------------------------------------------------------
# analytic reference values
# ----------------------------------------------------------
g = uqSetting.getSimulation()
numDims = cls.params.getStochasticDim()
U = cls.params.getIndependentJointDistribution()
computeWithMC = False
if cls.param_setting == "uniform":
print("computing analytic results")
cls.E_ana = ((2. / 3.))**numDims, 0.0
if numDims == 1:
cls.V_ana = (4. / 45.), 0.0
elif numDims == 2:
cls.V_ana = (176. / 2025.), 0.0
elif numDims == 3:
cls.V_ana = (60416. / 820125.), 0.0
elif numDims == 4:
cls.V_ana = (1705984. / 36905625.), 0.0
else:
computeWithMC = True
else:
if numDims == 1:
print("computing analytic results 1d")
cls.E_ana = quad(lambda x: g([x]) * U.pdf([x]), 0, 1)
cls.V_ana = quad(
lambda x: (g([x]) - cls.E_ana[0])**2 * U.pdf([x]), 0, 1)
elif numDims == 2:
print("computing analytic results 2d")
cls.E_ana = dblquad(lambda x, y: g([x, y]) * U.pdf([x, y]), 0,
1, lambda x: 0, lambda x: 1)
cls.V_ana = dblquad(
lambda x, y: (g([x, y]) - cls.E_ana[0])**2 * U.pdf([x, y]),
0, 1, lambda x: 0, lambda x: 1)
else:
computeWithMC = True
# ----------------------------------------------------------
# dicretize the stochastic space with Monte Carlo
# ----------------------------------------------------------
print("computing monte carlo reference values")
n -= uqSetting.getSize()
if n > 0:
mcSampler = MCSampler.withLatinHypercubeSampleGenerator(
cls.params, n)
samples = mcSampler.nextSamples(n)
uqSetting.runSamples(samples)
uqSetting.writeToFile()
# ----------------------------------------------------------
# monte carlo reference values
# ----------------------------------------------------------
res = uqSetting.getResults()
analysis = MCAnalysis(cls.params, res)
if computeWithMC:
print("computing analytic results > 2d")
cls.E_ana = analysis.mean()
cls.V_ana = analysis.var()
cls.refSize = len(res)
# ----------------------------------------------
# write reference values to file
# ----------------------------------------------
analysis.writeMoments("results/%s/%s.mc" %
(cls.param_setting, cls.param_setting))
# write reference values to file
stats = {
'data': [[cls.E_ana[0]], [cls.E_ana[1]], [cls.V_ana[0]],
[cls.V_ana[1]]],
'names': ["mean", "meanError", "var", "varError"],
'filename':
"results/%s/%s.ref.moments.arff" %
(cls.param_setting, cls.param_setting)
}
writeDataARFF(stats)
print("-" * 60)
print("E(f) = %.14f, %g" % cls.E_ana)
print("V(f) = %.14f, %g" % cls.V_ana)
print("-" * 60)