def testTensorProductExperiment1(): # Generate a tensorized Gauss-Legendre rule in 2 dimensions. # The first marginal has 3 nodes. # The first marginal has 5 nodes. experiment1 = ot.GaussProductExperiment(ot.Uniform(0.0, 1.0), [3]) experiment2 = ot.GaussProductExperiment(ot.Uniform(0.0, 1.0), [5]) collection = [experiment1, experiment2] multivariateExperiment = ot.TensorProductExperiment(collection) nodes, weights = multivariateExperiment.generateWithWeights() # Sort nodes, weights = sortNodesAndWeights(nodes, weights) nodesExact = [ [0.11270, 0.04691], [0.11270, 0.23076], [0.11270, 0.5], [0.11270, 0.76923], [0.11270, 0.95309], [0.5, 0.04691], [0.5, 0.23076], [0.5, 0.5], [0.5, 0.76923], [0.5, 0.95309], [0.88729, 0.04691], [0.88729, 0.23076], [0.88729, 0.5], [0.88729, 0.76923], [0.88729, 0.95309], ] weightsExact = [ 0.0329065, 0.0664762, 0.0790123, 0.0664762, 0.0329065, 0.0526504, 0.106362, 0.12642, 0.106362, 0.0526504, 0.0329065, 0.0664762, 0.0790123, 0.0664762, 0.0329065, ] rtol = 0.0 atol = 1.e-5 ott.assert_almost_equal(nodes, nodesExact, rtol, atol) ott.assert_almost_equal(weights, weightsExact, rtol, atol) # size = multivariateExperiment.getSize() assert size == 15 # distribution = multivariateExperiment.getDistribution() collection = [ot.Uniform(0.0, 1.0), ot.Uniform(0.0, 1.0)] expected_distribution = ot.BlockIndependentDistribution(collection) assert distribution == expected_distribution
def test_two_inputs_one_output(): # Kriging use case inputDimension = 2 # Learning data levels = [8, 5] box = ot.Box(levels) inputSample = box.generate() # Scale each direction inputSample *= 10.0 model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)']) outputSample = model(inputSample) # Validation sampleSize = 10 inputValidSample = ot.ComposedDistribution( 2 * [ot.Uniform(0, 10.0)]).getSample(sampleSize) outputValidSample = model(inputValidSample) # 2) Definition of exponential model # The parameters have been calibrated using TNC optimization # and AbsoluteExponential models covarianceModel = ot.SquaredExponential([5.33532, 2.61534], [1.61536]) # 3) Basis definition basis = ot.ConstantBasisFactory(inputDimension).build() # Kriging algorithm algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel, basis) algo.run() result = algo.getResult() # Get meta model metaModel = result.getMetaModel() outData = metaModel(inputValidSample) # 4) Errors # Interpolation ott.assert_almost_equal( outputSample, metaModel(inputSample), 3.0e-5, 3.0e-5) # 5) Kriging variance is 0 on learning points covariance = result.getConditionalCovariance(inputSample) ott.assert_almost_equal( covariance, ot.SquareMatrix(len(inputSample)), 7e-7, 7e-7) # Covariance per marginal & extract variance component coll = result.getConditionalMarginalCovariance(inputSample) var = [mat[0, 0] for mat in coll] ott.assert_almost_equal(var, [0]*len(var), 1e-14, 1e-14) # Variance per marginal var = result.getConditionalMarginalVariance(inputSample) ott.assert_almost_equal(var, ot.Point(len(inputSample)), 1e-14, 1e-14) # Estimation ott.assert_almost_equal(outputValidSample, metaModel( inputValidSample), 1.e-1, 1e-1)
def test_computeLogPDF(self): """Test InverseWishart.computeLogPDF""" dimension, DoF = self.dimension, self.DoF Scale, determinant = self.Scale, self.determinant inverse_wishart = ot.InverseWishart(Scale, DoF) logPDFatX = - self.logmultigamma(dimension, 0.5 * DoF) \ - 0.5 * (DoF * dimension * log(2.) + dimension + (dimension + 1) * log(determinant)) assert_almost_equal(inverse_wishart.computeLogPDF(Scale), logPDFatX)
def test_computeLogPDF(self): """Test InverseWishart.computeLogPDF""" dimension, DoF = self.dimension, self.DoF Scale, determinant = self.Scale, self.determinant inverse_wishart = ot.InverseWishart(Scale, DoF) logPDFatX = - self.logmultigamma(dimension, 0.5*DoF) \ - 0.5*(DoF*dimension*log(2.) + dimension \ + (dimension + 1)*log(determinant)) assert_almost_equal(inverse_wishart.computeLogPDF(Scale), logPDFatX)
def check_get_value(): with open('result.txt', 'w') as f: f.write('name,X0,X1,X2,X3,X4,X5\n') f.write('val,0.125,1.1,2.3,3.5,4.7,5.99\n') ott.assert_almost_equal( ct.get_value('result.txt', skip_line=1, skip_col=3, col_sep=','), 2.3) ott.assert_almost_equal( ct.get_value('result.txt', skip_line=1, skip_col=-1, col_sep=','), 5.99) os.remove('result.txt')
def test_stationary_fun(): # fix https://github.com/openturns/openturns/issues/1861 ot.RandomGenerator.SetSeed(0) rho = ot.SymbolicFunction("tau", "exp(-abs(tau))*cos(2*pi_*abs(tau))") model = ot.StationaryFunctionalCovarianceModel([1], [1], rho) x = ot.Normal().getSample(20) y = x + ot.Normal(0, 0.1).getSample(20) algo = ot.KrigingAlgorithm(x, y, model, ot.LinearBasisFactory().build()) algo.run() result = algo.getResult() variance = result.getConditionalMarginalVariance(x) ott.assert_almost_equal(variance, ot.Sample(len(x), 1), 1e-16, 1e-16)
def test_getSample_getMean(self): """Test InverseWishart.getSample and InverseWishart.getMean""" d, Scale, DoF, N = self.dimension, self.Scale, self.DoF, int(1E+4) Identity = ot.CovarianceMatrix(d) Scale_wishart = ot.CovarianceMatrix(Scale.solveLinearSystem(Identity)) inverse_wishart = ot.InverseWishart(Scale, DoF) sample_inverse = ot.Sample(N, (d * (d + 1)) // 2) sample = ot.Sample(N, (d * (d + 1)) // 2) for i in range(N): M_inverse = inverse_wishart.getRealizationAsMatrix() M = M_inverse.solveLinearSystem(Identity) indice = 0 for j in range(d): for k in range(j + 1): sample_inverse[i, indice] = M_inverse[k, j] sample[i, indice] = M[k, j] indice += 1 mean_inverse = sample_inverse.computeMean() mean = sample.computeMean() theoretical_mean_inverse = inverse_wishart.getMean() theoretical_mean = (ot.Wishart(Scale_wishart, DoF)).getMean() indice, coefficient = 0, 1. / (DoF - d - 1) for j in range(d): for k in range(j + 1): assert_almost_equal(theoretical_mean_inverse[indice], coefficient * Scale[k, j]) assert_almost_equal(theoretical_mean[indice], DoF * Scale_wishart[k, j]) assert_almost_equal(mean_inverse[indice], coefficient * Scale[k, j], 0.15, 1.E-3) assert_almost_equal(mean[indice], DoF * Scale_wishart[k, j], 0.15, 1.E-3) indice += 1
def test_two_outputs(): f = ot.SymbolicFunction(['x'], ['x * sin(x)', 'x * cos(x)']) sampleX = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0]] sampleY = f(sampleX) basis = ot.Basis([ot.SymbolicFunction(['x'], ['x']), ot.SymbolicFunction(['x'], ['x^2'])]) covarianceModel = ot.SquaredExponential([1.0]) covarianceModel.setActiveParameter([]) algo = ot.KrigingAlgorithm(sampleX, sampleY, covarianceModel, basis) algo.run() result = algo.getResult() mm = result.getMetaModel() assert mm.getOutputDimension() == 2, "wrong output dim" ott.assert_almost_equal(mm(sampleX), sampleY)
def test_getSample_getMean(self): """Test InverseWishart.getSample and InverseWishart.getMean""" d, Scale, DoF, N = self.dimension, self.Scale, self.DoF, int(1E+5) Identity = ot.CovarianceMatrix(d) Scale_wishart = ot.CovarianceMatrix(Scale.solveLinearSystem(Identity)) inverse_wishart = ot.InverseWishart(Scale, DoF) sample_inverse = ot.NumericalSample(N, (d*(d+1))//2) sample = ot.NumericalSample(N, (d*(d+1))//2) for i in range(N): M_inverse = inverse_wishart.getRealizationAsMatrix() M = M_inverse.solveLinearSystem(Identity) indice = 0 for j in range(d): for k in range(j+1): sample_inverse[i, indice] = M_inverse[k, j] sample[i, indice] = M[k, j] indice += 1 mean_inverse = sample_inverse.computeMean() mean = sample.computeMean() theoretical_mean_inverse = inverse_wishart.getMean() theoretical_mean = (ot.Wishart(Scale_wishart, DoF)).getMean() indice, coefficient = 0, 1./(DoF - d - 1) for j in range(d): for k in range(j+1): assert_almost_equal(theoretical_mean_inverse[indice], coefficient*Scale[k, j]) assert_almost_equal(theoretical_mean[indice], DoF*Scale_wishart[k, j]) assert_almost_equal(mean_inverse[indice], coefficient*Scale[k, j], 0.1, 1.E-3) assert_almost_equal(mean[indice], DoF*Scale_wishart[k, j], 0.1, 1.E-3) indice += 1
def test_computeLogPDF_diagonal_case(self): """Test InverseWishart.computeLogPDF in the case of diagonal matrices""" dimension, DoF = self.dimension, self.DoF k = 0.5*(DoF + dimension - 1) diagX = ot.Uniform(0.5, 1.).getSample(dimension) Scale = ot.CovarianceMatrix(dimension) X = ot.CovarianceMatrix(dimension) for d in range(dimension): Scale[d, d], X[d, d] = self.Scale[d, d], diagX[d, 0] inverse_wishart = ot.InverseWishart(Scale, DoF) logdensity = inverse_wishart.computeLogPDF(X) logratio = - self.logmultigamma(dimension, 0.5*DoF) \ + dimension*ot.SpecFunc_LnGamma(0.5*(DoF+dimension-1)) for d in range(dimension): inverse_gamma = ot.InverseGamma(k, 2./Scale[d, d]) logdensity = logdensity - inverse_gamma.computeLogPDF(diagX[d, 0]) logratio = logratio + 0.5*(1-dimension)*log(0.5*Scale[d, d]) assert_almost_equal(logdensity, logratio)
def test_scalar_model(myModel, x1=None, x2=None): if x1 is None and x2 is None: x1 = 2.0 x2 = -3.0 # Check that computeAsScalar(Scalar) == computeAsScalar(Point) ott.assert_almost_equal(myModel.computeAsScalar([x1], [x2]), myModel.computeAsScalar(x1, x2), 1.0e-14, 1.0e-14) # Gradient testing eps = 1e-5 grad = myModel.partialGradient([x1], [x2])[0, 0] x1_g = x1 + eps x1_d = x1 - eps gradfd = (myModel.computeAsScalar(x1_g, x2) - myModel.computeAsScalar(x1_d, x2)) / (2.0 * eps) ott.assert_almost_equal(gradfd, grad, 1e-5, 1e-5)
def test_computeLogPDF_diagonal_case(self): """Test InverseWishart.computeLogPDF in the case of diagonal matrices""" dimension, DoF = self.dimension, self.DoF k = 0.5 * (DoF + dimension - 1) diagX = ot.Uniform(0.5, 1.).getSample(dimension) Scale = ot.CovarianceMatrix(dimension) X = ot.CovarianceMatrix(dimension) for d in range(dimension): Scale[d, d], X[d, d] = self.Scale[d, d], diagX[d, 0] inverse_wishart = ot.InverseWishart(Scale, DoF) logdensity = inverse_wishart.computeLogPDF(X) logratio = - self.logmultigamma(dimension, 0.5 * DoF) \ + dimension * ot.SpecFunc_LnGamma(0.5 * (DoF + dimension - 1)) for d in range(dimension): inverse_gamma = ot.InverseGamma(k, 2. / Scale[d, d]) logdensity = logdensity - inverse_gamma.computeLogPDF(diagX[d, 0]) logratio = logratio + 0.5 * \ (1 - dimension) * log(0.5 * Scale[d, d]) assert_almost_equal(logdensity, logratio)
def test_solver(solver): relEps = solver.getRelativeError() absEps = solver.getAbsoluteError() def test_f1(x): y = exp(x[0]) - 1.9151695967140057e-174 return [y] f1 = ot.PythonFunction(1, 1, test_f1) root = solver.solve(f1, 0.0, -450.0, -350.0) ott.assert_almost_equal(root, -400.0, relEps, absEps) def test_f2(x): y = exp(x[0]) - 5.221469689764144e+173 return [y] f2 = ot.PythonFunction(1, 1, test_f2) root = solver.solve(f2, 0.0, 350.0, 450.0) ott.assert_almost_equal(root, 400.0, relEps, absEps)
def test_ZeroMean(self): # Create the KL result numberOfVertices = 10 interval = ot.Interval(-1.0, 1.0) mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval) covariance = ot.SquaredExponential() process = ot.GaussianProcess(covariance, mesh) sampleSize = 10 processSample = process.getSample(sampleSize) threshold = 0.0 algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold) algo.run() klresult = algo.getResult() # Create the KL reduction meanField = processSample.computeMean() klreduce = ot.KarhunenLoeveReduction(klresult) # Generate a trajectory and reduce it field = process.getRealization() values = field.getValues() reducedValues = klreduce(values) ott.assert_almost_equal(values, reducedValues)
def test_two_outputs(): f = ot.SymbolicFunction(['x'], ['x * sin(x)', 'x * cos(x)']) sampleX = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0]] sampleY = f(sampleX) basis = ot.Basis([ ot.SymbolicFunction(['x'], ['x']), ot.SymbolicFunction(['x'], ['x^2']) ]) covarianceModel = ot.SquaredExponential([1.0]) covarianceModel.setActiveParameter([]) algo = ot.KrigingAlgorithm(sampleX, sampleY, covarianceModel, basis) algo.run() result = algo.getResult() mm = result.getMetaModel() assert mm.getOutputDimension() == 2, "wrong output dim" ott.assert_almost_equal(mm(sampleX), sampleY) # Check the conditional covariance reference_covariance = ot.Matrix([[4.4527, 0.0, 8.34404, 0.0], [0.0, 2.8883, 0.0, 5.41246], [8.34404, 0.0, 15.7824, 0.0], [0.0, 5.41246, 0.0, 10.2375]]) ott.assert_almost_equal( result([[9.5], [10.0]]).getCovariance() - reference_covariance, ot.Matrix(4, 4), 0.0, 2e-2)
def test_computeLogPDF_1D_case(self): """Test InverseWishart.computeLogPDF in the one-dimensional case""" k, beta = self.k, self.beta def logPDF(x): if x <= 0.: raise ValueError("math domain error") return k*log(beta) - ot.SpecFunc_LogGamma(k) - (k+1)*log(x) - beta/x data = ((self.inverse_gamma.drawPDF()).getDrawable(0)).getData() i = 0 while data[i, 0] <= 0.: i += 1 for d in data[i:, 0]: x = d[0] logPDFx = logPDF(x) logPDFx_IW = self.one_dimensional_inverse_wishart.computeLogPDF(x) logPDFx_IG = self.inverse_gamma.computeLogPDF(x) assert_almost_equal(logPDFx_IW, logPDFx) assert_almost_equal(logPDFx_IG, logPDFx) assert_almost_equal(logPDFx_IW, logPDFx_IG)
def test_computeLogPDF_1D_case(self): """Test InverseWishart.computeLogPDF in the one-dimensional case""" k, beta = self.k, self.beta def logPDF(x): if x <= 0.: raise ValueError("math domain error") return k * log(beta) - ot.SpecFunc_LogGamma(k) - (k + 1) * log(x) - beta / x data = ((self.inverse_gamma.drawPDF()).getDrawable(0)).getData() i = 0 while data[i, 0] <= 0.: i += 1 for d in data[i:, 0]: x = d[0] logPDFx = logPDF(x) logPDFx_IW = self.one_dimensional_inverse_wishart.computeLogPDF(x) logPDFx_IG = self.inverse_gamma.computeLogPDF(x) assert_almost_equal(logPDFx_IW, logPDFx) assert_almost_equal(logPDFx_IG, logPDFx) assert_almost_equal(logPDFx_IW, logPDFx_IG)
def test_one_input_one_output(): sampleSize = 6 dimension = 1 f = ot.SymbolicFunction(['x0'], ['x0 * sin(x0)']) X = ot.Sample(sampleSize, dimension) X2 = ot.Sample(sampleSize, dimension) for i in range(sampleSize): X[i, 0] = 3.0 + i X2[i, 0] = 2.5 + i X[0, 0] = 1.0 X[1, 0] = 3.0 X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = f(X) Y2 = f(X2) # create algorithm basis = ot.ConstantBasisFactory(dimension).build() covarianceModel = ot.SquaredExponential([1e-02], [4.50736]) algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis) algo.run() # perform an evaluation result = algo.getResult() ott.assert_almost_equal(result.getMetaModel()(X), Y) ott.assert_almost_equal(result.getResiduals(), [1.32804e-07], 1e-3, 1e-3) ott.assert_almost_equal(result.getRelativeErrors(), [5.20873e-21]) # Kriging variance is 0 on learning points covariance = result.getConditionalCovariance(X) covariancePoint = ot.Point(covariance.getImplementation()) theoricalVariance = ot.Point(sampleSize * sampleSize) ott.assert_almost_equal(covariance, ot.Matrix(sampleSize, sampleSize), 8.95e-7, 8.95e-7) # Covariance per marginal & extract variance component coll = result.getConditionalMarginalCovariance(X) var = [mat[0, 0] for mat in coll] ott.assert_almost_equal(var, [0] * sampleSize, 1e-14, 1e-14) # Variance per marginal var = result.getConditionalMarginalVariance(X) ott.assert_almost_equal(var, ot.Point(sampleSize), 1e-14, 1e-14)
def test_parameters_iso(): scale = [] amplitude = 1.0 extraParameter = [] # model 1 atom_ex = ot.IsotropicCovarianceModel(ot.MaternModel(), 2) atom_ex.setScale([5]) atom_ex.setAmplitude([1.5]) scale.append(5) amplitude *= 1.5 extraParameter.append(atom_ex.getKernel().getFullParameter()[-1]) # model2 m = ot.MaternModel() m.setNu(2.5) m.setScale([3]) m.setAmplitude([3]) scale.append(3) amplitude *= 3 extraParameter.append(m.getNu()) # model 3 atom = ot.IsotropicCovarianceModel(ot.AbsoluteExponential(), 2) atom.setScale([2]) atom.setAmplitude([2.5]) scale.append(2) amplitude *= 2.5 model = ot.ProductCovarianceModel([atom_ex, m, atom]) ott.assert_almost_equal(model.getScale(), scale, 1e-16, 1e-16) ott.assert_almost_equal(model.getAmplitude(), [amplitude], 1e-16, 1e-16) ott.assert_almost_equal(model.getFullParameter(), scale + [amplitude] + extraParameter, 1e-16, 1e-16) # active parameter should be scale + amplitude ott.assert_almost_equal(model.getActiveParameter(), [0, 1, 2, 3], 1e-16, 1e-16) # setting new parameters extraParameter = [2.5, 0.5] model.setFullParameter([6, 7, 8, 2] + extraParameter) ott.assert_almost_equal(model.getCollection()[ 0].getScale()[0], 6, 1e-16, 1e-16) ott.assert_almost_equal(model.getCollection()[ 1].getScale()[0], 7, 1e-16, 1e-16) ott.assert_almost_equal(model.getCollection()[ 2].getScale()[0], 8, 1e-16, 1e-16) ott.assert_almost_equal(model.getAmplitude()[0], 2, 1e-16, 1e-16) ott.assert_almost_equal(model.getCollection( )[0].getFullParameter()[-1], extraParameter[0], 1e-16, 1e-16) ott.assert_almost_equal(model.getCollection( )[1].getFullParameter()[-1], extraParameter[1], 1e-16, 1e-16) # checking active par setting model.setActiveParameter([0, 1, 2, 3, 5]) ott.assert_almost_equal(model.getParameter(), [ 6, 7, 8, 2, extraParameter[-1]], 1e-16, 1e-16)
# algo.setMaximumCoefficientOfVariation(1e-6) algo.setStandardDeviationCriterionType('MAX') algo.setCoefficientOfVariationCriterionType('NONE') # algo.setMaximumStandardDeviation(1.6) # print(algo.getMaximumStandardDeviation()) # algo.setProgressCallback(progress) # algo.setStopCallback(stop) print('algo=', algo) # Perform the simulation algo.run() # Stream out the result result = algo.getResult() print('result=', result) ref_mu = composite.getSample(1000000).computeMean() ref_var = composite.getSample(1000000).computeVariance() print('mu=', ref_mu, 'var=', ref_var) ott.assert_almost_equal(result.getExpectationEstimate(), ref_mu, 1e-2, 1e-5) #ott.assert_almost_equal(result.getVarianceEstimate(), ref_var, 1e-2, 1e-5) expectationDistribution = result.getExpectationDistribution() print(expectationDistribution) convergenceGraph = algo.drawExpectationConvergence() #from openturns.viewer import View # View(convergenceGraph).ShowAll()
for i in range(obsSize): for j in range(chainDim): P[i, j] = p[i, j] Qn = P.transpose() * P + Q0 Qn_inv = ot.SquareMatrix(chainDim) for j in range(chainDim): I_j = [0] * chainDim I_j[j] = 1.0 Qn_inv_j = Qn.solveLinearSystem(I_j) for i in range(chainDim): Qn_inv[i, j] = Qn_inv_j[i] sigma_exp = [0] * chainDim for i in range(chainDim): sigma_exp[i] = m.sqrt(Qn_inv[i, i]) y_vec = [0] * obsSize for i in range(obsSize): y_vec[i] = y_obs[i, 0] x_emp = Qn.solveLinearSystem(P.transpose() * y_vec) mu_exp = Qn.solveLinearSystem((P.transpose() * P) * x_emp + ot.Matrix(Q0) * mu0) print('sample mean=', x_mu) print('expected mean=', mu_exp) ott.assert_almost_equal(x_mu, mu_exp, 1e-1, 1e-3) print('covariance=', x_cov) print('expected covariance=', Qn_inv) ott.assert_almost_equal(x_cov, Qn_inv, 1e-3, 2e-2)
for method in methods: print("method=", method) # 1. Check with local error covariance print("Local error covariance") algo = ot.GaussianLinearCalibration(modelX, x, y, candidate, priorCovariance, errorCovariance, method) algo.run() calibrationResult = algo.getResult() # Analysis of the results # Maximum A Posteriori estimator thetaMAP = calibrationResult.getParameterMAP() exactTheta = ot.Point([5.69186, 0.0832132, 0.992301]) rtol = 1.e-2 assert_almost_equal(thetaMAP, exactTheta, rtol) # Covariance matrix of theta thetaPosterior = calibrationResult.getParameterPosterior() covarianceThetaStar = matrixToSample(thetaPosterior.getCovariance()) exactCovarianceTheta = ot.Sample(\ [[ 0.308302, -0.000665387, 6.81135e-05 ], \ [ -0.000665387, 8.36243e-06, -8.86775e-07 ], \ [ 6.81135e-05, -8.86775e-07, 9.42234e-08 ]]) assert_almost_equal(covarianceThetaStar, exactCovarianceTheta) # Check other fields print("result=", calibrationResult) # 2. Check with global error covariance print("Global error covariance")
# Calibration of default optimizer ot.ResourceMap.SetAsScalar( 'GeneralLinearModelAlgorithm-DefaultOptimizationLowerBound', 1.0e-5) ot.ResourceMap.SetAsScalar( 'GeneralLinearModelAlgorithm-DefaultOptimizationUpperBound', 100) # Data & estimation inputDimension = 1 X = ot.Normal().getSample(100) X = X.sortAccordingToAComponent(0) covarianceModel = ot.SquaredExponential([1.0], [1.0]) model = ot.SymbolicFunction(["x"], ["x - 0.6 * cos(x/3)"]) Y = model(X) basis = ot.QuadraticBasisFactory(inputDimension).build() algo = ot.GeneralLinearModelAlgorithm(X, Y, covarianceModel, basis, True) algo.setOptimizationAlgorithm(ot.NLopt('LN_NELDERMEAD')) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y ott.assert_almost_equal(residual.computeCenteredMoment(2), [1.06e-05], 1e-5, 1e-5) ott.assert_almost_equal(conditionalCovariance.getParameter(), [0.619144, 0.000937], 5e-3, 1e-3) likelihood = algo.getObjectiveFunction() assert likelihood.getInputDimension() == 1, "likelihood dim" print("ok")
def test_one_input_one_output(): sampleSize = 6 dimension = 1 f = ot.SymbolicFunction(['x0'], ['x0 * sin(x0)']) X = ot.Sample(sampleSize, dimension) X2 = ot.Sample(sampleSize, dimension) for i in range(sampleSize): X[i, 0] = 3.0 + i X2[i, 0] = 2.5 + i X[0, 0] = 1.0 X[1, 0] = 3.0 X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = f(X) Y2 = f(X2) # create covariance model basis = ot.ConstantBasisFactory(dimension).build() covarianceModel = ot.SquaredExponential() # create algorithm algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis) # set sensible optimization bounds and estimate hyperparameters algo.setOptimizationBounds(ot.Interval(X.getMin(), X.getMax())) algo.run() # perform an evaluation result = algo.getResult() ott.assert_almost_equal(result.getMetaModel()(X), Y) ott.assert_almost_equal(result.getResiduals(), [1.32804e-07], 1e-3, 1e-3) ott.assert_almost_equal(result.getRelativeErrors(), [5.20873e-21]) # Kriging variance is 0 on learning points covariance = result.getConditionalCovariance(X) nullMatrix = ot.Matrix(sampleSize, sampleSize) ott.assert_almost_equal(covariance, nullMatrix, 0.0, 1e-13) # Kriging variance is non-null on validation points validCovariance = result.getConditionalCovariance(X2) values = ot.Matrix([[ 0.81942182, -0.35599947, -0.17488593, 0.04622401, -0.03143555, 0.04054783 ], [ -0.35599947, 0.20874735, 0.10943841, -0.03236419, 0.02397483, -0.03269184 ], [ -0.17488593, 0.10943841, 0.05832917, -0.01779918, 0.01355719, -0.01891618 ], [ 0.04622401, -0.03236419, -0.01779918, 0.00578327, -0.00467674, 0.00688697 ], [ -0.03143555, 0.02397483, 0.01355719, -0.00467674, 0.0040267, -0.00631173 ], [ 0.04054783, -0.03269184, -0.01891618, 0.00688697, -0.00631173, 0.01059488 ]]) ott.assert_almost_equal(validCovariance - values, nullMatrix, 0.0, 1e-7) # Covariance per marginal & extract variance component coll = result.getConditionalMarginalCovariance(X) var = [mat[0, 0] for mat in coll] ott.assert_almost_equal(var, [0] * sampleSize, 1e-14, 1e-13) # Variance per marginal var = result.getConditionalMarginalVariance(X) ott.assert_almost_equal(var, ot.Sample(sampleSize, 1), 1e-14, 1e-13) # Prediction accuracy ott.assert_almost_equal(Y2, result.getMetaModel()(X2), 0.3, 0.0)
X[1, 0] = 3.0 X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = model(X) # Data validation Y2 = model(X2) for i in range(sampleSize): # Add a small noise to data Y[i, 0] += 0.01 * ot.DistFunc.rNormal() basis = ot.LinearBasisFactory(spatialDimension).build() covarianceModel = ot.DiracCovarianceModel(spatialDimension) algo = ot.GeneralizedLinearModelAlgorithm(X, Y, covarianceModel, basis) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y assert_almost_equal(residual.computeCenteredMoment(2), [0.00013144], 1e-5, 1e-5) assert_almost_equal(conditionalCovariance.getParameter(), [ 0.011464782674211804], 1e-5, 1e-3) print("Test Ok") except: import sys print("t_GeneralizedLinearModelAlgorithm_std_hmat.py", sys.exc_info()[0], sys.exc_info()[1])
from __future__ import print_function import openturns as ot from openturns.testing import assert_almost_equal from openturns.usecases import stressed_beam as stressed_beam from math import pi ot.TESTPREAMBLE() ot.PlatformInfo.SetNumericalPrecision(5) """ Test the import of the AxialStressedBeam data class. """ sb = stressed_beam.AxialStressedBeam() # test parameters assert_almost_equal(sb.D, 0.02, 1e-12) assert_almost_equal(sb.muR, 3.0e6, 1e-12) assert_almost_equal(sb.sigmaR, 3.0e5, 1e-12) assert_almost_equal(sb.muF, 750.0, 1e-12) assert_almost_equal(sb.sigmaF, 50.0, 1e-12) # test marginals means assert_almost_equal(sb.distribution_R.getMean()[0], 3.0e6, 1e-12) assert_almost_equal(sb.distribution_F.getMean()[0], 750.0, 1e-12) # special value of the model function X = ot.Point([1.0, pi/10000.0]) assert_almost_equal(sb.model(X), [0.0], 1e-12)
X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = model(X) # Data validation Y2 = model(X2) for i in range(sampleSize): # Add a small noise to data Y[i, 0] += 0.01 * ot.DistFunc.rNormal() basis = ot.LinearBasisFactory(spatialDimension).build() covarianceModel = ot.DiracCovarianceModel(spatialDimension) algo = ot.GeneralizedLinearModelAlgorithm(X, Y, covarianceModel, basis) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y assert_almost_equal(residual.computeCenteredMoment(2), [0.00013144], 1e-5, 1e-5) assert_almost_equal(conditionalCovariance.getParameter(), [0.011464782674211804], 1e-5, 1e-3) print("Test Ok") except: import sys print("t_GeneralizedLinearModelAlgorithm_std_hmat.py", sys.exc_info()[0], sys.exc_info()[1])
def py_f(X): return X # Check if the meoization propagates through the finite difference gradients # Here we use a PythonFunction as its gradient/hessian are based on finite # differences by default ot_f = ot.MemoizeFunction(ot.PythonFunction(3, 3, py_f)) x = [1.0, 2.0, 3.0] n_calls_0 = ot_f.getCallsNumber() res_f = ot_f(x) res_grad = ot_f.gradient(x) res_hess = ot_f.hessian(x) n_calls_1 = ot_f.getCallsNumber() # 25=1+6+18 assert_almost_equal(n_calls_1 - n_calls_0, 25, 0.0, 0.0) # Do the computation once again n_calls_0 = n_calls_1 res_f = ot_f(x) res_grad = ot_f.gradient(x) res_hess = ot_f.hessian(x) n_calls_1 = ot_f.getCallsNumber() # 0=everything is reused assert_almost_equal(n_calls_1 - n_calls_0, 0, 0.0, 0.0) # Now, switch to noncentered gradients to reduce the calls to the minimum eps = 1e-8 gr_f = ot.NonCenteredFiniteDifferenceGradient(eps, ot_f.getEvaluation()) ot_f.setGradient(gr_f) x = [3, 1, 2] n_calls_0 = n_calls_1 res_f = ot_f(x)
ot.TESTPREAMBLE() f = ot.SymbolicFunction(["x"], ["sin(x)"]) a = -2.5 b = 4.5 # Integrate sin(t) between a & b --> cos(b) - sin(b) ref = math.cos(a) - math.cos(b) all_methods = [ot.FejerAlgorithm.FEJERTYPE1, ot.FejerAlgorithm.FEJERTYPE2, ot.FejerAlgorithm.CLENSHAWCURTIS] # 1D checking for method in all_methods: algo = ot.FejerAlgorithm([100], method) value, adaptedNodes = algo.integrateWithNodes(f, ot.Interval(a, b)) ott.assert_almost_equal(value[0], ref, 1e-10, 1e-10) g = ot.SymbolicFunction(["x", "y"], ["cos(pi_ * x / 2) * sin(pi_ * y)"]) ref = 8 / (math.pi * math.pi) interval = ot.Interval([-1, 0], [1, 1]) for method in all_methods: algo = ot.FejerAlgorithm([64, 64], method) value, adaptedNodes = algo.integrateWithNodes(g, interval) ott.assert_almost_equal(value[0], ref, 1e-10, 1e-10) # Now we use the same calculus using variables changes h = ot.SymbolicFunction( ["x", "y"], ["cos(pi_ * x / 2) * sin(pi_ * y / 2 + pi_/2 ) / 2"]) interval = ot.Interval([-1, -1], [1, 1]) for method in all_methods: algo = ot.FejerAlgorithm([64, 64], method)
X[0, 0] = 1.0 X[1, 0] = 3.0 X2[0, 0] = 2.0 X2[1, 0] = 4.0 Y = model(X) # Data validation Y2 = model(X2) for i in range(sampleSize): # Add a small noise to data Y[i, 0] += 0.01 * ot.DistFunc.rNormal() basis = ot.LinearBasisFactory(inputDimension).build() covarianceModel = ot.DiracCovarianceModel(inputDimension) algo = ot.GeneralLinearModelAlgorithm(X, Y, covarianceModel, basis) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y assert_almost_equal(residual.computeCenteredMoment(2), [0.00013144], 1e-5, 1e-5) print("Test Ok") except: import sys print("t_GeneralLinearModelAlgorithm_std_hmat.py", sys.exc_info()[0], sys.exc_info()[1])
Cov2.setScale(Y.computeStandardDeviation()) # This is the GSA-type estimator: weight is 1. W = ot.SquareMatrix(size) for i in range(size): W[i, i] = 1.0 # Using a biased estimator estimatorTypeV = ot.HSICVStat() # Loop over marginals hsicIndexRef = [0.02331323, 0.00205350, 0.00791711] for i in range(3): test = X.getMarginal(i) # Set input covariance scale Cov1.setScale(test.computeStandardDeviation()) hsicIndex = estimatorTypeV.computeHSICIndex(test, Y, Cov1, Cov2, W) ott.assert_almost_equal(hsicIndex, hsicIndexRef[i]) # Using an unbiased estimator estimatorTypeU = ot.HSICUStat() # Loop over marginals hsicIndexRef = [0.02228377, 0.00025668, 0.00599247] for i in range(3): test = X.getMarginal(i) # Set input covariance scale Cov1.setScale(test.computeStandardDeviation()) hsicIndex = estimatorTypeU.computeHSICIndex(test, Y, Cov1, Cov2, W) ott.assert_almost_equal(hsicIndex, hsicIndexRef[i])
# Define OptimizationProblem problem = ot.OptimizationProblem(objectiveFun) bounds = ot.Interval([0., 0., 0], [1., 1., 4]) varTypes = [ot.OptimizationProblemImplementation.INTEGER, ot.OptimizationProblemImplementation.CONTINUOUS, ot.OptimizationProblemImplementation.CONTINUOUS] problem.setBounds(bounds) problem.setVariablesType(varTypes) problem.setMinimization(True) # Define OptimizationAlgorithm x0 = [0]*3 algo = ot.Bonmin(problem, "B-BB") algo.setStartingPoint(x0) algo.setMaximumEvaluationNumber(10000) algo.setMaximumIterationNumber(1000) #ot.ResourceMap.AddAsScalar('Bonmin-bonmin.time_limit', 60) algo.run() # Retrieve result result = algo.getResult() x_star = result.getOptimalPoint() print("x*=", x_star) y_star = result.getOptimalValue() neval = result.getEvaluationNumber() print("f(x*)=", y_star, "neval=", neval) # ASSERTIONS ott.assert_almost_equal(x_star, [1.0, 0.0, 0.25], 1, 5e-4)
for minimization in [True, False]: if algoName == 'NONLINEAR_CONJUGATE_GRADIENT' and not minimization: # goes very far and the function cannot evaluate continue print('algoName=', algoName, 'minimization=', minimization) problem = ot.OptimizationProblem(f) problem.setMinimization(minimization) algo = ot.Ceres(problem, algoName) algo.setStartingPoint(startingPoint) # algo.setProgressCallback(progress) # algo.setStopCallback(stop) algo.run() result = algo.getResult() x_star = result.getOptimalPoint() if minimization and algoName != 'STEEPEST_DESCENT': ott.assert_almost_equal(x_star, p_ref, 5e-2) print(result) # least-squares optimization n = 3 m = 10 x = [[0.5 + i] for i in range(m)] model = ot.SymbolicFunction(['a', 'b', 'c', 'x'], ['a + b * exp(min(500, c * x))']) p_ref = [2.8, 1.2, 0.5] # a, b, c modelx = ot.ParametricFunction(model, [0, 1, 2], p_ref) y = modelx(x)
def computePDF(self, x): u = x[0] if u < -1 or u > 1: y = 0.0 else: y = self.c * (1 - u**2)**2 return y def getRange(self): return ot.Interval(-1.0, 1.0) # Using some reference values # See https://en.wikipedia.org/wiki/Kernel_(statistics)#Kernel_functions_in_common_use # First Normal dist with default ctor distribution = ot.Normal() ott.assert_almost_equal(distribution.getRoughness(), 0.5 /m.sqrt(m.pi)) # Dimension 2 (Fix https://github.com/openturns/openturns/issues/1485) # Indep copula : product of integrales distribution = ot.Normal(2) ott.assert_almost_equal(distribution.getRoughness(), compute_roughness_sampling(distribution)) # 2D Normal with scale & correlation # This allows checking that Normal::getRoughness is well implemented corr = ot.CorrelationMatrix(2) corr[1, 0] = 0.3 distribution = ot.Normal([0, 0], [1, 2], corr) ott.assert_almost_equal(distribution.getRoughness(), compute_roughness_sampling(distribution))
problem = ot.OptimizationProblem(objectiveFun) problem.setInequalityConstraint(constraintFun) bounds = ot.Interval([0., 0., 0., 0.], [1., 1., 1., 1.]) problem.setBounds(bounds) problem.setMinimization(True) problem.setVariablesType([ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY, ot.OptimizationProblemImplementation.BINARY]) # Define OptimizationAlgorithm x0 = [0., 0., 0., 0.] algo = ot.Bonmin(problem, "B-BB") algo.setStartingPoint(x0) algo.setMaximumEvaluationNumber(10000) algo.setMaximumIterationNumber(1000) ot.ResourceMap.AddAsScalar('Bonmin-bonmin.time_limit', 60) algo.run() # Retrieve result result = algo.getResult() x_star = result.getOptimalPoint() print("x*=", x_star) y_star = result.getOptimalValue() neval = result.getEvaluationNumber() print("f(x*)=", y_star, "neval=", neval) print("g(x*)=", constraintFun(x_star)) # ASSERTION ott.assert_almost_equal(x_star, [0, 1, 1, 1], 1, 5e-4)
print("================") print("Test using NLOpt") print("================") # Calibration of default optimizer ot.ResourceMap.SetAsNumericalScalar('GeneralizedLinearModelAlgorithm-DefaultOptimizationLowerBound', 1.0e-5) ot.ResourceMap.SetAsNumericalScalar('GeneralizedLinearModelAlgorithm-DefaultOptimizationUpperBound', 100) # Data & estimation spatialDimension = 1 X = ot.Normal().getSample(100) X = X.sortAccordingToAComponent(0) covarianceModel = ot.SquaredExponential( [1.0], [1.0]) model = ot.NumericalMathFunction(["x"], ["x - 0.6 * cos(x/3)"]) Y = model(X) basis = ot.QuadraticBasisFactory(spatialDimension).build() algo = ot.GeneralizedLinearModelAlgorithm(X, Y, covarianceModel, basis) algo.setOptimizationSolver(ot.NelderMead()) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y assert_almost_equal(residual.computeCenteredMoment(2), [1.06e-05], 1e-5, 1e-5) assert_almost_equal(conditionalCovariance.getParameter(), [0.702138,0.00137], 2e-3, 1e-3) print("Test Ok") except: import sys print("t_GeneralizedLinearModelAlgorithm_nlopt.py", sys.exc_info()[0], sys.exc_info()[1])