def make_prlc_rand(): md_RLC_rand = ( gr.Model("RLC with component tolerances") >> gr.cp_vec_function( fun=lambda df: gr.df_make( Rr=df.R * (1 + df.dR), Lr=df.L * (1 + df.dL), Cr=df.C * (1 + df.dC), ), var=["R", "dR", "L", "dL", "C", "dC"], out=["Rr", "Lr", "Cr"], ) >> gr.cp_vec_function( fun=lambda df: gr.df_make(omega0=np.sqrt(1 / df.Lr / df.Cr)), var=["Lr", "Cr"], out=["omega0"], ) >> gr.cp_vec_function( fun=lambda df: gr.df_make(Q=df.omega0 * df.Rr * df.Cr), name="parallel RLC", var=["omega0", "Rr", "Cr"], out=["Q"]) >> gr.cp_bounds( R=(1e-3, 1e0), L=(1e-9, 1e-3), C=(1e-3, 100), ) >> gr.cp_marginals( dR=dict(dist="uniform", loc=R_percent_lo, scale=R_percent_up - R_percent_lo), dL=dict(dist="uniform", loc=L_percent_lo, scale=L_percent_up - L_percent_lo), dC=dict(dist="uniform", loc=C_percent_lo, scale=C_percent_up - C_percent_lo), ) >> gr.cp_copula_independence()) return md_RLC_rand
def make_plate_buckle(): r"""Initialize a buckling plate model Variables (deterministic): w (in): Plate width h (in): Plate height t (in): Plate thickness m (-): Wavenumber L (kips): Applied (compressive) load; uniformly applied along top and bottom edges Variables (random): E (kips/in^2): Elasticity mu (-): Poisson's ratio Outputs: k_cr (-): Prefactor for buckling stress g_buckle (kips/in^2): Buckling limit state: critical stress - applied stress """ md = ( Model("Plate Buckling") >> cp_vec_function( fun=lambda df: df_make( k_cr=(df.m*df.h/df.w + df.w/df.m/df.h)**2 ), var=["w", "h", "m"], out=["k_cr"], ) >> cp_vec_function( fun=lambda df: df_make( g_buckle=df.k_cr * pi**2/12 * df.E / (1 - df.mu**2) * (df.t/df.h)**2 - df.L / df.t / df.w ), var=["k_cr", "t", "h", "w", "E", "mu", "L"], out=["g_buckle"], name="limit state", ) >> cp_bounds( t=(0.5 * THICKNESS, 2 * THICKNESS), h=(6, 18), w=(6, 18), m=(1, 5), L=(LOAD / 2, LOAD * 2), ) >> cp_marginals( E=marg_fit("norm", df_stang.E), mu=marg_fit("beta", df_stang.mu), ) >> cp_copula_gaussian(df_data=df_stang) ) return md
def make_channel_nondim(): r"""Make 1d channel model; dimensionless form Instantiates a model for particle and fluid temperature rise; particles are suspended in a fluid with bulk velocity along a square cross-section channel. The walls of said channel are transparent, and radiation heats the particles as they travel down the channel. References: Banko, A.J. "RADIATION ABSORPTION BY INERTIAL PARTICLES IN A TURBULENT SQUARE DUCT FLOW" (2018) PhD Thesis, Stanford University, Chapter 2 """ md = ( Model("1d Particle-laden Channel with Radiation; Dimensionless Form") >> cp_vec_function( fun=lambda df: df_make(beta=120 * (1 + df.Phi_M * df.chi)), var=["Phi_M", "chi"], out=["beta"], ) >> cp_vec_function( fun=lambda df: df_make( T_f=(df.Phi_M * df.chi) / (1 + df.Phi_M * df.chi) * (df.I * df.xst - df.beta**(-1) * df.I * (1 - exp(-df.beta * df.xst))), T_p=1 / (1 + df.Phi_M * df.chi) * (df.Phi_M * df.chi * df.I * df.xst + df.beta**(-1) * df.I * (1 - exp(-df.beta * df.xst))), ), var=["xst", "Phi_M", "chi", "I", "beta"], out=["T_f", "T_p"], ) >> cp_bounds( ## Dimensionless axial location (-) xst=(0, 5), ) >> cp_marginals( ## Mass loading ratio (-) Phi_M={ "dist": "uniform", "loc": 0, "scale": 1 }, ## Particle-fluid heat capacity ratio (-) chi={ "dist": "uniform", "loc": 0.1, "scale": 0.9 }, ## Normalized radiative intensity (-) I={ "dist": "uniform", "loc": 0.1, "scale": 0.9 }, ) >> cp_copula_independence()) return md
def make_prlc(): md_RLC_det = (gr.Model("RLC Circuit") >> gr.cp_vec_function( fun=lambda df: gr.df_make(np.sqrt(1 / df.L / df.C)), var=["L", "C"], out=["omega0"], ) >> gr.cp_function(fun=lambda df: gr.df_make(Q=df.omega0 * df.R * df.C), name="parallel RLC", var=["omega0", "R", "C"], out=["Q"]) >> gr.cp_bounds( R=(1e-3, 1e0), L=(1e-9, 1e-3), C=(1e-3, 100), )) return md_RLC_det
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 make_pareto_random(twoDim=True): """ Create a model of random points for a pareto frontier evaluation Args: twoDim (bool): determines whether to create a 2D or 3D model """ if twoDim == True: # Model to make dataset md_true = (Model() >> cp_vec_function( fun=lambda df: df_make( y1=df.x1 * cos(df.x2), y2=df.x1 * sin(df.x2), ), var=["x1", "x2"], out=["y1", "y2"], ) >> cp_marginals( x1=dict(dist="uniform", loc=0, scale=1), x2=dict(dist="uniform", loc=0, scale=pi / 2), ) >> cp_copula_independence()) return md_true else: # Model to make dataset md_true = (Model() >> cp_vec_function( fun=lambda df: df_make( y1=df.x1 * cos(df.x2), y2=df.x1 * sin(df.x2), y3=df.x1 * tan(df.x2), ), var=["x1", "x2", "x3"], out=["y1", "y2", "y3"], ) >> cp_marginals(x1=dict(dist="uniform", loc=0, scale=1), x2=dict(dist="uniform", loc=0, scale=pi / 2), x3=dict(dist="uniform", loc=0, scale=pi / 4)) >> cp_copula_independence()) return md_true
def fun_mp(i): x0 = df_init[var_fit].iloc[i].values ## Build evaluator 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() ## Run optimization res = minimize( objective, x0, args=(), method=method, jac=False, tol=tol, options={ "maxiter": n_maxiter, "disp": False, "ftol": ftol, "gtol": gtol, }, bounds=bounds, ) df_tmp = df_make( **dict(zip(var_fit, res.x)), **dict(zip(map(lambda s: s + "_0", var_fit), x0)), ) df_tmp["success"] = [res.success] df_tmp["message"] = [res.message] df_tmp["n_iter"] = [res.nit] df_tmp["mse"] = [res.fun] return df_tmp
def sir_vtime(T, S0, I0, R0, beta, gamma, rtol=1e-4): r"""Solve SIR IVP, vectorized over T Solves the initial value problem (IVP) associated with the SIR model, given parameter values and a span of time values. This routine uses an adaptive timestep to solve the IVP to a specified tolerance, then uses cubic interpolation to query the time points of interest. Args: T (array-like): Time points of interest S0 (float): Initial number of susceptible individuals (at t=0) I0 (float): Initial number of infected individuals (at t=0) R0 (float): Initial number of removed individuals (at t=0) beta (float): Infection rate parameter gamma (float): Removal rate parameter Returns: pandas DataFrame: Simulation timeseries results """ ## Solve SIR model on adaptive, coarse time mesh T_span = [0, max(T)] y0 = [S0, I0, R0] res = solve_ivp( sir_rhs, T_span, y0, args=(beta, gamma), rtol=rtol, t_eval=T, ) ## Interpolate to desired T points df_res = gr.df_make( t=T, S=res.y[0, :], I=res.y[1, :], R=res.y[2, :], S0=[S0], I0=[I0], R0=[R0], beta=[beta], gamma=[gamma], ) return df_res
def make_sir(rtol=1e-4): r"""Make an SIR model Instantiates a Susceptible, Infected, Removed (SIR) model for disease transmission. Args: rtol (float): Relative tolerance for IVP solver Returns: grama Model: SIR model References: "Compartmental models in epidemiology," Wikipedia, url: https://en.wikipedia.org/wiki/Compartmental_models_in_epidemiology """ md_sir = ( gr.Model("SIR Model") >> gr.cp_vec_function( fun=lambda df: gr.df_make( # Assume no recovered people at virus onset R0=0, # Assume total population of N=100 S0=df.N - df.I0, ), var=["I0", "N"], out=["S0", "R0"], name="Population setup", ) >> gr.cp_vec_function( fun=fun_sir(rtol=rtol), var=["t", "S0", "I0", "R0", "beta", "gamma"], out=["S", "I", "R"], name="ODE solver & interpolation", ) >> gr.cp_bounds( N=(100, 100), # Fixed population size I0=(1, 10), beta=(0.1, 0.5), gamma=(0.1, 0.5), t=(0, 100), )) return md_sir
def function_displacement(df): return df_make(g_disp=D_MAX - float64(4) * LENGTH**3 / df.E / df.w / df.t * sqrt(df.V**2 / df.t**4 + df.H**2 / df.w**4))
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
def eval_nls( model, df_data=None, out=None, var_fix=None, append=False, tol=1e-3, maxiter=25, nrestart=1, ): r"""Estimate with Nonlinear Least Squares (NLS) Estimate best-fit variable levels with nonlinear least squares (NLS). Args: model (gr.Model): Model to analyze. All model variables selected for fitting must be bounded or random. Deterministic variables may have semi-infinite bounds. df_data (DataFrame): Data for estimating parameters. Variables not found in df_data optimized in fitting. out (list or None): Output contributions to consider in computing MSE. Assumed to be model.out if left as None. var_fix (list or None): Variables to fix to nominal levels. Note that variables with domain width zero will automatically be fixed. append (bool): Append metadata? (Initial guess, MSE, optimizer status) tol (float): Optimizer convergence tolerance maxiter (int): Optimizer maximum iterations nrestart (int): Number of restarts; beyond nrestart=1 random restarts are used. Returns: DataFrame: Results of estimation Examples: >>> import grama as gr >>> from grama.data import df_trajectory_full >>> from grama.models import make_trajectory_linear >>> >>> md_trajectory = make_trajectory_linear() >>> >>> df_fit = ( >>> md_trajectory >>> >> gr.ev_nls(df_data=df_trajectory_full) >>> ) >>> >>> print(df_fit) """ ## Check `out` invariants if out is None: out = model.out print("... eval_nls setting out = {}".format(out)) set_diff = set(out).difference(set(df_data.columns)) if len(set_diff) > 0: raise ValueError("out must be subset of df_data.columns\n" + "difference = {}".format(set_diff)) ## Determine variables to be fixed if var_fix is None: var_fix = set() else: var_fix = set(var_fix) for var in model.var_det: wid = model.domain.get_width(var) if wid == 0: var_fix.add(var) print("... eval_nls setting var_fix = {}".format(list(var_fix))) ## Determine variables for evaluation var_feat = set(model.var).intersection(set(df_data.columns)) print("... eval_nls setting var_feat = {}".format(list(var_feat))) ## Determine variables for fitting var_fit = set(model.var).difference(var_fix.union(var_feat)) if len(var_fit) == 0: raise ValueError("No var selected for fitting!\n" + "Try checking model bounds and df_data.columns.") ## Separate var_fit into det and rand var_fit_det = list(set(model.var_det).intersection(var_fit)) var_fit_rand = list(set(model.var_rand).intersection(var_fit)) ## Construct bounds, fix var_fit order var_fit = var_fit_det + var_fit_rand bounds = [] var_prob = [] for var in var_fit_det: if not isfinite(model.domain.get_nominal(var)): var_prob.append(var) bounds.append(model.domain.get_bound(var)) if len(var_prob) > 0: raise ValueError( "all variables to be fitted must finite nominal value\n" + "offending var = {}".format(var_prob)) for var in var_fit_rand: bounds.append(( model.density.marginals[var].q(0), model.density.marginals[var].q(1), )) ## Determine initial guess points df_nom = eval_nominal(model, df_det="nom", skip=True) df_init = df_nom[var_fit] if nrestart > 1: raise NotImplementedError() ## Iterate over initial guesses df_res = DataFrame() for i in range(df_init.shape[0]): x0 = df_init[var_fit].iloc[i].values ## Build evaluator 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_res = eval_df(model, df=df_var) ## Compute joint MSE return ((df_res[out].values - df_data[out].values)**2).mean() ## Run optimization res = minimize( objective, x0, args=(), method="SLSQP", jac=False, tol=tol, options={ "maxiter": maxiter, "disp": False }, bounds=bounds, ) df_res = concat( ( df_res, df_make( **dict(zip(var_fit, res.x)), **dict(zip(map(lambda s: s + "_0", var_fit), x0)), status=res.status, mse=res.fun, ), ), axis=0, ) ## Post-process if append: return df_res else: return df_res[var_fit]
def make_channel(): r"""Make 1d channel model; dimensional form Instantiates a model for particle and fluid temperature rise; particles are suspended in a fluid with bulk velocity along a square cross-section channel. The walls of said channel are transparent, and radiation heats the particles as they travel down the channel. Note that this takes the same inputs as the builtin dataset `df_channel`. References: Banko, A.J. "RADIATION ABSORPTION BY INERTIAL PARTICLES IN A TURBULENT SQUARE DUCT FLOW" (2018) PhD Thesis, Stanford University, Chapter 2 Examples: >>> import grama as gr >>> from grama.data import df_channel >>> from grama.models import make_channel >>> md_channel = make_channel() >>> ( >>> df_channel >>> >> gr.tf_md(md_channel) >>> >> gr.ggplot(gr.aes("T_f", "T_norm")) >>> + gr.geom_abline(slope=1, intercept=0, linetype="dashed") >>> + gr.geom_point() >>> + gr.labs(x="1D Model", y="3D DNS") >>> ) """ md = ( Model("1d Particle-laden Channel with Radiation; Dimensional Form") >> cp_vec_function( fun=lambda df: df_make( Re=df.U * df.H / df.nu_f, chi=df.cp_p / df.cp_f, Pr=df.nu_f / df.alpha_f, Phi_M=df.rho_p * 0.524 * df.d_p**3 * df.n / df.rho_f, tau_flow=df.L / df.U, tau_pt=(df.rho_p * df.cp_p * 0.318 * df.d_p) / df.h_p, tau_rad=(df.rho_p * df.cp_p * 0.667 * df.d_p * df.T_0) / (df.Q_abs * 0.78 * df.I_0), ), var=[ "U", # Fluid bulk velocity "H", # Channel width "nu_f", # Fluid kinematic viscosity "cp_p", # Particle isobaric heat capacity "cp_f", # Fluid isobaric heat capacity "alpha_f", # Fluid thermal diffusivity "rho_p", # Particle density "rho_f", # Fluid density "d_p", # Particle diameter "n", # Particle number density "h_p", # Particle-to-gas convection coefficient "T_0", # Initial temperature "Q_abs", # Particle radiation absorption coefficient "I_0", # Incident radiation ], out=[ "Re", # Reynolds number "Pr", # Prandtl number "chi", # Particle-fluid heat capacity ratio "Phi_M", # Mass Loading Ratio "tau_flow", # Fluid residence time "tau_pt", # Particle thermal time constant "tau_rad", # Particle temperature doubling time (approximate) ], name="Dimensionless Numbers", ) >> cp_vec_function( fun=lambda df: df_make( ## Let xi = x / L xst=(df.xi * df.L) / df.H / df.Re / df.Pr, ## Assume an optically-thin scenario; I/I_0 = 1 Is=df.Re * df.Pr * (df.H / df.L) * (df.tau_flow / df.tau_rad) * 1, beta=df.Re * df.Pr * (df.H / df.L) * (df.tau_flow / df.tau_pt) * (1 + df.Phi_M * df.chi), ), var=[ "xi", "chi", "H", "L", "Phi_M", "tau_flow", "tau_rad", "tau_pt" ], out=[ "xst", # Flow-normalized channel axial location "Is", # Normalized heat flux "beta", # Spatial development coefficient ], name="Intermediate Dimensionless Numbers", ) >> cp_vec_function( fun=lambda df: df_make( T_f=(df.Phi_M * df.chi) / (1 + df.Phi_M * df.chi) * (df.Is * df.xst - df.Is / df.beta * (1 - exp(-df.beta * df.xst))), T_p=1 / (1 + df.Phi_M * df.chi) * (df.Phi_M * df.chi * df.Is * df.xst + df.Is / df.beta * (1 - exp(-df.beta * df.xst))), ), var=["xst", "Phi_M", "chi", "Is", "beta"], out=["T_f", "T_p"], ) >> cp_bounds( ## Normalized axial location; xi = x/L (-) xi=(0, 1), ) >> cp_marginals( ## Channel width (m) H={ "dist": "uniform", "loc": 0.038, "scale": 0.004 }, ## Channel length (m) L={ "dist": "uniform", "loc": 0.152, "scale": 0.016 }, ## Fluid bulk velocity (m/s) U={ "dist": "uniform", "loc": 1, "scale": 2.5 }, ## Fluid kinematic viscosity (m^2/s) nu_f={ "dist": "uniform", "loc": 1.4e-5, "scale": 0.1e-5 }, ## Particle isobaric heat capacity (J/(kg K)) cp_p={ "dist": "uniform", "loc": 100, "scale": 900 }, ## Fluid isobaric heat capacity (J/(kg K)) cp_f={ "dist": "uniform", "loc": 1000, "scale": 1000 }, ## Fluid thermal diffusivity (m^2/s) alpha_f={ "dist": "uniform", "loc": 50e-6, "scale": 50e-6 }, ## Particle density (kg / m^3) rho_p={ "dist": "uniform", "loc": 1e3, "scale": 9e3 }, ## Fluid density (kg / m^3) rho_f={ "dist": "uniform", "loc": 0.5, "scale": 1.0 }, ## Particle diameter (m) d_p={ "dist": "uniform", "loc": 1e-6, "scale": 9e-6 }, ## Particle number density (1 / m^3) n={ "dist": "uniform", "loc": 9.5e9, "scale": 1.0e9 }, ## Particle-to-gas convection coefficient (W / (m^2 K)) h_p={ "dist": "uniform", "loc": 1e3, "scale": 9e3 }, ## Initial temperature (K) T_0={ "dist": "uniform", "loc": 285, "scale": 30 }, ## Particle radiation absorption coefficient (-) Q_abs={ "dist": "uniform", "loc": 0.25, "scale": 0.50 }, ## Incident radiation (W/m^2) I_0={ "dist": "uniform", "loc": 9.5e6, "scale": 1.0e6 }, ) >> cp_copula_independence()) return md
def function_area(df): return df_make(c_area=df.w * df.t)
def eval_nls( model, df_data=None, out=None, var_fix=None, df_init=None, append=False, tol=1e-6, ftol=1e-9, gtol=1e-5, n_maxiter=100, n_restart=1, method="L-BFGS-B", seed=None, verbose=True, ): r"""Estimate with Nonlinear Least Squares (NLS) Estimate best-fit variable levels with nonlinear least squares (NLS). Args: model (gr.Model): Model to analyze. All model variables selected for fitting must be bounded or random. Deterministic variables may have semi-infinite bounds. df_data (DataFrame): Data for estimating parameters. Variables not found in df_data optimized in fitting. out (list or None): Output contributions to consider in computing MSE. Assumed to be model.out if left as None. 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 append (bool): Append metadata? (Initial guess, MSE, optimizer status) tol (float): Optimizer convergence tolerance n_maxiter (int): Optimizer maximum iterations n_restart (int): Number of restarts; beyond n_restart=1 random restarts are used. seed (int OR None): Random seed for restarts verbose (bool): Print messages to console? Returns: DataFrame: Results of estimation Examples: >>> import grama as gr >>> from grama.data import df_trajectory_full >>> from grama.models import make_trajectory_linear >>> >>> md_trajectory = make_trajectory_linear() >>> >>> df_fit = ( >>> md_trajectory >>> >> gr.ev_nls(df_data=df_trajectory_full) >>> ) >>> >>> print(df_fit) """ ## Check `out` invariants if out is None: out = model.out if verbose: print("... eval_nls setting out = {}".format(out)) set_diff = set(out).difference(set(df_data.columns)) if len(set_diff) > 0: raise ValueError("out must be subset of df_data.columns\n" + "difference = {}".format(set_diff)) ## Determine variables to be fixed if var_fix is None: var_fix = set() else: var_fix = set(var_fix) for var in model.var_det: wid = model.domain.get_width(var) if wid == 0: var_fix.add(var) if verbose: print("... eval_nls setting var_fix = {}".format(list(var_fix))) ## Determine variables for evaluation var_feat = set(model.var).intersection(set(df_data.columns)) if verbose: print("... eval_nls setting var_feat = {}".format(list(var_feat))) ## Determine variables for fitting var_fit = set(model.var).difference(var_fix.union(var_feat)) if len(var_fit) == 0: raise ValueError("No var selected for fitting!\n" + "Try checking model bounds and df_data.columns.") ## Separate var_fit into det and rand var_fit_det = list(set(model.var_det).intersection(var_fit)) var_fit_rand = list(set(model.var_rand).intersection(var_fit)) ## Construct bounds, fix var_fit order var_fit = var_fit_det + var_fit_rand bounds = [] var_prob = [] for var in var_fit_det: if not isfinite(model.domain.get_nominal(var)): var_prob.append(var) bounds.append(model.domain.get_bound(var)) if len(var_prob) > 0: raise ValueError( "all variables to be fitted must finite nominal value\n" + "offending var = {}".format(var_prob)) for var in var_fit_rand: bounds.append(( model.density.marginals[var].q(0), model.density.marginals[var].q(1), )) ## Determine initial guess points df_nom = eval_nominal(model, df_det="nom", skip=True) ## Use specified initial guess(es) if not (df_init is None): # Check invariants set_diff = set(var_fit).difference(set(df_init.columns)) if len(set_diff) > 0: raise ValueError("var_fit must be subset of df_init.columns\n" + "difference = {}".format(set_diff)) # Pull n_restart n_restart = df_init.shape[0] ## Generate initial guess(es) else: df_init = df_nom[var_fit] 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_monte_carlo( md_sweep, n=n_restart - 1, df_det="nom", skip=True, ) df_init = concat((df_init, df_rand[var_fit]), axis=0).reset_index(drop=True) ## Iterate over initial guesses df_res = DataFrame() for i in range(n_restart): x0 = df_init[var_fit].iloc[i].values ## Build evaluator 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() ## Run optimization res = minimize( objective, x0, args=(), method=method, jac=False, tol=tol, options={ "maxiter": n_maxiter, "disp": False, "ftol": ftol, "gtol": gtol, }, bounds=bounds, ) ## Package results df_tmp = df_make( **dict(zip(var_fit, res.x)), **dict(zip(map(lambda s: s + "_0", var_fit), x0)), ) df_tmp["success"] = [res.success] df_tmp["message"] = [res.message] df_tmp["n_iter"] = [res.nit] df_tmp["mse"] = [res.fun] df_res = concat( ( df_res, df_tmp, ), axis=0, ).reset_index(drop=True) ## Post-process if append: return df_res else: return df_res[var_fit]
def fun_y(df): v_inf = g * df.tau return df_make( y=df.tau * (df.v0 - v_inf) * (1 - exp(-df.t / df.tau)) + v_inf * df.t + y0 )
def function_stress(df): return df_make(g_stress=(df.Y - 600 * df.V / df.w / df.t**2 - 600 * df.H / df.w**2 / df.t) / MU_Y)
def tlmc_1f1m(md, N0, eps): import numpy as np import grama as gr X = gr.Intention() md1f1m = gr.make_tlmc_model_1f1m() # Check that md is OK --> same # inputs/outputs # Check inputs try: r = md.functions[0].func(0, 0) except TypeError: print( 'Input model must have 2 inputs: level and point at which to evaluate.' ) # Check outputs r = md.functions[0].func(0, 0) if len(r) != 2: raise ValueError( 'Level 0 function must have 2 outputs: result and cost.') r = md.functions[0].func(1, 0) if len(r) != 2: raise ValueError( 'Level 1 function must have 2 outputs: result and cost.') # Check that md has 1 function if len(md.functions) != 1: raise ValueError('Input model must have 1 function.') # make sure N0 and eps are greater than 0 if ((N0 <= 0) | (eps <= 0)): # make sure N0 and eps are greater than 0 raise ValueError('N0 and eps must be > 0.') its = 0 # initialize iteration counter Nlev = np.zeros((1, 2)) # samples taken per level (initialize) dNlev = np.array([[N0, N0]]) # samples left to take per level (initialize) Vlev = np.zeros((1, 2)) # variance per level (initialize) sumlev = np.zeros((2, 2)) # sample results per level (initialize) costlev = np.zeros((1, 2)) # total cost per level (initialize) while np.sum(dNlev) > 0: # check if there are samples left to be evaluated for lev in range(2): if dNlev[ 0, lev] > 0: # check if there are samples to be evaluated on level 'lev' df_mc_lev = md1f1m >> gr.ev_monte_carlo( n=dNlev[0, lev], df_det=gr.df_make(level=lev)) if lev > 0: df_prev = df_mc_lev >> gr.tf_select( gr.columns_between( "x", "level")) >> gr.tf_mutate(level=X.level - 1) df_mc_lev_prev = md1f1m >> gr.ev_df(df_prev) Y = df_mc_lev.P - df_mc_lev_prev.P C = sum(df_mc_lev.cost) + sum(df_mc_lev_prev.cost) else: Y = df_mc_lev.P C = sum(df_mc_lev.cost) cost = C sums = [sum(Y), sum(Y**2)] Nlev[0, lev] = Nlev[0, lev] + dNlev[ 0, lev] # update samples taken on level 'lev' sumlev[0, lev] = sumlev[0, lev] + sums[ 0] # update sample results on level 'lev' sumlev[1, lev] = sumlev[1, lev] + sums[ 1] # update sample results on level 'lev' costlev[0, lev] = costlev[ 0, lev] + cost # update total cost on level 'lev' mlev = np.abs(sumlev[0, :] / Nlev) # expected value per level Vlev = np.maximum( 0, (sumlev[1, :] / Nlev - mlev**2)) # variance per level Clev = costlev / Nlev # cost per result per level mu = eps**(-2) * sum(np.sqrt( Vlev * Clev)) # Lagrange multiplier to minimize variance for a fixed cost Ns = np.ceil( mu * np.sqrt(Vlev / Clev)) # optimal number of samples per level dNlev = np.maximum(0, Ns - Nlev) # update samples left to take per level its += 1 # update counter P = np.sum(sumlev[0, :] / Nlev) # evaluate two-level estimator return P, Nlev, Vlev, its
def fun_x(df): return df_make( x=df.tau * df.u0 * (1 - exp(-df.t / df.tau)) + x0 )