import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.MaternModel().__class__.__name__ == 'ExponentialModel': covarianceModel = ot.ExponentialModel([0.5], [5.0]) elif ot.MaternModel().__class__.__name__ == 'GeneralizedExponential': covarianceModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) elif ot.MaternModel().__class__.__name__ == 'ProductCovarianceModel': amplitude = [1.0] scale1 = [4.0] scale2 = [4.0] cov1 = ot.ExponentialModel(scale1, amplitude) cov2 = ot.ExponentialModel(scale2, amplitude) covarianceModel = ot.ProductCovarianceModel([cov1, cov2]) elif ot.MaternModel().__class__.__name__ == 'RankMCovarianceModel': variance = [1.0, 2.0] basis = ot.LinearBasisFactory().build() covarianceModel = ot.RankMCovarianceModel(variance, basis) else: covarianceModel = ot.MaternModel() title = str(covarianceModel)[:100] if covarianceModel.getInputDimension() == 1: scale = covarianceModel.getScale()[0] if covarianceModel.isStationary(): def f(x): return [covarianceModel(x)[0, 0]] func = ot.PythonFunction(1, 1, f) func.setDescription(['$tau$', '$cov$']) cov_graph = func.draw(-3.0 * scale, 3.0 * scale, 129)
def _exec(self, X): f = ot.Function( ot.PiecewiseLinearEvaluation( [x[0] for x in self.getInputMesh().getVertices()], X)) outputValues = ot.Sample(0, 1) for t in self.getOutputMesh().getVertices(): kernel = ot.Normal(t[0], 0.05) def pdf(X): return [kernel.computePDF(X)] weight = ot.Function(ot.PythonFunction(1, 1, pdf)) outputValues.add( self.algo_.integrate(weight * f, kernel.getRange())) return outputValues N = 5 X = ot.GaussianProcess(ot.GeneralizedExponential([0.1], 1.0), mesh) f = ot.FieldFunction(GaussianConvolution()) Y = ot.CompositeProcess(f, X) x_graph = X.getSample(N).drawMarginal(0) y_graph = Y.getSample(N).drawMarginal(0) fig = plt.figure(figsize=(10, 4)) plt.suptitle("Composite process") x_axis = fig.add_subplot(121) y_axis = fig.add_subplot(122) View(x_graph, figure=fig, axes=[x_axis], add_legend=False) View(y_graph, figure=fig, axes=[y_axis], add_legend=False)
precision = ot.PlatformInfo.GetNumericalPrecision() ot.PlatformInfo.SetNumericalPrecision(4) print('dCov/dP=', pGrad) ot.PlatformInfo.SetNumericalPrecision(precision) inputDimension = 2 myDefautModel = ot.SquaredExponential([2.0], [3.0]) print('myDefautModel = ', myDefautModel) test_model(myDefautModel) myModel = ot.SquaredExponential([2.0] * inputDimension, [3.0]) test_model(myModel) myDefautModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) print('myDefautModel = ', myDefautModel) test_model(myDefautModel) myModel = ot.GeneralizedExponential([2.0] * inputDimension, [3.0], 1.5) test_model(myModel) myDefautModel = ot.AbsoluteExponential([2.0], [3.0]) print('myDefautModel = ', myDefautModel) test_model(myDefautModel) myModel = ot.AbsoluteExponential([2.0] * inputDimension, [3.0]) test_model(myModel) myDefautModel = ot.MaternModel([2.0], [3.0], 1.5) print('myDefautModel = ', myDefautModel)
inputDimension = 2 # 1) SquaredExponential myModel = ot.SquaredExponential([2.0], [3.0]) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) test_model(myModel) myModel = ot.SquaredExponential([2.0] * inputDimension, [3.0]) ott.assert_almost_equal(myModel.getScale(), [2, 2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) test_model(myModel) # 2) GeneralizedExponential myModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) ott.assert_almost_equal(myModel.getP(), 1.5, 0, 0) test_model(myModel) myModel = ot.GeneralizedExponential([2.0] * inputDimension, [3.0], 1.5) ott.assert_almost_equal(myModel.getScale(), [2, 2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) ott.assert_almost_equal(myModel.getP(), 1.5, 0, 0) test_model(myModel) # 3) AbsoluteExponential myModel = ot.AbsoluteExponential([2.0], [3.0]) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0)
# MetaModelValidation - SPC metaModelValidationSPC = ot.MetaModelValidation( inputValidation, outputValidation, result.getMetaModel()) print("") print("Sparse chaos scoring") print( "Q2 = ", round(metaModelValidationSPC.computePredictivityFactor(), 5)) print("Residual sample = ", repr( metaModelValidationSPC.getResidualSample())) # 2) Kriging algorithm # KrigingAlgorithm basis = ot.QuadraticBasisFactory(dimension).build() # model already computed, separately covarianceModel = ot.GeneralizedExponential( [3.52, 2.15, 2.99], [11.41], 2.0) algo2 = ot.KrigingAlgorithm( inputSample, outputSample, covarianceModel, basis) algo2.setOptimizeParameters(False) algo2.run() result2 = algo2.getResult() # MetaModelValidation - KG metaModelValidationKG = ot.MetaModelValidation( inputValidation, outputValidation, result2.getMetaModel()) print("") print("Kriging scoring") print("Q2 = ", round(metaModelValidationKG.computePredictivityFactor(), 3)) ot.PlatformInfo.SetNumericalPrecision(2) print("Residual sample = ", repr( metaModelValidationKG.getResidualSample()))
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View # Create a bivariate normal process myMesh = ot.IntervalMesher([39, 39]).build(ot.Interval([0.0] * 2, [1.0] * 2)) myCov = ot.GeneralizedExponential(2, 0.1, 1.3) myProcess = ot.TemporalNormalProcess(myCov, myMesh) myField = myProcess.getRealization() graph = myField.drawMarginal(0, False) fig = plt.figure(figsize=(8, 4)) plt.suptitle("A field") axis = fig.add_subplot(111) axis.set_xlim(auto=True) View(graph, figure=fig, axes=[axis], add_legend=True)
import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt # ot.Log.Show(ot.Log.NONE) # %% # Definition of the covariance model # ---------------------------------- # # We define our Gaussian process from its covariance model. We consider a Gaussian kernel with the following parameters. # %% dimension = 1 amplitude = [1.0] * dimension scale = [1] * dimension covarianceModel = ot.GeneralizedExponential(scale, amplitude, 2) # %% # We define the time grid on which we want to sample the Gaussian process. # %% tmin = 0.0 step = 0.01 n = 10001 timeGrid = ot.RegularGrid(tmin, step, n) # %% # Finally we define the Gaussian process. process = ot.GaussianProcess(covarianceModel, timeGrid) print(process)
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View # Create a bivariate Gaussian process myMesh = ot.IntervalMesher([39, 39]).build(ot.Interval([0.0] * 2, [1.0] * 2)) myCov = ot.GeneralizedExponential(2 * [0.1], 1.3) myProcess = ot.GaussianProcess(myCov, myMesh) myField = myProcess.getRealization() graph = myField.drawMarginal(0, False) fig = plt.figure(figsize=(8, 4)) plt.suptitle("A field") axis = fig.add_subplot(111) axis.set_xlim(auto=True) View(graph, figure=fig, axes=[axis], add_legend=True)
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View covarianceModel = ot.GeneralizedExponential() if covarianceModel.getSpatialDimension() == 1: scale = covarianceModel.getScale()[0] if covarianceModel.isStationary(): def f(x): return [covarianceModel(x)[0, 0]] func = ot.PythonFunction(1, 1, f) func.setDescription(['$tau$', '$cov$']) cov_graph = func.draw(-3.0 * scale, 3.0 * scale, 129) fig = plt.figure(figsize=(10, 4)) plt.suptitle(str(covarianceModel)) cov_axis = fig.add_subplot(111) View(cov_graph, figure=fig, axes=[cov_axis], add_legend=False) else: def f(x): return [covarianceModel([x[0]], [x[1]])[0, 0]] func = ot.PythonFunction(2, 1, f) func.setDescription(['$s$', '$t$', '$cov$']) cov_graph = func.draw([-3.0 * scale] * 2, [3.0 * scale] * 2, [129] * 2) fig = plt.figure(figsize=(10, 4)) plt.suptitle(str(covarianceModel)) cov_axis = fig.add_subplot(111) View(cov_graph, figure=fig, axes=[cov_axis], add_legend=False)
inputValues = X.getValues() f = ot.NumericalMathFunction( ot.PiecewiseLinearEvaluationImplementation( [x[0] for x in inputTG.getVertices()], inputValues)) outputValues = ot.NumericalSample(0, 1) for t in self.outputGrid_.getVertices(): kernel = ot.Normal(t[0], 0.05) def pdf(X): return [kernel.computePDF(X)] weight = ot.NumericalMathFunction(ot.PythonFunction(1, 1, pdf)) outputValues.add( self.algo_.integrate(weight * f, kernel.getRange())) return ot.Field(self.outputGrid_, outputValues) N = 5 X = ot.TemporalNormalProcess(ot.GeneralizedExponential([0.1], 1.0), ot.RegularGrid(-5.0, 0.1, 101)) f = ot.DynamicalFunction(GaussianConvolution()) Y = ot.CompositeProcess(f, X) x_graph = X.getSample(N).drawMarginal(0) y_graph = Y.getSample(N).drawMarginal(0) fig = plt.figure(figsize=(10, 4)) plt.suptitle("Composite process") x_axis = fig.add_subplot(121) y_axis = fig.add_subplot(122) View(x_graph, figure=fig, axes=[x_axis], add_legend=False) View(y_graph, figure=fig, axes=[y_axis], add_legend=False)
# MetaModelValidation - SPC metaModelValidationSPC = ot.MetaModelValidation(inputValidation, outputValidation, result.getMetaModel()) print("") print("Sparse chaos scoring") print("Q2 = ", round(metaModelValidationSPC.computePredictivityFactor(), 5)) print("Residual sample = ", repr(metaModelValidationSPC.getResidualSample())) # 2) Kriging algorithm # KrigingAlgorithm basis = ot.QuadraticBasisFactory(dimension).build() # model already computed, separatly covarianceModel = ot.GeneralizedExponential([1.933, 1.18, 1.644], [10.85], 2.0) algo2 = ot.KrigingAlgorithm(inputSample, outputSample, basis, covarianceModel, True, True) algo2.run() result2 = algo2.getResult() # MetaModelValidation - KG metaModelValidationKG = ot.MetaModelValidation(inputValidation, outputValidation, result2.getMetaModel()) print("") print("Kriging scoring") print("Q2 = ", round(metaModelValidationKG.computePredictivityFactor(), 3)) ot.PlatformInfo.SetNumericalPrecision(2) print("Residual sample = ", repr(metaModelValidationKG.getResidualSample()))
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.GeneralizedExponential().__class__.__name__ == 'ExponentialModel': covarianceModel = ot.ExponentialModel([0.5], [5.0]) elif ot.GeneralizedExponential( ).__class__.__name__ == 'GeneralizedExponential': covarianceModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) elif ot.GeneralizedExponential( ).__class__.__name__ == 'ProductCovarianceModel': amplitude = [1.0] scale1 = [4.0] scale2 = [4.0] cov1 = ot.ExponentialModel(scale1, amplitude) cov2 = ot.ExponentialModel(scale2, amplitude) covarianceModel = ot.ProductCovarianceModel([cov1, cov2]) elif ot.GeneralizedExponential().__class__.__name__ == 'RankMCovarianceModel': variance = [1.0, 2.0] basis = ot.LinearBasisFactory().build() covarianceModel = ot.RankMCovarianceModel(variance, basis) else: covarianceModel = ot.GeneralizedExponential() title = str(covarianceModel)[:100] if covarianceModel.getInputDimension() == 1: scale = covarianceModel.getScale()[0] if covarianceModel.isStationary(): def f(x): return [covarianceModel(x)[0, 0]] func = ot.PythonFunction(1, 1, f)
def _exec(self, X): inputTG = X.getTimeGrid() inputValues = X.getValues() f = ot.NumericalMathFunction(ot.PiecewiseLinearEvaluationImplementation( [x[0] for x in inputTG.getVertices()], inputValues)) outputValues = ot.NumericalSample(0, 1) for t in self.outputGrid_.getVertices(): kernel = ot.Normal(t[0], 0.05) def pdf(X): return [kernel.computePDF(X)] weight = ot.NumericalMathFunction(ot.PythonFunction(1, 1, pdf)) outputValues.add(self.algo_.integrate( weight * f, kernel.getRange())) return ot.Field(self.outputGrid_, outputValues) N = 5 X = ot.TemporalNormalProcess(ot.GeneralizedExponential( 1, 0.1, 1.0), ot.RegularGrid(-5.0, 0.1, 101)) f = ot.DynamicalFunction(GaussianConvolution()) Y = ot.CompositeProcess(f, X) x_graph = X.getSample(N).drawMarginal(0) y_graph = Y.getSample(N).drawMarginal(0) fig = plt.figure(figsize=(10, 4)) plt.suptitle("Composite process") x_axis = fig.add_subplot(121) y_axis = fig.add_subplot(122) View(x_graph, figure=fig, axes=[x_axis], add_legend=False) View(y_graph, figure=fig, axes=[y_axis], add_legend=False)
# The :class:`~openturns.GeneralizedExponential` class implements a generalized exponential with a # parameter :math:`p < 0 \leq 2` exponent. The case :math:`p=1` is the standard exponential model # while :math:`p=2` is the squared exponential. # # %% # Various parameters p and a fixed correlation length of 0.1 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # In this part we set the correlation length to :math:`\theta = 0.1` and study three different models # with parameters :math:`p=0.25`, :math:`p=1` and :math:`p=2` and trajectories from gaussian processes # based on these models. # %% # We define the :math:`p = 0.25` generalized exponential model : covarianceModel = ot.GeneralizedExponential([0.1], 0.25) # %% # We define the :math:`p = 1` generalized exponential model : covarianceModel2 = ot.GeneralizedExponential([0.1], 1.0) # %% # We define the :math:`p = 2` generalized exponential model : covarianceModel3 = ot.GeneralizedExponential([0.1], 2.0) # %% # We draw the covariance models : graphModel = covarianceModel.draw() graphModel.add(covarianceModel2.draw()) graphModel.add(covarianceModel3.draw()) graphModel.setColors(["green", "orange", "blue"])
for j in range(currentValue.getSize()): gradfd[i, j] = (currentValue[j] - centralValue[j]) / eps; print("dCov (FD)=", repr(gradfd)) spatialDimension = 2 myDefautModel = ot.SquaredExponential() print("myDefautModel = ", myDefautModel) myModel = ot.SquaredExponential(spatialDimension) test_model(myModel) myDefautModel = ot.GeneralizedExponential() print("myDefautModel = ", myDefautModel) myModel = ot.GeneralizedExponential(spatialDimension, 10.0, 1.5) test_model(myModel) myDefautModel = ot.AbsoluteExponential() print("myDefautModel = ", myDefautModel) myModel = ot.AbsoluteExponential(spatialDimension) test_model(myModel) myDefautModel = ot.MaternModel() print("myDefautModel = ", myDefautModel)
x = ot.Point(hmat.getNbColumns()) x[i] = 1.0 y = ot.Point(hmat.getNbRows()) hmat.gemv('N', 1.0, x, 0.0, y) for j in range(hmat.getNbColumns()): res[i, j] = y[j] return res if __name__ == "__main__": models = [] refModels = [] # rho correlation scale = [4, 5] rho = ot.GeneralizedExponential(scale, 1) # Amplitude values amplitude = [1, 2] myModel = ot.KroneckerCovarianceModel(rho, amplitude) models.append(myModel) spatialCorrelation = ot.CorrelationMatrix(2) spatialCorrelation[0, 1] = 0.8 myModel = ot.KroneckerCovarianceModel(rho, amplitude, spatialCorrelation) models.append(myModel) spatialCovariance = ot.CovarianceMatrix(2) spatialCovariance[0, 0] = 4.0 spatialCovariance[1, 1] = 5.0 spatialCovariance[1, 0] = 1.2