def plotDensities(densities, functionName, out=False):
for setting, stats in list(densities.items()):
if setting != "nataf":
U = stats[0]["dist"]
if "kde" in setting:
label = r'$f_{\mathcal{S}_M}^{\kappa}(\xi_1, \xi_2)$'
if "gaussian" in setting:
title = "KDE (Gaussian)"
else:
title = "KDE (Epanechnikov)"
else:
label = r'$f_{\mathcal{I}}(\xi_1, \xi_2)$'
if "zero" in setting:
title = "SGDE (set-to-zero)"
else:
title = "SGDE (interp. bound.)"
fig = plt.figure()
plotDensity2d(U, color_bar_label=label)
plt.xlabel(r"$\xi_1$")
plt.ylabel(r"$\xi_2$")
xticks = np.arange(0, 1.2, 0.2)
plt.xticks(xticks, [str(xi) for xi in xticks])
plt.yticks(xticks, [str(xi) for xi in xticks])
plt.title(title, fontproperties=load_font_properties())
if out:
filename = os.path.join("plots",
"%s_%s" % (functionName, setting))
print(filename)
fig.set_size_inches(5.7, 5, forward=True)
savefig(fig, filename, tikz=True)
plt.close(fig)
if not out:
plt.show()
def plotGrid(grid, alpha, admissibleSet, params, refined=None):
gs = grid.getStorage()
T = params.getJointTransformation()
p = DataVector(2)
x = np.ndarray((gs.getSize(), 2))
for i in range(gs.getSize()):
gs.getCoordinates(gs.getPoint(i), p)
x[i, :] = T.unitToProbabilistic(p.array())
a = np.ndarray((gs.getSize(), 2))
for i, gp in enumerate(admissibleSet):
gs.getCoordinates(gp, p)
a[i, :] = T.unitToProbabilistic(p.array())
r = np.ndarray((len(refined), 2))
if refined:
for i, gpi in enumerate(refined):
gs.getCoordinates(gpi, p)
r[i, :] = T.unitToProbabilistic(p.array())
n = 50
U = params.getIndependentJointDistribution()
plotDensity2d(U)
# plot grid points
plt.plot(x[:, 0],
x[:, 1],
linestyle=' ',
marker='o',
color='g',
markersize=20) # grid
plt.plot(a[:, 0],
a[:, 1],
linestyle=' ',
marker='^',
color='y',
markersize=20) # admissible set
plt.plot(r[:, 0],
r[:, 1],
linestyle=' ',
marker='v',
color='r',
markersize=20) # refined points
plt.title("size = %i" % gs.getSize())
global myid
# plt.savefig("out_%i.jpg" % (myid))
# plt.close()
myid += 1
def estimateNatafDensity(functionName,
natafType,
testSamples=None,
iteration=0,
bounds=None,
plot=False,
out=True,
label="nataf"):
if "samples" in natafType:
trainSamples = natafType["samples"]
print("train: %i x %i (mean=%g, var=%g)" %
(trainSamples.shape[0], trainSamples.shape[1],
np.mean(trainSamples), np.var(trainSamples)))
if testSamples is not None:
print("test : %i x %i (mean=%g, var=%g)" %
(testSamples.shape[0], testSamples.shape[1],
np.mean(testSamples), np.var(testSamples)))
# -----------------------------------------------------------
if natafType["name"] == "samples":
natafDist = NatafDist.by_samples(natafType["samples"].T)
elif natafType["name"] == "gamma":
natafDist = NatafDist.gamma_marginals(natafType["alpha"],
natafType["beta"],
natafType["cov"], bounds)
elif natafType["name"] == "beta":
natafDist = NatafDist.beta_marginals(natafType["lwr"],
natafType["upr"],
natafType["alpha"],
natafType["beta"],
natafType["cov"], bounds)
elif natafType["name"] == "normal":
natafDist = NatafDist.normal_marginals(natafType["mean"],
natafType["stddev"],
natafType["cov"], bounds)
else:
raise AttributeError("nataf type '%s' is not supported" %
natafType["name"])
cvNataf = natafDist.crossEntropy(testSamples)
if plot and natafDist.getDim() == 2:
fig = plt.figure()
plotDensity2d(natafDist)
plt.title("log=%g" % cvNataf)
if out:
plt.tight_layout()
plt.savefig(
os.path.join(
pathResults,
"nataf_dist.%s.i%i.jpg" % (functionName, iteration)))
plt.savefig(
os.path.join(
pathResults,
"nataf_dist.%s.i%i.pdf" % (functionName, iteration)))
if out:
plt.close(fig)
else:
plt.show()
print("CV test = %g" % cvNataf)
# -----------------------------------------------------------
if out:
pathResults = os.path.join("data", label)
# serialize cross entropies
out_crossEntropies = os.path.join(
pathResults,
"nataf_cross_entropies.%s.i%i.csv" % (functionName, iteration))
fd = open(out_crossEntropies, 'wb')
file_writer = csv.writer(fd)
file_writer.writerow(["crossEntropy"])
file_writer.writerow([cvNataf])
fd.close()
# serialize samples
if "samples" in natafType:
np.savetxt(
os.path.join(
pathResults, "nataf_train_samples.%s.i%i.csv" %
(functionName, iteration)), trainSamples)
np.savetxt(
os.path.join(
pathResults,
"nataf_test_samples.%s.i%i.csv" % (functionName, iteration)),
testSamples)
if plot:
# plot density
fig = plt.figure()
plotDensity2d(natafDist)
plt.title("CV = %g" % (cvNataf, ))
plt.savefig(
os.path.join(
pathResults,
"nataf_pdf.%s.i%i.jpg" % (functionName, iteration)))
plt.close(fig)
# serialize best configuration to json
out_bestDist = os.path.join(
pathResults,
"nataf_best_config.%s.i%i.json" % (functionName, iteration))
text = natafDist.toJson()
fd = open(out_bestDist, "w")
fd.write(text)
fd.close()
# stats
stats = {
'config': {
'functionName': functionName,
'numDims': 2,
'label': label,
'cov': natafDist.cov(),
'iteration': iteration
},
'testSamples': testSamples,
'crossEntropyTestNataf': cvNataf,
'NatafDist_json': natafDist.toJson()
}
return natafDist, stats
def estimateKDEDensity(functionName,
trainSamples,
testSamples=None,
iteration=0,
plot=False,
out=True,
label="kde_gaussian",
bandwidthOptimizationTypeStr="rot"):
print("train: %i x %i (mean=%g, var=%g)" %
(trainSamples.shape[0], trainSamples.shape[1], np.mean(trainSamples),
np.var(trainSamples)))
if testSamples is not None:
print("test : %i x %i (mean=%g, var=%g)" %
(testSamples.shape[0], testSamples.shape[1],
np.mean(testSamples), np.var(testSamples)))
if "gaussian" in label:
kernelType = KernelType_GAUSSIAN
elif "epanechnikov" in label:
kernelType = KernelType_EPANECHNIKOV
else:
raise AttributeError("label is unknown")
bandwidthOptimizationType = strTobandwidthOptimizationType(
bandwidthOptimizationTypeStr)
kdeDist = KDEDist(trainSamples,
kernelType=kernelType,
bandwidthOptimizationType=bandwidthOptimizationType)
# -----------------------------------------------------------
cvKDE = kdeDist.crossEntropy(testSamples)
if plot and kdeDist.getDim() == 2:
fig = plt.figure()
plotDensity2d(kdeDist)
plt.title("log=%g" % cvKDE)
if out:
plt.tight_layout()
plt.savefig(
os.path.join(pathResults, "kde_dist.%s.i%i.jpg" %
(functionName, iteration)))
plt.savefig(
os.path.join(pathResults, "kde_dist.%s.i%i.pdf" %
(functionName, iteration)))
if out:
plt.close(fig)
else:
plt.show()
print("CV test = %g" % cvKDE)
# -----------------------------------------------------------
if out:
pathResults = os.path.join("data", label)
# serialize cross entropies
out_crossEntropies = os.path.join(
pathResults,
"kde_cross_entropies.%s.i%i.csv" % (functionName, iteration))
fd = open(out_crossEntropies, 'wb')
file_writer = csv.writer(fd)
file_writer.writerow(["crossEntropy"])
file_writer.writerow([cvKDE])
fd.close()
# serialize samples
np.savetxt(
os.path.join(
pathResults,
"kde_train_samples.%s.i%i.csv" % (functionName, iteration)),
trainSamples)
np.savetxt(
os.path.join(
pathResults,
"kde_test_samples.%s.i%i.csv" % (functionName, iteration)),
testSamples)
if plot:
# plot density
fig = plt.figure()
plotDensity2d(kdeDist)
plt.title("%s -> CV = %g" % (kdeDist.getBandwidths(), cvKDE))
plt.savefig(
os.path.join(pathResults,
"kde_pdf.%s.i%i.jpg" % (functionName, iteration)))
plt.close(fig)
# serialize best configuration to json
out_bestDist = os.path.join(
pathResults,
"kde_best_config.%s.i%i.json" % (functionName, iteration))
text = kdeDist.toJson()
fd = open(out_bestDist, "w")
fd.write(text)
fd.close()
# stats
stats = {
'config': {
'functionName': functionName,
'numDims': 2,
'label': label,
'bandwidth_optimization':
BandwidthOptimizationType_MAXIMUMLIKELIHOOD,
'kernelType': kernelType,
'iteration': iteration
},
'trainSamples': trainSamples,
'testSamples': testSamples,
'crossEntropyTrainKDE': kdeDist.crossEntropy(trainSamples),
'crossEntropyTestKDE': cvKDE,
'KDEDist_json': kdeDist.toJson()
}
return kdeDist, stats
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:
return -2.
def getBounds(self):
return [[0, 1], [0, 1]]
dist = myDist()
# plot analytic density
fig = plt.figure()
plotDensity2d(dist)
plt.title("analytic, KL = 0")
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
# get a sprse grid approximation
level = 6
grid = Grid.createLinearGrid(2)
grid.getGenerator().regular(level)
gs = grid.getStorage()
nodalValues = DataVector(grid.getSize())
p = DataVector(gs.getDimension())
for i in range(gs.getSize()):
gs.getCoordinates(gs.getPoint(i), p)
default="beta",
type=str,
help="marginals")
args = parser.parse_args()
if args.marginalType == "uniform":
marginal = Uniform(0, 1)
elif args.marginalType == "beta":
marginal = Beta(5, 10)
else:
marginal = Normal(0.5, 0.1, 0, 1)
# plot pdf
dist = J([marginal] * numDims)
fig = plt.figure()
plotDensity2d(dist)
savefig(fig, "/tmp/%s" % (args.marginalType, ))
plt.close(fig)
w = pysgpp.singleFunc(marginal.pdf)
grids = pysgpp.AbstractPointHierarchyVector()
grids.push_back(pysgpp.CombiHierarchies.linearLeja(w))
grids.push_back(pysgpp.CombiHierarchies.linearLeja(w))
evaluators = pysgpp.FloatScalarAbstractLinearEvaluatorVector()
evaluators.push_back(pysgpp.CombiEvaluators.polynomialInterpolation())
evaluators.push_back(pysgpp.CombiEvaluators.polynomialInterpolation())
# To create a CombigridOperation object with our own configuration, we have to provide a
# LevelManager as well: