def getFirstOrderAsymptoticDistribution(self):
indicesFO = self.getAggregatedFirstOrderIndices()
varianceFO, varianceTO = self.computeVariance()
foDist = ot.DistributionCollection(self.input_dim)
for p in range(self.input_dim):
foDist[p] = ot.Normal(indicesFO[p], np.sqrt(varianceFO[p]))
return foDist
def setInputRandomVector(inList):
#setting the input random vector X
myCollection = ot.DistributionCollection(len(inList))
for index in range(len(inList)):
myCollection[index] = ot.Distribution(inList[index])
myDistribution = ot.ComposedDistribution(myCollection)
VectX = ot.RandomVector(ot.Distribution(myDistribution))
return myDistribution, VectX
def __init__(self, monteCarloResult, distribution, deltas):
# the monte carlo result must have its underlying function with
# the history enabled because the failure sample is obtained using it
self._monteCarloResult = monteCarloResult
self.function = ot.MemoizeFunction(
self._monteCarloResult.getEvent().getFunction())
if self.function.getOutputHistory().getSize() == 0:
raise AttributeError("The performance function of the Monte Carlo "+\
"simulation result should be a MemoizeFunction.")
# the original distribution
if distribution.hasIndependentCopula():
self._distribution = distribution
else:
raise Exception(
"The distribution must have an independent copula.")
self._dim = self._distribution.getDimension()
# the 1d or 2d sequence of deltas
self._originalDelta = np.vstack(np.array(deltas))
self._deltaValues = self._originalDelta.copy()
self._deltaSize = self._deltaValues.shape[0]
if self._deltaValues.shape[1] != 1 and self._deltaValues.shape[
1] != self._dim:
raise AttributeError('The deltas parameter must be 1d sequence of ' + \
'float or 2d sequence of float of dimension ' +\
'equal to {}.'.format(self._dim))
# check if the delta values have only one dimension -> copy the columns
if self._deltaValues.shape[1] == 1:
self._deltaValues = np.ones((self._deltaValues.shape[0], self._dim)) * \
self._deltaValues
# initialize array result
# rows : delta
# columns : maginal
self._pfdelta = np.zeros((self._deltaSize, self._dim))
self._varPfdelta = np.zeros((self._deltaSize, self._dim))
self._indices = np.zeros((self._deltaSize, self._dim))
# for loop to avoid copy id of the distribution collection
self._estimatorDist = [
ot.DistributionCollection(self._dim)
for i in range(self._deltaSize)
]
# set the gaus Kronrod algorithm
self._gaussKronrod = ot.GaussKronrod(
50, 1e-5, ot.GaussKronrodRule(ot.GaussKronrodRule.G7K15))
def GenerateExperiencePlan(paras_range=paras_ris_range, n_sample=50000):
"""
"""
for k, v in paras_range.items():
assert v[0] < v[1], 'ERROR of v[0]>=v[1] for ranges {}'.format(k)
# le nombre de paramètre doit être proportionné au dimension de ranges
len_actual_parameters = len(paras_range)
# Specify the input random vector.
# instance de classe densite de proba a definir
myCollection = ot.DistributionCollection(len_actual_parameters)
for i, p_name in enumerate(paras_range):
distribution = ot.Uniform(paras_range[p_name][0],
paras_range[p_name][1])
myCollection[i] = ot.Distribution(distribution)
myDistribution = ot.ComposedDistribution(myCollection)
vectX = ot.RandomVector(ot.Distribution(myDistribution))
# Sample the input random vector.
Xsample = GenerateSample(vectX, n_sample, method='QMC')
xsample = np.array(Xsample)
return xsample
distribution_J3 = ot.Normal(mu_J, sigma_J) distribution_J4 = ot.Normal(mu_J, sigma_J) # Précharge : Delta_P = 0.025 mu_P = 0.045 sigma_P = Delta_P/6 distribution_P1 = ot.Normal(mu_P, sigma_P) distribution_P2 = ot.Normal(mu_P, sigma_P) distribution_P3 = ot.Normal(mu_P, sigma_P) distribution_P4 = ot.Normal(mu_P, sigma_P) # Création de la collection des distributions d'entrées myCollection = ot.DistributionCollection(dim) myCollection[0] = distribution_Dx1 myCollection[1] = distribution_Dx2 myCollection[2] = distribution_Dx3 myCollection[3] = distribution_Dx4 myCollection[4] = distribution_Dy1 myCollection[5] = distribution_Dy2 myCollection[6] = distribution_Dy3 myCollection[7] = distribution_Dy4 myCollection[8] = distribution_J1 myCollection[9] = distribution_J2 myCollection[10] = distribution_J3 myCollection[11] = distribution_J4 myCollection[12] = distribution_P1 myCollection[13] = distribution_P2 myCollection[14] = distribution_P3
ot.TESTPREAMBLE()
# Instantiate one distribution object
dimension = 3
meanPoint = ot.Point(dimension, 1.0)
meanPoint[0] = 0.5
meanPoint[1] = -0.5
sigma = ot.Point(dimension, 1.0)
sigma[0] = 2.0
sigma[1] = 3.0
R = ot.CorrelationMatrix(dimension)
for i in range(1, dimension):
R[i, i - 1] = 0.5
# Create a collection of distribution
aCollection = ot.DistributionCollection()
aCollection.add(ot.Normal(meanPoint, sigma, R))
meanPoint += ot.Point(meanPoint.getDimension(), 1.0)
aCollection.add(ot.Normal(meanPoint, sigma, R))
meanPoint += ot.Point(meanPoint.getDimension(), 1.0)
aCollection.add(ot.Normal(meanPoint, sigma, R))
# Instantiate one distribution object
distribution = ot.Mixture(aCollection, ot.Point(aCollection.getSize(), 2.0))
print("Distribution ", repr(distribution))
print("Weights = ", repr(distribution.getWeights()))
weights = distribution.getWeights()
weights[0] = 2.0 * weights[0]
distribution.setWeights(weights)
print("After update, new weights = ", repr(distribution.getWeights()))
Zb = 55.5 # m
S = Zv + (Q / (Ks * B * m.sqrt((Zm - Zv) / L)))**(3. / 5) - (Hd + Zb)
return [S]
function = ot.PythonFunction(dim, 1, flood_model)
Q_law = ot.TruncatedDistribution(
ot.Gumbel(1. / 558., 1013., ot.Gumbel.ALPHABETA), 0.,
ot.TruncatedDistribution.LOWER)
# alpha=1/b, beta=a | you can use Gumbel(a, b, Gumbel.AB) starting from OT 1.2
Ks_law = ot.TruncatedDistribution(ot.Normal(30.0, 7.5), 0.,
ot.TruncatedDistribution.LOWER)
Zv_law = ot.Triangular(49., 50., 51.)
Zm_law = ot.Triangular(54., 55., 56.)
coll = ot.DistributionCollection([Q_law, Ks_law, Zv_law, Zm_law])
distribution = ot.ComposedDistribution(coll)
x = list(map(lambda dist: dist.computeQuantile(0.5)[0], coll))
fx = function(x)
for k in [0.0, 2.0, 5.0, 8.][0:1]:
randomVector = ot.RandomVector(distribution)
composite = ot.RandomVector(function, randomVector)
print('--------------------')
print('model flood S <', k, 'gamma=', end=' ')
print('f(', ot.NumericalPoint(x), ')=', fx)
event = ot.Event(composite, ot.Greater(), k)
for n in [100, 1000, 5000][1:2]:
# Configure the optimization solver
# ---------------------------------
# %%
# The following example checks the robustness of the optimization of the kriging algorithm with respect to the optimization of the likelihood function in the covariance model parameters estimation. We use a `MultiStart` algorithm in order to avoid to be trapped by a local minimum. Furthermore, we generate the design of experiments using a `LHSExperiments`, which guarantees that the points will fill the space.
# %%
sampleSize_train = 10
X_train = myDistribution.getSample(sampleSize_train)
Y_train = model(X_train)
# %%
# First, we create a multivariate distribution, based on independent `Uniform` marginals which have the bounds required by the covariance model.
# %%
distributions = ot.DistributionCollection()
for i in range(dim):
distributions.add(ot.Uniform(lbounds[i], ubounds[i]))
boundedDistribution = ot.ComposedDistribution(distributions)
# %%
# We first generate a Latin Hypercube Sampling (LHS) design made of 25 points in the sample space. This LHS is optimized so as to fill the space.
# %%
K = 25 # design size
LHS = ot.LHSExperiment(boundedDistribution, K)
LHS.setAlwaysShuffle(True)
SA_profile = ot.GeometricProfile(10., 0.95, 20000)
LHS_optimization_algo = ot.SimulatedAnnealingLHS(LHS, SA_profile, ot.SpaceFillingC2())
LHS_optimization_algo.generate()
LHS_design = LHS_optimization_algo.getResult()
ot.TESTPREAMBLE()
# Instantiate one distribution object
dim = 2
meanPoint = [0.5, -0.5]
sigma = [2.0, 3.0]
R = ot.CorrelationMatrix(dim)
for i in range(1, dim):
R[i, i - 1] = 0.5
distribution = ot.Normal(meanPoint, sigma, R)
discretization = 100
kernel = ot.KernelSmoothing()
sample = distribution.getSample(discretization)
kernels = ot.DistributionCollection(0)
kernels.add(ot.Normal())
kernels.add(ot.Epanechnikov())
kernels.add(ot.Uniform())
kernels.add(ot.Triangular())
kernels.add(ot.Logistic())
kernels.add(ot.Beta(2.0, 2.0, -1.0, 1.0))
kernels.add(ot.Beta(3.0, 3.0, -1.0, 1.0))
meanExact = distribution.getMean()
covarianceExact = distribution.getCovariance()
for i in range(kernels.getSize()):
kernel = kernels[i]
print("kernel=", kernel.getName())
smoother = ot.KernelSmoothing(kernel)
smoothed = smoother.build(sample)
bw = smoother.getBandwidth()
cstride=1,
cmap=pl.matplotlib.cm.jet)
ax.set_xlabel('$x_1$')
ax.set_ylabel('$x_2$')
ax.set_zlabel('$\\varphi_i(\mathbf{x})$')
pl.savefig('2D_identification_eigensolution_%d.png' % i)
pl.close()
# Calculation of the KL coefficients by functional projection using
# Gauss-Legendre quadrature
xi = estimated_random_field.compute_coefficients(sample_paths)
# Statistical inference of the KL coefficients' distribution
kernel_smoothing = ot.KernelSmoothing(ot.Normal())
xi_marginal_distributions = ot.DistributionCollection([
kernel_smoothing.build(xi[:, i][:, np.newaxis])
for i in xrange(truncation_order)
])
try:
xi_copula = ot.NormalCopulaFactory().build(xi)
except RuntimeError:
print('ERR: The normal copula correlation matrix built from the given\n' +
'Spearman correlation matrix is not definite positive.\n' +
'This would require expert judgement on the correlation\n' +
'coefficients significance (using e.g. Spearman test).\n' +
'Assuming an independent copula in the sequel...')
xi_copula = ot.IndependentCopula(truncation_order)
xi_estimated_distribution = ot.ComposedDistribution(xi_marginal_distributions,
xi_copula)
# Matrix plot of the empirical KL coefficients & their estimated distribution
matrix_plot(xi,
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
ot.RandomGenerator.SetSeed(0)
# Generate sample with the given plane
distribution = ot.ComposedDistribution(
ot.DistributionCollection(
[ot.Exponential(), ot.Triangular(-1.0, -0.5, 1.0)]))
marginalDegrees = ot.Indices([3, 6])
myPlane = ot.GaussProductExperiment(ot.Distribution(distribution),
marginalDegrees)
sample = myPlane.generate()
# Create an empty graph
graph = ot.Graph("", "x1", "x2", True, "")
# Create the cloud
cloud = ot.Cloud(sample, "blue", "fsquare", "")
# Then, draw it
graph.add(cloud)
fig = plt.figure(figsize=(4, 4))
plt.suptitle("Gauss product experiment")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
View(graph, figure=fig, axes=[axis], add_legend=False)
#! /usr/bin/env python
import openturns as ot
ot.TESTPREAMBLE()
# Instantiate one distribution object
dimension = 3
meanPoint = ot.Point([0.5, -0.5, 1])
sigma = [2, 3, 1]
sample = ot.Sample(0, dimension)
# Create a collection of distribution
aCollection = ot.DistributionCollection()
aCollection.add(ot.Normal(meanPoint, sigma, ot.IdentityMatrix(dimension)))
sample.add(meanPoint)
meanPoint += [1.0] * dimension
aCollection.add(ot.Normal(meanPoint, sigma, ot.IdentityMatrix(dimension)))
sample.add(meanPoint)
meanPoint += [1.0] * dimension
aCollection.add(ot.Normal(meanPoint, sigma, ot.IdentityMatrix(dimension)))
sample.add(meanPoint)
# Instantiate one distribution object
distribution = ot.KernelMixture(ot.Normal(), sigma, sample)
print("Distribution ", repr(distribution))
print("Distribution ", distribution)
distributionRef = ot.Mixture(aCollection)
# Is this distribution elliptical ?
#! /usr/bin/env python from __future__ import print_function import openturns as ot from math import fabs import openturns.testing as ott ot.TESTPREAMBLE() ot.RandomGenerator.SetSeed(0) continuousDistributionCollection = ot.DistributionCollection() discreteDistributionCollection = ot.DistributionCollection() distributionCollection = ot.DistributionCollection() beta = ot.Beta(2.0, 1.0, 0.0, 1.0) distributionCollection.add(beta) continuousDistributionCollection.add(beta) gamma = ot.Gamma(1.0, 2.0, 3.0) distributionCollection.add(gamma) continuousDistributionCollection.add(gamma) gumbel = ot.Gumbel(1.0, 2.0) distributionCollection.add(gumbel) continuousDistributionCollection.add(gumbel) lognormal = ot.LogNormal(1.0, 1.0, 2.0) distributionCollection.add(lognormal) continuousDistributionCollection.add(lognormal) logistic = ot.Logistic(1.0, 1.0)
print("kurtosis =", kurtosis)
print("kurtosis (ref)=", distributionReference.getKurtosis())
covariance = distribution.getCovariance()
print("covariance =", covariance)
print("covariance (ref)=", distributionReference.getCovariance())
parameters = distribution.getParametersCollection()
print("parameters=", parameters)
print("Standard representative=", distribution.getStandardRepresentative())
print("blockMin=", distribution.getBlockMin())
print("blockMax=", distribution.getBlockMax())
print("maxSize=", distribution.getMaxSize())
print("alpha=", distribution.getAlpha())
print("beta=", distribution.getBeta())
# Tests of the simplification mechanism
weights = ot.Point(0)
coll = ot.DistributionCollection(0)
coll.add(ot.Dirac(0.5))
weights.add(1.0)
coll.add(ot.Normal(1.0, 2.0))
weights.add(2.0)
coll.add(ot.Normal(2.0, 1.0))
weights.add(-3.0)
coll.add(ot.Uniform(-2.0, 2.0))
weights.add(-1.0)
coll.add(ot.Uniform(2.0, 4.0))
weights.add(2.0)
coll.add(ot.Exponential(2.0, -3.0))
weights.add(1.5)
rm = ot.RandomMixture(coll, weights)
coll.add(rm)
weights.add(-2.5)
sys.exit()
return model
#§ 2. Random vector definition
# Create the marginal distributions of the input random vector
dict_distribution = {
"PARE0":ot.Normal(7032392.1, 20700.0),
"QARE0":ot.Normal(2142.972222, 8.5),
"TARE0":ot.Normal(500.2497543, 3.0),
"QGSS0":ot.Normal(183.713226, 0.75),
"QGRE0":ot.Normal(1922.331218, 8.5),
"PGCT0":ot.Normal(6.54e6, 6.40e4),
}
# Create the input probability distribution
collectionMarginals = ot.DistributionCollection()
for distribution in list(dict_distribution.values()):
collectionMarginals.add(ot.Distribution(distribution))
inputDistribution = ot.ComposedDistribution(collectionMarginals)
# Give a description of each component of the input distribution
inputDistribution.setDescription(list(dict_distribution.keys()))
inputRandomVector = ot.RandomVector(inputDistribution)
#§
def run_demo(with_initialization_script, seed=None, n_simulation=None):
"""Run the demonstration
Parameters
----------
# Posterior for mu: E(mu|y)=w*y_mean+(1-w)*mu0, and Var(mu|y)=w*(sigmay^2)/n # => weighted average of the prior an the sample mean # with w = n*sigma0^2 / (n*sigma0^2 + sigma^2) # Log::Show(Log::ALL) # observations size = 10 realDist = ot.Normal(31., 1.2) data = realDist.getSample(size) # calibration parameters calibrationColl = [ot.CalibrationStrategy()] * 2 # proposal distribution proposalColl = ot.DistributionCollection() mean_proposal = ot.Uniform(-2.0, 2.0) std_proposal = ot.Uniform(-2.0, 2.0) proposalColl.add(mean_proposal) proposalColl.add(std_proposal) # prior distribution mu0 = 25. sigma0s = [0.1, 1.0] # sigma0s.append(2.0) # play with the variance of the prior: # if the prior variance is low (information concernig the mu parameter is strong) # then the posterior mean will be equal to the prior mean # if large, the the posterior distribution is equivalent to the
