def test_akmcs_expected_feasibility(): from UQpy.surrogates.kriging.regression_models.LinearRegression import LinearRegression from UQpy.surrogates.kriging.correlation_models.ExponentialCorrelation import ExponentialCorrelation marginals = [Normal(loc=0., scale=4.), Normal(loc=0., scale=4.)] x = MonteCarloSampling(distributions=marginals, nsamples=20, random_state=1) model = PythonModel(model_script='series.py', model_object_name="series") rmodel = RunModel(model=model) regression_model = LinearRegression() correlation_model = ExponentialCorrelation() K = Kriging( regression_model=regression_model, correlation_model=correlation_model, optimizations_number=10, correlation_model_parameters=[1, 1], optimizer=MinimizeOptimizer('l-bfgs-b'), ) # OPTIONS: 'U', 'EFF', 'Weighted-U' learning_function = ExpectedFeasibility(eff_a=0, eff_epsilon=2, eff_stop=0.001) a = AdaptiveKriging(distributions=marginals, runmodel_object=rmodel, surrogate=K, learning_nsamples=10**3, n_add=1, learning_function=learning_function, random_state=2) a.run(nsamples=25, samples=x.samples) assert a.samples[23, 0] == 1.366058523912817 assert a.samples[20, 1] == -12.914668932772358
def test_akmcs_expected_improvement_global_fit(): from UQpy.surrogates.kriging.regression_models.LinearRegression import LinearRegression from UQpy.surrogates.kriging.correlation_models.ExponentialCorrelation import ExponentialCorrelation marginals = [Normal(loc=0., scale=4.), Normal(loc=0., scale=4.)] x = MonteCarloSampling(distributions=marginals, nsamples=20, random_state=1) model = PythonModel(model_script='series.py', model_object_name="series") rmodel = RunModel(model=model) regression_model = LinearRegression() correlation_model = ExponentialCorrelation() K = Kriging( regression_model=regression_model, correlation_model=correlation_model, optimizations_number=10, correlation_model_parameters=[1, 1], optimizer=MinimizeOptimizer('l-bfgs-b'), ) # OPTIONS: 'U', 'EFF', 'Weighted-U' learning_function = ExpectedImprovementGlobalFit() a = AdaptiveKriging(distributions=marginals, runmodel_object=rmodel, surrogate=K, learning_nsamples=10**3, n_add=1, learning_function=learning_function, random_state=2) a.run(nsamples=25, samples=x.samples) assert a.samples[23, 0] == 11.939859785098493 assert a.samples[20, 1] == -8.429899469300118
def test_akmcs_u(): from UQpy.surrogates.kriging.regression_models.LinearRegression import LinearRegression from UQpy.surrogates.kriging.correlation_models.ExponentialCorrelation import ExponentialCorrelation marginals = [Normal(loc=0., scale=4.), Normal(loc=0., scale=4.)] x = MonteCarloSampling(distributions=marginals, nsamples=20, random_state=1) model = PythonModel(model_script='series.py', model_object_name="series") rmodel = RunModel(model=model) regression_model = LinearRegression() correlation_model = ExponentialCorrelation() K = Kriging(regression_model=regression_model, correlation_model=correlation_model, optimizer=MinimizeOptimizer('l-bfgs-b'), optimizations_number=10, correlation_model_parameters=[1, 1], random_state=0) # OPTIONS: 'U', 'EFF', 'Weighted-U' learning_function = UFunction(u_stop=2) a = AdaptiveKriging(distributions=marginals, runmodel_object=rmodel, surrogate=K, learning_nsamples=10**3, n_add=1, learning_function=learning_function, random_state=2) a.run(nsamples=25, samples=x.samples) assert a.samples[23, 0] == -4.141979058326188 assert a.samples[20, 1] == -1.6476534435429009
def test_akmcs_samples_error(): from UQpy.surrogates.kriging.regression_models.LinearRegression import LinearRegression from UQpy.surrogates.kriging.correlation_models.ExponentialCorrelation import ExponentialCorrelation marginals = [Normal(loc=0., scale=4.), Normal(loc=0., scale=4.)] x = MonteCarloSampling(distributions=marginals, nsamples=20, random_state=0) model = PythonModel(model_script='series.py', model_object_name="series") rmodel = RunModel(model=model) regression_model = LinearRegression() correlation_model = ExponentialCorrelation() K = Kriging(regression_model=regression_model, correlation_model=correlation_model, optimizer=MinimizeOptimizer('l-bfgs-b'), optimizations_number=10, correlation_model_parameters=[1, 1], random_state=1) # OPTIONS: 'U', 'EFF', 'Weighted-U' learning_function = WeightedUFunction(weighted_u_stop=2) with pytest.raises(NotImplementedError): a = AdaptiveKriging(distributions=[Normal(loc=0., scale=4.)] * 3, runmodel_object=rmodel, surrogate=K, learning_nsamples=10**3, n_add=1, learning_function=learning_function, random_state=2, samples=x.samples)
def test_dist_object(): """Validate dist_object, when dist_object is a distribution object.""" with pytest.raises(BeartypeCallHintPepParamException): MonteCarloSampling(distributions='abc', random_state=np.random.RandomState(123))
def test_run_random_state(): """Check if random_state attribute is not an integer, np.random.RandomState object or None, when when 'run' method is called.""" with pytest.raises(BeartypeCallHintPepParamException): MonteCarloSampling(distributions=dist1).run(nsamples=5, random_state='abc')
def test_random_state2(): """Check if random_state attribute is not an integer, np.random.RandomState object or None, when dist_object is a list of multiple distribution class object.""" with pytest.raises(BeartypeCallHintPepParamException): MonteCarloSampling(distributions=[dist1, dist2], random_state='abc')
def test_nsamples_not_integer(): """Validate error check, when nsamples is not an integer, while calling 'run' method.""" with pytest.raises(BeartypeCallHintPepParamException): MonteCarloSampling(distributions=dist1, random_state=np.random.RandomState(123)).run(nsamples='abc')
import numpy as np import pytest from beartype.roar import BeartypeCallHintPepParamException from UQpy.distributions import Normal, MultivariateNormal from UQpy.sampling import MonteCarloSampling dist1 = Normal(loc=0., scale=1.) dist2 = Normal(loc=0., scale=1.) x = MonteCarloSampling(distributions=dist1, nsamples=5, random_state=np.random.RandomState(123)) x.transform_u01() y = MonteCarloSampling(distributions=[dist1, dist2]) y.run(nsamples=5, random_state=123) y.transform_u01() # Call run method multiple time, to cover lines where samples are append to existing ones z1 = MonteCarloSampling(distributions=dist1, nsamples=2, random_state=123) z1.run(nsamples=2) z2 = MonteCarloSampling(distributions=[dist1, dist2], nsamples=2, random_state=np.random.RandomState(123)) z2.run(nsamples=2) # Same object as z2, just to cover lines where, random_state is an integer z3 = MonteCarloSampling(distributions=[dist1, dist2], nsamples=2, random_state=123) z4 = MonteCarloSampling(distributions=[MultivariateNormal([0, 0])], nsamples=2, random_state=np.random.RandomState(123)) z4.run(nsamples=2) z4.transform_u01() dist3 = Normal(loc=0., scale=1.) del dist3.rvs z5 = MonteCarloSampling(distributions=[dist3], random_state=np.random.RandomState(123))
from UQpy.sampling import MonteCarloSampling, AdaptiveKriging from UQpy.run_model.RunModel import RunModel from UQpy.distributions import Uniform from local_BraninHoo import function import time from UQpy.utilities.MinimizeOptimizer import MinimizeOptimizer # %% md # # Using UQpy :class:`MonteCarloSampling` class to generate samples for two random variables, which are uniformly # distributed # %% marginals = [Uniform(loc=-5, scale=15), Uniform(loc=0, scale=15)] x = MonteCarloSampling(distributions=marginals, nsamples=20) # %% md # # :class:`.RunModel` class is used to define an object to evaluate the model at sample points. # %% model = PythonModel(model_script='local_BraninHoo.py', model_object_name='function') rmodel = RunModel(model=model) # %% md # # :class:`.Kriging` class defines an object to generate a surrogate model for a given set of data.
# %% normal1 = normal2 = Normal() # %% md # # Next, we'll construct a :code:`MonteCarloSampling` object :code:`mc` to generate random samples following those # distributions. Here, we specify an optional initial number of samples, :code:`nsamples` to be generated at the # object's construction. For teh purposes of this demonstration, we also supply a random seed :code:`random_state`. # # We access the generated samples via the :code:`samples` attribute. # %% mc = MonteCarloSampling(distributions=[normal1, normal2], nsamples=5, random_state=RandomState(123)) mc.samples # %% md # # To generate more samples on :code:`mc` after construction, we call :code:`mc.run` and once again specify # :code:`nsamples`. # %% mc.run(nsamples=2, random_state=RandomState(23)) mc.samples
import shutil from beartype.roar import BeartypeCallHintPepParamException from UQpy.run_model.model_execution.PythonModel import PythonModel from UQpy.run_model import ThirdPartyModel, RunModel from UQpy.sampling import MonteCarloSampling from UQpy.run_model.RunModel import RunModel from UQpy.distributions import Normal import pytest import os import numpy as np d = Normal(loc=0, scale=1) x_mcs = MonteCarloSampling(distributions=[d, d, d], nsamples=5, random_state=1234) x_mcs_new = MonteCarloSampling(distributions=[d, d, d], nsamples=5, random_state=2345) verbose_parameter = True # def test_div_zero(): # with pytest.raises(TypeError): # model = PythonModel(model_script='python_model.py', model_object_name='SumRVs', fmt=20, # delete_files=True) # runmodel_object = RunModel_New(model=model) # # # def test_fmt_1(): # with pytest.raises(TypeError):
# Define the distribution objects. # %% dist1 = Uniform(location=15000, scale=10000) dist2 = Uniform(location=450000, scale=80000) dist3 = Uniform(location=2.0e8, scale=0.5e8) # %% md # # Draw the samples using MCS. # %% x = MonteCarloSampling(distributions=[dist1, dist2, dist3] * 6, samples_number=5, random_state=938475) samples = np.array(x.samples).round(2) # %% md # # Run the model. # %% names_ = [ 'fc1', 'fy1', 'Es1', 'fc2', 'fy2', 'Es2', 'fc3', 'fy3', 'Es3', 'fc4', 'fy4', 'Es4', 'fc5', 'fy5', 'Es5', 'fc6', 'fy6', 'Es6' ] opensees_rc6_model = RunModel(samples=samples,
# %% m = PythonModel(model_script='local_eigenvalue_model.py', model_object_name="RunPythonModel") model = RunModel(model=m) # model = RunModel(model_script='local_eigenvalue_model.py') model.run(samples=y.samples) r_srom = model.qoi_list # %% md # # :class:`MonteCarloSampling` class is used to generate 1000 samples. # %% x_mcs = MonteCarloSampling(distributions=marginals, nsamples=1000) # %% md # # Run the model 'eigenvalue_model.py' for each sample generated through :class:`.MonteCarloSampling` class. # %% model.run(samples=x_mcs.samples, append_samples=False) r_mcs = model.qoi_list # %% md # # Plot the distribution of each eigenvalue, estimated using :class:`.SROM` and :class:`.MonteCarloSampling` weights. # %%
def test_dist_object3(): """Create a MCS object using DistributionND class object. Validate dist_object, when dist_object is not a list of distribution object.""" with pytest.raises(BeartypeCallHintPepParamException): MonteCarloSampling(distributions=['abc'], random_state=np.random.RandomState(123))
d2 = Uniform(location=0.02, scale=0.01) d3 = Uniform(location=0.02, scale=0.01) d4 = Uniform(location=0.0025, scale=0.0075) d5 = Uniform(location=0.02, scale=0.06) d6 = Uniform(location=0.02, scale=0.01) d7 = Uniform(location=0.02, scale=0.01) d8 = Uniform(location=0.0025, scale=0.0075) # %% md # # Draw the samples using MCS. # %% x = MonteCarloSampling(distributions=[d1, d2, d3, d4, d5, d6, d7, d8], samples_number=12, random_state=349875) # %% md # # Run the model. # %% run_ = RunModel(samples=x.samples, ntasks=6, model_script='dyna_script.py', input_template='dyna_input.k', var_names=['x0', 'y0', 'z0', 'R0', 'x1', 'y1', 'z1', 'R1'], model_dir='dyna_test', cluster=True,
from UQpy.run_model.RunModel import RunModel from UQpy.distributions import Normal from local_series import series import matplotlib.pyplot as plt import time from UQpy.utilities.MinimizeOptimizer import MinimizeOptimizer # %% md # # Using UQpy :class:`.MonteCarloSampling` class to generate samples for two random variables, which are normally # distributed with mean :math:`0` and variance :math:`1`. # %% marginals = [Normal(loc=0., scale=4.), Normal(loc=0., scale=4.)] x = MonteCarloSampling(distributions=marginals, nsamples=20, random_state=1) # %% md # # RunModel class is used to define an object to evaluate the model at sample points. # %% model = PythonModel(model_script='local_series.py', model_object_name='series') rmodel = RunModel(model=model) # %% md # # :class:`.Kriging` class defines an object to generate a surrogate model for a given set of data. # %%
# %% md # # Example 1: Three scalar random variables # ---------------------------------------------------- # In this example, we pass three scalar random variables. Note that this is different from assigning a single variable # with three components, which will be handled in the following example. # # Here we will pass the samples both as an ndarray and as a list. Recall that UQpy converts all samples into an ndarray # of at least two dimensions internally. # %% if pick_model in {'scalar', 'vector', 'all'}: d = Normal(loc=0, scale=1) x_mcs = MonteCarloSampling(distributions=[d, d, d], nsamples=5, random_state=987979) names = ['var1', 'var11', 'var111'] # UQpy returns samples as an ndarray. Convert them to a list for part 1.2 x_mcs_list = list(x_mcs.samples) print( "Monte Carlo samples of three random variables from a standard normal distribution." ) print('Samples stored as an array:') print('Data type:', type(x_mcs.samples)) print('Number of samples:', len(x_mcs.samples)) print('Dimensions of samples:', np.shape(x_mcs.samples)) print('Samples') print(x_mcs.samples) print()
# %% md # # Towards defining the sampling scheme # The fire load density is assumed to be uniformly distributed between 50 :math:`MJ/m^2` and 450 :math:`MJ/m^2`. # The yield strength is assumed to be normally distributed, with the parameters # being: mean = 250 :math:`MPa` and coefficient of variation of :math:`7%`. # # Creating samples using MCS. # %% d_n = Normal(loc=50, scale=400) d_u = Uniform(location=2.50e8, scale=1.75e7) x_mcs = MonteCarloSampling(distributions=[d_n, d_u], samples_number=100, random_state=987979) # %% md # # Running simulations using the previously defined model object and samples # %% sample_points = x_mcs.samples abaqus_sfe_model.run(samples=sample_points) # %% md # # The outputs from the analysis are the values of the performance function.
plt.ylabel(r'Stiffness ($k$)') plt.grid(True) plt.tight_layout() plt.show() m = PythonModel(model_script='local_Resonance_pfn.py', model_object_name="RunPythonModel") model = RunModel(model=m) # %% md # # Monte Carlo Simulation # %% x_mcs = MonteCarloSampling(distributions=[d1, d2]) x_mcs.run(nsamples=1000000) model.run(samples=x_mcs.samples) A = np.asarray(model.qoi_list) < 0 pf = np.shape(np.asarray( model.qoi_list)[np.asarray(model.qoi_list) < 0])[0] / 1000000 print(pf) ntrials = 1 pf_stretch = np.zeros((ntrials, 1)) cov1_stretch = np.zeros((ntrials, 1)) cov2_stretch = np.zeros((ntrials, 1)) m = np.ones(2) m[0] = 5