def _computePValuesAsymptotic(self): W = self._computeWeightMatrix(self.Y) self.PValuesAsymptotic = ot.Point() H = np.eye(self.n) - 1 / self.n * np.ones((self.n, self.n)) Ky = np.array(self.CovY.discretize(self.Y)) Ky_mdiag = copy.deepcopy(Ky) np.fill_diagonal(Ky_mdiag, 0.) Ey = 1 / self.n / (self.n - 1) * np.sum(Ky_mdiag) By = H @ Ky @ H for dim in range(self.d): HSIC_obs = self._computeHSICIndex(self.X[:, dim], self.Y, self.CovX[dim], self.CovY, W) Kx = np.array(self.CovX[dim].discretize(self.X[:, dim])) Kx_mdiag = copy.deepcopy(Kx) np.fill_diagonal(Kx_mdiag, 0.) Ex = 1 / self.n / (self.n - 1) * np.sum(Kx_mdiag) Bx = H @ Kx @ H B = np.multiply(Bx, By) B = B**2 np.fill_diagonal(B, 0.) mHSIC = 1 / self.n * (1 + Ex * Ey - Ex - Ey) varHSIC = (2 * (self.n - 4) * (self.n - 5) / self.n / (self.n - 1) / (self.n - 2) / (self.n - 3) * np.ones( (1, self.n)) @ B @ np.ones( (self.n, 1)) / self.n / (self.n - 1)) varHSIC = varHSIC[0, 0] alpha = mHSIC**2 / varHSIC beta = self.n * varHSIC / mHSIC gamma = ot.Gamma(alpha, 1 / beta) p = self.HSICstat._computePValue(gamma, self.n, HSIC_obs, mHSIC) self.PValuesAsymptotic.add(p) return 0
import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Create a function R^n --> R^p # For example R^4 --> R myModel = ot.SymbolicFunction(['x1', 'x2', 'x3', 'x4'], ['1+x1*x2 + 2*x3^2+x4^4']) # Create a distribution of dimension n # for example n=3 with indpendent components distribution = ot.ComposedDistribution([ ot.Normal(), ot.Uniform(), ot.Gamma(2.75, 1.0), ot.Beta(2.5, 1.0, -1.0, 2.0) ]) # %% # Prepare the input/output samples sampleSize = 250 X = distribution.getSample(sampleSize) Y = myModel(X) dimension = X.getDimension() # %% # build the orthogonal basis coll = [ ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i)) for i in range(dimension)
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)})
# Histogram tests normal = ot.Normal(1) size = 100 sample = normal.getSample(size) graph = ot.HistogramFactory().build(sample, 10).drawPDF() # graph.draw('curve3.png') view = View(graph) # view.save('curve3.png') view.show() # QQPlot tests size = 100 normal = ot.Normal(1) sample = normal.getSample(size) sample2 = ot.Gamma(3.0, 4.0, 0.0).getSample(size) graph = ot.VisualTest.DrawQQplot(sample, sample2, 100) # graph.draw('curve4.png') view = View(graph) # view.save('curve4.png') view.ShowAll(block=True) # Clouds tests dimension = 2 R = ot.CorrelationMatrix(dimension) R[0, 1] = 0.8 distribution = ot.Normal(ot.Point(dimension, 3.0), ot.Point(dimension, 2.0), R) size = 100 sample1 = ot.Normal([3.0] * dimension, [2.0] * dimension, R).getSample(size)
Tobs = np.array([4380, 1791, 1611, 1291, 6132, 5694, 5296, 4818, 4818, 4380]) fail = np.array([True] * 4 + [False] * 6) x = ot.Sample(np.vstack((Tobs, fail)).T) # %% # Define a uniform prior distribution for :math:`\alpha` and a Gamma prior distribution for :math:`\beta`. # # %% alpha_min, alpha_max = 0.5, 3.8 a_beta, b_beta = 2, 2e-4 priorCopula = ot.IndependentCopula(2) # prior independence priorMarginals = [] # prior marginals priorMarginals.append(ot.Gamma(a_beta, b_beta)) # Gamma prior for beta priorMarginals.append(ot.Uniform(alpha_min, alpha_max)) # uniform prior for alpha prior = ot.ComposedDistribution(priorMarginals, priorCopula) prior.setDescription(['beta', 'alpha']) # %% # We select prior means as the initial point of the Metropolis-Hastings algorithm. # # %% initialState = [a_beta / b_beta, 0.5 * (alpha_max - alpha_min)] # %% # For our random walk proposal distributions, we choose normal steps, with standard deviation equal to roughly :math:`10\%` of the prior range (for the uniform prior) or standard deviation (for the normal prior).
#! /usr/bin/env python from __future__ import print_function import openturns as ot ot.TESTPREAMBLE() ot.RandomGenerator.SetSeed(0) distribution = ot.Gamma(0.2, 1.0, 1.0) size = 10000 sample = distribution.getSample(size) factory = ot.GammaFactory() estimatedDistribution = factory.build(sample) print("distribution=", repr(distribution)) print("Estimated distribution=", repr(estimatedDistribution)) distribution = ot.Gamma(2.3, 1.0, 1.0) sample = distribution.getSample(size) estimatedDistribution = factory.build(sample) print("distribution=", repr(distribution)) print("Estimated distribution=", repr(estimatedDistribution)) distribution = ot.Gamma(2.3, 1.0, 1.0) sample = distribution.getSample(size) estimatedDistribution = factory.build(sample) print("Distribution =", distribution) print("Estimated distribution=", estimatedDistribution) estimatedDistribution = factory.build() print("Default distribution=", estimatedDistribution) estimatedDistribution = factory.build(distribution.getParameter()) print("Distribution from parameters=", estimatedDistribution) estimatedGamma = factory.buildAsGamma(sample) print("Gamma =", distribution)
# %% from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Create a function R^n --> R^p # For example R^4 --> R myModel = ot.SymbolicFunction(['x1', 'x2', 'x3', 'x4'], ['1+x1*x2 + 2*x3^2+x4^4']) # Create a distribution of dimension n # for example n=3 with indpendent components distribution = ot.ComposedDistribution( [ot.Normal(), ot.Uniform(), ot.Gamma(2.75, 1.0), ot.Beta(2.5, 1.0, -1.0, 2.0)]) # %% # Prepare the input/output samples sampleSize = 250 X = distribution.getSample(sampleSize) Y = myModel(X) dimension = X.getDimension() # %% # build the orthogonal basis coll = [ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i)) for i in range(dimension)] enumerateFunction = ot.LinearEnumerateFunction(dimension) productBasis = ot.OrthogonalProductPolynomialFactory(coll, enumerateFunction) # %%
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) distributionCollection.add(logistic) continuousDistributionCollection.add(logistic)
ot.RandomGenerator.SetSeed(0) ot.ResourceMap.SetAsUnsignedInteger("RandomMixture-DefaultMaxSize", 4000000) # Deactivate the simplification mechanism as we want to test the Poisson formula # based algorithm here ot.ResourceMap.SetAsBool("RandomMixture-SimplifyAtoms", False) # Create a collection of test-cases and the associated references numberOfTests = 3 testCases = list() references = list() testCases.append([ot.Uniform(-1.0, 3.0)] * 2) references.append(ot.Triangular(-2.0, 2.0, 6.0)) testCases.append([ot.Normal(), ot.Normal(1.0, 2.0), ot.Normal(-2.0, 2.0)]) references.append(ot.Normal(-1.0, 3.0)) testCases.append([ot.Exponential()] * 3) references.append(ot.Gamma(3.0, 1.0, 0.0)) print("testCases=", testCases) print("references=", references) for testIndex in range(len(testCases)): # Instanciate one distribution object distribution = ot.RandomMixture(testCases[testIndex]) distribution.setBlockMin(5) distribution.setBlockMax(20) distributionReference = references[testIndex] print("Distribution ", repr(distribution)) print("Distribution ", distribution) # Is this distribution elliptical ? print("Elliptical = ", distribution.isElliptical()) # Is this distribution continuous ?
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.Gamma().__class__.__name__ == 'ComposedDistribution': correlation = ot.CorrelationMatrix(2) correlation[1, 0] = 0.25 aCopula = ot.NormalCopula(correlation) marginals = [ot.Normal(1.0, 2.0), ot.Normal(2.0, 3.0)] distribution = ot.ComposedDistribution(marginals, aCopula) elif ot.Gamma().__class__.__name__ == 'CumulativeDistributionNetwork': distribution = ot.CumulativeDistributionNetwork( [ot.Normal(2), ot.Dirichlet([0.5, 1.0, 1.5])], ot.BipartiteGraph([[0, 1], [0, 1]])) elif ot.Gamma().__class__.__name__ == 'Histogram': distribution = ot.Histogram([-1.0, 0.5, 1.0, 2.0], [0.45, 0.4, 0.15]) else: distribution = ot.Gamma() dimension = distribution.getDimension() if dimension == 1: distribution.setDescription(['$x$']) pdf_graph = distribution.drawPDF() cdf_graph = distribution.drawCDF() fig = plt.figure(figsize=(10, 4)) plt.suptitle(str(distribution)) pdf_axis = fig.add_subplot(121) cdf_axis = fig.add_subplot(122) View(pdf_graph, figure=fig, axes=[pdf_axis], add_legend=False) View(cdf_graph, figure=fig, axes=[cdf_axis], add_legend=False) elif dimension == 2: distribution.setDescription(['$x_1$', '$x_2$']) pdf_graph = distribution.drawPDF()
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View pdf_graph = ot.Graph('PDF graph', 'x', 'PDF', True, 'topleft') cdf_graph = ot.Graph('CDF graph', 'x', 'CDF', True, 'topleft') palette = ot.Drawable.BuildDefaultPalette(10) for i, p in enumerate([(1, 0.5), (2, 0.5), (3, 0.5), (5, 1), (9, 2)]): k, l = p distribution = ot.Gamma(k, l, 0.0) pdf_curve = distribution.drawPDF().getDrawable(0) cdf_curve = distribution.drawCDF().getDrawable(0) pdf_curve.setColor(palette[i]) cdf_curve.setColor(palette[i]) pdf_curve.setLegend('k,l={},{}'.format(k, l)) cdf_curve.setLegend('k,l={},{}'.format(k, l)) pdf_graph.add(pdf_curve) cdf_graph.add(cdf_curve) fig = plt.figure(figsize=(10, 4)) pdf_axis = fig.add_subplot(121) cdf_axis = fig.add_subplot(122) View(pdf_graph, figure=fig, axes=[pdf_axis], add_legend=True) View(cdf_graph, figure=fig, axes=[cdf_axis], add_legend=True) fig.suptitle('Gamma(k,l,0)')
iMax = 5 distributionCollection = [ ot.Laplace(1.0, 0.0), ot.Logistic(0.0, 1.0), ot.Normal(0.0, 1.0), ot.Normal(1.0, 1.0), ot.Rayleigh(1.0), ot.Student(22.0), ot.Triangular(-1.0, 0.3, 1.0), ot.Uniform(-1.0, 1.0), ot.Uniform(-1.0, 3.0), ot.Weibull(1.0, 3.0), ot.Beta(1.0, 3.0, -1.0, 1.0), ot.Beta(0.5, 1.0, -1.0, 1.0), ot.Beta(0.5, 1.0, -2.0, 3.0), ot.Gamma(1.0, 3.0), ot.Arcsine() ] for n in range(len(distributionCollection)): distribution = distributionCollection[n] name = distribution.getClassName() polynomialFactory = ot.StandardDistributionPolynomialFactory( ot.AdaptiveStieltjesAlgorithm(distribution)) print("polynomialFactory(", name, "=", polynomialFactory, ")") for i in range(iMax): print(name, " polynomial(", i, ")=", clean(polynomialFactory.build(i))) roots = polynomialFactory.getRoots(iMax - 1) print(name, " polynomial(", iMax - 1, ") roots=", roots) nodes, weights = polynomialFactory.getNodesAndWeights(iMax - 1) print(name, " polynomial(", iMax - 1, ") nodes=", nodes, " and weights=", weights)
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if (ot.Gamma().__class__.__name__ == 'ComposedDistribution'): correlation = ot.CorrelationMatrix(2) correlation[1, 0] = 0.25 aCopula = ot.NormalCopula(correlation) marginals = [ot.Normal(1.0, 2.0), ot.Normal(2.0, 3.0)] distribution = ot.ComposedDistribution(marginals, aCopula) elif (ot.Gamma().__class__.__name__ == 'CumulativeDistributionNetwork'): distribution = ot.CumulativeDistributionNetwork( [ot.Normal(2), ot.Dirichlet([0.5, 1.0, 1.5])], ot.BipartiteGraph([[0, 1], [0, 1]])) else: distribution = ot.Gamma() dimension = distribution.getDimension() if dimension <= 2: if distribution.getDimension() == 1: distribution.setDescription(['$x$']) pdf_graph = distribution.drawPDF() cdf_graph = distribution.drawCDF() fig = plt.figure(figsize=(10, 4)) plt.suptitle(str(distribution)) pdf_axis = fig.add_subplot(121) cdf_axis = fig.add_subplot(122) View(pdf_graph, figure=fig, axes=[pdf_axis], add_legend=False) View(cdf_graph, figure=fig, axes=[cdf_axis], add_legend=False) else: distribution.setDescription(['$x_1$', '$x_2$']) pdf_graph = distribution.drawPDF() fig = plt.figure(figsize=(10, 5))
from __future__ import print_function import openturns as ot from math import pi ot.TESTPREAMBLE() ot.Log.Show(0) ot.PlatformInfo.SetNumericalPrecision(3) dim = 2 R = ot.CorrelationMatrix(2) R[0, 1] = 0.5 src = [ ot.ComposedDistribution([ot.Uniform(-pi, pi)] * dim), ot.ComposedDistribution([ot.Normal(4.0, 2.0)] * dim), ot.ComposedDistribution([ot.Gamma()] * dim), ot.ComposedDistribution([ot.Gamma(1.5, 2.5, -0.5)] * dim), ot.ComposedDistribution([ot.Arcsine(5.2, 11.6)] * dim), ot.Normal([3.0] * dim, [2.0] * dim, R) ] for sd in src: sample = sd.getSample(2000) d = ot.MetaModelAlgorithm.BuildDistribution(sample) print(d) sample = ot.Sample([[0], [142.857], [285.714], [428.571], [571.429], [714.286], [857.143], [1000.0]]) d = ot.MetaModelAlgorithm.BuildDistribution(sample) print(d)
from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # An introductory example # ----------------------- # # %% # We create the data from a Gamma distribution : ot.RandomGenerator.SetSeed(0) distribution = ot.Gamma(6.0, 1.0) sample = distribution.getSample(800) # %% # We define the kernel smoother and build the smoothed estimate. kernel = ot.KernelSmoothing() estimated = kernel.build(sample) # %% # We can draw the original distribution vs the kernel smoothing. graph = distribution.drawPDF() graph.setTitle("Kernel smoothing vs original") kernel_plot = estimated.drawPDF().getDrawable(0) kernel_plot.setColor("blue") graph.add(kernel_plot) graph.setLegends(["original", "KS"])