def con_limit(z): ## Transform: standard normal-to-random variable df_norm = DataFrame(data=[z], columns=model.var_rand) df_rand = model.norm2rand(df_norm) df = model.var_outer(df_rand, df_det=df_inner) ## Eval limit state df_res = gr.eval_df(model, df=df) g = df_res[key].iloc[0] return g
def objective(z): ## Transform: standard normal-to-random variable df_norm = DataFrame(data=[z], columns=model.var_rand) df_rand = model.norm2rand(df_norm) df = model.var_outer(df_rand, df_det=df_inner) df_res = gr.eval_df(model, df=df) g = df_res[key].iloc[0] # return (g, jac) return g
def objective(x): """x = [var_fit]""" ## Evaluate model df_var = tran_outer( df_data[var_feat], concat( (df_nom[var_fix].iloc[[0]], df_make(**dict(zip(var_fit, x)))), axis=1, ), ) df_tmp = eval_df(model, df=df_var) ## Compute joint MSE return ((df_tmp[out].values - df_data[out].values) ** 2).mean()
def eval_lhs(model, n=1, df_det=None, seed=None, append=True, skip=False, criterion=None): r"""Latin Hypercube evaluation Evaluates a given model on a latin hypercube sample (LHS) using the model's density. Args: model (gr.Model): Model to evaluate n (numeric): Number of LHS samples to draw df_det (DataFrame): Deterministic levels for evaluation; use "nom" for nominal deterministic levels. seed (int): Random seed to use append (bool): Append results to conservative inputs? skip (bool): Skip evaluation of the functions? criterion (str): flag for LHS sample criterion allowable values: None, "center" ("c"), "maxmin" ("m"), "centermaxmin" ("cm"), "correlation" ("corr") Returns: DataFrame: Results of evaluation or unevaluated design Notes: - Wrapper on pyDOE.lhs """ ## Set seed only if given if seed is not None: set_seed(seed) ## Ensure sample count is int if not isinstance(n, Integral): print("eval_lhs() is rounding n...") n = int(n) ## Draw samples df_quant = DataFrame(data=lhs(model.n_var_rand, samples=n), columns=model.var_rand) ## Convert samples to desired marginals df_rand = model.density.pr2sample(df_quant) ## Construct outer-product DOE df_samp = model.var_outer(df_rand, df_det=df_det) if skip: return df_samp else: return gr.eval_df(model, df=df_samp, append=append)
def eval_sinews( model, n_density=10, n_sweeps=3, seed=None, df_det=None, varname="sweep_var", indname="sweep_ind", append=True, skip=False, ): r"""Sweep study Perform coordinate sweeps over each model random variable ("sinew" design). Use random starting points drawn from the joint density. Optionally sweep the deterministic variables. For more expensive models, it can be helpful to tune n_density and n_sweeps to achieve a reasonable runtime. Use gr.plot_auto() to construct a quick visualization of the output dataframe. Use `skip` version to visualize the design, and non-skipped version to visualize the results. Args: model (gr.Model): Model to evaluate n_density (numeric): Number of points along each sweep n_sweeps (numeric): Number of sweeps per-random variable seed (int): Random seed to use df_det (DataFrame): Deterministic levels for evaluation; use "nom" for nominal deterministic levels, use "swp" to sweep deterministic variables varname (str): Column name to give for sweep variable; default="sweep_var" indname (str): Column name to give for sweep index; default="sweep_ind" append (bool): Append results to conservative inputs? skip (bool): Skip evaluation of the functions? Returns: DataFrame: Results of evaluation or unevaluated design Examples: >>> import grama as gr >>> md = gr.make_cantilever_beam() >>> # Skip evaluation, vis. design >>> df_design = md >> gr.ev_sinews(df_det="nom", skip=True) >>> df_design >> gr.pt_auto() >>> # Vis results >>> df_sinew = md >> gr.ev_sinews(df_det="nom") >>> df_sinew >> gr.pt_auto() """ ## Override model if deterministic sweeps desired if df_det == "swp": ## Collect sweep-able deterministic variables var_sweep = list( filter( lambda v: isfinite(model.domain.get_width(v)) & (model.domain.get_width(v) > 0), model.var_det, )) ## Generate pseudo-marginals dicts_var = {} for v in var_sweep: dicts_var[v] = { "dist": "uniform", "loc": model.domain.get_bound(v)[0], "scale": model.domain.get_width(v), } ## Overwrite model model = comp_marginals(model, **dicts_var) ## Restore flag df_det = "nom" ## Set seed only if given if seed is not None: set_seed(seed) ## Ensure sample count is int if not isinstance(n_density, Integral): print("eval_sinews() is rounding n_density...") n_density = int(n_density) if not isinstance(n_sweeps, Integral): print("eval_sinews() is rounding n_sweeps...") n_sweeps = int(n_sweeps) ## Build quantile sweep data q_random = tile(random((1, model.n_var_rand, n_sweeps)), (n_density, 1, 1)) q_dense = linspace(0, 1, num=n_density) Q_all = zeros((n_density * n_sweeps * model.n_var_rand, model.n_var_rand)) C_var = ["tmp"] * (n_density * n_sweeps * model.n_var_rand) C_ind = [0] * (n_density * n_sweeps * model.n_var_rand) ## Interlace for i_input in range(model.n_var_rand): ind_base = i_input * n_density * n_sweeps for i_sweep in range(n_sweeps): ind_start = ind_base + i_sweep * n_density ind_end = ind_base + (i_sweep + 1) * n_density Q_all[ind_start:ind_end] = q_random[:, :, i_sweep] Q_all[ind_start:ind_end, i_input] = q_dense C_var[ind_start:ind_end] = [model.var_rand[i_input]] * n_density C_ind[ind_start:ind_end] = [i_sweep] * n_density ## Modify endpoints for infinite support if not isfinite( model.density.marginals[model.var_rand[i_input]].q(0)): Q_all[ind_start, i_input] = 1 / n_density / 10 if not isfinite( model.density.marginals[model.var_rand[i_input]].q(1)): Q_all[ind_end - 1, i_input] = 1 - 1 / n_density / 10 ## Assemble sampling plan df_pr = DataFrame(data=Q_all, columns=model.var_rand) df_rand = model.density.pr2sample(df_pr) df_rand[varname] = C_var df_rand[indname] = C_ind ## Construct outer-product DOE df_samp = model.var_outer(df_rand, df_det=df_det) if skip: ## Evaluation estimate runtime_est = model.runtime(df_samp.shape[0]) if runtime_est > 0: print( "Estimated runtime for design with model ({0:1}):\n {1:4.3} sec" .format(model.name, runtime_est)) else: print( "Design runtime estimates unavailable; model has no timing data." ) ## For autoplot with catch_warnings(): simplefilter("ignore") df_samp._plot_info = { "type": "sinew_inputs", "var": model.var_rand } ## Pass-through return df_samp ## Apply df_res = eval_df(model, df=df_samp, append=append) ## For autoplot with catch_warnings(): simplefilter("ignore") df_res._plot_info = { "type": "sinew_outputs", "var": model.var_rand, "out": model.out, } return df_res
def eval_hybrid( model, n=1, plan="first", df_det=None, varname="hybrid_var", seed=None, append=True, skip=False, ): r"""Hybrid points for Sobol' indices Use the "hybrid point" design (Sobol', 1999) to support estimating Sobol' indices. Use gr.tran_sobol() to post-process the results and compute estimates. Args: model (gr.Model): Model to evaluate; must have CopulaIndependence n (numeric): Number of points along each sweep plan (str): Sobol' index to compute; plan={"first", "total"} seed (int): Random seed to use df_det (DataFrame): Deterministic levels for evaluation; use "nom" for nominal deterministic levels. varname (str): Column name to give for sweep variable; default="hybrid_var" append (bool): Append results to conservative inputs? skip (bool): Skip evaluation of the functions? Returns: DataFrame: Results of evaluation or unevaluated design References: I.M. Sobol', "Sensitivity Estimates for Nonlinear Mathematical Models" (1999) MMCE, Vol 1. Examples: >>> import grama as gr >>> md = gr.make_cantilever_beam() >>> df_first = md >> gr.ev_hybrid(df_det="nom", plan="first") >>> df_first >> gr.tf_sobol() >>> >>> df_total = md >> gr.ev_hybrid(df_det="nom", plan="total") >>> df_total >> gr.tf_sobol() """ ## Check invariants if not isinstance(model.density.copula, CopulaIndependence): raise ValueError( "model must have CopulaIndependence structure;\n" + "Sobol' indices only defined for independent variables") ## Set seed only if given if seed is not None: set_seed(seed) if not isinstance(n, Integral): print("eval_hybrid() is rounding n...") n = int(n) ## Draw hybrid points X = random((n, model.n_var_rand)) Z = random((n, model.n_var_rand)) ## Reserve space Q_all = zeros((n * (model.n_var_rand + 1), model.n_var_rand)) Q_all[:n] = X # Base samples C_var = ["_"] * (n * (model.n_var_rand + 1)) ## Interleave samples for i_in in range(model.n_var_rand): i_start = (i_in + 1) * n i_end = (i_in + 2) * n if plan == "first": Q_all[i_start:i_end, :] = Z Q_all[i_start:i_end, i_in] = X[:, i_in] elif plan == "total": Q_all[i_start:i_end, :] = X Q_all[i_start:i_end, i_in] = Z[:, i_in] else: raise ValueError("plan must be `first` or `total`") C_var[i_start:i_end] = [model.var_rand[i_in]] * n ## Construct sampling plan df_pr = DataFrame(data=Q_all, columns=model.var_rand) ## Convert samples to desired marginals df_rand = model.density.pr2sample(df_pr) df_rand[varname] = C_var ## Construct outer-product DOE df_samp = model.var_outer(df_rand, df_det=df_det) if skip: with catch_warnings(): simplefilter("ignore") df_samp._meta = dict( type="eval_hybrid", varname=varname, plan=plan, var_rand=model.var_rand, out=model.out, ) return df_samp df_res = eval_df(model, df=df_samp, append=append) with catch_warnings(): simplefilter("ignore") df_res._meta = dict( type="eval_hybrid", varname=varname, plan=plan, var_rand=model.var_rand, out=model.out, ) return df_res
def eval_monte_carlo(model, n=1, df_det=None, seed=None, append=True, skip=False): r"""Monte Carlo evaluation Evaluates a given model at a given dataframe. Generates outer product with deterministic samples. Args: model (gr.Model): Model to evaluate n (numeric): number of Monte Carlo samples to draw df_det (DataFrame): Deterministic levels for evaluation; use "nom" for nominal deterministic levels. seed (int): random seed to use append (bool): Append results to random values? skip (bool): Skip evaluation of the functions? Returns: DataFrame: Results of evaluation or unevaluated design Examples: >>> import grama as gr >>> from grama.models import make_test >>> md = make_test() >>> df = md >> gr.ev_monte_carlo(n=1e2, df_det="nom") >>> df.describe() """ ## Set seed only if given if seed is not None: set_seed(seed) ## Ensure sample count is int if not isinstance(n, Integral): print("eval_monte_carlo() is rounding n...") n = int(n) ## Draw samples df_rand = model.density.sample(n=n, seed=seed) ## Construct outer-product DOE df_samp = model.var_outer(df_rand, df_det=df_det) if skip: ## Evaluation estimate runtime_est = model.runtime(df_samp.shape[0]) if runtime_est > 0: print( "Estimated runtime for design with model ({0:1}):\n {1:4.3} sec" .format(model.name, runtime_est)) else: print( "Design runtime estimates unavailable; model has no timing data." ) ## Attach metadata with warnings.catch_warnings(): warnings.simplefilter("ignore") df_samp._plot_info = { "type": "monte_carlo_inputs", "var": model.var_rand, } return df_samp else: df_res = gr.eval_df(model, df=df_samp, append=append) ## Attach metadata with warnings.catch_warnings(): warnings.simplefilter("ignore") df_res._plot_info = { "type": "monte_carlo_outputs", "out": model.out } return df_res
def fit_nls( df_data, md=None, out=None, var_fix=None, df_init=None, verbose=True, uq_method=None, **kwargs, ): r"""Fit a model with Nonlinear Least Squares (NLS) Estimate best-fit variable levels with nonlinear least squares (NLS), and return an executable model with those frozen best-fit levels. Optionally, fit a distribution on the parameters to quantify parametric uncertainty. Note: This is a *synonym* for eval_nls(); see the documentation for eval_nls() for keyword argument options available beyond those listed here. Args: df_data (DataFrame): Data for estimating best-fit variable levels. Variables not found in df_data optimized for fitting. md (gr.Model): Model to analyze. All model variables selected for fitting must be bounded or random. Deterministic variables may have semi-infinite bounds. var_fix (list or None): Variables to fix to nominal levels. Note that variables with domain width zero will automatically be fixed. df_init (DataFrame): Initial guesses for parameters; overrides n_restart n_restart (int): Number of restarts to try; the first try is at the nominal conditions of the model. Returned model will use the least-error parameter set among restarts tested. n_maxiter (int): Optimizer maximum iterations verbose (bool): Print best-fit parameters to console? uq_method (str OR None): If string, select method to quantify parameter uncertainties. If None, provide best-fit values only. Methods: uq_method = "linpool": assume normal errors; linearly approximate parameter effects; equally pool variance matrices for each output Returns: gr.Model: Model for evaluation with best-fit variables frozen to optimized levels. Examples: >>> import grama as gr >>> from grama.data import df_trajectory_windowed >>> from grama.models import make_trajectory_linear >>> X = gr.Intention() >>> >>> md_trajectory = make_trajectory_linear() >>> md_fitted = ( >>> df_trajectory_windowed >>> >> gr.ft_nls( >>> md=md_trajectory, >>> uq_method="linpool", >>> ) >>> ) """ ## Check `out` invariants if out is None: out = md.out print("... fit_nls setting out = {}".format(out)) ## Check invariants if md is None: raise ValueError("Must provide model md") ## Determine variables to be fixed if var_fix is None: var_fix = set() else: var_fix = set(var_fix) for var in md.var_det: wid = md.domain.get_width(var) if wid == 0: var_fix.add(var) ## Run eval_nls to fit model parameter values df_fit = eval_nls( md, df_data=df_data, var_fix=var_fix, df_init=df_init, append=True, verbose=verbose, **kwargs, ) ## Select best-fit values df_best = df_fit.sort_values(by="mse", axis=0).iloc[[0]].reset_index(drop=True) if verbose: print(df_fit.sort_values(by="mse", axis=0)) ## Determine variables that were fitted var_fitted = list(set(md.var).intersection(set(df_best.columns))) var_remain = list(set(md.var).difference(set(var_fitted))) if len(var_remain) == 0: raise ValueError("Resulting model is constant!") ## Assemble and return fitted model if md.name is None: name = "(Fitted Model)" else: name = md.name + " (Fitted)" ## Calibrate parametric uncertainty, if requested if uq_method == "linpool": ## Precompute data df_nom = eval_nominal(md, df_det="nom") df_base = tran_outer( df_data, concat((df_best[var_fitted], df_nom[var_fix]), axis=1)) df_pred = eval_df(md, df=df_base) df_grad = eval_grad_fd(md, df_base=df_base, var=var_fitted) ## Pool variance matrices n_obs = df_data.shape[0] n_fitted = len(var_fitted) Sigma_pooled = zeros((n_fitted, n_fitted)) for output in out: ## Approximate sigma_sq sigma_sq = npsum( nppow(df_data[output].values - df_pred[output].values, 2)) / (n_obs - n_fitted) ## Approximate (pseudo)-inverse hessian var_grad = list(map(lambda v: "D" + output + "_D" + v, var_fitted)) Z = df_grad[var_grad].values Hinv = pinv(Z.T.dot(Z), hermitian=True) ## Add variance matrix to pooled Sigma Sigma_pooled = Sigma_pooled + sigma_sq * Hinv / n_fitted ## Check model for identifiability kappa_out = cond(Sigma_pooled) if kappa_out > 1e10: warn( "Model is locally unidentifiable as measured by the " + "condition number of the pooled covariance matrix; " + "kappa = {}".format(kappa_out), RuntimeWarning, ) ## Convert to std deviations and correlation sigma_comp = npsqrt(diag(Sigma_pooled)) corr_mat = Sigma_pooled / (atleast_2d(sigma_comp).T.dot( atleast_2d(sigma_comp))) corr_data = [] I, J = triu_indices(n_fitted, k=1) for ind in range(len(I)): i = I[ind] j = J[ind] corr_data.append([var_fitted[i], var_fitted[j], corr_mat[i, j]]) df_corr = DataFrame(data=corr_data, columns=["var1", "var2", "corr"]) ## Assemble marginals marginals = {} for ind, var_ in enumerate(var_fitted): marginals[var_] = { "dist": "norm", "loc": df_best[var_].values[0], "scale": sigma_comp[ind], } ## Construct model with Gaussian copula if len(var_fix) > 0: md_res = (Model(name) >> cp_function( lambda x: df_nom[var_fix].values, var=set(var_remain).difference(var_fix), out=var_fix, name="Fix variable levels", ) >> cp_md_det(md=md) >> cp_marginals(**marginals) >> cp_copula_gaussian(df_corr=df_corr)) else: md_res = (Model(name) >> cp_md_det(md=md) >> cp_marginals( **marginals) >> cp_copula_gaussian(df_corr=df_corr)) ## Return deterministic model elif uq_method is None: md_res = (Model(name) >> cp_function( lambda x: df_best[var_fitted].values, var=var_remain, out=var_fitted, name="Fix variable levels", ) >> cp_md_det(md=md)) else: raise ValueError( "uq_method option {} not recognized".format(uq_method)) return md_res
def eval_contour( model, var=None, out=None, df=None, levels=None, n_side=20, n_levels=5, ): r"""Generate contours from a model Generates contours from a model. Evaluates the model on a dense grid, then runs marching squares to generate contours. Supports targeting multiple outputs and handling auxiliary inputs not included in the contour map. Args: model (gr.Model): Model to evaluate. var (list of str): Model inputs to target; must provide exactly two inputs, and both must have finite domain width. out (list of str): Model output(s) for contour generation. df (DataFrame or None): Levels for model variables not included in var (auxiliary inputs). If provided var and model.var contain the same values, then df may equal None. levels (dict): Specific output levels for contour generation; overrides n_levels. n_side (int): Side resolution for grid; n_side**2 total evaluations. n_levels (int): Number of contour levels. Returns: DataFrame: Points along contours, organized by output and auxiliary variable levels. Examples:: import grama as gr ## Multiple outputs ( gr.Model() >> gr.cp_vec_function( fun=lambda df: gr.df_make( f=df.x**2 + df.y**2, g=df.x + df.y, ), var=["x", "y"], out=["f", "g"], ) >> gr.cp_bounds( x=(-1, +1), y=(-1, +1), ) >> gr.ev_contour( var=["x", "y"], out=["f", "g"], ) # Contours with no auxiliary variables can autoplot >> gr.pt_auto() ) ## Auxiliary inputs ( gr.Model() >> gr.cp_vec_function( fun=lambda df: gr.df_make( f=df.c * df.x + (1 - df.c) * df.y, ), var=["x", "y"], out=["f", "g"], ) >> gr.cp_bounds( x=(-1, +1), y=(-1, +1), ) >> gr.ev_contour( var=["x", "y"], out=["f"], df=gr.df_make(c=[0, 1]) ) # Contours with auxiliary variables should be manually plotted >> gr.ggplot(gr.aes("x", "y")) + gr.geom_segment(gr.aes(xend="x_end", yend="y_end", group="level", color="c")) ) """ ## Check invariants invariants_eval_model(model) invariants_eval_df(df, acc_none=True) # Argument given if var is None: raise ValueError("No `var` given") # Correct number of inputs if len(var) != 2: raise ValueError("Must provide exactly 2 inputs in `var`.") # Inputs available var_diff = set(var).difference(set(model.var)) if len(var_diff) > 0: raise ValueError( "`var` must be a subset of model.var; missing: {}".format( var_diff)) # All inputs supported var_diff = set(model.var).difference(set(var)) if len(var_diff) > 0: if df is None: raise ValueError( "Must provide values for remaining model variables using df; " + "missing values: {}".format(var_diff)) # Drop the swept variables df = df.drop(columns=var, errors="ignore") # Check for unsupported inputs var_diff2 = var_diff.difference(set(df.columns)) if len(var_diff2) > 0: raise ValueError( "All model variables need values in provided df; " + "missing values: {}".format(var_diff2)) if df.shape[0] > 1: has_aux = True else: has_aux = False else: has_aux = False # Finite bound width if not all([ isfinite(model.domain.get_width(v)) and (model.domain.get_width(v) > 0) for v in var ]): raise ValueError( "All model bounds for `var` must be finite and nonzero") # Argument given if out is None: raise ValueError("No `out` given") # Outputs available out_diff = set(out).difference(set(model.out)) if len(out_diff) > 0: raise ValueError( "`out` must be a subset of model.out; missing: {}".format( out_diff)) ## Generate data xv = linspace(*model.domain.get_bound(var[0]), n_side) yv = linspace(*model.domain.get_bound(var[1]), n_side) df_x = DataFrame({var[0]: xv}) df_y = DataFrame({var[1]: yv}) df_input = (df_x >> tf_outer(df_outer=df_y)) # Create singleton level if necessary if df is None: df = DataFrame({"_foo": [0]}) ## Loop over provided auxiliary levels df_res = DataFrame() for i in range(df.shape[0]): df_in_tmp = (df_input >> tf_outer(df_outer=df.iloc[[i]])) df_out = eval_df( model, df=df_in_tmp, ) ## Set output threshold levels if levels is None: # Do not overwrite `levels`, to adapt per loop levels_wk = dict( zip(out, [ linspace(df_out[o].min(), df_out[o].max(), n_levels + 2)[1:-1] for o in out ])) else: levels_wk = levels ## Run marching squares # Output quantity for o in out: # Reshape data Data = reshape(df_out[o].values, (n_side, n_side)) # Threshold level for t in levels_wk[o]: # Run marching squares segments = marching_square(xv, yv, Data, t) sqdata = array(segments).squeeze() if len(sqdata) > 0: # Package df_tmp = DataFrame( data=sqdata, columns=[ var[0], var[1], var[0] + "_end", var[1] + "_end" ], ) df_tmp["out"] = [o] * df_tmp.shape[0] df_tmp["level"] = [t] * df_tmp.shape[0] df_tmp = (df_tmp >> tf_outer(df_outer=df.iloc[[i]])) df_res = concat((df_res, df_tmp), axis=0) else: warn("Output {0:} had no contours at level {1:}".format( o, t, )) ## Remove dummy column, if present if "_foo" in df_res.columns: df_res.drop("_foo", axis=1, inplace=True) # Drop index df_res = df_res.reset_index(drop=True) ## Attach metadata with catch_warnings(): simplefilter("ignore") df_res._plot_info = { "type": "contour", "var": var, "out": "out", "level": "level", "aux": has_aux, } ## Return the results return df_res
def fun(x): df = DataFrame([x], columns=model.var) df_res = eval_df(model, df) return sign * df_res[out]
def eval_min( model, out_min=None, out_geq=None, out_leq=None, out_eq=None, method="SLSQP", tol=1e-6, n_restart=1, n_maxiter=50, seed=None, df_start=None, ): r"""Constrained minimization using functions from a model Perform constrained minimization using functions from a model. Model must have deterministic variables only. Wrapper for scipy.optimize.minimize Args: model (gr.Model): Model to analyze. All model variables must be deterministic. out_min (str): Output to use as minimization objective. out_geq (None OR list of str): Outputs to use as geq constraints; out >= 0 out_leq (None OR list of str): Outputs to use as leq constraints; out <= 0 out_eq (None OR list of str): Outputs to use as equality constraints; out == 0 method (str): Optimization method; see the documentation for scipy.optimize.minimize for options. tol (float): Optimization objective convergence tolerance n_restart (int): Number of restarts; beyond n_restart=1 random restarts are used. df_start (None or DataFrame): Specific starting values to use; overrides n_restart if non None provided. Returns: DataFrame: Results of optimization Examples: >>> import grama as gr >>> md = ( >>> gr.Model("Constrained Rosenbrock") >>> >> gr.cp_function( >>> fun=lambda x: (1 - x[0])**2 + 100*(x[1] - x[0]**2)**2, >>> var=["x", "y"], >>> out=["c"], >>> ) >>> >> gr.cp_function( >>> fun=lambda x: (x[0] - 1)**3 - x[1] + 1, >>> var=["x", "y"], >>> out=["g1"], >>> ) >>> >> gr.cp_function( >>> fun=lambda x: x[0] + x[1] - 2, >>> var=["x", "y"], >>> out=["g2"], >>> ) >>> >> gr.cp_bounds( >>> x=(-1.5, +1.5), >>> y=(-0.5, +2.5), >>> ) >>> ) >>> md >> gr.ev_min( >>> out_min="c", >>> out_leq=["g1", "g2"] >>> ) """ ## Check that model has only deterministic variables if model.n_var_rand > 0: raise ValueError("model must have no random variables") ## Check that objective is in model if not (out_min in model.out): raise ValueError("model must contain out_min") ## Check that constraints are in model if not (out_geq is None): out_diff = set(out_geq).difference(set(model.out)) if len(out_diff) > 0: raise ValueError( "model must contain each out_geq; missing {}".format(out_diff)) if not (out_leq is None): out_diff = set(out_leq).difference(set(model.out)) if len(out_diff) > 0: raise ValueError( "model must contain each out_leq; missing {}".format(out_diff)) if not (out_eq is None): out_diff = set(out_eq).difference(set(model.out)) if len(out_diff) > 0: raise ValueError( "model must contain each out_eq; missing {}".format(out_diff)) ## Formulate initial guess df_nom = eval_nominal(model, df_det="nom", skip=True) if df_start is None: df_start = df_nom[model.var] if n_restart > 1: if not (seed is None): setseed(seed) ## Collect sweep-able deterministic variables var_sweep = list( filter( lambda v: isfinite(model.domain.get_width(v)) & (model.domain.get_width(v) > 0), model.var_det, )) ## Generate pseudo-marginals dicts_var = {} for v in var_sweep: dicts_var[v] = { "dist": "uniform", "loc": model.domain.get_bound(v)[0], "scale": model.domain.get_width(v), } ## Overwrite model md_sweep = comp_marginals(model, **dicts_var) md_sweep = comp_copula_independence(md_sweep) ## Generate random start points df_rand = eval_sample( md_sweep, n=n_restart - 1, df_det="nom", skip=True, ) df_start = concat((df_start, df_rand[model.var]), axis=0).reset_index(drop=True) else: n_restart = df_start.shape[0] ## Factory for wrapping model's output def make_fun(out, sign=+1): def fun(x): df = DataFrame([x], columns=model.var) df_res = eval_df(model, df) return sign * df_res[out] return fun ## Create helper functions for constraints constraints = [] if not (out_geq is None): for out in out_geq: constraints.append({ "type": "ineq", "fun": make_fun(out), }) if not (out_leq is None): for out in out_leq: constraints.append({ "type": "ineq", "fun": make_fun(out, sign=-1), }) if not (out_eq is None): for out in out_eq: constraints.append({ "type": "eq", "fun": make_fun(out), }) ## Parse the bounds for minimize bounds = list(map(lambda k: model.domain.bounds[k], model.var)) ## Run optimization df_res = DataFrame() for i in range(n_restart): x0 = df_start[model.var].iloc[i].values res = minimize( make_fun(out_min), x0, args=(), method=method, jac=False, tol=tol, options={ "maxiter": n_maxiter, "disp": False }, constraints=constraints, bounds=bounds, ) df_opt = df_make( **dict(zip(model.var, res.x)), **dict(zip(map(lambda s: s + "_0", model.var), x0)), ) df_tmp = eval_df(model, df=df_opt) df_tmp["success"] = [res.success] df_tmp["message"] = [res.message] df_tmp["n_iter"] = [res.nit] df_res = concat((df_res, df_tmp), axis=0).reset_index(drop=True) return df_res