def fun_sir(df, rtol=1e-4): r"""Fully-vectorized SIR solver SIR IVP solver, vectorized over parameter values **and** time. The routine identifies groups of parameter values and runs a vectorized IVP solver over all associated time points, and gathers all results into a single output DataFrame. Intended for use in a grama model. Args: df (pd.DataFrame): All input values; must contain columns for all SIR parameters Preconditions: ["t", "S0", "I0", "R0", "beta", "gamma"] in df.columns Postconditions: Row-ordering of input data is reflected in the row-ordering of the output. Returns: pd.DataFrame: Solution results """ ## Find all groups of non-t parameters df_grouped = (df >> gr.tf_mutate(_idx=DF.index, _code=gr.str_c( "S0", DF.S0, "I0", DF.I0, "R0", DF.R0, "beta", DF.beta, "gamma", DF.gamma, ))) ## Run time-vectorized SIR solver over each group df_results = gr.df_grid() codes = set(df_grouped._code) for code in codes: df_param = (df_grouped >> gr.tf_filter(DF._code == code)) df_results = (df_results >> gr.tf_bind_rows( sir_vtime( df_param.t, df_param.S0[0], df_param.I0[0], df_param.R0[0], df_param.beta[0], df_param.gamma[0], rtol=rtol, ) >> gr.tf_mutate(_idx=df_param._idx))) ## Sort to match original ordering # NOTE: Without this, the output rows will be scrambled, relative # to the input rows, leading to very confusing output! return (df_results >> gr.tf_arrange(DF._idx) >> gr.tf_drop("_idx"))
def tran_kfolds( df, k=None, ft=None, out=None, var_fold=None, suffix="_mean", summaries=None, tf=tf_summarize, shuffle=True, seed=None, ): r"""Perform k-fold CV Perform k-fold cross-validation (CV) using a given fitting procedure (ft). Optionally provide a fold identifier column, or (randomly) assign folds. Args: df (DataFrame): Data to pass to given fitting procedure ft (gr.ft_): Partially-evaluated grama fit function; defines model fitting procedure and outputs to aggregate tf (gr.tf_): Partially-evaluated grama transform function; evaluation of fitted model will be passed to tf and provided with keyword arguments from summaries out (list or None): Outputs for which to compute `summaries`; None uses ft.out var_fold (str or None): Column to treat as fold identifier; overrides `k` suffix (str): Suffix for predicted value; used to distinguish between predicted and actual summaries (dict of functions): Summary functions to pass to tf; will be evaluated for outputs of ft. Each summary must have signature summary(f_pred, f_meas). Grama includes builtin options: gr.mse, gr.rmse, gr.rel_mse, gr.rsq, gr.ndme k (int): Number of folds; k=5 to k=10 recommended [1] shuffle (bool): Shuffle the data before CV? True recommended [1] Notes: - Many grama functions support *partial evaluation*; this allows one to specify things like hyperparameters in fitting functions without providing data and executing the fit. You can take advantage of this functionality to easly do hyperparameter studies. Returns: DataFrame: Aggregated results within each of k-folds using given model and summary transform References: [1] James, Witten, Hastie, and Tibshirani, "An introduction to statistical learning" (2017), Chapter 5. Resampling Methods Examples: >>> import grama as gr >>> from grama.data import df_stang >>> from grama.fit import ft_rf >>> df_kfolds = ( >>> df_stang >>> >> gr.tf_kfolds( >>> k=5, >>> ft=ft_rf(out=["thick"], var=["E", "mu"]), >>> ) """ ## Check invariants if ft is None: raise ValueError("Must provide ft keyword argument") if (k is None) and (var_fold is None): print("... tran_kfolds is using default k=5") k = 5 if summaries is None: print("... tran_kfolds is using default summaries mse and rsq") summaries = dict(mse=mse, rsq=rsq) n = df.shape[0] ## Handle custom folds if not (var_fold is None): ## Check for a valid var_fold if not (var_fold in df.columns): raise ValueError("var_fold must be in df.columns or None") ## Build folds levels = unique(df[var_fold]) k = len(levels) print("... tran_kfolds found {} levels via var_folds".format(k)) Is = [] for l in levels: Is.append(list(arange(n)[df[var_fold] == l])) else: ## Shuffle data indices if shuffle: if seed: set_seed(seed) I = permutation(n) else: I = arange(n) ## Build folds di = int(ceil(n / k)) Is = [I[i * di:min((i + 1) * di, n)] for i in range(k)] ## Iterate over folds df_res = DataFrame() for i in range(k): ## Train by out-of-fold data md_fit = df >> tf_filter(~var_in(X.index, Is[i])) >> ft ## Determine predicted and actual if out is None: out = str_replace(md_fit.out, suffix, "") else: out = str_replace(out, suffix, "") ## Test by in-fold data df_pred = md_fit >> ev_df(df=df >> tf_filter(var_in(X.index, Is[i])), append=False) ## Specialize summaries for output names summaries_all = ChainMap(*[{ key + "_" + o: fun(X[o + suffix], X[o]) for key, fun in summaries.items() } for o in out]) ## Aggregate df_summary_tmp = ( df_pred >> tf_bind_cols(df[out] >> tf_filter(var_in(X.index, Is[i]))) >> tf(**summaries_all) # >> tf_mutate(_kfold=i) ) if var_fold is None: df_summary_tmp = df_summary_tmp >> tf_mutate(_kfold=i) else: df_summary_tmp[var_fold] = levels[i] df_res = concat((df_res, df_summary_tmp), axis=0).reset_index(drop=True) return df_res
def get_buoyant_properties(df_hull_rot, df_mass, w_slope, w_intercept): r""" Args: df_hull_rot (DataFrame): Rotated hull points df_mass (DataFrame): Mass properties eq_water (lambda): takes in an x value, spits out a y """ # x and y intervals dx = df_mass.dx[0] dy = df_mass.dy[0] # Define equation for the surface of the water using slope intercept form eq_water = lambda x: w_slope * x + w_intercept # Find points under sloped waterline df_hull_under = (df_hull_rot >> gr.tf_mutate( under=df_hull_rot.y <= eq_water(df_hull_rot.x)) >> gr.tf_filter(DF.under == True)) # x and y position of COB x_cob = average(df_hull_under.x) y_cob = average(df_hull_under.y) # Pull x and y of COM as well x_com = df_mass.x[0] y_com = df_mass.y[0] # Total mass of water by finding area under curve m_water = RHO_WATER * len(df_hull_under) * dx * dy # Net force results from the difference in masses between the boat and the water F_net = (m_water - df_mass.mass[0]) * G # Distance to determine torque is ORTHOGONAL TO WATERLINE # Equation from https://www.geeksforgeeks.org/perpendicular-distance-between-a-point-and-a-line-in-2-d/ # Calculate righting moment for different cases of w_slope # Account for zero slope if w_slope == 0: M_net = G * m_water * x_cob else: # norm_dist = ((1 * y_com) + (1/w_slope * x_com) + ((1/w_slope) * x_cob) + y_cob) / np.sqrt(1 + (1/w_slope)**2) a = 1 / w_slope b = 1 c = (1 / w_slope) * x_cob + y_cob x1 = x_com y1 = y_com norm_dist = (a * x1 + b * y1 + c) / np.sqrt(a**2 + b**2) if w_slope > 0: # positive water slope creates a positive moment M_net = G * m_water * norm_dist elif w_slope < 0: # negative water slope creates a negative moment M_net = -G * m_water * norm_dist return DataFrame(dict( x=[x_cob], y=[y_cob], F_net=[F_net], M_net=[M_net], ))