def __init__(self, monteCarloResult, distribution, deltas): # the monte carlo result must have its underlying function with # the history enabled because the failure sample is obtained using it self._monteCarloResult = monteCarloResult self.function = ot.MemoizeFunction( self._monteCarloResult.getEvent().getFunction()) if self.function.getOutputHistory().getSize() == 0: raise AttributeError("The performance function of the Monte Carlo "+\ "simulation result should be a MemoizeFunction.") # the original distribution if distribution.hasIndependentCopula(): self._distribution = distribution else: raise Exception( "The distribution must have an independent copula.") self._dim = self._distribution.getDimension() # the 1d or 2d sequence of deltas self._originalDelta = np.vstack(np.array(deltas)) self._deltaValues = self._originalDelta.copy() self._deltaSize = self._deltaValues.shape[0] if self._deltaValues.shape[1] != 1 and self._deltaValues.shape[ 1] != self._dim: raise AttributeError('The deltas parameter must be 1d sequence of ' + \ 'float or 2d sequence of float of dimension ' +\ 'equal to {}.'.format(self._dim)) # check if the delta values have only one dimension -> copy the columns if self._deltaValues.shape[1] == 1: self._deltaValues = np.ones((self._deltaValues.shape[0], self._dim)) * \ self._deltaValues # initialize array result # rows : delta # columns : maginal self._pfdelta = np.zeros((self._deltaSize, self._dim)) self._varPfdelta = np.zeros((self._deltaSize, self._dim)) self._indices = np.zeros((self._deltaSize, self._dim)) # for loop to avoid copy id of the distribution collection self._estimatorDist = [ ot.DistributionCollection(self._dim) for i in range(self._deltaSize) ] # set the gaus Kronrod algorithm self._gaussKronrod = ot.GaussKronrod( 50, 1e-5, ot.GaussKronrodRule(ot.GaussKronrodRule.G7K15))
def _runMonteCarlo(self, defect): # set a parametric function where the first parameter = given defect g = ot.ParametricFunction(self._metamodel, [0], [defect]) g = ot.MemoizeFunction(g) g.enableHistory() g.clearHistory() g.clearCache() output = ot.CompositeRandomVector(g, ot.RandomVector(self._distribution)) event = ot.ThresholdEvent(output, ot.Greater(), self._detectionBoxCox) ##### Monte Carlo ######## algo_MC = ot.ProbabilitySimulationAlgorithm(event) algo_MC.setMaximumOuterSampling(self._samplingSize) # set negative coef of variation to be sure the stopping criterion is the sampling size algo_MC.setMaximumCoefficientOfVariation(-1) algo_MC.run() return algo_MC.getResult()
def numericalmathfunction(*args, **kwargs): wrapper_instance = wrapper(*args, **kwargs) func = ot.Function(wrapper_instance) # Enable cache if self.enableCache: func = ot.MemoizeFunction(func) func.disableHistory() # Update __doc__ of the function if self.doc is None: # Inherit __doc__ from ParallelWrapper. func.__doc__ = wrapper.__doc__ else: func.__doc__ = self.doc # Add the kwargs as attributes of the function for reference # purposes. func.__dict__.update(kwargs) func.__dict__.update(wrapper_instance.__dict__) return func
# %% def functionFlooding(X) : L = 5.0e3 B = 300.0 Q, K_s, Z_v, Z_m = X alpha = (Z_m - Z_v)/L if alpha < 0.0 or K_s <= 0.0: H = np.inf else: H = (Q/(K_s*B*np.sqrt(alpha)))**(3.0/5.0) return [H] # %% g = ot.PythonFunction(4, 1, functionFlooding) g = ot.MemoizeFunction(g) g.setOutputDescription(["H (m)"]) # %% # We load the input distribution for :math:`Q` : # %% Q = fm.Q print(Q) # %% # Set the parameters to be calibrated. # %% K_s = ot.Dirac(30.0) Z_v = ot.Dirac(50.0)
print(modelFunc.gradient([s[0], r, c]).transpose()) print(mycf.parameterGradient(s).transpose()) # Check if parametric functions and memoize functions work well together n_calls = 0 def py_f(X): global n_calls n_calls += 1 return X ot_f = ot.MemoizeFunction(ot.PythonFunction(3, 3, py_f)) param_f = ot.ParametricFunction(ot_f, [0, 1], [1.0, 2.0]) x = [3.0] y = [1.5] n_calls_0 = ot_f.getCallsNumber() par_grad = param_f.parameterGradient(x) n_calls_1 = ot_f.getCallsNumber() assert n_calls_1 - n_calls_0 == 4, "Expected n_calls_1 - n_calls_0 == 4, here n_calls_1 - n_calls_0 == " + \ str(n_calls_1 - n_calls_0) assert n_calls == 4, "Expected n_calls == 4, here n_calls == " + str(n_calls) n_calls = 0 n_calls_0 = ot_f.getCallsNumber() f_grad = param_f.gradient(y) n_calls_1 = ot_f.getCallsNumber()
def python_eval(X): a, b = X y = a + b return [y] func4 = ot.PythonFunction(2, 1, python_eval) # %% # Ask for the dimension of the input and output vectors print(f.getInputDimension()) print(f.getOutputDimension()) # %% # Enable the history mechanism f = ot.MemoizeFunction(f) # %% # Evaluate the function at a particular point x = [1.0] * f.getInputDimension() y = f(x) print('x=', x, 'y=', y) # %% # Get the history samplex = f.getInputHistory() sampley = f.getOutputHistory() print('evaluation history = ', samplex, sampley) # %% # Clear the history mechanism
def rastriginPy(X): A = 10.0 delta = [x**2 - A * np.cos(2 * np.pi * x) for x in X] y = A + sum(delta) return [y] dim = 2 rastrigin = ot.PythonFunction(dim, 1, rastriginPy) print(rastrigin([1.0, 1.0])) # %% # Making `rastrigin` into a :class:`~openturns.MemoizeFunction` will make it recall all evaluated points. # %% rastrigin = ot.MemoizeFunction(rastrigin) # %% # This example is academic and the point achieving the global minimum of the function is known. # %% xexact = [0.0] * dim print(xexact) # %% # The optimization bounds must be specified. # %% lowerbound = [-4.4] * dim upperbound = [5.12] * dim bounds = ot.Interval(lowerbound, upperbound)
# %% x0 = ot.Point([-1.0, 1.0]) # %% xexact = ot.Point([1.0, 1.0]) # %% lowerbound = [-2.0, -2.0] upperbound = [2.0, 2.0] # %% # Plot the iso-values of the objective function # --------------------------------------------- # %% rosenbrock = ot.MemoizeFunction(rosenbrock) # %% graph = rosenbrock.draw(lowerbound, upperbound, [100] * 2) graph.setTitle("Rosenbrock function") view = viewer.View(graph) # %% # We see that the minimum is on the top right of the picture and the starting point is on the top left of the picture. Since the function has a long valley following the curve :math:`x_2 - x^2=0`, the algorithm generally have to follow the bottom of the valley. # %% # Create and solve the optimization problem # ----------------------------------------- # %% problem = ot.OptimizationProblem(rosenbrock)
# GumbelMuSigma parameter save gms_parameters = ot.GumbelMuSigma(1.5, 1.3) myStudy.add('gms_parameters', gms_parameters) # LogNormalMuSigma parameter save lnms_parameters = ot.LogNormalMuSigma(30000.0, 9000.0, 15000) myStudy.add('lnms_parameters', lnms_parameters) # LogNormalMuSigmaOverMu parameter save lnmsm_parameters = ot.LogNormalMuSigmaOverMu(0.63, 5.24, -0.5) myStudy.add('lnmsm_parameters', lnmsm_parameters) # WeibullMinMuSigma parameter save wms_parameters = ot.WeibullMinMuSigma(1.3, 1.23, -0.5) myStudy.add('wms_parameters', wms_parameters) # MemoizeFunction f = ot.SymbolicFunction(['x1', 'x2'], ['x1*x2']) memoize = ot.MemoizeFunction(f) memoize([5, 6]) myStudy.add('memoize', memoize) # print ('Study = ' , myStudy) myStudy.save() # Create a new Study Object myStudy = ot.Study() myStudy.setStorageManager(ot.XMLStorageManager(fileName)) myStudy.load() # print 'loaded Study = ' , myStudy # MemoizeFunction memoize = ot.MemoizeFunction()
g.add(curve) curve = u[0].draw(a, b).getDrawable(0) curve.setLineWidth(2) curve.setColor('red') g.add(curve) # Evaluate the integral with high precision: Iref = ot.IteratedQuadrature( ot.GaussKronrod(100000, 1e-13, ot.GaussKronrodRule( ot.GaussKronrodRule.G11K23))).integrate(f, a, b, l, u) # Evaluate the integral with the default GaussKronrod algorithm: f = ot.MemoizeFunction(f) I1 = ot.IteratedQuadrature(ot.GaussKronrod()).integrate(f, a, b, l, u) sample1 = f.getInputHistory() print('I1=', I1, '#evals=', sample1.getSize(), 'err=', abs(100.0 * (1.0 - I1[0] / Iref[0])), '%') cloud = ot.Cloud(sample1) cloud.setPointStyle('fcircle') cloud.setColor('green') g.add(cloud) f.clearHistory() # Evaluate the integral with the default IteratedQuadrature algorithm: I2 = ot.IteratedQuadrature().integrate(f, a, b, l, u) sample2 = f.getInputHistory() # print('I2=', I2, '#evals=', sample2.getSize(), \
#! /usr/bin/env python import openturns as ot from openturns.testing import assert_almost_equal f = ot.SymbolicFunction("x", "x^2") f = ot.MemoizeFunction(f) f.disableHistory() print(f) size = 4 inputSample = ot.Sample(size, 1) for i in range(size): inputSample[i, 0] = i outputSample = f(inputSample) print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) f.enableHistory() outputSample = f(inputSample) print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) f.clearHistory() print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) # Perform the computation twice outputSample = f(inputSample) outputSample = f(inputSample) print("input history=", f.getInputHistory())
# %% # Create the model. # %% model = ot.SymbolicFunction(['R', 'F'], ['R-F/(pi_*100.0)']) # %% modelCallNumberBefore = model.getEvaluationCallsNumber() modelGradientCallNumberBefore = model.getGradientCallsNumber() modelHessianCallNumberBefore = model.getHessianCallsNumber() # %% # To have access to the input and output samples after the simulation, activate the History mechanism. # %% model = ot.MemoizeFunction(model) # %% # Remove all the values stored in the history mechanism. # Care : it is done regardless the status of the History mechanism. # %% model.clearHistory() # %% # Create the event whose probability we want to estimate. # %% vect = ot.RandomVector(distribution) G = ot.CompositeRandomVector(model, vect) event = ot.ThresholdEvent(G, ot.Less(), 0.0)
# # The `MemoizeFunction` class defines a history system to store the calls to the function. # # ==================== =============================================== # Methods Description # ==================== =============================================== # `enableHistory()` enables the history (it is enabled by default) # `disableHistory()` disables the history # `clearHistory()` deletes the content of the history # `getHistoryInput()` a `Sample`, the history of inputs X # `getHistoryOutput()` a `Sample`, the history of outputs Y # ==================== =============================================== # %% myfunction = ot.PythonFunction(3, 2, mySimulator) myfunction = ot.MemoizeFunction(myfunction) # %% outputVariableOfInterest = ot.CompositeRandomVector(myfunction, inputRandomVector) montecarlosize = 10 outputSample = outputVariableOfInterest.getSample(montecarlosize) # %% # Get the history of input points. # %% inputs = myfunction.getInputHistory() inputs # %%
#! /usr/bin/env python from __future__ import print_function import openturns as ot f = ot.SymbolicFunction("x", "x^2") f = ot.MemoizeFunction(f) f.disableHistory() print(f) size = 4 inputSample = ot.Sample(size, 1) for i in range(size): inputSample[i, 0] = i outputSample = f(inputSample) print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) f.enableHistory() outputSample = f(inputSample) print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) f.clearHistory() print("Is history enabled for f? ", f.isHistoryEnabled()) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory()) # Perform the computation twice outputSample = f(inputSample) outputSample = f(inputSample) print("input history=", f.getInputHistory()) print("output history=", f.getOutputHistory())