def test_derivatives_1_no_samples(): dist1 = Normal(loc=200, scale=20) dist2 = Normal(loc=150, scale=10) rx = np.array([[1.0, 0.0], [0.0, 1.0]]) ntf_obj = Nataf(distributions=[dist1, dist2], corr_x=rx) for file_name in glob.glob("Model_Runs_*"): shutil.rmtree(file_name) with pytest.raises(Exception): assert TaylorSeries._derivatives(nataf_object=ntf_obj, runmodel_object=model_i)
def test_sorm(setup): dist1 = Normal(loc=500, scale=100) dist2 = Normal(loc=1000, scale=100) dist = [dist1, dist2] form_obj = FORM(distributions=dist, runmodel_object=setup) form_obj.run() sorm_obj = SORM(form_object=form_obj) for file_name in glob.glob("Model_Runs_*"): shutil.rmtree(file_name) np.testing.assert_allclose(sorm_obj.failure_probability, 2.8803e-7, rtol=1e-02)
def test_derivatives_6_second(): model = PythonModel(model_script='pfn2.py', model_object_name='model_j', delete_files=True) h_func = RunModel(model=model) dist1 = Normal(loc=500, scale=100) dist2 = Normal(loc=1000, scale=100) point_u = np.array([1.73673009, 0.16383283]) rx = np.array([[1.0, 0.0], [0.0, 1.0]]) ntf_obj = Nataf(distributions=[dist1, dist2], corr_x=rx) hessian = TaylorSeries._derivatives(point_u=point_u, runmodel_object=h_func, nataf_object=ntf_obj, order='second') np.testing.assert_allclose(hessian, [[-0.00720754, 0.00477726], [0.00477726, -0.00316643]], rtol=1e-04)
def test_derivatives_5_run_model(setup): dist1 = Normal(loc=200, scale=20) dist2 = Normal(loc=150, scale=10) point_u = np.array([-2, 1]) rx = np.array([[1.0, 0.0], [0.0, 1.0]]) ntf_obj = Nataf(distributions=[dist1, dist2], corr_x=rx) gradient, qoi, array_of_samples = TaylorSeries._derivatives(point_u=point_u, runmodel_object=setup, nataf_object=ntf_obj) for file_name in glob.glob("Model_Runs_*"): shutil.rmtree(file_name) np.testing.assert_allclose(array_of_samples[0], [160, 160], rtol=1e-09) np.testing.assert_allclose(gradient, [20, -10], rtol=1e-09)
def get_polys(self, x): """ Calculates the normalized Hermite polynomials evaluated at sample points. :param x: :class:`numpy.ndarray` containing the samples. :return: Α list of :class:`numpy.ndarray` with the design matrix and the normalized polynomials. """ a, b = -np.inf, np.inf mean_ = Polynomials.get_mean(self) std_ = Polynomials.get_std(self) x_ = Polynomials.standardize_normal(x, mean_, std_) norm = Normal(0, 1) pdf_st = norm.pdf p = [] for i in range(self.degree): p.append(special.hermitenorm(i, monic=False)) return Polynomials.normalized(self.degree, x_, a, b, pdf_st, p)
def __init__( self, pdf_target: Union[Callable, list[Callable]] = None, log_pdf_target: Union[Callable, list[Callable]] = None, args_target: tuple = None, burn_length: Annotated[int, Is[lambda x: x >= 0]] = 0, jump: int = 1, dimension: int = None, seed: list = None, save_log_pdf: bool = False, concatenate_chains: bool = True, n_chains: int = None, proposal: Distribution = None, proposal_is_symmetric: bool = False, random_state: RandomStateType = None, nsamples: PositiveInteger = None, nsamples_per_chain: PositiveInteger = None, ): """ Metropolis-Hastings algorithm :cite:`MCMC1` :cite:`MCMC2` :param pdf_target: Target density function from which to draw random samples. Either `pdf_target` or `log_pdf_target` must be provided (the latter should be preferred for better numerical stability). If `pdf_target` is a callable, it refers to the joint pdf to sample from, it must take at least one input **x**, which are the point(s) at which to evaluate the pdf. Within :class:`.MCMC` the pdf_target is evaluated as: :code:`p(x) = pdf_target(x, \*args_target)` where **x** is a :class:`numpy.ndarray of shape :code:`(nsamples, dimension)` and `args_target` are additional positional arguments that are provided to :class:`.MCMC` via its `args_target` input. If `pdf_target` is a list of callables, it refers to independent marginals to sample from. The marginal in dimension :code:`j` is evaluated as: :code:`p_j(xj) = pdf_target[j](xj, \*args_target[j])` where **x** is a :class:`numpy.ndarray` of shape :code:`(nsamples, dimension)` :param log_pdf_target: Logarithm of the target density function from which to draw random samples. Either `pdf_target` or `log_pdf_target` must be provided (the latter should be preferred for better numerical stability). Same comments as for input `pdf_target`. :param args_target: Positional arguments of the pdf / log-pdf target function. See `pdf_target` :param burn_length: Length of burn-in - i.e., number of samples at the beginning of the chain to discard (note: no thinning during burn-in). Default is :math:`0`, no burn-in. :param jump: Thinning parameter, used to reduce correlation between samples. Setting :code:`jump=n` corresponds to skipping :code:`n-1` states between accepted states of the chain. Default is :math:`1` (no thinning). :param dimension: A scalar value defining the dimension of target density function. Either `dimension` and `n_chains` or `seed` must be provided. :param seed: Seed of the Markov chain(s), shape :code:`(n_chains, dimension)`. Default: :code:`zeros(n_chains x dimension)`. If seed is not provided, both n_chains and dimension must be provided. :param save_log_pdf: Boolean that indicates whether to save log-pdf values along with the samples. Default: :any:`False` :param concatenate_chains: Boolean that indicates whether to concatenate the chains after a run, i.e., samples are stored as an :class:`numpy.ndarray` of shape :code:`(nsamples * n_chains, dimension)` if :any:`True`, :code:`(nsamples, n_chains, dimension)` if :any:`False`. Default: :any:`True` :param n_chains: The number of Markov chains to generate. Either dimension and `n_chains` or `seed` must be provided. :param proposal: Proposal distribution, must have a log_pdf/pdf and rvs method. Default: standard multivariate normal :param proposal_is_symmetric: Indicates whether the proposal distribution is symmetric, affects computation of acceptance probability alpha Default: :any:`False`, set to :any:`True` if default proposal is used :param random_state: Random seed used to initialize the pseudo-random number generator. Default is :any:`None`. :param nsamples: Number of samples to generate. :param nsamples_per_chain: Number of samples to generate per chain. """ self.nsamples = nsamples self.nsamples_per_chain = nsamples_per_chain super().__init__( pdf_target=pdf_target, log_pdf_target=log_pdf_target, args_target=args_target, dimension=dimension, seed=seed, burn_length=burn_length, jump=jump, save_log_pdf=save_log_pdf, concatenate_chains=concatenate_chains, random_state=random_state, n_chains=n_chains, ) self.logger = logging.getLogger(__name__) # Initialize algorithm specific inputs self.proposal = proposal self.proposal_is_symmetric = proposal_is_symmetric if self.proposal is None: if self.dimension is None: raise ValueError( "UQpy: Either input proposal or dimension must be provided." ) from UQpy.distributions import JointIndependent, Normal self.proposal = JointIndependent([Normal()] * self.dimension) self.proposal_is_symmetric = True else: self._check_methods_proposal(self.proposal) self.logger.info("\nUQpy: Initialization of " + self.__class__.__name__ + " algorithm complete.") if (nsamples is not None) or (nsamples_per_chain is not None): self.run( nsamples=nsamples, nsamples_per_chain=nsamples_per_chain, )
import shutil import numpy as np from UQpy.run_model.RunModel import RunModel from UQpy.run_model.model_execution.PythonModel import PythonModel from UQpy.distributions import Normal from UQpy.reliability import FORM from UQpy.reliability import SORM from UQpy.distributions import Lognormal m0 = 7 v0 = 1.4 mu = np.log(m0) - np.log(np.sqrt(1 + (v0 / m0) ** 2)) scale = np.exp(mu) s = np.sqrt(np.log(1 + (v0 / m0) ** 2)) loc_ = 0.0 dist1 = Normal(loc=20., scale=2) dist2 = Lognormal(s=s, loc=0.0, scale=scale) model = PythonModel(model_script='pfn.py', model_object_name="example4",) RunModelObject4 = RunModel(model=model) form = FORM(distributions=[dist1, dist2], runmodel_object=RunModelObject4) form.run() Q0 = SORM(form_object=form) # print results print('SORM probability of failure: %s' % Q0.failure_probability)
#%% import shutil import numpy as np import matplotlib.pyplot as plt from UQpy.run_model.RunModel import RunModel from UQpy.run_model.model_execution.PythonModel import PythonModel from UQpy.distributions import Normal from UQpy.reliability import FORM model = PythonModel(model_script='pfn.py', model_object_name="example1") RunModelObject = RunModel(model=model) dist1 = Normal(loc=200., scale=20.) dist2 = Normal(loc=150, scale=10.) Q = FORM(distributions=[dist1, dist2], runmodel_object=RunModelObject, tol1=1e-5, tol2=1e-5) Q.run() # print results print('Design point in standard normal space: %s' % Q.DesignPoint_U) print('Design point in original space: %s' % Q.DesignPoint_X) print('Hasofer-Lind reliability index: %s' % Q.beta) print('FORM probability of failure: %s' % Q.failure_probability) print(Q.dg_u_record) # Supporting function def multivariate_gaussian(pos, mu, Sigma):
# :math:`g(U) = -\frac{1}{\sqrt{d}}\sum_{i=1}^{d} u_i + \beta` # # The probability of failure in this case is :math:`P(F) ≈ 10^{−3}` for :math:`β = 3.0902` # # Initially we have to import the necessary modules. #%% import shutil from UQpy.run_model.RunModel import RunModel from UQpy.run_model.model_execution.PythonModel import PythonModel from UQpy.distributions import Normal from UQpy.reliability import FORM dist1 = Normal(loc=0., scale=1.) dist2 = Normal(loc=0., scale=1.) model = PythonModel(model_script='pfn.py', model_object_name="example2") RunModelObject2 = RunModel(model=model) Z = FORM(distributions=[dist1, dist2], runmodel_object=RunModelObject2) Z.run() # print results print('Design point in standard normal space: %s' % Z.DesignPoint_U) print('Design point in original space: %s' % Z.DesignPoint_X) print('Hasofer-Lind reliability index: %s' % Z.beta) print('FORM probability of failure: %s' % Z.failure_probability)
the Ne eigenvalues """ ev = [(m * np.pi / lx)**2 + (n * np.pi / ly)**2 for m in range(1, Ne + 1) for n in range(1, Ne + 1)] ev = np.array(ev) return ev[:Ne] # %% md # # Create a distribution object. # %% pdf_lx = Normal(loc=2, scale=0.02) pdf_ly = Normal(loc=1, scale=0.01) margs = [pdf_lx, pdf_ly] joint = JointIndependent(marginals=margs) # %% md # # Define the number of input dimensions and choose the number of output dimensions (number of eigenvalues). # %% dim_in = 2 dim_out = 10 # %% md #
k_hi = (omega - epsilon)**2 * m k_lo = (omega + epsilon)**2 * m # %% md # # Plot the failure domain # %% x = np.linspace(2, 8, 1000) y = np.linspace(25, 225, 1000) X, Y = np.meshgrid(x, y) Z = np.zeros((1000, 1000)) d1 = Normal(loc=5, scale=1) d2 = Normal(loc=125, scale=20) dist = JointIndependent(marginals=[d1, d2]) for i in range(len(x)): Z[i, :] = dist.pdf( np.append(np.atleast_2d(X[i, :]), np.atleast_2d(Y[i, :]), 0).T) fig, ax = plt.subplots() CS = ax.contour(X, Y, Z, 15) plt.plot(m, k_hi, 'k') plt.plot(m, k_lo, 'k') # plt.fill_between(m,k_lo,k_hi) plt.xlim([mu_m - 3 * sigma_m, mu_m + 3 * sigma_m]) plt.ylim([mu_k - 3 * sigma_k, mu_k + 3 * sigma_k])
count, bins, ignored = plt.hist(data_1, 30, density=True) plt.plot(bins, 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(- (bins - mu) ** 2 / (2 * sigma ** 2)), linewidth=2, color='r') plt.title('Histogram of the data') plt.show() #%% md # # Create an instance of the class Model. The user must define the number of parameters to be estimated, in this case 2 # (mean and standard deviation), and set those parameters to be learnt as None when instantiating the Distribution # object. For maximum likelihood estimation, no prior pdf is required. #%% # set parameters to be learnt as None dist = Normal(loc=None, scale=None) candidate_model = DistributionModel(n_parameters=2, distributions=dist) ml_estimator = MLE(inference_model=candidate_model, data=data_1, n_optimizations=3) print('ML estimates of the mean={0:.3f} (true=0.) and std. dev={1:.3f} (true=0.1)'.format( ml_estimator.mle[0], ml_estimator.mle[1])) #%% md # # We can also fix one of the parameters and learn the remaining one #%% d = Normal(loc=0., scale=None) candidate_model = DistributionModel(n_parameters=1, distributions=d)
#%% param_true = np.array([1.0, 2.0]).reshape(1, -1) var_n = 1 error_covariance = var_n * np.eye(50) print(param_true.shape) z = RunModel(samples=param_true, model_script='local_pfn_models.py', model_object_name='model_quadratic', vec=False, var_names=['theta_1', 'theta_2']) data_clean = z.qoi_list[0].reshape((-1, )) data = data_clean + Normal(scale=np.sqrt(var_n)).rvs(nsamples=data_clean.size, random_state=456).reshape( (-1, )) #%% md # # Define the models, compute the true values of the evidence. # # For all three models, a Gaussian prior is chosen for the parameters, with mean and covariance matrix of the # appropriate dimensions. Each model is given prior probability :math:`P(m_{j}) = 1/3`. #%% model_names = ['model_linear', 'model_quadratic', 'model_cubic'] model_n_params = [1, 2, 3] model_prior_means = [[0.], [0., 0.], [0., 0., 0.]] model_prior_stds = [[10.], [1., 1.], [1., 2., 0.25]]
verbose=True, cores_per_task=1) print('Example: Created the model object.') # %% 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
# Example of a multivariate distribution from joint independent marginals # ------------------------------------------------------------------------ #%% from UQpy.distributions import Normal, JointIndependent from UQpy.distributions import Gumbel, JointCopula #%% md # # Define a Copula # --------------- # The definition of bivariate distribution with a copula, is similar to defining a multivariate distribution from # independent marginals. In both cases a list of marginals needs to be defined. In case of #%% marginals = [Normal(loc=0., scale=1), Normal(loc=0., scale=1)] copula = Gumbel(theta=3.) # dist_1 is a multivariate normal with independent marginals dist_1 = JointIndependent(marginals) print('Does the distribution with independent marginals have an rvs method?') print(hasattr(dist_1, 'rvs')) # dist_2 exhibits dependence between the two dimensions, defined using a gumbel copula dist_2 = JointCopula(marginals=marginals, copula=copula) print('Does the distribution with copula have an rvs method?') print(hasattr(dist_2, 'rvs')) #%% md # # Plot the pdf of the distribution before and after the copula
# %% md # # Step-by-step: continuous univariate distribution # ------------------------------------------------- # First, we import UQpy's normal distribution class. # %% from UQpy.distributions import Normal # %% md # # We'll start by constructing two identical standard normal distributions :code:`normal1` and :code:`normal2` # %% 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))
plt.title('data as histogram and true distribution to be estimated') plt.show() #%% md # # In a Bayesian setting, the definition of a prior pdf is a key point. The prior for the parameters must be defined in # the model. Note that if no prior is given, an improper, uninformative, prior is chosen, :math:`p(\theta)=1` for all # :math:`\theta`. #%% p0 = Uniform(loc=0., scale=15) p1 = Lognormal(s=1., loc=0., scale=1.) prior = JointIndependent(marginals=[p0, p1]) candidate_model = DistributionModel(distributions=Normal(loc=None, scale=None), n_parameters=2, prior=prior) # Learn the unknown parameters using MCMC from UQpy.sampling import MetropolisHastings mh1 = MetropolisHastings(jump=10, burn_length=10, seed=[1.0, 0.2], random_state=123) bayes_estimator = BayesParameterEstimation(inference_model=candidate_model, data=data_1, nsamples=500, sampling_class=mh1)
import matplotlib.pyplot as plt from UQpy.inference import DistributionModel, MLE from UQpy.distributions import Normal from UQpy.inference import MinimizeOptimizer from UQpy.distributions import JointIndependent, JointCopula, Gumbel from UQpy.sampling import ImportanceSampling #%% md # # First data is generated from a true model. A distribution with copulas does not possess a fit method, thus sampling is # performed using importance sampling/resampling. #%% # dist_true exhibits dependence between the two dimensions, defined using a gumbel copula dist_true = JointCopula(marginals=[Normal(), Normal()], copula=Gumbel(theta=2.)) # generate data using importance sampling: sample from a bivariate gaussian without copula, then weight samples u = ImportanceSampling( proposal=JointIndependent(marginals=[Normal(), Normal()]), log_pdf_target=dist_true.log_pdf, nsamples=500) print(u.samples.shape) print(u.weights.shape) # Resample to obtain 5,000 data points u.resample(nsamples=5000) data_2 = u.unweighted_samples print('Shape of data: {}'.format(data_2.shape)) fig, ax = plt.subplots()
from UQpy.reliability import SubsetSimulation from UQpy.run_model.RunModel import RunModel from UQpy.sampling import ModifiedMetropolisHastings, Stretch # First import the file that contains the newly defined Rosenbrock distribution from local_Rosenbrock import Rosenbrock # %% md # # :class:`.ModifiedMetropolisHastings` Initial Samples # %% m = PythonModel(model_script='local_Rosenbrock_pfn.py', model_object_name="RunPythonModel") model = RunModel(model=m) dist = Rosenbrock(p=100.) dist_prop1 = Normal(loc=0, scale=1) dist_prop2 = Normal(loc=0, scale=10) x = stats.norm.rvs(loc=0, scale=1, size=(100, 2), random_state=83276) mcmc_init1 = ModifiedMetropolisHastings(dimension=2, log_pdf_target=dist.log_pdf, seed=x.tolist(), burn_length=1000, proposal=[dist_prop1, dist_prop2], random_state=8765) mcmc_init1.run(10000) sampling=Stretch(log_pdf_target=dist.log_pdf, dimension=2, n_chains=1000, random_state=38546) x_ss_MMH = SubsetSimulation(sampling=sampling, runmodel_object=model, conditional_probability=0.1, nsamples_per_subset=10000, samples_init=mcmc_init1.samples) for i in range(len(x_ss_MMH.performance_function_per_level)): plt.scatter(x_ss_MMH.samples[i][:, 0], x_ss_MMH.samples[i][:, 1], marker='o')
rstate = np.random.RandomState(123) data_noisy = data_clean + rstate.randn(*data_clean.shape) from scipy.stats import norm def log_target(x, data, x_domain): log_target_value = np.zeros(x.shape[0]) for i, xx in enumerate(x): h_xx = xx[0] * x_domain + xx[1] * x_domain**2 log_target_value[i] = np.sum( [norm.logpdf(hxi - datai) for hxi, datai in zip(h_xx, data)]) return log_target_value proposal = JointIndependent([Normal(scale=0.1), Normal(scale=0.05)]) sampler = MetropolisHastings(nsamples=500, dimension=2, log_pdf_target=log_target, burn_length=10, jump=10, n_chains=1, args_target=(data_noisy, domain), proposal=proposal) print(sampler.samples.shape) samples = sampler.samples plt.plot(samples[:, 0], samples[:, 1], 'o', alpha=0.5) plt.plot(1., 2., marker='x', color='orange')
# The probability of failure in this case is :math:`P_f ≈ 0.079` for :math:`\beta = 1.413` # %% # %% md # # Initially we have to import the necessary modules. # %% from UQpy.run_model.RunModel import RunModel from UQpy.run_model.model_execution.PythonModel import PythonModel from UQpy.distributions import Normal from UQpy.reliability import FORM dist1 = Normal(loc=20., scale=3.5) dist2 = Normal(loc=5., scale=0.8) dist3 = Normal(loc=4., scale=0.4) model = PythonModel( model_script='pfn.py', model_object_name="example3", ) RunModelObject3 = RunModel(model=model) Z0 = FORM(distributions=[dist1, dist2, dist3], runmodel_object=RunModelObject3) Z0.run() print('Design point in standard normal space: %s' % Z0.DesignPoint_U) print('Design point in original space: %s' % Z0.DesignPoint_X) print('Hasofer-Lind reliability index: %s' % Z0.beta)
ax.plot(np.sqrt(adaptive_covariance[:, 0, i, i]), label='dimension {}'.format(i)) ax.set_title('Adaptive proposal std. dev. in both dimensions') ax.legend() plt.show() # %% md # MMH: target pdf is given as a joint pdf # ---------------------------------------- # The target pdf should be a 1 dimensional distribution or set of 1D distributions. # %% from UQpy.distributions import Normal proposal = [Normal(), Normal()] proposal_is_symmetric = [False, False] x = ModifiedMetropolisHastings(dimension=2, burn_length=500, jump=50, log_pdf_target=log_Rosenbrock, proposal=proposal, proposal_is_symmetric=proposal_is_symmetric, n_chains=1, nsamples=500) fig, ax = plt.subplots() ax.plot(x.samples[:, 0], x.samples[:, 1], linestyle='none', marker='.') # %% md
# %% def oakley_function(x): return 5 + x + np.cos(x) # %% md # # Create a distribution object, generate samples and evaluate the function at the samples. # %% np.random.seed(1) dist = Normal(loc=0, scale=2) n_samples = 100 x = dist.rvs(n_samples) y = oakley_function(x) # %% md # # Create an object from the PCE class, construct a total-degree polynomial basis given a maximum polynomial degree, and # compute the PCE coefficients using least squares regression. # %% max_degree = 8 polynomial_basis = TotalDegreeBasis(dist, max_degree) least_squares = LeastSquareRegression() pce_lstsq = PolynomialChaosExpansion(polynomial_basis=polynomial_basis,
#%% # Generate data param_true = np.array([1.0, 2.0]).reshape((1, -1)) print('Shape of true parameter vector: {}'.format(param_true.shape)) model = PythonModel(model_script='local_pfn_models.py', model_object_name='model_quadratic', delete_files=True, var_names=['theta_0', 'theta_1']) h_func = RunModel(model=model) h_func.run(samples=param_true) # Add noise error_covariance = 1. data_clean = np.array(h_func.qoi_list[0]) noise = Normal(loc=0., scale=np.sqrt(error_covariance)).rvs(nsamples=50).reshape((50,)) data_3 = data_clean + noise print('Shape of data: {}'.format(data_3.shape)) #%% md # # Then we create an instance of the Model class, using model_type='python', and we perform maximum likelihood estimation # of the two parameters. #%% candidate_model = ComputationalModel(n_parameters=2, runmodel_object=h_func, error_covariance=error_covariance) optimizer = MinimizeOptimizer(method='nelder-mead') ml_estimator = MLE(inference_model=candidate_model, data=data_3, n_optimizations=1)
from UQpy.sampling import MonteCarloSampling, AdaptiveKriging 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.
pick_model = 'all' # %% 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')
# Generate data param_true = np.array([1.0, 2.0]).reshape((1, -1)) print('Shape of true parameter vector: {}'.format(param_true.shape)) model = PythonModel(model_script='local_pfn_models.py', model_object_name='model_quadratic', var_names=['theta_0', 'theta_1']) h_func = RunModel(model=model) h_func.run(samples=param_true) data_clean = np.array(h_func.qoi_list[0]) print(data_clean.shape) # Add noise, use a RandomState for reproducible results error_covariance = 1. noise = Normal(loc=0., scale=np.sqrt(error_covariance)).rvs(nsamples=50, random_state=123).reshape( (50, )) data_3 = data_clean + noise print('Shape of data: {}'.format(data_3.shape)) print(data_3[:4]) p0 = Normal() p1 = Normal() prior = JointIndependent(marginals=[p0, p1]) inference_model = ComputationalModel(n_parameters=2, runmodel_object=h_func, error_covariance=error_covariance, prior=prior) proposal = JointIndependent([Normal(scale=0.1), Normal(scale=0.05)])
param_true = np.array([1.0, 2.0]).reshape((1, -1)) print('Shape of true parameter vector: {}'.format(param_true.shape)) model = PythonModel(model_script='local_pfn_models.py', model_object_name='model_quadratic', delete_files=True, var_names=['theta_0', 'theta_1']) h_func = RunModel(model=model) h_func.run(samples=param_true) # Add noise error_covariance = 1. data_clean = np.array(h_func.qoi_list[0]) noise = Normal(loc=0., scale=np.sqrt(error_covariance)).rvs(nsamples=50).reshape( (50, )) data_3 = data_clean + noise print('Shape of data: {}'.format(data_3.shape)) inference_model = ComputationalModel(n_parameters=2, runmodel_object=h_func, error_covariance=error_covariance) sampling = ImportanceSampling(proposal=JointIndependent([Normal(scale=2, )] * 2)) bayes_estimator =\ BayesParameterEstimation(inference_model=inference_model, data=data_3, sampling_class=sampling, nsamples=5000)
print(seed) print(x.samples[0, :, :]) # %% md # # The algorithm-specific parameters for MetropolisHastings are proposal and proposal_is_symmetric # ------------------------------------------------------------------------------------------------- # The default proposal is standard normal (symmetric). # %% # Define a few proposals to try out from UQpy.distributions import JointIndependent, Normal, Uniform proposals = [ JointIndependent([Normal(), Normal()]), JointIndependent( [Uniform(loc=-0.5, scale=1.5), Uniform(loc=-0.5, scale=1.5)]), Normal() ] proposals_is_symmetric = [True, False, False] fig, ax = plt.subplots(ncols=3, figsize=(16, 4)) for i, (proposal, symm) in enumerate(zip(proposals, proposals_is_symmetric)): print(i) try: x = MetropolisHastings(dimension=2, burn_length=500, jump=100,