def test_ProcessHDRAlgorithmPC1(self):
# With 1 principal component
setup_HDRenv()
# Dataset
fname = os.path.join(othdr.__path__[0], "..", "tests", "data",
"npfda-elnino.dat")
processSample = readProcessSample(fname)
# Customize the dimension reduction
reduction = othdr.KarhunenLoeveDimensionReductionAlgorithm(
processSample, 1)
reduction.run()
reducedComponents = reduction.getReducedComponents()
# Distribution fit in reduced space
ks = ot.KernelSmoothing()
reducedDistribution = ks.build(reducedComponents)
# Check higher dimension
hdr = othdr.ProcessHighDensityRegionAlgorithm(processSample,
reducedComponents,
reducedDistribution,
[0.1, 0.6])
hdr.run()
# Plot outlier trajectories
graph = hdr.draw(drawInliers=True, discreteMean=True)
otv.View(graph)
graph = hdr.draw(bounds=False)
otv.View(graph)
return
def draw_pressure(graph, pressure):
print("Build and draw pressure distribution")
t0 = time()
dist_stationary_pressure = ot.KernelSmoothing(ot.Normal(), False, 1000000,
True).build(pressure)
print("t=", time() - t0, "s")
graph.add(dist_stationary_pressure.drawPDF())
def define_distribution():
"""
Define the distribution of the training example (beam).
Return a ComposedDistribution object from openTURNS
"""
sample_E = ot.Sample.ImportFromCSVFile("sample_E.csv")
kernel_smoothing = ot.KernelSmoothing(ot.Normal())
bandwidth = kernel_smoothing.computeSilvermanBandwidth(sample_E)
E = kernel_smoothing.build(sample_E, bandwidth)
E.setDescription(['Young modulus'])
F = ot.LogNormal()
F.setParameter(ot.LogNormalMuSigma()([30000, 9000, 15000]))
F.setDescription(['Load'])
L = ot.Uniform(250, 260)
L.setDescription(['Length'])
I = ot.Beta(2.5, 4, 310, 450)
I.setDescription(['Inertia'])
marginal_distributions = [F, E, L, I]
SR_cor = ot.CorrelationMatrix(len(marginal_distributions))
SR_cor[2, 3] = -0.2
copula = ot.NormalCopula(ot.NormalCopula.GetCorrelationFromSpearmanCorrelation(SR_cor))
return(ot.ComposedDistribution(marginal_distributions, copula))
def test_HighDensityRegionAlgorithm1D(self):
# With 1D
ot.RandomGenerator.SetSeed(0)
numberOfPointsForSampling = 500
ot.ResourceMap.SetAsBool("Distribution-MinimumVolumeLevelSetBySampling", True)
ot.ResourceMap.Set(
"Distribution-MinimumVolumeLevelSetSamplingSize",
str(numberOfPointsForSampling),
)
# Dataset
ot.RandomGenerator_SetSeed(1976)
sample = ot.Normal().getSample(100)
# Creation du kernel smoothing
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
dp = othdr.HighDensityRegionAlgorithm(sample, distribution)
dp.run()
# Draw contour/inliers/outliers
otv.View(dp.draw())
otv.View(dp.draw(drawInliers=True))
otv.View(dp.draw(drawOutliers=False))
outlierIndices = dp.computeIndices()
expected_outlierIndices = [16, 24, 33, 49, 71, 84]
assert_equal(outlierIndices, expected_outlierIndices)
def test_SquaredExponential(self):
# With 2 principal components
setup_HDRenv()
# Test with no outlier in the band
xmin = 0.0
step = 0.1
n = 100
timeGrid = ot.RegularGrid(xmin, step, n + 1)
amplitude = [7.0]
scale = [1.5]
covarianceModel = ot.SquaredExponential(scale, amplitude)
process = ot.GaussianProcess(covarianceModel, timeGrid)
nbTrajectories = 50
processSample = process.getSample(nbTrajectories)
# KL decomposition
reduction = othdr.KarhunenLoeveDimensionReductionAlgorithm(
processSample, 2)
reduction.run()
reducedComponents = reduction.getReducedComponents()
# Distribution fit in reduced space
ks = ot.KernelSmoothing()
reducedDistribution = ks.build(reducedComponents)
hdr = othdr.ProcessHighDensityRegionAlgorithm(processSample,
reducedComponents,
reducedDistribution,
[0.95, 0.5])
hdr.run()
graph = hdr.draw()
otv.View(graph)
def CBN_PC(data, result_structure_path):
print("CBN with PC")
skeleton_path = result_structure_path.joinpath("skeleton")
skeleton_path.mkdir(parents=True, exist_ok=True)
pdag_path = result_structure_path.joinpath("pdag")
pdag_path.mkdir(parents=True, exist_ok=True)
dag_path = result_structure_path.joinpath("dag")
dag_path.mkdir(parents=True, exist_ok=True)
skeleton_file_name = "skeleton_" + str(size).zfill(7) + ".dot"
skeleton_done = skeleton_path.joinpath(skeleton_file_name).exists()
pdag_file_name = "pdag_" + str(size).zfill(7) + ".dot"
pdag_done = pdag_path.joinpath(pdag_file_name).exists()
dag_file_name = "dag_" + str(size).zfill(7) + ".dot"
dag_done = dag_path.joinpath(dag_file_name).exists()
alpha = 0.01
conditioningSet = 4
learner = otagr.ContinuousPC(data, conditioningSet, alpha)
learner.setVerbosity(True)
if not skeleton_done:
skel = learner.learnSkeleton()
gu.write_graph(
skel,
skeleton_path.joinpath("skeleton_" + str(size).zfill(7) + ".dot"))
if not pdag_done:
pdag = learner.learnPDAG()
gu.write_graph(
pdag, pdag_path.joinpath("pdag_" + str(size).zfill(7) + ".dot"))
if not dag_done:
dag = learner.learnDAG()
gu.write_graph(dag,
dag_path.joinpath("dag_" + str(size).zfill(7) + ".dot"))
else:
dag, names = gu.read_graph(
dag_path.joinpath("dag_" + str(size).zfill(7) + ".dot"))
dag = otagr.NamedDAG(dag, names)
print("Learning parameters")
factories = [
ot.KernelSmoothing(ot.Epanechnikov()),
ot.BernsteinCopulaFactory()
]
ot.Log.SetFile("log")
ot.Log.Show(ot.Log.INFO)
model = otagr.ContinuousBayesianNetworkFactory(factories, dag, alpha,
conditioningSet,
False).build(data)
ot.Log.Show(ot.Log.INFO)
return model
def KS_learning(data):
# Naive estimation of the coefficients distribution using
# a multivariate kernel smoothing
print("Build KS coefficients distribution")
t0 = time()
distribution = ot.KernelSmoothing().build(data)
print("t=", time() - t0, "s")
return distribution
def kernel_fit_distribution(sample):
var = sample[:, 0]
#Define the type of kernel
kernel_distribution = ot.Epanechnikov()
# Estimate Kernel Smoothing marginals
kernel_function = ot.KernelSmoothing(kernel_distribution)
kernel_distribution = kernel_function.build(var)
return kernel_distribution
def ot_kernel_copula_fit(Pared):
kernel_distribution = ot.Epanechnikov()
sample_Pared = ot.Sample(Pared)
marginals = ot_kernel_Marginals(sample_Pared)
KernelSmoothing_copula_distribution = ot.KernelSmoothing(
kernel_distribution).build(sample_Pared).getCopula()
bivariate_distribution = ot.ComposedDistribution(
marginals, KernelSmoothing_copula_distribution)
return bivariate_distribution
def test_DrawUnivariateSampleDistribution(self):
sample = ot.Normal().getSample(500)
# Distribution fit in reduced space
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
graph = othdr.DrawUnivariateSampleDistribution(sample, distribution)
otv.View(graph)
return
def _drawResiduals1Dimension(self, outputObservations, outputAtPrior,
outputAtPosterior, observationsError):
"""
Plot the distribution of the residuals and
the distribution of the observation errors.
Can manage only 1D samples.
"""
ydescription = outputObservations.getDescription()
xlabel = "%s Residuals" % (ydescription[0])
graph = ot.Graph("Residuals analysis", xlabel,
"Probability distribution function", True, "topright")
yDim = outputObservations.getDimension()
yPriorDim = outputAtPrior.getDimension()
yPosteriorDim = outputAtPrior.getDimension()
if (yDim == 1) and (yPriorDim == 1):
posteriorResiduals = outputObservations - outputAtPrior
kernel = ot.KernelSmoothing()
fittedDist = kernel.build(posteriorResiduals)
residualPDF = fittedDist.drawPDF()
residualPDF.setColors([self.priorColor])
residualPDF.setLegends(["Prior"])
graph.add(residualPDF)
else:
raise TypeError('Output prior observations are not 1D.')
if (yDim == 1) and (yPosteriorDim == 1):
posteriorResiduals = outputObservations - outputAtPosterior
kernel = ot.KernelSmoothing()
fittedDist = kernel.build(posteriorResiduals)
residualPDF = fittedDist.drawPDF()
residualPDF.setColors([self.posteriorColor])
residualPDF.setLegends(["Posterior"])
graph.add(residualPDF)
else:
raise TypeError('Output posterior observations are not 1D.')
# Plot the distribution of the observation errors
if (observationsError.getDimension() == 1):
# In the other case, we just do not plot
obserrgraph = observationsError.drawPDF()
obserrgraph.setColors([self.observationColor])
obserrgraph.setLegends(["Observation errors"])
graph.add(obserrgraph)
return graph
def runKS(self):
# Create kernel smoothing
myks = ot.KernelSmoothing()
principalComponentsSample = ot.Sample(self.principalComponents)
sampleDistribution = myks.build(principalComponentsSample)
# Create DensityPlot
self.densityPlot = HighDensityRegionAlgorithm(
principalComponentsSample, sampleDistribution)
self.densityPlot.setContoursAlpha(self.contoursAlpha)
self.densityPlot.setOutlierAlpha(self.outlierAlpha)
self.densityPlot.run()
def runKS(self):
"""Create kernel smoothing."""
ks = ot.KernelSmoothing()
sample_distribution = ks.build(self.principalComponents)
# Create DensityPlot
self.densityPlot = HighDensityRegionAlgorithm(self.principalComponents,
sample_distribution)
self.densityPlot.setContoursAlpha(self.contoursAlpha)
self.densityPlot.setOutlierAlpha(self.outlierAlpha)
self.densityPlot.run()
def test_MatrixPlot(mock_show):
fname = os.path.join(os.path.dirname(__file__), 'data', 'gauss-mixture.csv')
sample = ot.Sample.ImportFromCSVFile(fname)
mp = MatrixPlot(sample)
mp.draw()
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
mp = MatrixPlot(sample,distribution)
mp.draw()
fname = os.path.join(os.path.dirname(__file__), 'data', 'gauss-mixture-3D.csv')
sample = ot.Sample.ImportFromCSVFile(fname)
mp = MatrixPlot(sample)
mp.draw()
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
mp = MatrixPlot(sample,distribution)
mp.draw()
def test_HighDensityRegionAlgorithm():
ot.RandomGenerator.SetSeed(0)
numberOfPointsForSampling = 500
ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetBySampling', 'true')
ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetSamplingSize',
str(numberOfPointsForSampling))
# Dataset
fname = os.path.join(os.path.dirname(__file__), 'data',
'gauss-mixture.csv')
sample = ot.Sample.ImportFromCSVFile(fname)
# Creation du kernel smoothing
ks = ot.KernelSmoothing()
sample_distribution = ks.build(sample)
dp = HighDensityRegionAlgorithm(sample, sample_distribution)
dp.run()
# Draw contour/inliers/outliers
graph = ot.Graph('High Density Region draw', '', '', True, 'topright')
fig, axs, graphs = dp.drawContour()
plt.show()
fig, axs, graphs = dp.drawContour(drawData=True)
plt.show()
fig, axs, graphs = dp.drawContour(drawOutliers=False)
plt.show()
graph.add(dp.drawInliers())
View(graph)
plt.show()
# Plot data
graph.add(dp.drawOutliers())
View(graph)
plt.show()
outlierIndices = dp.computeOutlierIndices()
expected_outlierIndices = [
31, 60, 84, 105, 116, 121, 150, 151, 200, 207, 215, 218, 220, 248, 282,
284, 291, 359, 361, 378, 382, 404, 412, 418, 425, 426, 433, 449, 450,
457, 461, 466, 474, 490, 498, 567, 587, 616, 634, 638, 652, 665, 687,
714, 729, 730, 748, 751, 794, 876, 894, 896, 903, 925, 928, 963, 968,
987
]
assert_equal(outlierIndices, expected_outlierIndices)
def test_ProcessHDRAlgorithmDefault(self):
# With 2 principal components
setup_HDRenv()
# Dataset
fname = os.path.join(othdr.__path__[0], "..", "tests", "data",
"npfda-elnino.dat")
processSample = readProcessSample(fname)
# KL decomposition
reduction = othdr.KarhunenLoeveDimensionReductionAlgorithm(
processSample, 2)
reduction.run()
reducedComponents = reduction.getReducedComponents()
# Distribution fit in reduced space
ks = ot.KernelSmoothing()
reducedDistribution = ks.build(reducedComponents)
# Compute HDRPlot
hdr = othdr.ProcessHighDensityRegionAlgorithm(processSample,
reducedComponents,
reducedDistribution,
[0.8, 0.5])
hdr.run()
# Plot outlier trajectories
graph = hdr.draw(drawInliers=True, discreteMean=True)
otv.View(graph)
#
for discreteMean in [True, False]:
graph = hdr.draw(discreteMean=discreteMean)
otv.View(graph)
# Do not plot outlier trajectories
graph = hdr.draw(drawOutliers=False, discreteMean=True)
otv.View(graph)
#
graph = hdr.draw(bounds=False)
otv.View(graph)
#
outlier_indices = hdr.computeIndices()
expected_outlier_indices = [3, 7, 22, 32, 33, 41, 47]
assert_equal(outlier_indices, expected_outlier_indices)
#
inlier_indices = hdr.computeIndices(False)
assert_equal(len(inlier_indices), 47)
return
def test_HighDensityRegionAlgorithm3D(self):
# With 3D
ot.RandomGenerator.SetSeed(0)
numberOfPointsForSampling = 500
ot.ResourceMap.SetAsBool("Distribution-MinimumVolumeLevelSetBySampling", True)
ot.ResourceMap.Set(
"Distribution-MinimumVolumeLevelSetSamplingSize",
str(numberOfPointsForSampling),
)
# Dataset
fname = os.path.join(othdrplot.__path__[0], "data", "gauss-mixture-3D.csv")
sample = ot.Sample.ImportFromCSVFile(fname)
# Creation du kernel smoothing
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
dp = othdr.HighDensityRegionAlgorithm(sample, distribution, [0.8, 0.3])
dp.run()
# Draw contour/inliers/outliers
otv.View(dp.draw())
otv.View(dp.draw(drawInliers=True))
otv.View(dp.draw(drawOutliers=False))
outlierIndices = dp.computeIndices()
expected_outlierIndices = [
75,
79,
145,
148,
189,
246,
299,
314,
340,
351,
386,
471,
]
assert_equal(outlierIndices, expected_outlierIndices)
def test_HighDensityRegionAlgorithm(mock_show):
ot.RandomGenerator.SetSeed(0)
numberOfPointsForSampling = 500
ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetBySampling', 'true')
ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetSamplingSize',
str(numberOfPointsForSampling))
fname = os.path.join(os.path.dirname(__file__), 'data',
'gauss-mixture.csv')
sample = ot.Sample.ImportFromCSVFile(fname)
# Creation du kernel smoothing
myks = ot.KernelSmoothing()
sampleDistribution = myks.build(sample)
mydp = HighDensityRegionAlgorithm(sample, sampleDistribution)
mydp.run()
# Draw contour
plotData = False
mydp.plotContour(plotData)
plt.show()
# Plot data
mydp.plotContour(True)
plt.show()
outlierIndices = mydp.computeOutlierIndices()
expected_outlierIndices = [
31, 60, 84, 105, 116, 121, 150, 151, 200, 207, 215, 218, 220, 248, 282,
284, 291, 359, 361, 378, 382, 404, 412, 418, 425, 426, 433, 449, 450,
457, 461, 466, 474, 490, 498, 567, 587, 616, 634, 638, 652, 665, 687,
714, 729, 730, 748, 751, 794, 876, 894, 896, 903, 925, 928, 963, 968,
987
]
assert_equal(outlierIndices, expected_outlierIndices)
# myXproc R^2 --> R
amplitude = [1.0]
scale = [0.2, 0.2]
myCovModel = ot.ExponentialModel(scale, amplitude)
myXproc = ot.GaussianProcess(myCovModel, myMesh)
# Transform myXproc to make its variance depend on the vertex (s,t)
# and to get a positive process
# thanks to the spatial function g
# myXtProcess R --> R
g = ot.SymbolicFunction(['x1'], ['exp(x1)'])
myDynTransform = ot.ValueFunction(g, 2)
myXtProcess = ot.CompositeProcess(myDynTransform, myXproc)
myField = myXtProcess.getRealization()
graphMarginal1 = ot.KernelSmoothing().build(myField.getValues()).drawPDF()
graphMarginal1.setTitle("")
graphMarginal1.setXTitle("X")
graphMarginal1.setLegendPosition("")
# Initiate a BoxCoxFactory
myBoxCoxFactory = ot.BoxCoxFactory()
graph = ot.Graph()
shift = [0.0]
# We estimate the lambda parameter from the field myField
# All values of the field are positive
myModelTransform = myBoxCoxFactory.build(myField, shift, graph)
graphMarginal2 = ot.KernelSmoothing().build(
myModelTransform(myField).getValues()).drawPDF()
import openturns as ot
from openturns.viewer import View
sample = ot.Gamma(6.0, 1.0).getSample(100)
ks = ot.KernelSmoothing()
bandwidth = [0.9]
fittedDist = ks.build(sample, bandwidth)
graph = fittedDist.drawPDF()
graph.add( ot.Gamma(6.0, 1.0).drawPDF())
graph.setColors(ot.Drawable.BuildDefaultPalette(2))
graph.setLegends(['KS dist', 'Gamma'])
View(graph)
#View(graph, figure_kw={'figsize': (8, 4)})
sampleSize = 10000
sample = sampler.getSample(sampleSize)
# %%
# Look at the acceptance rate (basic check of the sampling efficiency:
# values close to :math:`0.2` are usually recommended
# for Normal posterior distributions).
# %%
[mh.getAcceptanceRate() for mh in sampler.getMetropolisHastingsCollection()]
# %%
# Build the distribution of the posterior by kernel smoothing.
# %%
kernel = ot.KernelSmoothing()
posterior = kernel.build(sample)
# %%
# Display prior vs posterior for each parameter.
# %%
fig = pl.figure(figsize=(12, 4))
for parameter_index in range(paramDim):
graph = posterior.getMarginal(parameter_index).drawPDF()
priorGraph = prior.getMarginal(parameter_index).drawPDF()
priorGraph.setColors(["blue"])
graph.add(priorGraph)
graph.setLegends(["Posterior", "Prior"])
def test_HighDensityRegionAlgorithm2D(self):
# With 2D
ot.RandomGenerator.SetSeed(0)
numberOfPointsForSampling = 500
ot.ResourceMap.SetAsBool("Distribution-MinimumVolumeLevelSetBySampling", True)
ot.ResourceMap.Set(
"Distribution-MinimumVolumeLevelSetSamplingSize",
str(numberOfPointsForSampling),
)
# Dataset
fname = os.path.join(othdrplot.__path__[0], "data", "gauss-mixture.csv")
sample = ot.Sample.ImportFromCSVFile(fname)
# Creation du kernel smoothing
ks = ot.KernelSmoothing()
distribution = ks.build(sample)
dp = othdr.HighDensityRegionAlgorithm(sample, distribution)
dp.run()
# Draw contour/inliers/outliers
otv.View(dp.draw())
otv.View(dp.draw(drawInliers=True))
otv.View(dp.draw(drawOutliers=False))
outlierIndices = dp.computeIndices()
expected_outlierIndices = [
31,
60,
84,
105,
116,
121,
150,
151,
200,
207,
215,
218,
220,
248,
282,
284,
291,
359,
361,
378,
382,
404,
412,
418,
425,
426,
433,
449,
450,
457,
461,
466,
474,
490,
498,
567,
587,
616,
634,
638,
652,
665,
687,
714,
729,
730,
748,
751,
794,
876,
894,
896,
903,
925,
928,
963,
968,
987,
]
assert_equal(outlierIndices, expected_outlierIndices)
# Mode
mode_index = dp.getMode()
assert_equal(mode_index, 424)
]
mixture = ot.Mixture(dists)
# 3-d test
R1 = ot.CovarianceMatrix(3)
R1[2, 1] = -0.25
R2 = ot.CovarianceMatrix(3)
R2[1, 0] = 0.5
R2[2, 1] = -0.3
R2[0, 0] = 1.3
print(R2)
dists = [ot.Normal([1.0, -2.0, 3.0], R1), ot.Normal([-1.0, 2.0, -2.0], R2)]
mixture = ot.Mixture(dists, [2.0 / 3.0, 1.0 / 3.0])
sample = mixture.getSample(1000)
distribution = ot.KernelSmoothing().build(sample)
algo = ot.MinimumVolumeClassifier(distribution, 0.8)
threshold = algo.getThreshold()
print("threshold=", threshold)
assert m.fabs(threshold - 0.0012555) < 1e-3, "wrong threshold"
cls_ref = [
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 0, 1, 1, 1, 1, 1
]
for i in range(35):
x = sample[i]
cls = algo.classify(x)
pdf = mixture.computePDF(x)
print(i, x, cls, pdf - threshold)
assert cls == cls_ref[i], "wrong class"
algo = ot.ExpectationSimulationAlgorithm(Y)
algo.setMaximumOuterSampling(1000)
algo.setCoefficientOfVariationCriterionType('NONE')
algo.run()
print('model evaluation calls number=', f.getEvaluationCallsNumber())
expectation_result = algo.getResult()
expectation_mean = expectation_result.getExpectationEstimate()
print('monte carlo mean=', expectation_mean, 'var=',
expectation_result.getVarianceEstimate())
# %%
# Central dispersion analysis based on a sample
# ---------------------------------------------
# %%
# Directly compute statistical moments based on a sample of Y. Sometimes the probabilistic model is not available and the study needs to start from the data.
# %%
Y_s = Y.getSample(1000)
y_mean = Y_s.computeMean()
y_stddev = Y_s.computeStandardDeviation()
y_quantile_95p = Y_s.computeQuantilePerComponent(0.95)
print('mean=', y_mean, 'stddev=', y_stddev, 'quantile@95%', y_quantile_95p)
# %%
graph = ot.KernelSmoothing().build(Y_s).drawPDF()
graph.setTitle("Kernel smoothing approximation of the output distribution")
view = viewer.View(graph)
plt.show()
ot.TruncatedDistribution.UPPER)
graph = truncated.drawPDF()
view = viewer.View(graph)
# %%
# truncated on both bounds
truncated = ot.TruncatedDistribution(distribution, 0.2, 1.5)
graph = truncated.drawPDF()
view = viewer.View(graph)
# %%
# Define a multivariate distribution
dimension = 2
size = 70
sample = ot.Normal(dimension).getSample(size)
ks = ot.KernelSmoothing().build(sample)
# %%
# Truncate it between (-2;2)^n
bounds = ot.Interval([-2.0] * dimension, [2.0] * dimension)
truncatedKS = ot.Distribution(ot.TruncatedDistribution(ks, bounds))
# %%
# Draw its PDF
graph = truncatedKS.drawPDF([-2.5] * dimension, [2.5] * dimension,
[256] * dimension)
graph.add(ot.Cloud(truncatedKS.getSample(200)))
graph.setColors(["blue", "red"])
view = viewer.View(graph)
plt.show()
import openturns as ot
from math import *
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)
(res, res)),
rstride=1,
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)
def run(self):
"""
Run all active methods.
"""
# run the univariate linear model analysis with gaussian residuals hypothesis
if self._verbose:
print("\nStart univariate linear model analysis...")
self._analysis = UnivariateLinearModelAnalysis(self._inputSample[:, 0],
self._signals, self._noiseThres,
self._saturationThres,
ot.NormalFactory(), self._boxCox)
# run the univariate linear model with gaussian residuals
if self._activeMethods['LinearGauss']:
if self._verbose:
print("\nStart univariate linear model POD with Gaussian residuals...")
self._PODgauss = UnivariateLinearModelPOD(self._inputSample[:, 0], self._signals,
self._detection, self._noiseThres,
self._saturationThres,
ot.NormalFactory(), self._boxCox)
self._PODgauss.setVerbose(self._verbose)
self._PODgauss.setSimulationSize(self._simulationSize)
self._PODgauss.run()
# run the univariate linear model with no hypothesis on the residuals
if self._activeMethods['LinearBinomial']:
if self._verbose:
print("\nStart univariate linear model POD with no hypothesis on the residuals...")
self._PODbin = UnivariateLinearModelPOD(self._inputSample[:, 0], self._signals,
self._detection, self._noiseThres,
self._saturationThres,
None, self._boxCox)
self._PODbin.setVerbose(self._verbose)
self._PODbin.run()
# run the univariate linear model with kernel smoothing on the residuals
if self._activeMethods['LinearKernelSmoothing']:
if self._verbose:
print("\nStart univariate linear model POD with kernel smoothing on the residuals...")
self._PODks = UnivariateLinearModelPOD(self._inputSample[:, 0], self._signals,
self._detection, self._noiseThres,
self._saturationThres,
ot.KernelSmoothing(), self._boxCox)
self._PODks.setVerbose(self._verbose)
self._PODks.setSimulationSize(self._simulationSize)
self._PODks.run()
# run the quantile regression
if self._activeMethods['QuantileRegression']:
if self._verbose:
print("\nStart quantile regression POD...")
self._PODqr = QuantileRegressionPOD(self._inputSample[:, 0], self._signals,
self._detection, self._noiseThres,
self._saturationThres, self._boxCox)
self._PODqr.setVerbose(self._verbose)
self._PODqr.setSimulationSize(self._simulationSize)
self._PODqr.run()
# run the polynomial chaos
if self._activeMethods['PolynomialChaos']:
if self._verbose:
print("\nStart polynomial chaos POD...")
self._PODchaos = PolynomialChaosPOD(self._inputSample, self._signals,
self._detection, self._noiseThres,
self._saturationThres, self._boxCox)
self._PODchaos.setVerbose(self._verbose)
self._PODchaos.setSimulationSize(self._simulationSize)
self._PODchaos.setSamplingSize(self._samplingSize)
self._PODchaos.run()
# run the kriging
if self._dim > 1 and self._activeMethods['Kriging']:
if self._verbose:
print("\nStart kriging POD...")
self._PODkriging = KrigingPOD(self._inputSample, self._signals,
self._detection, self._noiseThres,
self._saturationThres, self._boxCox)
self._PODkriging.setVerbose(self._verbose)
self._PODkriging.setSimulationSize(self._simulationSize)
self._PODkriging.setSamplingSize(self._samplingSize)
self._PODkriging.run()
def get_KS_marginals(data):
print("Marginal KS")
dimension = data.getDimension()
KS = ot.KernelSmoothing(ot.Epanechnikov(), False, 0, False)
marginals = [KS.build(data.getMarginal(i)) for i in range(dimension)]
return marginals
def fullKS(data):
# First model: full KS
print("Full KS")
model = ot.KernelSmoothing(ot.Epanechnikov(), False, 0, False).build(data)
return model
