def testProductCopula(self):
U = dists.J([dists.Uniform(0, 1), dists.Uniform(0, 1)])
self.assertEqual(U.mean(), 0.25)
self.assertEqual(U.var(), 1./9 - 1./16)
U = dists.J([dists.TNormal(0, 2, -5, 5)])
self.assertEqual(U.mean(), 0)
self.assertEqual(U.var(), 4)
U = dists.J([dists.TNormal(1, 2, -4, 6), dists.TNormal(2, 3, -3, 7)])
self.assertEqual(U.mean(), 2)
self.assertEqual(U.var(), 5. * 13. - 1. * 4.)
def test2DNormalDist(self):
# prepare data
U = dists.J(
[dists.Normal(2.0, .5, -1, 4),
dists.Normal(1.0, .5, -1, 3)])
U = dists.J(
[dists.Normal(0.5, .5, -1, 2),
dists.Normal(0.5, .4, -1, 2)])
np.random.seed(1234567)
trainSamples = U.rvs(300)
testSamples = U.rvs(1000)
# build parameter set
dist = SGDEdist.byLearnerSGDEConfig(
trainSamples,
config={
"grid_level": 5,
"grid_type": "modlinear",
"refinement_numSteps": 0,
"refinement_numPoints": 10,
"regularization_type": "Laplace",
"crossValidation_lambda": 0.000562341,
"crossValidation_enable": False,
"crossValidation_kfold": 5,
"crossValidation_silent": False,
"sgde_makePositive": False,
"sgde_makePositive_candidateSearchAlgorithm": "joined",
"sgde_makePositive_interpolationAlgorithm": "setToZero",
"sgde_makePositive_generateConsistentGrid": False,
"sgde_makePositive_verbose": True,
"sgde_unitIntegrand": True
},
bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(U)
fig.show()
fig = plt.figure()
plotSG2d(dist.grid,
dist.alpha,
addContour=True,
show_negative=True,
show_grid_points=True)
fig.show()
print("2d: mean = %g ~ %g" % (U.mean(), dist.mean()))
print("2d: var = %g ~ %g" % (U.var(), dist.var()))
plt.show()
print("KL = %g" % U.klDivergence(dist, testSamples, testSamples))
print("CE = %g" % dist.crossEntropy(testSamples))
print("MSE = %g" % dist.l2error(U, testSamples, testSamples))
def testDiscretization(self):
epsilon = 1e-14
U = dists.J([dists.Uniform(-1, 2), dists.Uniform(0, 3)])
_, error = U.discretize(level=1, hasBorder=True)
assert error < epsilon
epsilon = 1e-3
U = dists.J([dists.TNormal(0.5, 0.1, 0, 1)])
sgde, error = U.discretize(level=10)
assert error < epsilon
epsilon = 1e-1
U = dists.J([dists.TNormal(0.5, 0.1, 0, 1), dists.Beta(5, 10)])
_, error = U.discretize(10)
assert error < epsilon
def test2DNormalDist(self):
# prepare data
U = dists.J(
[dists.Normal(1.0, .1, 0, 2),
dists.Normal(0.5, .01, 0, 1)])
trainSamples = U.rvs(300)
testSamples = U.rvs(1000)
# build parameter set
dist = dists.KDEDist(trainSamples, bounds=U.getBounds())
samples = dist.rvs(1000, shuffle=True)
# fig = plt.figure()
# plotDensity2d(U)
# fig.show()
#
# fig = plt.figure()
# plotDensity2d(dist)
# plt.scatter(samples[:, 0], samples[:, 1])
# fig.show()
print("quad = %s" % (dblquad(lambda x, y: dist.pdf([x, y]), 0, 2,
lambda _: 0, lambda _: 1), ))
print("mean = %g ~ %g" % (U.mean(), dist.mean()))
print("var = %g ~ %g" % (U.var(), dist.var()))
print("KL = %g" % U.klDivergence(dist, testSamples, testSamples))
print("CE = %g" % dist.crossEntropy(testSamples))
print("MSE = %g" % dist.l2error(U, testSamples, testSamples))
plt.show()
def test_2DNormalDist_variance(self):
# prepare data
U = dists.J(
[dists.Normal(2.0, .5, -1, 4),
dists.Normal(1.0, .5, -1, 3)])
# U = dists.J([dists.Normal(0.5, .5, -1, 2),
# dists.Normal(0.5, .4, -1, 2)])
# define linear transformation
trans = JointTransformation()
for a, b in U.getBounds():
trans.add(LinearTransformation(a, b))
# get a sparse grid approximation
grid = Grid.createPolyGrid(U.getDim(), 10)
grid.getGenerator().regular(5)
gs = grid.getStorage()
# now refine adaptively 5 times
p = DataVector(gs.getDimension())
nodalValues = np.ndarray(gs.getSize())
# set function values in alpha
for i in range(gs.getSize()):
gs.getPoint(i).getStandardCoordinates(p)
nodalValues[i] = U.pdf(trans.unitToProbabilistic(p.array()))
# hierarchize
alpha = hierarchize(grid, nodalValues)
# # make positive
# alpha_vec = DataVector(alpha)
# createOperationMakePositive().makePositive(grid, alpha_vec)
# alpha = alpha_vec.array()
dist = SGDEdist(grid, alpha, bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(U)
fig.show()
fig = plt.figure()
plotSG2d(dist.grid,
dist.alpha,
addContour=True,
show_negative=True,
show_grid_points=True)
fig.show()
print("2d: mean = %g ~ %g" % (U.mean(), dist.mean()))
print("2d: var = %g ~ %g" % (U.var(), dist.var()))
plt.show()
def test2DNormalMoments(self):
mean = 0
var = 0.5
U = dists.J([dists.Normal(mean, var, -2, 2),
dists.Normal(mean, var, -2, 2)])
trainSamples = U.rvs(10000)
dist = KDEDist(trainSamples)
# -----------------------------------------------
self.assertTrue(np.abs(U.mean() - dist.mean()) < 1e-2, "KDE mean wrong")
self.assertTrue(np.abs(U.var() - dist.var()) < 1e-2, "KDE variance wrong")
def test2DPPF(self):
# prepare data
C = np.array([[0.1, 0.08], [0.08, 0.1]]) / 10.
U = dists.MultivariateNormal([0.5, 0.5], C, 0, 1)
train_samples = U.rvs(1000)
fig = plt.figure()
plotDensity2d(U)
plt.title('true density')
fig.show()
dist = SGDEdist.byLearnerSGDEConfig(train_samples,
config={
"grid_level": 5,
"grid_type": "linear",
"refinement_numSteps": 0,
"refinement_numPoints": 10,
"regularization_type":
"Laplace",
"crossValidation_lambda":
0.000562341,
"crossValidation_enable":
False,
"crossValidation_kfold": 5,
"crossValidation_silent": True
},
bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(dist)
plt.title('estimated SGDE density')
fig.show()
samples = dists.J([dists.Uniform(0, 1), dists.Uniform(0, 1)]).rvs(1000)
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('uniformly drawn samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
transformed_samples = dist.ppf(samples)
fig = plt.figure()
plt.plot(transformed_samples[:, 0], transformed_samples[:, 1], "o ")
plt.title('transformed samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
plt.show()
def test2DCDFandPPF(self):
# prepare data
C = np.array([[0.1, 0.08], [0.08, 0.1]]) / 10.
U = dists.MultivariateNormal([0.5, 0.5], C, 0, 1)
train_samples = U.rvs(1000)
fig = plt.figure()
plotDensity2d(U)
plt.title('true density')
fig.show()
dist = KDEDist(train_samples, bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(dist)
plt.title('estimated KDE density')
fig.show()
samples = dists.J([dists.Uniform(0, 1),
dists.Uniform(0, 1)]).rvs(1000)
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('u space')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
transformed_samples = dist.ppf(samples)
fig = plt.figure()
plt.plot(transformed_samples[:, 0], transformed_samples[:, 1], "o ")
plt.title('x space (transformed)')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
samples = dist.cdf(transformed_samples)
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('u space (transformed)')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
plt.show()
def tesst2DPPF(self):
# prepare data
numDims = 2
mean = 0.5
C = np.array([[0.1, 0.08], [0.08, 0.1]]) / 10.
stddev = np.sqrt(C[0, 0])
U = dists.MultivariateNormal(np.ones(numDims) * mean, C, 0, 1)
dist = NatafDist.normal_marginals(mean,
stddev,
C,
bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(U)
plt.title('true density')
fig.show()
fig = plt.figure()
plotDensity2d(dist)
plt.title('estimated Nataf density')
fig.show()
samples = dists.J([dists.Uniform(0, 1), dists.Uniform(0, 1)]).rvs(1000)
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('uniformly drawn samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
transformed_samples = dist.ppf(samples)
fig = plt.figure()
plt.plot(transformed_samples[:, 0], transformed_samples[:, 1], "o ")
plt.title('transformed samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
plt.show()
def test2DPPF(self):
# prepare data
C = np.array([[0.1, 0.08], [0.08, 0.1]]) / 10.
U = dists.MultivariateNormal([0.5, 0.5], C, 0, 1)
fig = plt.figure()
plotDensity2d(U)
plt.title('true density')
fig.show()
dist = KDEDist(U.rvs(1000),
kernelType=KernelType_EPANECHNIKOV,
bounds=U.getBounds())
fig = plt.figure()
plotDensity2d(dist)
plt.title('estimated KDE density')
fig.show()
samples = dists.J([dists.Uniform(0, 1),
dists.Uniform(0, 1)]).rvs(1000)
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('uniformly drawn samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
transformed_samples = dist.ppf(samples)
fig = plt.figure()
plt.plot(transformed_samples[:, 0], transformed_samples[:, 1], "o ")
plt.title('transformed samples')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
plt.show()
def test2DCDFandPPF(self, plot=True):
# prepare data
C = np.array([[0.1, 0.08], [0.08, 0.1]]) / 10.
U = dists.MultivariateNormal([0.5, 0.5], C, 0, 1)
train_samples = U.rvs(1000)
if plot:
fig = plt.figure()
plotDensity2d(U)
plt.title('true density')
fig.show()
dist = SGDEdist.byLearnerSGDEConfig(train_samples,
config={
"grid_level": 5,
"grid_type":
"polyClenshawCurtis",
"refinement_numSteps": 0,
"refinement_numPoints": 10,
"regularization_type":
"Laplace",
"crossValidation_lambda":
0.000562341,
"crossValidation_enable":
False,
"crossValidation_kfold": 5,
"crossValidation_silent": True,
"sgde_makePositive": False
},
bounds=U.getBounds())
if plot:
fig = plt.figure()
plotDensity2d(dist)
plt.title('estimated SGDE density')
fig.show()
samples = dists.J([dists.Uniform(0, 1), dists.Uniform(0, 1)]).rvs(500)
if plot:
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('u space')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
else:
print("-" * 80)
print(samples)
transformed_samples = dist.ppf(samples, shuffle=False)
if plot:
fig = plt.figure()
plt.plot(transformed_samples[:, 0], transformed_samples[:, 1],
"o ")
plt.title('x space (transformed)')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
else:
print("-" * 80)
print(transformed_samples)
samples = dist.cdf(transformed_samples, shuffle=False)
if plot:
fig = plt.figure()
plt.plot(samples[:, 0], samples[:, 1], "o ")
plt.title('u space (transformed)')
plt.xlim(0, 1)
plt.ylim(0, 1)
fig.show()
plt.show()
else:
print("-" * 80)
print(samples)
def test2DNormalMoments(self):
mean = 0
var = 0.5
U = dists.J(
[dists.Normal(mean, var, -2, 2),
dists.Normal(mean, var, -2, 2)])
np.random.seed(1234567)
trainSamples = U.rvs(1000)
dist = SGDEdist.byLearnerSGDEConfig(trainSamples,
config={
"grid_level": 5,
"grid_type": "linear",
"refinement_numSteps": 0,
"refinement_numPoints": 10,
"regularization_type":
"Laplace",
"crossValidation_lambda":
0.000562341,
"crossValidation_enable":
False,
"crossValidation_kfold": 5,
"crossValidation_silent": True,
"sgde_makePositive": True
},
bounds=U.getBounds())
samples_dist = dist.rvs(1000, shuffle=True)
kde = KDEDist(trainSamples)
samples_kde = kde.rvs(1000, shuffle=True)
# -----------------------------------------------
self.assertTrue(
np.abs(U.mean() - dist.mean()) < 1e-2, "SGDE mean wrong")
self.assertTrue(
np.abs(U.var() - dist.var()) < 4e-2, "SGDE variance wrong")
# -----------------------------------------------
# print the results
print("E(x) ~ %g ~ %g" % (kde.mean(), dist.mean()))
print("V(x) ~ %g ~ %g" % (kde.var(), dist.var()))
print(
"log ~ %g ~ %g" %
(kde.crossEntropy(trainSamples), dist.crossEntropy(trainSamples)))
print("-" * 60)
print(dist.cov())
print(kde.cov())
sgde_x1 = dist.marginalizeToDimX(0)
kde_x1 = kde.marginalizeToDimX(0)
plt.figure()
plotDensity1d(U.getDistributions()[0], label="analytic")
plotDensity1d(sgde_x1, label="sgde")
plotDensity1d(kde_x1, label="kde")
plt.title("mean: sgde=%g, kde=%g; var: sgde=%g, kde=%g" %
(sgde_x1.mean(), kde_x1.mean(), sgde_x1.var(), kde_x1.var()))
plt.legend()
fig = plt.figure()
plotDensity2d(U, addContour=True)
plt.title("analytic")
fig = plt.figure()
plotDensity2d(kde, addContour=True)
plt.scatter(samples_kde[:, 0], samples_kde[:, 1])
plt.title("kde")
fig = plt.figure()
plotDensity2d(dist, addContour=True)
plt.scatter(samples_dist[:, 0], samples_dist[:, 1])
plt.title(
"sgde (I(f) = %g)" %
(np.prod(U.getBounds()) * doQuadrature(dist.grid, dist.alpha), ))
plt.show()
def test_sgdeLaplace():
l2_samples = 10000
# sample_range = np.arange(10, 500, 50)
sample_range = [10, 20, 50, 100, 200, 500]
points = {}
grids = ["linear",
"modlinear", # keine OperationQuadrature
"poly",
"modpoly",
"polyBoundary",
"polyClenshawCurtis",
"modPolyClenshawCurtis",
"polyClenshawCurtisBoundary",
"bsplineClenshawCurtis",
"modBsplineClenshawCurtis" # keine OperationMultipleEval
]
U = dists.J([dists.Lognormal.by_alpha(0.5, 0.1, 0.001),
dists.Lognormal.by_alpha(0.5, 0.1, 0.001)])
l2_errors = {}
for grid in grids:
l2_errors[grid] = []
points[grid] = []
l2_errors["kde"] = []
samples = 1000
for samples in sample_range:
# for lvl in range(5, 6):
trainSamples = U.rvs(samples)
# testSamples = U.rvs(l2_samples)
for grid_name in grids:
# build parameter set
print("--------------------Samples: {} Grid: {}--------------------".format(samples, grid_name))
dist_sgde = SGDEdist.byLearnerSGDEConfig(trainSamples,
bounds=U.getBounds(),
unitIntegrand=True,
config={"grid_level": 1,
"grid_type": grid_name,
"grid_maxDegree": 6,
"refinement_numSteps": 0,
"refinement_numPoints": 10,
"solver_threshold": 1e-10,
"solver_verbose": False,
"regularization_type": "Laplace",
"crossValidation_lambda": 1e-6,
"crossValidation_enable": True,
"crossValidation_kfold": 4,
"crossValidation_lambdaSteps": 10,
"crossValidation_silent": False})
points[grid_name].append(dist_sgde.grid.getSize())
# l2_errors[grid_name].append(dist_sgde.l2error(U, testSamplesUnit=testSamples))
l2_errors[grid_name].append(dist_sgde.l2error(U, n=l2_samples))
# plt.figure()
# plotDensity2d(U, levels=(10, 20, 40, 50, 60))
# plt.figure()
# plotDensity2d(dist_sgde, levels=(10, 20, 40, 50, 60))
# plt.show()
dist_kde = dists.KDEDist(trainSamples,
kernelType=KernelType_GAUSSIAN,
bandwidthOptimizationType=BandwidthOptimizationType_SILVERMANSRULE)
l2_errors["kde"].append(dist_kde.l2error(U, testSamplesUnit=testSamples))
for grid_name in grids:
plt.plot(sample_range, l2_errors[grid_name], label=grid_name)
# plt.plot(points[grid], l2_errors[grid_name],".-", label=grid_name)
plt.plot(sample_range, l2_errors["kde"], label="KDE")
# plt.plot([x for x in range(1,300, 100)], [l2_errors["kde"][0] for i in range(1,4)], label="KDE")
plt.xlabel("# Gitterpunkte")
plt.ylabel("L2-Fehler")
plt.yscale("log")
plt.legend()
plt.show()
