import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View covarianceModel = ot.ExponentialModel() 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)
test_model(myModel, x1=[0.5, 0.0], x2=[0.5, 0.0]) myDefautModel = ot.ProductCovarianceModel() print('myDefautModel = ', myDefautModel) test_model(myDefautModel) cov1 = ot.AbsoluteExponential([2.0], [3.0]) cov2 = ot.SquaredExponential([2.0], [3.0]) myModel = ot.ProductCovarianceModel([cov1, cov2]) test_model(myModel) # Collection ==> add covariance models # Add AbsoluteExponentialModel to the collection myAbsoluteExponential = ot.AbsoluteExponential([2.0] * inputDimension, [3.0]) mySquaredExponential = ot.SquaredExponential([2.0] * inputDimension, [3.0]) # Add exponentialModel to the collection amplitude = [4.0, 2.0] scale = [1.0] * inputDimension # Define a spatial correlation spatialCorrelation = ot.CorrelationMatrix(inputDimension) spatialCorrelation[1, 0] = 0.3 myExponentialModel = ot.ExponentialModel(scale, amplitude, spatialCorrelation) # Build TensorizedCovarianceModel with scale = [1,..,1] myModel = ot.TensorizedCovarianceModel( [myAbsoluteExponential, mySquaredExponential, myExponentialModel]) test_model(myModel, test_grad=False) # Define new scale scale = [2.5, 1.5] myModel.setScale(scale) test_model(myModel, test_grad=False)
# Create a process X: R^2 --> R^2 # Define a bi dimensional mesh as a box myIndices = ot.Indices([40, 20]) myMesher = ot.IntervalMesher(myIndices) lowerBound = [0.0, 0.0] upperBound = [2.0, 1.0] myInterval = ot.Interval(lowerBound, upperBound) myMesh = myMesher.build(myInterval) # Define a scalar temporal normal process on the mesh # this process is stationary # myXproc R^2 --> R amplitude = [1.0] scale = [0.2, 0.2] myCovModel = ot.ExponentialModel(myMesh.getDimension(), amplitude, scale) myXproc = ot.TemporalNormalProcess(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.NumericalMathFunction(['x1'], ['exp(x1)']) myDynTransform = ot.SpatialFunction(g, 2) myXtProcess = ot.CompositeProcess(myDynTransform, myXproc) myField = myXtProcess.getRealization() graphMarginal1 = ot.KernelSmoothing().build(myField.getValues()).drawPDF() graphMarginal1.setTitle("") graphMarginal1.setXTitle("X") graphMarginal1.setLegendPosition("")
outputDimension = 1 # Amplitude values amplitude = [1.0] * outputDimension # Scale values scale = [1.0] * inputDimension tmin = 0.0 step = 0.1 n = 11 myTimeGrid = ot.RegularGrid(tmin, step, n) size = 25 # Second order model with parameters myCovModel = ot.ExponentialModel(scale, amplitude) print("myCovModel = ", myCovModel) myProcess1 = ot.GaussianProcess(myCovModel, myTimeGrid) print("myProcess1 = ", myProcess1) print("is stationary? ", myProcess1.isStationary()) myProcess1.setSamplingMethod(ot.GaussianProcess.CHOLESKY) print("mean over ", size, " realizations = ", myProcess1.getSample(size).computeMean()) myProcess1.setSamplingMethod(ot.GaussianProcess.GIBBS) print("mean over ", size, " realizations = ", myProcess1.getSample(size).computeMean()) # With constant trend trend = ot.TrendTransform(ot.SymbolicFunction("t", "4.0"), myTimeGrid) myProcess2 = ot.GaussianProcess(trend, myCovModel, myTimeGrid)
### The 1D Mesh : elems_1D = [99] mesher_1D = ot.IntervalMesher(elems_1D) lowerBound_1D = [0] upperBound_1D = [100] interval_1D = ot.Interval(lowerBound_1D, upperBound_1D) mesh_1D = mesher_1D.build(interval_1D) print('The 1D mesh is\n', mesh_1D, '\n') print('The 2D mesh is\n', mesh_2D, '\n') ## Now let's define the covariance models of both processes. ## we will for both use exponential models with the same base parameters ### The 1D cova model: model_1D = ot.ExponentialModel([10], [1]) ### The 2D cova model: model_2D = ot.ExponentialModel([1, 1], [1]) ##Now finally let's get our two processes and the ditribution. ### The 1D Gaussian process process_1D = ot.GaussianProcess(model_1D, mesh_1D) ### The 2D Gaussian process process_2D = ot.GaussianProcess(model_2D, mesh_2D) ### The normal distribution: scalar_distribution = ot.Normal() ## Now the we have our processes and distributions, let's first evaluate the function
# Scale vector (input dimension 1) scale = [4.0] # spatialCorrelation spatialCorrelation = ot.CorrelationMatrix(3) spatialCorrelation[0, 1] = 0.8 spatialCorrelation[0, 2] = 0.6 spatialCorrelation[1, 2] = 0.1 # spatialCovariance spatialCovariance = ot.CovarianceMatrix(3) spatialCovariance[0, 0] = 4.0 spatialCovariance[1, 1] = 5.0 spatialCovariance[2, 2] = 6.0 spatialCovariance[0, 1] = 1.2 spatialCovariance[0, 2] = 0.9 spatialCovariance[1, 2] = -0.2 # %% # Create the covariance model from the amplitude and scale, no spatial correlation ot.ExponentialModel(scale, amplitude) # %% # or from the amplitude, scale and spatialCovariance ot.ExponentialModel(scale, amplitude, spatialCorrelation) # %% # or from the scale and spatialCovariance ot.ExponentialModel(scale, spatialCovariance)
# Sample [int64] indexing s0 = ot.Sample(5, 3) idx = np.array([1, 3, 4]) print('sample[[int64]]:', s0[idx]) s0[idx] = ot.Normal(3).getSample(3) print('sample[[int64]]=Sample:', s0) # generic int64 indexing s0 = ot.Description(5, 'aa') idx = np.int64(2) print('Description[int64]:', s0[idx]) s0[idx] = 'zou' print('Description[int64]=str', s0[idx]) # generic [int64] indexing s0 = ot.Description(5, 'aa') idx = np.array([1, 3, 4]) print('Description[[int64]]:', s0[idx]) s0[idx] = ['zou'] * 3 print('Description[[int64]]=str', s0[idx]) # Field int64 indexing mesher = ot.IntervalMesher([10, 5]) mesh = mesher.build(ot.Interval([0.0, 0.0], [2.0, 1.0])) process = ot.GaussianProcess(ot.ExponentialModel([0.2] * 2, [1.0]), mesh) field = process.getRealization() idx = np.int64(2) print('Field[int64]', field[idx]) field[idx] = [6.0] print('Field[int64]=Point', field[idx])
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)
import openturns as ot from math import exp from matplotlib import pyplot as plt from openturns.viewer import View N = 512 a = 20.0 # myMesh = ot.IntervalMesher([N]).build(ot.Interval(-a, a)) myMesh = ot.RegularGrid(0.0, 2 * a / N, N + 1) covarianceModel = ot.ExponentialModel([1.0], [1.0]) myProcess = ot.GaussianProcess(covarianceModel, myMesh) mySample = myProcess.getSample(1000) myCovarianceFactory = ot.StationaryCovarianceModelFactory() myEstimatedModel = myCovarianceFactory.build(mySample) def f(x): res = covarianceModel(x)[0, 0] return [res] func = ot.PythonFunction(1, 1, f) func.setDescription(['$t$', '$cov$']) def fEst(X): res = myEstimatedModel(X)[0, 0]
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View # Create a bivariate normal process myTG = ot.RegularGrid(0.0, 0.01, 100) myCov = ot.ExponentialModel([3.0], [1.2]) myProcess = ot.GaussianProcess(myCov, myTG) myTS = myProcess.getRealization() graph = myTS.drawMarginal(0) fig = plt.figure(figsize=(8, 4)) plt.suptitle("A time series") 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 # Create a process on a regular grid myGrid = ot.RegularGrid(0.0, 0.1, 100) amplitude = [5.0] scale = [0.2] myCovModel = ot.ExponentialModel(1, amplitude, scale) myXProcess = ot.TemporalNormalProcess(myCovModel, myGrid) # Create a trend fTrend = ot.NumericalMathFunction(["t"], ["1+2*t+t^2"]) fTemp = ot.TrendTransform(fTrend) # Add the trend to the process and get a field myYProcess = ot.CompositeProcess(fTemp, myXProcess) myYField = myYProcess.getRealization() # Create a TrendFactory myBasisSequenceFactory = ot.LAR() myFittingAlgorithm = ot.KFold() func1 = ot.NumericalMathFunction(["t"], ["1"]) func2 = ot.NumericalMathFunction(["t"], ["t"]) func3 = ot.NumericalMathFunction(["t"], ["t^2"]) myBasis = ot.Basis([func1, func2, func3]) myTrendFactory = ot.TrendFactory(myBasisSequenceFactory, myFittingAlgorithm) # Estimate the trend
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View if ot.ExponentialModel().__class__.__name__ == 'ExponentialModel': covarianceModel = ot.ExponentialModel([0.5], [5.0]) elif ot.ExponentialModel().__class__.__name__ == 'GeneralizedExponential': covarianceModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) elif ot.ExponentialModel().__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.ExponentialModel().__class__.__name__ == 'RankMCovarianceModel': variance = [1.0, 2.0] basis = ot.LinearBasisFactory().build() covarianceModel = ot.RankMCovarianceModel(variance, basis) else: covarianceModel = ot.ExponentialModel() 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) cov_graph.setTitle(title) fig = plt.figure(figsize=(10, 4))
print('no') # check that hmat library was found print('7: HMatrix (hmat-oss)'.ljust(width), end=' ') try: # This is a little bit tricky because HMat 1.0 fails with 1x1 matrices ot.ResourceMap.SetAsUnsignedInteger('TemporalNormalProcess-SamplingMethod', 1) vertices = [[0.0, 0.0, 0.0]] vertices.append([1.0, 0.0, 0.0]) vertices.append([0.0, 1.0, 0.0]) vertices.append([0.0, 0.0, 1.0]) simplices = [[0, 1, 2, 3]] # Discard messages from HMat ot.Log.Show(0) process = ot.TemporalNormalProcess(ot.ExponentialModel(3), ot.Mesh(vertices, simplices)) f = process.getRealization() print('OK') except: print('no') # check that nlopt library was found print('8: optimization (NLopt)'.ljust(width), end=' ') try: problem = ot.OptimizationProblem() algo = ot.SLSQP() algo.setProblem(problem) print('OK') except: print('no')
hmat.gemv('N', 1.0, x, 3.0, y) print('y=', y) # block assembly class TestHMatrixTensorRealAssemblyFunction(object): def __init__(self, covarianceModel, vertices): self.covarianceModel = covarianceModel self.vertices = vertices def __call__(self, i, j): pt1 = self.vertices[i] pt2 = self.vertices[j] val = self.covarianceModel(pt1, pt2) return val covarianceModel = ot.ExponentialModel([0.1] * 2, [1.0] * 2) hmat = factory.build(vertices, covarianceModel.getDimension(), True, parameters) blockAssembly = TestHMatrixTensorRealAssemblyFunction(covarianceModel, vertices) hmat.assembleTensor(blockAssembly, covarianceModel.getDimension(), 'L') hmatRef = ot.HMatrix(hmat) hmat.factorize('LLt') hmatRef.gemm('N', 'T', -1.0, hmat, hmat, 1.0) if hmatRef.norm() < 1e-10: print('norm(A-LLt) < 1e-10') else: print('norm(A-LLt) =', hmatRef.norm())
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View # Create a bivariate normal process myTG = ot.RegularGrid(0.0, 0.01, 100) myCov = ot.ExponentialModel(1, [1.2], [3.0]) myProcess = ot.TemporalNormalProcess(myCov, myTG) myTS = myProcess.getRealization() graph = myTS.drawMarginal(0) fig = plt.figure(figsize=(8, 4)) plt.suptitle("A time series") axis = fig.add_subplot(111) axis.set_xlim(auto=True) View(graph, figure=fig, axes=[axis], add_legend=True)
lambd = result.getEigenValues() KLModes = result.getModesAsProcessSample() print("KL modes=", KLModes) print("KL eigenvalues=", lambd) process = ot.TemporalNormalProcess(cov1D, KLModes.getMesh()) coefficients = result.project(process.getSample(10)) print("KL coefficients=", coefficients) KLFunctions = result.getModes() print("KL functions=", KLFunctions) print("KL lift=", result.lift(coefficients[0])) print("KL lift as field=", result.liftAsField(coefficients[0])) R = ot.CorrelationMatrix(2) R[0, 1] = 0.5 scale = [1.0] amplitude = [1.0, 2.0] cov2D = ot.ExponentialModel(scale, amplitude, R) algo = ot.KarhunenLoeveP1Algorithm(mesh, cov2D, 0.0) algo.run() result = algo.getResult() lambd = result.getEigenValues() KLModes = result.getModesAsProcessSample() print("KL modes=", KLModes) print("KL eigenvalues=", lambd) process = ot.TemporalNormalProcess(cov2D, KLModes.getMesh()) coefficients = result.project(process.getSample(10)) print("KL coefficients=", coefficients) KLFunctions = result.getModes() print("KL functions=", KLFunctions) print("KL lift=", result.lift(coefficients[0])) print("KL lift as field=", result.liftAsField(coefficients[0])) except:
ott.assert_almost_equal(oneDimensionalCovMatrix[1, 1], 2.250000000002, 1e-12, 0.0) ott.assert_almost_equal(isotropicCovMatrix[0, 0], 2.250000000002, 1e-12, 0.0) ott.assert_almost_equal(isotropicCovMatrix[1, 1], 2.250000000002, 1e-12, 0.0) ott.assert_almost_equal(oneDimensionalCovMatrix[0, 1], 1.992315565746, 1e-12, 0.0) ott.assert_almost_equal(isotropicCovMatrix[0, 1], 1.992315565746, 1e-12, 0.0) # Exponential covariance model inputDimension = 2 scale = [4, 5] spatialCovariance = ot.CovarianceMatrix(inputDimension) spatialCovariance[0, 0] = 4 spatialCovariance[1, 1] = 5 spatialCovariance[1, 0] = 1.2 myModel = ot.ExponentialModel(scale, spatialCovariance) test_model(myModel) # assert that spatialCovariance is taken into account checkDiag = spatialCovariance.isDiagonal() == myModel.isDiagonal() if (not checkDiag): raise Exception( "isDiagonal differ between spatial covariance & covariance model") rho = spatialCovariance[1, 0] / sqrt( spatialCovariance[0, 0] * spatialCovariance[1, 1]) ott.assert_almost_equal(myModel.getOutputCorrelation()[0, 1], rho, 0, 0, "in ExponentialModel correlation") # Kronecker covariance model # rho correlation scale = [4, 5]
# Create a process X: R^2 --> R^2 # Define a bi dimensional mesh as a box myIndices = ot.Indices([40, 20]) myMesher = ot.IntervalMesher(myIndices) lowerBound = [0.0, 0.0] upperBound = [2.0, 1.0] myInterval = ot.Interval(lowerBound, upperBound) myMesh = myMesher.build(myInterval) # Define a scalar temporal Gaussian process on the mesh # this process is stationary # 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("")
coll = ot.CovarianceModelCollection() coll.add(ot.AbsoluteExponential(1, 3.0)) coll.add(ot.SquaredExponential(1, 2.0)) myModel = ot.ProductCovarianceModel(coll) test_model(myModel) collection = ot.CovarianceModelCollection() # Collection ==> add covariance models # Add AbsoluteExponentialModel to the collection myAbsoluteExponential = ot.AbsoluteExponential(spatialDimension, 3.0) collection.add(myAbsoluteExponential) # Add SquaredExponentialModel to the collection mySquaredExponential = ot.SquaredExponential(spatialDimension, 2.0) collection.add(mySquaredExponential) # Add exponentialModel to the collection amplitude = [4.0, 2.0] scale = [1.0] * spatialDimension # Define a spatial correlation spatialCorrelation = ot.CorrelationMatrix(spatialDimension) spatialCorrelation[1,0] = 0.3 myExponentialModel = ot.ExponentialModel(spatialDimension, amplitude, scale, spatialCorrelation) collection.add(myExponentialModel) # Build TensorizedCovarianceModel with scale = [1,..,1] myModel = ot.TensorizedCovarianceModel(collection) test_model(myModel) # Define new scale scale = [2.5, 1.5] myModel.setScale(scale) test_model(myModel)