A DuckDB extension for statistical regression and inference in SQL - OLS, Ridge, Elastic Net, LARS/LassoLars, WLS, recursive least squares, robust estimators (Huber, RANSAC, Theil-Sen), GLMs (Poisson, Negative Binomial, Binomial, Tweedie, Gamma, Logistic) with offset support, mixed-effects/hierarchical GLMs with random slopes and crossed/nested factors, AFT survival regression, explicit priors with Laplace intervals, empirical-Bayes shrinkage, and time-series regression, all with full diagnostics and inference.
Maintainer(s):
sipemu
Compatibility Matrix
This table covers all DuckDB releases that have not reached end-of-life, including LTS releases, and shows the 2 most recent patch releases of each. Older patch releases are not listed, but the extension may be available for them as well.
| Platform | 1.4.4 | 1.4.5 | 1.5.5 | 1.5.6 | 2.0.0 |
|---|---|---|---|---|---|
| Linux AMD64 | |||||
| Linux ARM64 | |||||
| macOS AMD64 | |||||
| macOS ARM64 | |||||
| Windows AMD64 | |||||
| Windows ARM64 | |||||
| WebAssembly |
Installing and Loading
INSTALL anofox_statistics FROM community;
LOAD anofox_statistics;
Added Functions
| function_name | function_type | description | comment | examples |
|---|---|---|---|---|
| acf_agg | aggregate | Sample autocorrelation function of x in the aggregate's ORDER BY order (R acf): one row per lag 0..max_lag with the 95% white-noise band conf_low/conf_high = -/+ qnorm(0.975)/sqrt(n). max_lag defaults to R's floor(10 log10 n). NULL values are skipped; NULL when n <= max_lag. | NULL | [acf_agg(resid, 10 ORDER BY t)] |
| acf_by | table_macro | Table macro: the sample autocorrelation function (R acf) of value_col ordered by order_col within each group of source, one row per lag (the integration contract's curve schema, curve_type 'acf'): the group column, model_id, series, curve_type, x (lag), y, y_low / y_high (95% white-noise band), threshold, weight, n_censor. max_lag defaults to R's floor(10 log10 n). |
NULL | [acf_by('residuals', store, resid, t, max_lag := 12)] |
| aft_cdf | scalar | Cumulative distribution P(T <= t) of an AFT survival time with linear predictor eta, scale and distribution (weibull, lognormal, loglogistic, exponential). | NULL | [aft_cdf(5.0, f.intercept + f.coefficients[1] * x1, f.scale, 'weibull')] |
| aft_fit_agg | aggregate | Fits an accelerated failure time (AFT) survival model to right-censored durations (event = 1 observed, 0 censored); coefficients are on the log-time scale. | NULL | [aft_fit_agg(duration, [x1, x2], event)] |
| aft_fit_agg | aggregate | Fits an accelerated failure time (AFT) survival model with a MAP of options (distribution, fit_intercept, compute_inference, confidence_level, …). | NULL | [aft_fit_agg(duration, [x1, x2], event, {'distribution': 'lognormal'})] |
| aft_glance_by | table_macro | Table macro: fits an accelerated failure time (AFT) survival model per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [aft_glance_by('my_table', group_col, y, [x1, x2], event)] |
| aft_quantile | scalar | p-quantile of an AFT survival time with linear predictor eta, scale and distribution (weibull, lognormal, loglogistic, exponential). | NULL | [aft_quantile(0.5, f.intercept + f.coefficients[1] * x1, f.scale, 'weibull')] |
| aft_survival | scalar | Model-based survival curve S(t | x) of a fitted AFT model (the STRUCT returned by aft_fit_agg) for the covariate row x, at each of times (R psurvreg(t, eta, scale, dist, lower.tail = FALSE)): one {time, surv} per time. | NULL | [aft_survival(m, [1.0, 0.5], [1, 5, 10, 20])] |
| aft_tidy_by | table_macro | Table macro: fits an accelerated failure time (AFT) survival model per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [aft_tidy_by('my_table', group_col, y, [x1, x2], event, names := ['x1', 'x2'])] |
| aic | scalar | Computes Akaike Information Criterion (AIC) from residual sum of squares, number of observations, and number of parameters. | NULL | [aic(rss, n, k)] |
| aid_agg | aggregate | Classifies demand patterns (smooth, intermittent, erratic, lumpy) using Automatic Identification of Demand (AID). | NULL | [aid_agg(y)] |
| aid_agg | aggregate | Classifies demand patterns using AID with a MAP of options (intermittent_threshold, outlier_method). | NULL | [aid_agg(y, {'intermittent_threshold': 0.3})] |
| aid_anomaly_agg | aggregate | Identifies anomalies in demand time series using AID with a MAP of options (intermittent_threshold, outlier_method). | NULL | [aid_anomaly_agg(y, {'outlier_method': 'iqr'})] |
| aid_anomaly_agg | aggregate | Identifies anomalies in demand time series using the AID classification framework. | NULL | [aid_anomaly_agg(y)] |
| aid_anomaly_by | table_macro | Table macro: AID anomaly flags per group of source, ordered by order_col; returns one row per input row with stockout, new_product, obsolete_product, high_outlier and low_outlier flags. | NULL | [aid_anomaly_by('sales', product_id, date, demand)] |
| aid_by | table_macro | Table macro: Automatic Identification of Demand (AID); classifies the demand pattern of each group of source and returns one row per group. | NULL | [aid_by('sales', product_id, demand)] |
| alm_fit_agg | aggregate | Fits an Additive Linear Model (ALM) and returns coefficients and fit statistics. | NULL | [alm_fit_agg(y, x)] |
| alm_fit_agg | aggregate | Fits an Additive Linear Model (ALM) and returns coefficients and fit statistics. | NULL | [alm_fit_agg(y, x, {'fit_intercept': true})] |
| alm_fit_predict_agg | aggregate | Fits an Additive Linear Model on training rows with a MAP of options and predicts all rows. | NULL | [alm_fit_predict_agg(y, x, split_col, {'distribution': 'laplace'})] |
| alm_fit_predict_agg | aggregate | Fits an Additive Linear Model over a partition and returns per-row predictions. | NULL | [alm_fit_predict_agg(y, x)] |
| alm_fit_predict_agg | aggregate | Fits an Additive Linear Model over a partition with a MAP of options and returns per-row predictions. | NULL | [alm_fit_predict_agg(y, x, {'distribution': 'laplace'})] |
| alm_fit_predict_agg | aggregate | Fits an Additive Linear Model using only training rows (split_col='train') and predicts all rows. | NULL | [alm_fit_predict_agg(y, x, split_col)] |
| alm_fit_predict_by | table_macro | Table macro: fits an Augmented Linear Model (ALM) per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [alm_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| alm_glance_by | table_macro | Table macro: fits an augmented linear model (ALM) per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [alm_glance_by('my_table', group_col, y, [x1, x2])] |
| alm_prediction_by | table_macro | Table macro: fits an augmented linear model (ALM) per group of source (alm_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('alm'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [alm_prediction_by('sales', store, week, revenue, [price, promo])] |
| alm_tidy_by | table_macro | Table macro: fits an augmented linear model (ALM) per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [alm_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| anofox_contract_version | scalar | Returns the version of the anofox integration contract (output schemas and duckdb_functions() tags) this extension implements. | NULL | [anofox_contract_version()] |
| ard_fit_agg | aggregate | Fits an ARD regression per group (scikit-learn ARDRegression: one Gaussian prior precision per coefficient, features whose precision reaches threshold_lambda are pruned to 0) and returns the posterior mean coefficients, intercept, R^2, noise_precision (alpha_), weight_precisions (lambda_, one per feature), the posterior standard deviation of each coefficient and the iteration count. | NULL | [ard_fit_agg(y, [x1, x2, x3])] |
| ard_fit_agg | aggregate | Fits an ARD regression per group (scikit-learn ARDRegression: one Gaussian prior precision per coefficient, features whose precision reaches threshold_lambda are pruned to 0) and returns the posterior mean coefficients, intercept, R^2, noise_precision (alpha_), weight_precisions (lambda_, one per feature), the posterior standard deviation of each coefficient and the iteration count. | NULL | [ard_fit_agg(y, [x1, x2, x3], {'threshold_lambda': 1000})] |
| ard_fit_predict_agg | aggregate | Fits an ARD (automatic relevance determination) regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [ard_fit_predict_agg(y, x)] |
| ard_fit_predict_agg | aggregate | Fits an ARD (automatic relevance determination) regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [ard_fit_predict_agg(y, x, split)] |
| ard_fit_predict_agg | aggregate | Fits an ARD (automatic relevance determination) regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [ard_fit_predict_agg(y, x, split, {'fit_intercept': false})] |
| ard_fit_predict_agg | aggregate | Fits an ARD (automatic relevance determination) regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [ard_fit_predict_agg(y, x, {'confidence_level': 0.9})] |
| ard_fit_predict_by | table_macro | Table macro: fits an ARD (automatic relevance determination) regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training appended. | NULL | [ard_fit_predict_by('my_table', group_col, y, [x1, x2, x3])] |
| ard_glance_by | table_macro | Table macro: fits an ARD (automatic relevance determination) regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [ard_glance_by('my_table', group_col, y, [x1, x2])] |
| ard_prediction_by | table_macro | Table macro: fits an ARD (automatic relevance determination) regression per group of source (ard_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('ard'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [ard_prediction_by('sales', store, week, revenue, [price, promo])] |
| ard_tidy_by | table_macro | Table macro: fits an ARD (automatic relevance determination) regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [ard_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| auc_agg | aggregate | Area under the ROC curve (scikit-learn roc_auc_score, pROC auc); ties count one half. NULL when only one class is present. | NULL | [auc_agg(y_true, score)] |
| bayesian_ridge_fit_agg | aggregate | Fits a Bayesian Ridge regression per group (scikit-learn BayesianRidge: Gaussian prior on the coefficients, noise and weight precisions estimated by evidence maximisation) and returns the posterior mean coefficients, intercept, R^2, noise_precision (alpha_), weight_precision (lambda_), the posterior standard deviation of each coefficient, the iteration count and the log marginal likelihood. | NULL | [bayesian_ridge_fit_agg(y, [x1, x2, x3])] |
| bayesian_ridge_fit_agg | aggregate | Fits a Bayesian Ridge regression per group (scikit-learn BayesianRidge: Gaussian prior on the coefficients, noise and weight precisions estimated by evidence maximisation) and returns the posterior mean coefficients, intercept, R^2, noise_precision (alpha_), weight_precision (lambda_), the posterior standard deviation of each coefficient, the iteration count and the log marginal likelihood. | NULL | [bayesian_ridge_fit_agg(y, [x1, x2, x3], {'max_iterations': 500})] |
| bayesian_ridge_fit_predict_agg | aggregate | Fits a Bayesian Ridge regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [bayesian_ridge_fit_predict_agg(y, x)] |
| bayesian_ridge_fit_predict_agg | aggregate | Fits a Bayesian Ridge regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [bayesian_ridge_fit_predict_agg(y, x, split)] |
| bayesian_ridge_fit_predict_agg | aggregate | Fits a Bayesian Ridge regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [bayesian_ridge_fit_predict_agg(y, x, split, {'fit_intercept': false})] |
| bayesian_ridge_fit_predict_agg | aggregate | Fits a Bayesian Ridge regression over a partition (training rows: y NOT NULL, or split = 'train') and returns one STRUCT per row: y, yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training. | NULL | [bayesian_ridge_fit_predict_agg(y, x, {'confidence_level': 0.9})] |
| bayesian_ridge_fit_predict_by | table_macro | Table macro: fits a Bayesian Ridge regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat, yhat_lower / yhat_upper (posterior predictive interval at confidence_level, default 0.95) and is_training appended. | NULL | [bayesian_ridge_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| bayesian_ridge_glance_by | table_macro | Table macro: fits a Bayesian Ridge regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [bayesian_ridge_glance_by('my_table', group_col, y, [x1, x2])] |
| bayesian_ridge_prediction_by | table_macro | Table macro: fits a Bayesian Ridge regression per group of source (bayesian_ridge_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('bayesian_ridge'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [bayesian_ridge_prediction_by('sales', store, week, revenue, [price, promo])] |
| bayesian_ridge_tidy_by | table_macro | Table macro: fits a Bayesian Ridge regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [bayesian_ridge_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| bic | scalar | Computes Bayesian Information Criterion (BIC) from residual sum of squares, number of observations, and number of parameters. | NULL | [bic(rss, n, k)] |
| binom_test_agg | aggregate | Performs an exact binomial test comparing an observed success count to a hypothesized probability, using default options. | NULL | [binom_test_agg(value)] |
| binom_test_agg | aggregate | Performs an exact binomial test comparing an observed success count to a hypothesized probability. | NULL | [binom_test_agg(value, {'p0': 0.5, 'alternative': 'two_sided'})] |
| binomial_augment_agg | aggregate | Fits a Binomial GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [binomial_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| binomial_augment_agg | aggregate | Fits a Binomial GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [binomial_augment_agg(y, [x1, x2], {'binomial_link': 'logit'}) OVER ()] |
| binomial_augment_by | table_macro | Table macro: fits a Binomial GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [binomial_augment_by('my_table', group_col, y, [x1, x2])] |
| binomial_effects_by | table_macro | Table macro: marginal-effect grid of a binomial GLM per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of binomial_tidy_by). |
NULL | [binomial_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| binomial_fit_agg | aggregate | Fits a Binomial GLM (logit link by default) and returns coefficients, deviance, AIC, dispersion, and fit statistics. y is the success rate in [0, 1]. | NULL | [binomial_fit_agg(y, x)] |
| binomial_fit_agg | aggregate | Fits a Binomial GLM (user-selectable link: logit / probit / cloglog; default logit) and returns coefficients, deviance, AIC, dispersion (= 1 for canonical binomial), and fit statistics. y is the success rate in [0, 1]. | NULL | [binomial_fit_agg(y, x, {'binomial_link': 'logit', 'fit_intercept': true})] |
| binomial_fit_predict_by | table_macro | Table macro: fits a binomial GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [binomial_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| binomial_glance_by | table_macro | Table macro: fits a binomial GLM per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [binomial_glance_by('my_table', group_col, y, [x1, x2])] |
| binomial_partial_residuals_agg | aggregate | Fits a Binomial GLM over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [binomial_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| binomial_partial_residuals_by | table_macro | Table macro: fits a binomial GLM per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [binomial_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| binomial_prediction_by | table_macro | Table macro: fits a binomial GLM per group of source (binomial_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('binomial'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [binomial_prediction_by('sales', store, week, revenue, [price, promo])] |
| binomial_tidy_by | table_macro | Table macro: fits a binomial GLM per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [binomial_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| bls_fit_agg | aggregate | Fits a Bounded Least Squares (BLS) regression with coefficient bounds and returns fit statistics. | NULL | [bls_fit_agg(y, x)] |
| bls_fit_agg | aggregate | Fits a Bounded Least Squares (BLS) regression with coefficient bounds and returns fit statistics. | NULL | [bls_fit_agg(y, x, {'lower_bound': 0.0, 'upper_bound': 1.0})] |
| bls_fit_predict_agg | aggregate | Fits a Bounded Least Squares model on training rows with a MAP of options and predicts all rows. | NULL | [bls_fit_predict_agg(y, x, split_col, {'null_policy': 'drop'})] |
| bls_fit_predict_agg | aggregate | Fits a Bounded Least Squares model over a partition and returns per-row predictions. | NULL | [bls_fit_predict_agg(y, x)] |
| bls_fit_predict_agg | aggregate | Fits a Bounded Least Squares model over a partition with a MAP of options and returns per-row predictions. | NULL | [bls_fit_predict_agg(y, x, {'null_policy': 'drop'})] |
| bls_fit_predict_agg | aggregate | Fits a Bounded Least Squares model using only training rows (split_col='train') and predicts all rows. | NULL | [bls_fit_predict_agg(y, x, split_col)] |
| bls_fit_predict_by | table_macro | Table macro: fits a bounded/non-negative least squares (BLS) regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [bls_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| bls_glance_by | table_macro | Table macro: fits a bounded least squares regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [bls_glance_by('my_table', group_col, y, [x1, x2])] |
| bls_prediction_by | table_macro | Table macro: fits a bounded least squares regression per group of source (bls_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('bls'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [bls_prediction_by('sales', store, week, revenue, [price, promo])] |
| bls_tidy_by | table_macro | Table macro: fits a bounded least squares regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [bls_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| box_pierce_agg | aggregate | Box-Pierce portmanteau test for autocorrelation of x in the aggregate's ORDER BY order (R Box.test(x, lag, type = 'Box-Pierce', fitdf)). lag defaults to 1, fitdf to 0. | NULL | [box_pierce_agg(resid, 10 ORDER BY t)] |
| breusch_pagan_agg | aggregate | Breusch-Pagan test for heteroskedasticity of regression residuals against the regressors x (R lmtest::bptest): statistic, df1, p_value. studentize (default true) is Koenker's robust variant, bptest's default; false gives the original 1979 statistic. | NULL | [breusch_pagan_agg(resid, [x1, x2])] |
| breusch_pagan_agg | aggregate | Breusch-Pagan test for heteroskedasticity of regression residuals against the regressors x (R lmtest::bptest): statistic, df1, p_value. studentize (default true) is Koenker's robust variant, bptest's default; false gives the original 1979 statistic. | NULL | [breusch_pagan_agg(resid, [x1, x2], false)] |
| brier_agg | aggregate | Brier score: mean squared difference between the predicted probability and the 0/1 outcome (scikit-learn brier_score_loss). | NULL | [brier_agg(y_true, prob)] |
| brown_forsythe_agg | aggregate | Tests equality of variances across groups using the Brown-Forsythe test. | NULL | [brown_forsythe_agg(value, group_id)] |
| brunner_munzel_agg | aggregate | Performs the Brunner-Munzel test for stochastic equality of two independent samples, using default options. | NULL | [brunner_munzel_agg(value, group_id)] |
| brunner_munzel_agg | aggregate | Performs the Brunner-Munzel test for stochastic equality of two independent samples. | NULL | [brunner_munzel_agg(value, group_id, {'alternative': 'two_sided'})] |
| calibration_agg | aggregate | Calibration (reliability) curve over n_bins equal-width bins of [0, 1] as a LIST of {bin, mean_pred, frac_pos, n, conf_low, conf_high} (scikit-learn calibration_curve, strategy 'uniform'); empty bins are omitted, bin is zero-based, and conf_low/conf_high are Wilson intervals (default conf_level 0.95). | NULL | [calibration_agg(y_true, prob, 10)] |
| calibration_curve_by | table_macro | Table macro: computes the calibration curve (x = mean predicted probability, y = fraction of positives, y_low/y_high = Wilson interval, weight = bin count; see calibration_agg) per group of source and returns one row per point in curve order (the integration contract's curve schema): the group column, model_id, series, curve_type ('calibration'), x, y, y_low, y_high, threshold, weight, n_censor. y_true_col is BOOLEAN or 0/1. |
NULL | [calibration_curve_by('scored', model, label, prob, n_bins := 10)] |
| chisq_gof_agg | aggregate | Performs a chi-squared goodness-of-fit test comparing observed frequencies to expected probabilities. | NULL | [chisq_gof_agg(observed, expected_prob)] |
| chisq_test_agg | aggregate | Performs a chi-squared test of independence on a 2×2 contingency table from two categorical columns. | NULL | [chisq_test_agg(row_var, col_var)] |
| chisq_test_agg | aggregate | Performs a chi-squared test of independence on a 2×2 contingency table from two categorical columns. | NULL | [chisq_test_agg(row_var, col_var, {'correction': true})] |
| clark_west_agg | aggregate | Performs the Clark-West test to compare a nested forecast model against an encompassing model, using default options. | NULL | [clark_west_agg(actual, forecast_restricted, forecast_unrestricted)] |
| clark_west_agg | aggregate | Performs the Clark-West test to compare a nested forecast model against an encompassing model. | NULL | [clark_west_agg(actual, forecast_restricted, forecast_unrestricted, {'horizon': 1})] |
| cohen_kappa_agg | aggregate | Computes Cohen's kappa, a measure of inter-rater agreement for categorical classifications. | NULL | [cohen_kappa_agg(rater1, rater2)] |
| cohen_kappa_agg | aggregate | Computes Cohen's kappa, a measure of inter-rater agreement for categorical classifications. | NULL | [cohen_kappa_agg(rater1, rater2, {'weighted': false})] |
| contingency_coef_agg | aggregate | Computes the contingency coefficient (C), a measure of association for categorical variables. | NULL | [contingency_coef_agg(row_var, col_var)] |
| cramers_v_agg | aggregate | Computes Cramér's V, a measure of association strength for nominal categorical variables. | NULL | [cramers_v_agg(row_var, col_var)] |
| dagostino_k2_agg | aggregate | Performs the D'Agostino-Pearson K² omnibus normality test based on skewness and kurtosis. | NULL | [dagostino_k2_agg(value)] |
| diebold_mariano_agg | aggregate | Performs the Diebold-Mariano test to compare predictive accuracy of two forecast models, using default options. | NULL | [diebold_mariano_agg(actual, forecast1, forecast2)] |
| diebold_mariano_agg | aggregate | Performs the Diebold-Mariano test to compare predictive accuracy of two forecast models. | NULL | [diebold_mariano_agg(actual, forecast1, forecast2, {'loss': 'squared'})] |
| distance_cor_agg | aggregate | Computes the distance correlation between two variables, detecting both linear and nonlinear dependence, using default options. | NULL | [distance_cor_agg(x, y)] |
| distance_cor_agg | aggregate | Computes the distance correlation between two variables, detecting both linear and nonlinear dependence. | NULL | [distance_cor_agg(x, y, {'n_permutations': 1000})] |
| dunn_test_agg | aggregate | Dunn's test for all pairwise differences of mean ranks after Kruskal-Wallis (FSA::dunnTest). Returns one row per pair: estimate (mean rank of group2 - group1), statistic (z for group2 - group1), p_value, p_adj. Options: p_adjust (holm [default], hochberg, hommel, bonferroni, BH/fdr, BY, none). | NULL | [dunn_test_agg(value, group, {'p_adjust': 'holm'})] |
| dunn_test_by | table_macro | Table macro: runs Dunn's rank test with p-value adjustment (FSA::dunnTest) between the levels of factor_col within each group of source and returns one row per pair (the integration contract's test schema): the group column, model_id, test_id (' |
NULL | [dunn_test_by('my_table', experiment, response, treatment)] |
| durbin_watson_agg | aggregate | Durbin-Watson statistic sum((e_t - e_{t-1})^2) / sum(e_t^2) of residuals in the aggregate's ORDER BY order (the statistic of R lmtest::dwtest). p_value is NULL here: pass the regressors, durbin_watson_agg(resid, x ORDER BY t), for the test with a p-value. | NULL | [durbin_watson_agg(resid ORDER BY t)] |
| durbin_watson_agg | aggregate | Durbin-Watson test for first-order autocorrelation of regression residuals in the aggregate's ORDER BY order, with the p-value of R lmtest::dwtest: x are the model's regressors (an intercept column is added unless fit_intercept is false). The p-value is exact (Imhof) for n < 100, else the normal approximation. alternative: 'greater' (default, positive autocorrelation), 'less' or 'two_sided'. | NULL | [durbin_watson_agg(resid, [x1, x2] ORDER BY t)] |
| eb_shrink_agg | aggregate | Empirical-Bayes (random-effects) shrinkage of per-group estimates with standard errors toward their precision-weighted mean; returns the shrunken estimates with mu and tau_squared. | NULL | [eb_shrink_agg(estimate, se)] |
| eb_shrink_agg | aggregate | Empirical-Bayes shrinkage of per-group estimates with a MAP of options (tau_squared, tau_method). | NULL | [eb_shrink_agg(estimate, se, {'tau_method': 'dl'})] |
| eb_shrink_by | table_macro | Table macro: empirical-Bayes shrinkage of the estimates in estimate_col (standard errors in se_col); returns every source row with shrunken, shrunken_se, weight, mu and tau_squared appended. | NULL | [eb_shrink_by('my_table', estimate, se)] |
| elasticnet_cv_agg | aggregate | k-fold cross-validation of the elastic-net path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. |
NULL | [elasticnet_cv_agg(y, [x1, x2])] |
| elasticnet_cv_agg | aggregate | k-fold cross-validation of the elastic-net path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. |
NULL | [elasticnet_cv_agg(y, [x1, x2], {'l1_ratio': 0.5, 'folds': 5})] |
| elasticnet_cv_agg | aggregate | k-fold cross-validation of the elastic-net path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. With fold_id, each row's fold is given (any labels, at least 3 distinct). |
NULL | [elasticnet_cv_agg(y, [x1, x2], fold_id, {'lambdas': [1.0, 0.1, 0.01]})] |
| elasticnet_cv_by | table_macro | Table macro: computes the k-fold cross-validation curve of the elastic-net path (cv.glmnet) per group of source with elasticnet_cv_agg (same options) and returns one row per lambda in the integration contract's curve schema: the group column, id (the group), model_id and model_name (the method), curve_type ('lambda_cv'), series, x (lambda), y (cv_mean), y_low, y_high (cv_mean -/+ cv_se), threshold, weight, n_censor, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds. |
NULL | [elasticnet_cv_by('my_table', group_col, y, [x1, x2])] |
| elasticnet_fit | scalar | Fits an ElasticNet regression model (L1+L2 regularization) with optional MAP of settings (fit_intercept, alpha, l1_ratio, max_iterations, tolerance). | NULL | [elasticnet_fit(y, x, {'alpha': 1.0, 'l1_ratio': 0.5})] |
| elasticnet_fit | scalar | Fits an ElasticNet regression model combining L1 and L2 regularization to the given response and feature data. | NULL | [elasticnet_fit(y, x)] |
| elasticnet_fit_agg | aggregate | Fits an ElasticNet model combining L1 and L2 regularization and returns coefficients and fit statistics. | NULL | [elasticnet_fit_agg(y, x)] |
| elasticnet_fit_agg | aggregate | Fits an ElasticNet model combining L1 and L2 regularization and returns coefficients and fit statistics. | NULL | [elasticnet_fit_agg(y, x, {'alpha': 1.0, 'l1_ratio': 0.5})] |
| elasticnet_fit_predict | aggregate | Window aggregate: fits an ElasticNet regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use elasticnet_fit_predict_agg. | NULL | [elasticnet_fit_predict(y, x)] |
| elasticnet_fit_predict | aggregate | Window aggregate: fits an ElasticNet regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use elasticnet_fit_predict_agg. | NULL | [elasticnet_fit_predict(y, x, {'null_policy': 'drop'})] |
| elasticnet_fit_predict_agg | aggregate | Fits ElasticNet regression on training rows with a MAP of options and predicts all rows. | NULL | [elasticnet_fit_predict_agg(y, x, split_col, {'null_policy': 'drop'})] |
| elasticnet_fit_predict_agg | aggregate | Fits ElasticNet regression over a partition and returns per-row predictions with prediction intervals. | NULL | [elasticnet_fit_predict_agg(y, x)] |
| elasticnet_fit_predict_agg | aggregate | Fits ElasticNet regression over a partition with a MAP of options and returns per-row predictions with prediction intervals. | NULL | [elasticnet_fit_predict_agg(y, x, {'null_policy': 'drop'})] |
| elasticnet_fit_predict_agg | aggregate | Fits ElasticNet regression using only training rows (split_col='train') and predicts all rows. | NULL | [elasticnet_fit_predict_agg(y, x, split_col)] |
| elasticnet_fit_predict_by | table_macro | Table macro: fits an ElasticNet regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [elasticnet_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| elasticnet_glance_by | table_macro | Table macro: fits an Elastic Net regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [elasticnet_glance_by('my_table', group_col, y, [x1, x2])] |
| elasticnet_path_agg | aggregate | Elastic-net coefficient path per group, as glmnet(alpha = l1_ratio) (default l1_ratio 0.5). Returns a LIST of terms rows (term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name = 'lambda', index_value = lambda), one per lambda and term, intercept first. Options: lambdas (default glmnet's grid), n_lambda (100), lambda_min_ratio, standardize (false), fit_intercept, feature_names. |
NULL | [elasticnet_path_agg(y, [x1, x2])] |
| elasticnet_path_agg | aggregate | Elastic-net coefficient path per group, as glmnet(alpha = l1_ratio) (default l1_ratio 0.5). Returns a LIST of terms rows (term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name = 'lambda', index_value = lambda), one per lambda and term, intercept first. Options: lambdas (default glmnet's grid), n_lambda (100), lambda_min_ratio, standardize (false), fit_intercept, feature_names. |
NULL | [elasticnet_path_agg(y, [x1, x2], {'l1_ratio': 0.5, 'lambdas': [1.0, 0.1, 0.01]})] |
| elasticnet_path_by | table_macro | Table macro: computes the elastic-net coefficient path (glmnet, l1_ratio = alpha) per group of source with elasticnet_path_agg (same options) and returns one row per index value and term in the terms schema: the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('lambda'), index_value. names := […] labels the terms. |
NULL | [elasticnet_path_by('my_table', group_col, y, [x1, x2])] |
| elasticnet_prediction_by | table_macro | Table macro: fits an Elastic Net regression per group of source (elasticnet_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('elasticnet'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [elasticnet_prediction_by('sales', store, week, revenue, [price, promo])] |
| elasticnet_rolling_tidy_by | table_macro | Table macro: fits an Elastic Net regression over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [elasticnet_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], window_size := 24)] |
| elasticnet_tidy_by | table_macro | Table macro: fits an Elastic Net regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [elasticnet_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| energy_distance_agg | aggregate | Computes the energy distance between two samples as a measure of distributional difference, using default options. | NULL | [energy_distance_agg(value, group_id)] |
| energy_distance_agg | aggregate | Computes the energy distance between two samples as a measure of distributional difference. | NULL | [energy_distance_agg(value, group_id, {'n_permutations': 1000})] |
| fisher_exact_agg | aggregate | Performs Fisher's exact test for association in a 2×2 contingency table. | NULL | [fisher_exact_agg(row_var, col_var)] |
| fisher_exact_agg | aggregate | Performs Fisher's exact test for association in a 2×2 contingency table. | NULL | [fisher_exact_agg(row_var, col_var, {'alternative': 'two_sided'})] |
| g_test_agg | aggregate | Performs a G-test (log-likelihood ratio test) for goodness of fit or independence. | NULL | [g_test_agg(row_var, col_var)] |
| gamma_augment_agg | aggregate | Fits a Gamma GLM (log link) over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [gamma_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| gamma_augment_agg | aggregate | Fits a Gamma GLM (log link) over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [gamma_augment_agg(y, [x1, x2], {'fit_intercept': true}) OVER ()] |
| gamma_augment_by | table_macro | Table macro: fits a Gamma GLM (log link) per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [gamma_augment_by('my_table', group_col, y, [x1, x2])] |
| gamma_effects_by | table_macro | Table macro: marginal-effect grid of a Gamma GLM per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of gamma_tidy_by). |
NULL | [gamma_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| gamma_fit_agg | aggregate | Fits a Gamma GLM (log link, var_power = 2.0 fixed) and returns coefficients, deviance, AIC, dispersion, and fit statistics. | NULL | [gamma_fit_agg(y, x)] |
| gamma_fit_agg | aggregate | Fits a Gamma GLM (log link, var_power = 2.0 fixed) and returns coefficients, deviance, AIC, dispersion, and fit statistics. y must be strictly positive. | NULL | [gamma_fit_agg(y, x, {'fit_intercept': true})] |
| gamma_fit_predict_by | table_macro | Table macro: fits a Gamma GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [gamma_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| gamma_glance_by | table_macro | Table macro: fits a Gamma GLM per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [gamma_glance_by('my_table', group_col, y, [x1, x2])] |
| gamma_partial_residuals_agg | aggregate | Fits a Gamma GLM (log link) over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [gamma_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| gamma_partial_residuals_by | table_macro | Table macro: fits a Gamma GLM per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [gamma_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| gamma_prediction_by | table_macro | Table macro: fits a Gamma GLM per group of source (gamma_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('gamma'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [gamma_prediction_by('sales', store, week, revenue, [price, promo])] |
| gamma_tidy_by | table_macro | Table macro: fits a Gamma GLM per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [gamma_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| glance | scalar | Model-level summary with the same fields for every model: model_type, family, link, n_observations, n_features, r_squared, adj_r_squared, residual_std_error, f_statistic, f_pvalue, log_likelihood, aic, bic, deviance, null_deviance, pseudo_r_squared, dispersion, iterations, converged. Fields a model does not have are NULL. | NULL | [glance(ols_fit_agg(y, [x1, x2])).*] |
| glmm_fit_agg | aggregate | Fits a generalized linear mixed model with a MAP of options (family, reml, random slopes, crossed groups, compute_inference, …). | NULL | [glmm_fit_agg(y, [x1, x2], store_id, {'family': 'poisson'})] |
| glmm_fit_agg | aggregate | Fits a generalized linear mixed model with a random intercept per group (one model across all groups); returns fixed effects, variance components and per-group random effects. | NULL | [glmm_fit_agg(y, [x1, x2], store_id)] |
| glmm_fit_by | table_macro | Table macro: fits one generalized linear mixed model (random intercept per group_col) over the whole table and returns one row per group with its random effect and the fixed effects and variance components. | NULL | [glmm_fit_by('my_table', group_col, y, [x1, x2])] |
| huber_fit | scalar | Fits a Huber M-estimator regression model with optional MAP of settings (epsilon, alpha, fit_intercept, compute_inference, confidence_level, max_iterations, tolerance). | NULL | [huber_fit(y, x, {'epsilon': 1.35, 'alpha': 0.01})] |
| huber_fit | scalar | Fits a Huber M-estimator robust regression model. Returns coefficients, fit statistics, the MAD-based scale, and the outlier count as a struct. | NULL | [huber_fit(y, x)] |
| huber_fit_agg | aggregate | Fits a Huber M-estimator robust regression model and returns coefficients, fit statistics, the MAD-based scale, and the outlier count as a struct. | NULL | [huber_fit_agg(y, x)] |
| huber_fit_agg | aggregate | Fits a Huber M-estimator robust regression model and returns coefficients, fit statistics, the MAD-based scale, and the outlier count as a struct. | NULL | [huber_fit_agg(y, x, {'epsilon': 1.35, 'fit_intercept': true})] |
| huber_fit_predict | aggregate | Window aggregate: fits a Huber M-estimator regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use huber_fit_predict_agg. | NULL | [huber_fit_predict(y, x) OVER (PARTITION BY g ORDER BY t)] |
| huber_fit_predict | aggregate | Window aggregate: fits a Huber M-estimator regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use huber_fit_predict_agg. | NULL | [huber_fit_predict(y, x, {'epsilon': 1.5}) OVER (…)] |
| huber_fit_predict_agg | aggregate | Fits Huber regression on training rows with a MAP of options and predicts all rows. | NULL | [huber_fit_predict_agg(y, x, split_col, {'epsilon': 1.5})] |
| huber_fit_predict_agg | aggregate | Fits Huber regression over a partition with a MAP of options and returns per-row predictions with prediction intervals. | NULL | [huber_fit_predict_agg(y, x, {'epsilon': 1.35, 'null_policy': 'drop'})] |
| huber_fit_predict_agg | aggregate | Fits Huber regression using only training rows (split_col='train') and predicts all rows. | NULL | [huber_fit_predict_agg(y, x, split_col)] |
| huber_fit_predict_agg | aggregate | Fits a Huber M-estimator robust regression over a partition and returns per-row predictions with prediction intervals. | NULL | [huber_fit_predict_agg(y, x)] |
| huber_fit_predict_by | table_macro | Table macro: fits a Huber M-estimator regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [huber_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| huber_glance_by | table_macro | Table macro: fits a Huber M-estimator regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [huber_glance_by('my_table', group_col, y, [x1, x2])] |
| huber_prediction_by | table_macro | Table macro: fits a Huber M-estimator regression per group of source (huber_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('huber'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [huber_prediction_by('sales', store, week, revenue, [price, promo])] |
| huber_rolling_tidy_by | table_macro | Table macro: fits a Huber M-estimator regression over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [huber_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], window_size := 24)] |
| huber_tidy_by | table_macro | Table macro: fits a Huber M-estimator regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [huber_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| icc_agg | aggregate | Computes the Intraclass Correlation Coefficient (ICC) to measure rater or measurement consistency. | NULL | [icc_agg(value, subject_id, rater_id)] |
| icc_agg | aggregate | Computes the Intraclass Correlation Coefficient (ICC) to measure rater or measurement consistency. | NULL | [icc_agg(value, subject_id, rater_id, {'type': 'single'})] |
| isotonic_fit_agg | aggregate | Fits a monotonic (isotonic) regression of y on a single x per group and returns the step function as sorted knots x with fitted values. | NULL | [isotonic_fit_agg(y, x)] |
| isotonic_fit_agg | aggregate | Fits a monotonic (isotonic) regression of y on a single x per group and returns the step function as sorted knots x with fitted values. | NULL | [isotonic_fit_agg(y, x, {'increasing': false})] |
| isotonic_fit_predict_agg | aggregate | Fits an isotonic regression model on training rows with a MAP of options and predicts all rows. | NULL | [isotonic_fit_predict_agg(y, x, split_col, {'increasing': true})] |
| isotonic_fit_predict_agg | aggregate | Fits an isotonic regression model over a partition and returns per-row predictions. | NULL | [isotonic_fit_predict_agg(y, x)] |
| isotonic_fit_predict_agg | aggregate | Fits an isotonic regression model over a partition with a MAP of options and returns per-row predictions. | NULL | [isotonic_fit_predict_agg(y, x, {'increasing': true})] |
| isotonic_fit_predict_agg | aggregate | Fits an isotonic regression model using only training rows (split_col='train') and predicts all rows. | NULL | [isotonic_fit_predict_agg(y, x, split_col)] |
| isotonic_fit_predict_by | table_macro | Table macro: fits an isotonic regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [isotonic_fit_predict_by('my_table', group_col, y, x)] |
| isotonic_prediction_by | table_macro | Table macro: fits an isotonic regression per group of source (isotonic_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('isotonic'), x (x_col, the plot position and row order, and the model's one feature), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [isotonic_prediction_by('sales', store, price, revenue)] |
| jarque_bera | scalar | Tests whether a sample has skewness and kurtosis consistent with a normal distribution (Jarque-Bera test). | NULL | [jarque_bera(values)] |
| jarque_bera_agg | aggregate | Aggregate version of the Jarque-Bera normality test, applied to a column of values. | NULL | [jarque_bera_agg(value)] |
| kaplan_meier_agg | aggregate | Kaplan-Meier survival curve of right-censored durations (event true/1 = observed, false/0 = censored), as R survival::survfit: one row per distinct time with surv, the pointwise confidence interval conf_low/conf_high (Greenwood; conf_type 'log' [default], 'log-log' or 'plain'; conf_level default 0.95), n_risk, n_event, n_censor and the Greenwood std_err of surv. | NULL | [kaplan_meier_agg(duration, event, 0.95, 'log-log')] |
| kaplan_meier_by | table_macro | Table macro: one Kaplan-Meier curve per stratum of source (R survfit(Surv(time, event) ~ strata)), one row per distinct time (the integration contract's curve schema, curve_type 'km', series = stratum): the stratum column, model_id, series, curve_type, x (time), y (survival), y_low / y_high (pointwise interval), threshold, weight (number at risk), n_censor, then n_risk, n_event and std_err. |
NULL | [kaplan_meier_by('patients', treatment, duration, event, conf_type := 'log-log')] |
| kendall_agg | aggregate | Computes Kendall's tau rank correlation coefficient and tests its significance. | NULL | [kendall_agg(x, y)] |
| kendall_agg | aggregate | Computes Kendall's tau rank correlation coefficient and tests its significance. | NULL | [kendall_agg(x, y, {'alternative': 'two_sided'})] |
| kruskal_wallis_agg | aggregate | Performs the Kruskal-Wallis H-test, a nonparametric alternative to one-way ANOVA. | NULL | [kruskal_wallis_agg(value, group_id)] |
| lars_fit_agg | aggregate | Fits a Least Angle Regression (LARS / LassoLars) model and returns coefficients and fit statistics. | NULL | [lars_fit_agg(y, x, {'fit_intercept': true, 'alpha': 0.0})] |
| lars_fit_agg | aggregate | Fits a Least Angle Regression (LARS) model and returns coefficients and fit statistics. | NULL | [lars_fit_agg(y, x)] |
| lars_glance_by | table_macro | Table macro: fits a LARS / Lasso-LARS regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [lars_glance_by('my_table', group_col, y, [x1, x2])] |
| lars_path_agg | aggregate | LARS / Lasso-LARS coefficient path per group, one entry per knot (index_name 'alpha', index_value the knot's alpha = max_j |x_j'(y - yhat)| on the centred design, columns scaled to unit norm with standardize; this is n * glmnet's lambda without standardize and sqrt(n) * lambda with it). Options: method ('lasso' default, 'lar'), standardize (true), n_nonzero_coefs, fit_intercept, feature_names. | NULL | [lars_path_agg(y, [x1, x2, x3])] |
| lars_path_agg | aggregate | LARS / Lasso-LARS coefficient path per group, one entry per knot (index_name 'alpha', index_value the knot's alpha = max_j |x_j'(y - yhat)| on the centred design, columns scaled to unit norm with standardize; this is n * glmnet's lambda without standardize and sqrt(n) * lambda with it). Options: method ('lasso' default, 'lar'), standardize (true), n_nonzero_coefs, fit_intercept, feature_names. | NULL | [lars_path_agg(y, [x1, x2])] |
| lars_path_by | table_macro | Table macro: computes the LARS / Lasso-LARS coefficient path per group of source with lars_path_agg (same options) and returns one row per index value and term in the terms schema: the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('alpha'), index_value. names := […] labels the terms. |
NULL | [lars_path_by('my_table', group_col, y, [x1, x2])] |
| lars_tidy_by | table_macro | Table macro: fits a LARS / Lasso-LARS regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [lars_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| linear_predict | scalar | Applies coefficients and an intercept to column-layout feature data (LIST of feature columns) and returns the list of predictions. Same as the 3-argument predict(). | NULL | [linear_predict([[1.0, 2.0], [3.0, 4.0]], [0.5, 1.5], 2.0)] |
| ljung_box_agg | aggregate | Ljung-Box portmanteau test for autocorrelation of x in the aggregate's ORDER BY order (R Box.test(x, lag, type = 'Ljung-Box', fitdf)): statistic Q, df1 = lag - fitdf, p_value. lag defaults to 1, fitdf to 0. | NULL | [ljung_box_agg(resid, 10, 2 ORDER BY t)] |
| lm_dynamic_fit_agg | aggregate | Fits a dynamic linear model with time-varying coefficients (greybox lmDynamic, bruteforce): every subset of the regressors is fitted, each row weights them by its pointwise information criterion and gets the weighted coefficients. Rows are in input order (give it with ORDER BY). Returns the time-averaged coefficients and intercept, fit statistics, n_models and, per row used, dynamic_intercept, dynamic_coefficients and fitted_values. Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_agg(y, [x1, x2] ORDER BY t)] |
| lm_dynamic_fit_agg | aggregate | Fits a dynamic linear model with time-varying coefficients (greybox lmDynamic, bruteforce): every subset of the regressors is fitted, each row weights them by its pointwise information criterion and gets the weighted coefficients. Rows are in input order (give it with ORDER BY). Returns the time-averaged coefficients and intercept, fit statistics, n_models and, per row used, dynamic_intercept, dynamic_coefficients and fitted_values. Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_agg(y, [x1, x2], {'ic': 'bic', 'span': 0.5} ORDER BY t)] |
| lm_dynamic_fit_predict_agg | aggregate | Fits a dynamic linear model (greybox lmDynamic) on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (the row's own time-varying fit; rows outside the fit use the time-averaged coefficients), yhat_lower / yhat_upper (NULL), is_training, and the row's dynamic intercept and coefficients (NULL outside the fit). Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_predict_agg(y, x ORDER BY t)] |
| lm_dynamic_fit_predict_agg | aggregate | Fits a dynamic linear model (greybox lmDynamic) on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (the row's own time-varying fit; rows outside the fit use the time-averaged coefficients), yhat_lower / yhat_upper (NULL), is_training, and the row's dynamic intercept and coefficients (NULL outside the fit). Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_predict_agg(y, x, split ORDER BY t)] |
| lm_dynamic_fit_predict_agg | aggregate | Fits a dynamic linear model (greybox lmDynamic) on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (the row's own time-varying fit; rows outside the fit use the time-averaged coefficients), yhat_lower / yhat_upper (NULL), is_training, and the row's dynamic intercept and coefficients (NULL outside the fit). Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_predict_agg(y, x, split, {'ic': 'aic'} ORDER BY t)] |
| lm_dynamic_fit_predict_agg | aggregate | Fits a dynamic linear model (greybox lmDynamic) on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (the row's own time-varying fit; rows outside the fit use the time-averaged coefficients), yhat_lower / yhat_upper (NULL), is_training, and the row's dynamic intercept and coefficients (NULL outside the fit). Options: ic ('aicc' default | 'aic' | 'bic'), span (lowess f smoothing the model weights over time, default 0.3; 0 = no smoothing), fit_intercept. | NULL | [lm_dynamic_fit_predict_agg(y, x, {'span': 0} ORDER BY t)] |
| lm_dynamic_fit_predict_by | table_macro | Table macro: fits a dynamic linear model with time-varying coefficients (greybox lmDynamic) per group of source in order_by order (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (the row's own time-varying fit; rows outside the fit use the time-averaged coefficients), yhat_lower / yhat_upper (NULL) and is_training appended. | NULL | [lm_dynamic_fit_predict_by('my_table', group_col, y, [x1, x2], order_by := t)] |
| lm_dynamic_glance_by | table_macro | Table macro: fits a dynamic linear model with time-varying coefficients (greybox lmDynamic) per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. Rows are fitted in order_col order (the model is sequential). | NULL | [lm_dynamic_glance_by('my_table', group_col, t, y, [x1, x2])] |
| lm_dynamic_prediction_by | table_macro | Table macro: fits a dynamic linear model with time-varying coefficients (greybox lmDynamic) per group of source (lm_dynamic_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('lm_dynamic'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [lm_dynamic_prediction_by('sales', store, week, revenue, [price, promo])] |
| lm_dynamic_tidy_by | table_macro | Table macro: fits a dynamic linear model with time-varying coefficients (greybox lmDynamic) per group of source (rows in order_col order) and returns the time-varying coefficients of every fitted row as terms rows, intercept first (the shape of |
NULL | [lm_dynamic_tidy_by('my_table', group_col, t, y, [x1, x2], names := ['x1', 'x2'])] |
| log_loss_agg | aggregate | Log loss (mean binary cross-entropy, scikit-learn log_loss); probabilities are clipped to [eps, 1 - eps]. | NULL | [log_loss_agg(y_true, prob)] |
| log_rank_test_agg | aggregate | Log-rank test of equal survival across two or more groups (R survival::survdiff, rho = 0): statistic (chi-squared), df1 (groups - 1), p_value, n. | NULL | [log_rank_test_agg(duration, event, treatment)] |
| logistic_augment_agg | aggregate | Fits a logistic regression over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [logistic_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| logistic_augment_agg | aggregate | Fits a logistic regression over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [logistic_augment_agg(y, [x1, x2], {'fit_intercept': true}) OVER ()] |
| logistic_augment_by | table_macro | Table macro: fits a logistic regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [logistic_augment_by('my_table', group_col, y, [x1, x2])] |
| logistic_effects_by | table_macro | Table macro: marginal-effect grid of a logistic regression per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of logistic_tidy_by). |
NULL | [logistic_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| logistic_fit_agg | aggregate | Fits a binary Logistic regression (binomial GLM with logit link; classifier API). y must be binary (0 or 1). Result struct extends the standard GLM shape with accuracy (on training data, at the configured threshold) and the threshold echo. Optional L2 (ridge) penalty. |
NULL | [logistic_fit_agg(y, x, {'glm_lambda': 0.1, 'threshold': 0.5})] |
| logistic_fit_agg | aggregate | Fits a binary Logistic regression (binomial GLM with logit link; classifier API). y must be binary (0 or 1). Result struct extends the standard GLM shape with accuracy and the threshold echo. |
NULL | [logistic_fit_agg(y, x)] |
| logistic_fit_predict_by | table_macro | Table macro: fits a logistic regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [logistic_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| logistic_glance_by | table_macro | Table macro: fits a logistic regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [logistic_glance_by('my_table', group_col, y, [x1, x2])] |
| logistic_partial_residuals_agg | aggregate | Fits a logistic regression over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [logistic_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| logistic_partial_residuals_by | table_macro | Table macro: fits a logistic regression per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [logistic_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| logistic_prediction_by | table_macro | Table macro: fits a logistic regression per group of source (logistic_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('logistic'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [logistic_prediction_by('sales', store, week, revenue, [price, promo])] |
| logistic_tidy_by | table_macro | Table macro: fits a logistic regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [logistic_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| lowess_agg | aggregate | LOWESS scatterplot smoother of y on x per group (R stats::lowess: local linear fits with tricube weights over the frac * n nearest points, iterations robustifying passes; delta at R's default). Returns the curve as a LIST of {x, yhat}, x increasing, one point per complete row. frac defaults to 2/3, iterations to 3. | NULL | [lowess_agg(y, x)] |
| lowess_agg | aggregate | LOWESS scatterplot smoother of y on x per group (R stats::lowess: local linear fits with tricube weights over the frac * n nearest points, iterations robustifying passes; delta at R's default). Returns the curve as a LIST of {x, yhat}, x increasing, one point per complete row. frac defaults to 2/3, iterations to 3. | NULL | [lowess_agg(y, x, 0.3)] |
| lowess_agg | aggregate | LOWESS scatterplot smoother of y on x per group (R stats::lowess: local linear fits with tricube weights over the frac * n nearest points, iterations robustifying passes; delta at R's default). Returns the curve as a LIST of {x, yhat}, x increasing, one point per complete row. frac defaults to 2/3, iterations to 3. | NULL | [lowess_agg(y, x, 0.3, 0)] |
| lowess_by | table_macro | Table macro: the LOWESS smoother of y_col on x_col per group of source (R stats::lowess(x, y, f = frac, iter = iterations), see lowess_agg), one row per point in x order (the integration contract's curve schema, curve_type 'lowess'): the group column, id (the group), model_id and model_name ('lowess'), curve_type, series, x, y (the smoothed value), y_low, y_high, threshold, weight, n_censor. |
NULL | [lowess_by('measurements', sensor, temperature, load, frac := 0.3)] |
| mann_whitney_u_agg | aggregate | Performs the Mann-Whitney U test (Wilcoxon rank-sum) for two independent samples, using default options. | NULL | [mann_whitney_u_agg(value, group_id)] |
| mann_whitney_u_agg | aggregate | Performs the Mann-Whitney U test (Wilcoxon rank-sum) for two independent samples. | NULL | [mann_whitney_u_agg(value, group_id, {'alternative': 'two_sided'})] |
| mcnemar_agg | aggregate | Performs McNemar's test for marginal homogeneity in paired categorical data. | NULL | [mcnemar_agg(var1, var2)] |
| mcnemar_agg | aggregate | Performs McNemar's test for marginal homogeneity in paired categorical data. | NULL | [mcnemar_agg(var1, var2, {'correction': true})] |
| mmd_agg | aggregate | Computes the Maximum Mean Discrepancy (MMD) between two samples to test distributional similarity, using default options. | NULL | [mmd_agg(value, group_id)] |
| mmd_agg | aggregate | Computes the Maximum Mean Discrepancy (MMD) between two samples to test distributional similarity. | NULL | [mmd_agg(value, group_id, {'n_permutations': 1000})] |
| negbinom_augment_agg | aggregate | Fits a Negative Binomial GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [negbinom_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| negbinom_augment_agg | aggregate | Fits a Negative Binomial GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [negbinom_augment_agg(y, [x1, x2], {'theta': 2.0}) OVER ()] |
| negbinom_augment_by | table_macro | Table macro: fits a Negative Binomial GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [negbinom_augment_by('my_table', group_col, y, [x1, x2])] |
| negbinom_effects_by | table_macro | Table macro: marginal-effect grid of a negative binomial GLM per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of negbinom_tidy_by). |
NULL | [negbinom_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| negbinom_fit_agg | aggregate | Fits a Negative Binomial GLM (log link, overdispersion parameter estimated jointly) and returns coefficients, deviance, AIC, dispersion (= alpha), and fit statistics. | NULL | [negbinom_fit_agg(y, x)] |
| negbinom_fit_agg | aggregate | Fits a Negative Binomial GLM (log link, overdispersion parameter estimated jointly) and returns coefficients, deviance, AIC, dispersion (= alpha), and fit statistics. | NULL | [negbinom_fit_agg(y, x, {'fit_intercept': true})] |
| negbinom_fit_predict_by | table_macro | Table macro: fits a negative binomial GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [negbinom_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| negbinom_glance_by | table_macro | Table macro: fits a negative binomial GLM per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [negbinom_glance_by('my_table', group_col, y, [x1, x2])] |
| negbinom_partial_residuals_agg | aggregate | Fits a Negative Binomial GLM over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [negbinom_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| negbinom_partial_residuals_by | table_macro | Table macro: fits a negative binomial GLM per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [negbinom_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| negbinom_prediction_by | table_macro | Table macro: fits a negative binomial GLM per group of source (negbinom_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('negbinom'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [negbinom_prediction_by('sales', store, week, revenue, [price, promo])] |
| negbinom_tidy_by | table_macro | Table macro: fits a negative binomial GLM per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [negbinom_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| nnls_fit_agg | aggregate | Fits a Non-Negative Least Squares (NNLS) regression with non-negativity constraints. | NULL | [nnls_fit_agg(y, x)] |
| nnls_fit_agg | aggregate | Fits a Non-Negative Least Squares (NNLS) regression with non-negativity constraints. | NULL | [nnls_fit_agg(y, x, {'tolerance': 1e-6})] |
| nnls_glance_by | table_macro | Table macro: fits a non-negative least squares regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [nnls_glance_by('my_table', group_col, y, [x1, x2])] |
| nnls_tidy_by | table_macro | Table macro: fits a non-negative least squares regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [nnls_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| ols_augment_agg | aggregate | Fits OLS over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). | NULL | [ols_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| ols_augment_agg | aggregate | Fits OLS over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). | NULL | [ols_augment_agg(y, [x1, x2], {'fit_intercept': true}) OVER ()] |
| ols_augment_by | table_macro | Table macro: fits an OLS regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. | NULL | [ols_augment_by('my_table', group_col, y, [x1, x2])] |
| ols_effects_by | table_macro | Table macro: marginal-effect grid of an OLS regression per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of ols_tidy_by). |
NULL | [ols_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| ols_fit | scalar | Fits an OLS regression model with optional MAP of settings (fit_intercept, compute_inference, confidence_level, solver, hc_type, alias_tolerance). | NULL | [ols_fit(y, x, {'compute_inference': true, 'confidence_level': 0.95})] |
| ols_fit | scalar | Fits an Ordinary Least Squares (OLS) regression model to the given response and feature data. | NULL | [ols_fit(y, x)] |
| ols_fit_agg | aggregate | Fits an OLS regression model and returns coefficients and fit statistics as a struct. | NULL | [ols_fit_agg(y, x)] |
| ols_fit_agg | aggregate | Fits an OLS regression model and returns coefficients and fit statistics as a struct. | NULL | [ols_fit_agg(y, x, {'fit_intercept': true})] |
| ols_fit_predict | aggregate | Window aggregate: fits an OLS regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ols_fit_predict_agg. | NULL | [ols_fit_predict(y, x)] |
| ols_fit_predict | aggregate | Window aggregate: fits an OLS regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ols_fit_predict_agg. | NULL | [ols_fit_predict(y, x, {'null_policy': 'drop'})] |
| ols_fit_predict_agg | aggregate | Fits OLS regression on training rows with a MAP of options and predicts all rows. | NULL | [ols_fit_predict_agg(y, x, split_col, {'null_policy': 'drop'})] |
| ols_fit_predict_agg | aggregate | Fits OLS regression over a partition and returns per-row predictions with prediction intervals. | NULL | [ols_fit_predict_agg(y, x)] |
| ols_fit_predict_agg | aggregate | Fits OLS regression over a partition with a MAP of options and returns per-row predictions with prediction intervals. | NULL | [ols_fit_predict_agg(y, x, {'null_policy': 'drop'})] |
| ols_fit_predict_agg | aggregate | Fits OLS regression using only training rows (split_col='train') and predicts all rows. | NULL | [ols_fit_predict_agg(y, x, split_col)] |
| ols_fit_predict_by | table_macro | Table macro: fits an OLS regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [ols_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| ols_glance_by | table_macro | Table macro: fits an OLS regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [ols_glance_by('my_table', group_col, y, [x1, x2])] |
| ols_partial_residuals_agg | aggregate | Fits OLS over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots). Rows not used for fitting get NULL residuals. | NULL | [ols_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| ols_partial_residuals_by | table_macro | Table macro: fits an OLS regression per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (x_j and y residualised on the other columns). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [ols_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| ols_prediction_by | table_macro | Table macro: fits an OLS regression per group of source (ols_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('ols'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [ols_prediction_by('sales', store, week, revenue, [price, promo])] |
| ols_rolling_tidy_by | table_macro | Table macro: fits an OLS regression over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [ols_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], window_size := 24)] |
| ols_tidy_by | table_macro | Table macro: fits an OLS regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [ols_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| one_way_anova_agg | aggregate | Performs a one-way ANOVA F-test to compare means across multiple groups. | NULL | [one_way_anova_agg(value, group_id)] |
| pacf_agg | aggregate | Sample partial autocorrelation function of x in the aggregate's ORDER BY order (R pacf): one row per lag 1..max_lag with the 95% white-noise band. max_lag defaults to R's floor(10 log10 n). | NULL | [pacf_agg(resid, 10 ORDER BY t)] |
| pacf_by | table_macro | Table macro: the sample partial autocorrelation function (R pacf) of value_col ordered by order_col within each group of source, one row per lag (the integration contract's curve schema, curve_type 'pacf'): the group column, model_id, series, curve_type, x (lag), y, y_low / y_high (95% white-noise band), threshold, weight, n_censor. max_lag defaults to R's floor(10 log10 n). |
NULL | [pacf_by('residuals', store, resid, t, max_lag := 12)] |
| pairwise_t_test_agg | aggregate | Pairwise t-tests between all groups with multiple-comparison adjustment (R pairwise.t.test). Returns one row per pair: group1, group2, estimate (mean of group2 - group1), statistic (t), p_value, p_adj, and the confidence interval of estimate (conf_low, conf_high at conf_level) from the same SE and df: per comparison with p_adjust none, Bonferroni-adjusted otherwise (as emmeans); one-sided for a one-sided alternative. Options: p_adjust (holm [default], hochberg, hommel, bonferroni, BH/fdr, BY, none), pool_sd (default true), alternative (two_sided, less, greater; for group2 - group1), confidence_level (default 0.95). | NULL | [pairwise_t_test_agg(value, group, {'p_adjust': 'holm', 'pool_sd': true})] |
| pairwise_t_test_by | table_macro | Table macro: runs pairwise t-tests with p-value adjustment (R pairwise.t.test) between the levels of factor_col within each group of source and returns one row per pair (the integration contract's test schema): the group column, model_id, test_id (' |
NULL | [pairwise_t_test_by('my_table', experiment, response, treatment)] |
| passive_aggressive_fit_agg | aggregate | Fits a Passive-Aggressive online regression (scikit-learn PassiveAggressiveRegressor) by updating the coefficients row by row in input order, without shuffling; give the order with ORDER BY. Returns the coefficients, intercept, R^2 and the number of passes. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_agg(y, [x1, x2] ORDER BY t)] |
| passive_aggressive_fit_agg | aggregate | Fits a Passive-Aggressive online regression (scikit-learn PassiveAggressiveRegressor) by updating the coefficients row by row in input order, without shuffling; give the order with ORDER BY. Returns the coefficients, intercept, R^2 and the number of passes. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_agg(y, [x1, x2], {'c': 0.5, 'epsilon': 0.05, 'variant': 'pa2'} ORDER BY t)] |
| passive_aggressive_fit_predict | aggregate | Window aggregate: runs the Passive-Aggressive online update over the rows of the window frame in frame order and returns the prediction for the LAST row of the frame (yhat; yhat_lower / yhat_upper are NULL). Use frames ending at CURRENT ROW over a unique ordering. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict(y, [x1, x2]) OVER (ORDER BY t ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)] |
| passive_aggressive_fit_predict | aggregate | Window aggregate: runs the Passive-Aggressive online update over the rows of the window frame in frame order and returns the prediction for the LAST row of the frame (yhat; yhat_lower / yhat_upper are NULL). Use frames ending at CURRENT ROW over a unique ordering. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict(y, [x1, x2], {'c': 0.5}) OVER (ORDER BY t ROWS BETWEEN 49 PRECEDING AND CURRENT ROW)] |
| passive_aggressive_fit_predict_agg | aggregate | Fits a Passive-Aggressive online regression on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (from the final coefficients), yhat_lower / yhat_upper (NULL: the model has no interval) and is_training. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict_agg(y, x ORDER BY t)] |
| passive_aggressive_fit_predict_agg | aggregate | Fits a Passive-Aggressive online regression on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (from the final coefficients), yhat_lower / yhat_upper (NULL: the model has no interval) and is_training. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict_agg(y, x, split ORDER BY t)] |
| passive_aggressive_fit_predict_agg | aggregate | Fits a Passive-Aggressive online regression on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (from the final coefficients), yhat_lower / yhat_upper (NULL: the model has no interval) and is_training. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict_agg(y, x, split, {'variant': 'pa2'} ORDER BY t)] |
| passive_aggressive_fit_predict_agg | aggregate | Fits a Passive-Aggressive online regression on the training rows of a partition (y NOT NULL, or split = 'train') in input order and returns one STRUCT per row: y, yhat (from the final coefficients), yhat_lower / yhat_upper (NULL: the model has no interval) and is_training. Options: c (aggressiveness, default 1), epsilon (insensitive zone, 0.1), variant ('pa1' default | 'pa2'), fit_intercept, max_iterations (passes over the rows, default 1 = online) and tolerance (early stopping of multi-pass fits). | NULL | [passive_aggressive_fit_predict_agg(y, x, {'c': 0.5} ORDER BY t)] |
| passive_aggressive_fit_predict_by | table_macro | Table macro: fits a Passive-Aggressive online regression per group of source, updating row by row in order_by order (training rows: y_col NOT NULL and split NULL or 'train'), and returns every source row with yhat from the final coefficients, yhat_lower / yhat_upper (NULL: no interval) and is_training appended. | NULL | [passive_aggressive_fit_predict_by('my_table', group_col, y, [x1, x2], order_by := t)] |
| passive_aggressive_glance_by | table_macro | Table macro: fits a Passive-Aggressive online regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. Rows are fitted in order_col order (the model is sequential). | NULL | [passive_aggressive_glance_by('my_table', group_col, t, y, [x1, x2])] |
| passive_aggressive_prediction_by | table_macro | Table macro: fits a Passive-Aggressive online regression per group of source (passive_aggressive_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('passive_aggressive'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [passive_aggressive_prediction_by('sales', store, week, revenue, [price, promo])] |
| passive_aggressive_tidy_by | table_macro | Table macro: fits a Passive-Aggressive online regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Rows are fitted in order_col order (the model is sequential). The model has no coefficient inference. names := […] labels the terms. | NULL | [passive_aggressive_tidy_by('my_table', group_col, t, y, [x1, x2], names := ['x1', 'x2'])] |
| pearson_agg | aggregate | Computes Pearson's product-moment correlation coefficient and tests its significance. | NULL | [pearson_agg(x, y)] |
| pearson_agg | aggregate | Computes Pearson's product-moment correlation coefficient and tests its significance. | NULL | [pearson_agg(x, y, {'alternative': 'two_sided'})] |
| permutation_t_test_agg | aggregate | Performs a permutation-based two-sample t-test using resampling, using default options. | NULL | [permutation_t_test_agg(value, group_id)] |
| permutation_t_test_agg | aggregate | Performs a permutation-based two-sample t-test using resampling. | NULL | [permutation_t_test_agg(value, group_id, {'alternative': 'two_sided', 'n_permutations': 10000})] |
| phi_coefficient_agg | aggregate | Computes the phi coefficient (φ), a measure of association for 2×2 contingency tables. | NULL | [phi_coefficient_agg(row_var, col_var)] |
| pls_fit_agg | aggregate | Fits a Partial Least Squares regression per group and returns the coefficients, intercept, R^2 and number of components. | NULL | [pls_fit_agg(y, [x1, x2, x3])] |
| pls_fit_agg | aggregate | Fits a Partial Least Squares regression per group and returns the coefficients, intercept, R^2 and number of components. | NULL | [pls_fit_agg(y, [x1, x2, x3], {'n_components': 2})] |
| pls_fit_predict_agg | aggregate | Fits a Partial Least Squares model on training rows with a MAP of options and predicts all rows. | NULL | [pls_fit_predict_agg(y, x, split_col, {'n_components': 2})] |
| pls_fit_predict_agg | aggregate | Fits a Partial Least Squares model over a partition and returns per-row predictions. | NULL | [pls_fit_predict_agg(y, x)] |
| pls_fit_predict_agg | aggregate | Fits a Partial Least Squares model over a partition with a MAP of options and returns per-row predictions. | NULL | [pls_fit_predict_agg(y, x, {'n_components': 2})] |
| pls_fit_predict_agg | aggregate | Fits a Partial Least Squares model using only training rows (split_col='train') and predicts all rows. | NULL | [pls_fit_predict_agg(y, x, split_col)] |
| pls_fit_predict_by | table_macro | Table macro: fits a partial least squares (PLS) regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [pls_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| pls_glance_by | table_macro | Table macro: fits a partial least squares regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [pls_glance_by('my_table', group_col, y, [x1, x2])] |
| pls_prediction_by | table_macro | Table macro: fits a partial least squares regression per group of source (pls_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('pls'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [pls_prediction_by('sales', store, week, revenue, [price, promo])] |
| pls_tidy_by | table_macro | Table macro: fits a partial least squares regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [pls_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| poisson_augment_agg | aggregate | Fits a Poisson GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [poisson_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| poisson_augment_agg | aggregate | Fits a Poisson GLM over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [poisson_augment_agg(y, [x1, x2], {'poisson_link': 'log'}) OVER ()] |
| poisson_augment_by | table_macro | Table macro: fits a Poisson GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [poisson_augment_by('my_table', group_col, y, [x1, x2])] |
| poisson_effects_by | table_macro | Table macro: marginal-effect grid of a Poisson GLM per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of poisson_tidy_by). |
NULL | [poisson_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| poisson_fit_agg | aggregate | Fits a Poisson regression (GLM with log link) and returns coefficients, deviance, AIC, and fit statistics. | NULL | [poisson_fit_agg(y, x)] |
| poisson_fit_agg | aggregate | Fits a Poisson regression (GLM with log link) and returns coefficients, deviance, AIC, and fit statistics. | NULL | [poisson_fit_agg(y, x, {'fit_intercept': true})] |
| poisson_fit_predict_agg | aggregate | Fits a Poisson regression on training rows with a MAP of options and predicts all rows. | NULL | [poisson_fit_predict_agg(y, x, split_col, {'link': 'log'})] |
| poisson_fit_predict_agg | aggregate | Fits a Poisson regression over a partition and returns per-row predictions. | NULL | [poisson_fit_predict_agg(y, x)] |
| poisson_fit_predict_agg | aggregate | Fits a Poisson regression over a partition with a MAP of options and returns per-row predictions. | NULL | [poisson_fit_predict_agg(y, x, {'link': 'log'})] |
| poisson_fit_predict_agg | aggregate | Fits a Poisson regression using only training rows (split_col='train') and predicts all rows. | NULL | [poisson_fit_predict_agg(y, x, split_col)] |
| poisson_fit_predict_by | table_macro | Table macro: fits a Poisson GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [poisson_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| poisson_glance_by | table_macro | Table macro: fits a Poisson GLM per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [poisson_glance_by('my_table', group_col, y, [x1, x2])] |
| poisson_partial_residuals_agg | aggregate | Fits a Poisson GLM over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [poisson_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| poisson_partial_residuals_by | table_macro | Table macro: fits a Poisson GLM per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [poisson_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| poisson_prediction_by | table_macro | Table macro: fits a Poisson GLM per group of source (poisson_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('poisson'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [poisson_prediction_by('sales', store, week, revenue, [price, promo])] |
| poisson_rolling_tidy_by | table_macro | Table macro: fits a Poisson GLM over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [poisson_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], window_size := 24)] |
| poisson_tidy_by | table_macro | Table macro: fits a Poisson GLM per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [poisson_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| pr_agg | aggregate | Precision-recall curve as a LIST of {threshold, recall, precision} in increasing threshold order, as scikit-learn precision_recall_curve; the final point (recall 0, precision 1) has a NULL threshold. | NULL | [pr_agg(y_true, score)] |
| pr_curve_by | table_macro | Table macro: computes the precision-recall curve (x = recall, y = precision; scikit-learn precision_recall_curve, see pr_agg) per group of source and returns one row per point in curve order (the integration contract's curve schema): the group column, model_id, series, curve_type ('pr'), x, y, y_low, y_high, threshold, weight, n_censor. y_true_col is BOOLEAN or 0/1. |
NULL | [pr_curve_by('scored', model, label, score)] |
| predict | scalar | Applies pre-fitted coefficients and intercept to feature data to generate predictions. | NULL | [predict(x, coefficients, intercept)] |
| predict | scalar | Predicts one row from a fitted model STRUCT (as returned by any *_fit_agg or *_fit function). GLM models are mapped to the response scale through their link unless {'type': 'link'} is given; isotonic models are interpolated. | NULL | [predict(ols_fit_agg(y, [x1, x2]), [1.5, 2.0])] |
| predict | scalar | Predicts one row from a fitted model STRUCT with a MAP of options; {'type': 'link'} returns a GLM prediction on the link scale. {'se_fit': true} and/or {'interval': 'confidence' | 'prediction', 'level': 0.95} return STRUCT(yhat, se_fit, yhat_lower, yhat_upper) from the model's covariance (OLS, WLS, Ridge and GLM fits with {'compute_inference': true}); GLM intervals are built on the link scale and transformed. | NULL | [predict(model, [x1, x2], {'type': 'link'}), predict(model, [x1, x2], {'se_fit': true, 'interval': 'prediction', 'level': 0.9})] |
| prop_test_one_agg | aggregate | Tests whether an observed proportion differs from a hypothesized value (one-sample proportion test), using default options. | NULL | [prop_test_one_agg(value)] |
| prop_test_one_agg | aggregate | Tests whether an observed proportion differs from a hypothesized value (one-sample proportion test). | NULL | [prop_test_one_agg(value, {'p0': 0.5, 'alternative': 'two_sided'})] |
| prop_test_two_agg | aggregate | Tests whether two observed proportions are equal (two-sample proportion test), using default options. | NULL | [prop_test_two_agg(value, group_id)] |
| prop_test_two_agg | aggregate | Tests whether two observed proportions are equal (two-sample proportion test). | NULL | [prop_test_two_agg(value, group_id, {'alternative': 'two_sided'})] |
| quantile_fit_agg | aggregate | Fits a linear quantile regression per group and returns the coefficients and intercept for the requested quantile tau. With {'compute_inference': true} or {'se': 'iid' | 'nid' | 'boot'} it adds standard errors, t statistics, p-values and conf_low / conf_high (quantreg::summary.rq). | NULL | [quantile_fit_agg(y, [x1, x2])] |
| quantile_fit_agg | aggregate | Fits a linear quantile regression per group and returns the coefficients and intercept for the requested quantile tau. With {'compute_inference': true} or {'se': 'iid' | 'nid' | 'boot'} it adds standard errors, t statistics, p-values and conf_low / conf_high (quantreg::summary.rq). | NULL | [quantile_fit_agg(y, [x1, x2], {'tau': 0.9, 'se': 'nid'})] |
| quantile_fit_predict_agg | aggregate | Fits a quantile regression model on training rows with a MAP of options and predicts all rows. | NULL | [quantile_fit_predict_agg(y, x, split_col, {'quantile': 0.5})] |
| quantile_fit_predict_agg | aggregate | Fits a quantile regression model over a partition and returns per-row predictions. | NULL | [quantile_fit_predict_agg(y, x)] |
| quantile_fit_predict_agg | aggregate | Fits a quantile regression model over a partition with a MAP of options and returns per-row predictions. | NULL | [quantile_fit_predict_agg(y, x, {'quantile': 0.5})] |
| quantile_fit_predict_agg | aggregate | Fits a quantile regression model using only training rows (split_col='train') and predicts all rows. | NULL | [quantile_fit_predict_agg(y, x, split_col)] |
| quantile_fit_predict_by | table_macro | Table macro: fits a quantile regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [quantile_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| quantile_glance_by | table_macro | Table macro: fits a quantile regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [quantile_glance_by('my_table', group_col, y, [x1, x2])] |
| quantile_prediction_by | table_macro | Table macro: fits a quantile regression per group of source (quantile_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('quantile'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [quantile_prediction_by('sales', store, week, revenue, [price, promo])] |
| quantile_process_agg | aggregate | Regression-quantile process per group: a quantile regression at each of taus (default 0.1, …, 0.9) with standard errors as quantreg::summary.rq (se 'nid' default, 'iid', 'boot'; 'compute_inference': false for estimates only). Returns a LIST of terms rows with index_name = 'tau', index_value = tau. |
NULL | [quantile_process_agg(y, [x1, x2])] |
| quantile_process_agg | aggregate | Regression-quantile process per group: a quantile regression at each of taus (default 0.1, …, 0.9) with standard errors as quantreg::summary.rq (se 'nid' default, 'iid', 'boot'; 'compute_inference': false for estimates only). Returns a LIST of terms rows with index_name = 'tau', index_value = tau. |
NULL | [quantile_process_agg(y, [x1, x2], {'taus': [0.25, 0.5, 0.75], 'se': 'iid'})] |
| quantile_process_by | table_macro | Table macro: computes the regression-quantile process (one quantile regression per tau, with inference) per group of source with quantile_process_agg (same options) and returns one row per index value and term in the terms schema: the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('tau'), index_value. names := […] labels the terms. |
NULL | [quantile_process_by('my_table', group_col, y, [x1, x2])] |
| quantile_tidy_by | table_macro | Table macro: fits a quantile regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [quantile_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| ransac_fit | scalar | Fits a RANSAC regression model with optional MAP of settings (residual_threshold, max_trials, min_samples, stop_probability, stop_n_inliers, random_state, fit_intercept, compute_inference, confidence_level). | NULL | [ransac_fit(y, x, {'residual_threshold': 0.5, 'random_state': 42})] |
| ransac_fit | scalar | Fits a RANSAC robust regression model. Returns coefficients, fit statistics, the residual threshold used, and the inlier / trial counts as a struct. | NULL | [ransac_fit(y, x)] |
| ransac_fit_agg | aggregate | Fits a RANSAC robust regression model and returns coefficients, fit statistics, the residual threshold used, and the inlier / trial counts as a struct. | NULL | [ransac_fit_agg(y, x)] |
| ransac_fit_agg | aggregate | Fits a RANSAC robust regression model and returns coefficients, fit statistics, the residual threshold used, and the inlier / trial counts as a struct. | NULL | [ransac_fit_agg(y, x, {'residual_threshold': 0.5, 'random_state': 42})] |
| ransac_fit_predict | aggregate | Window aggregate: fits a RANSAC regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ransac_fit_predict_agg. | NULL | [ransac_fit_predict(y, x) OVER (PARTITION BY g ORDER BY t)] |
| ransac_fit_predict | aggregate | Window aggregate: fits a RANSAC regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ransac_fit_predict_agg. | NULL | [ransac_fit_predict(y, x, {'residual_threshold': 0.5}) OVER (…)] |
| ransac_fit_predict_agg | aggregate | Fits RANSAC on training rows with a MAP of options and predicts all rows. | NULL | [ransac_fit_predict_agg(y, x, split_col, {'residual_threshold': 0.5})] |
| ransac_fit_predict_agg | aggregate | Fits RANSAC over a partition with a MAP of options and returns per-row predictions. | NULL | [ransac_fit_predict_agg(y, x, {'residual_threshold': 0.5, 'random_state': 42})] |
| ransac_fit_predict_agg | aggregate | Fits RANSAC using only training rows (split_col='train') and predicts all rows. | NULL | [ransac_fit_predict_agg(y, x, split_col)] |
| ransac_fit_predict_agg | aggregate | Fits a RANSAC robust regression over a partition and returns per-row predictions with prediction intervals. | NULL | [ransac_fit_predict_agg(y, x)] |
| ransac_fit_predict_by | table_macro | Table macro: fits a RANSAC robust regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [ransac_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| ransac_glance_by | table_macro | Table macro: fits a RANSAC regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [ransac_glance_by('my_table', group_col, y, [x1, x2])] |
| ransac_prediction_by | table_macro | Table macro: fits a RANSAC regression per group of source (ransac_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('ransac'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [ransac_prediction_by('sales', store, week, revenue, [price, promo])] |
| ransac_tidy_by | table_macro | Table macro: fits a RANSAC regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [ransac_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| residuals_diagnostics | scalar | Computes raw residuals from actuals and predictions. Standardized and studentized residuals, leverage and Cook's distance need the feature matrix: use residuals_diagnostics(y, y_hat, x, residual_std_error, include_studentized). | NULL | [residuals_diagnostics(y, y_hat)] |
| residuals_diagnostics | scalar | Computes raw, standardized and studentized residuals, leverage and Cook's distance from actuals, predictions and the feature matrix (residual_std_error may be NULL to estimate it from the residuals). | NULL | [residuals_diagnostics(y, y_hat, x, rse, true)] |
| residuals_diagnostics_agg | aggregate | Aggregate version of residuals diagnostics with feature matrix: computes raw, standardized, studentized residuals, leverage and Cook's distance from predicted and actual values and the feature matrix. | NULL | [residuals_diagnostics_agg(y, y_hat, x)] |
| residuals_diagnostics_agg | aggregate | Aggregate version of residuals diagnostics: computes raw residuals from predicted and actual values. Standardized and studentized residuals, leverage and Cook's distance need the feature matrix: use residuals_diagnostics_agg(y, y_hat, x). | NULL | [residuals_diagnostics_agg(y, y_hat)] |
| ridge_cv_agg | aggregate | k-fold cross-validation of the ridge path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. |
NULL | [ridge_cv_agg(y, [x1, x2])] |
| ridge_cv_agg | aggregate | k-fold cross-validation of the ridge path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. |
NULL | [ridge_cv_agg(y, [x1, x2], {'folds': 5, 'seed': 1})] |
| ridge_cv_agg | aggregate | k-fold cross-validation of the ridge path per group. Returns a LIST of curve rows (curve_type = 'lambda_cv', x = lambda, y = cv_mean, y_low / y_high = cv_mean -/+ cv_se, threshold NULL, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds), as cv.glmnet (type.measure = 'mse'). Options: as the path, plus folds (10) and seed for the seeded folds. With fold_id, each row's fold is given (any labels, at least 3 distinct). |
NULL | [ridge_cv_agg(y, [x1, x2], fold_id, {'lambdas': [1.0, 0.1, 0.01]})] |
| ridge_cv_by | table_macro | Table macro: computes the k-fold cross-validation curve of the ridge path (cv.glmnet) per group of source with ridge_cv_agg (same options) and returns one row per lambda in the integration contract's curve schema: the group column, id (the group), model_id and model_name (the method), curve_type ('lambda_cv'), series, x (lambda), y (cv_mean), y_low, y_high (cv_mean -/+ cv_se), threshold, weight, n_censor, lambda, cv_mean, cv_se, n_nonzero, is_min, is_1se, n_folds. |
NULL | [ridge_cv_by('my_table', group_col, y, [x1, x2])] |
| ridge_effects_by | table_macro | Table macro: marginal-effect grid of a Ridge regression per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of ridge_tidy_by). |
NULL | [ridge_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| ridge_fit | scalar | Fits a Ridge regression model with L2 regularization and optional MAP of settings (fit_intercept, compute_inference, confidence_level, alpha, solver). | NULL | [ridge_fit(y, x, {'alpha': 1.0, 'compute_inference': true})] |
| ridge_fit | scalar | Fits a Ridge regression model with L2 regularization to the given response and feature data. | NULL | [ridge_fit(y, x)] |
| ridge_fit_agg | aggregate | Fits a Ridge regression model with L2 regularization and returns coefficients and fit statistics. | NULL | [ridge_fit_agg(y, x)] |
| ridge_fit_agg | aggregate | Fits a Ridge regression model with L2 regularization and returns coefficients and fit statistics. | NULL | [ridge_fit_agg(y, x, {'alpha': 1.0})] |
| ridge_fit_predict | aggregate | Window aggregate: fits a Ridge regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ridge_fit_predict_agg. | NULL | [ridge_fit_predict(y, x)] |
| ridge_fit_predict | aggregate | Window aggregate: fits a Ridge regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use ridge_fit_predict_agg. | NULL | [ridge_fit_predict(y, x, {'null_policy': 'drop'})] |
| ridge_fit_predict_agg | aggregate | Fits Ridge regression on training rows with a MAP of options and predicts all rows. | NULL | [ridge_fit_predict_agg(y, x, split_col, {'null_policy': 'drop'})] |
| ridge_fit_predict_agg | aggregate | Fits Ridge regression over a partition and returns per-row predictions with prediction intervals. | NULL | [ridge_fit_predict_agg(y, x)] |
| ridge_fit_predict_agg | aggregate | Fits Ridge regression over a partition with a MAP of options and returns per-row predictions with prediction intervals. | NULL | [ridge_fit_predict_agg(y, x, {'null_policy': 'drop'})] |
| ridge_fit_predict_agg | aggregate | Fits Ridge regression using only training rows (split_col='train') and predicts all rows. | NULL | [ridge_fit_predict_agg(y, x, split_col)] |
| ridge_fit_predict_by | table_macro | Table macro: fits a Ridge regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [ridge_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| ridge_glance_by | table_macro | Table macro: fits a Ridge regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [ridge_glance_by('my_table', group_col, y, [x1, x2])] |
| ridge_path_agg | aggregate | Ridge coefficient path per group, as glmnet(alpha = 0): lambda is glmnet's per-observation penalty (1/(2n) RSS + lambda/2 ||b||^2 with y scaled to unit variance internally). Returns a LIST of terms rows (term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name = 'lambda', index_value = lambda), one per lambda and term, intercept first. Options: lambdas (default glmnet's grid), n_lambda (100), lambda_min_ratio, standardize (false), fit_intercept, feature_names. |
NULL | [ridge_path_agg(y, [x1, x2])] |
| ridge_path_agg | aggregate | Ridge coefficient path per group, as glmnet(alpha = 0): lambda is glmnet's per-observation penalty (1/(2n) RSS + lambda/2 ||b||^2 with y scaled to unit variance internally). Returns a LIST of terms rows (term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name = 'lambda', index_value = lambda), one per lambda and term, intercept first. Options: lambdas (default glmnet's grid), n_lambda (100), lambda_min_ratio, standardize (false), fit_intercept, feature_names. |
NULL | [ridge_path_agg(y, [x1, x2], {'n_lambda': 20})] |
| ridge_path_by | table_macro | Table macro: computes the ridge coefficient path (glmnet alpha = 0) per group of source with ridge_path_agg (same options) and returns one row per index value and term in the terms schema: the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('lambda'), index_value. names := […] labels the terms. |
NULL | [ridge_path_by('my_table', group_col, y, [x1, x2])] |
| ridge_prediction_by | table_macro | Table macro: fits a Ridge regression per group of source (ridge_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('ridge'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [ridge_prediction_by('sales', store, week, revenue, [price, promo])] |
| ridge_rolling_tidy_by | table_macro | Table macro: fits a Ridge regression over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [ridge_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], window_size := 24)] |
| ridge_tidy_by | table_macro | Table macro: fits a Ridge regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [ridge_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| rls_fit | scalar | Fits a Recursive Least Squares (RLS) model to the given response and feature data. | NULL | [rls_fit(y, x)] |
| rls_fit | scalar | Fits a Recursive Least Squares (RLS) model with optional MAP of settings (fit_intercept, forgetting_factor, initial_p_diagonal). | NULL | [rls_fit(y, x, {'forgetting_factor': 0.99})] |
| rls_fit_agg | aggregate | Fits a Recursive Least Squares model and returns coefficients and fit statistics. | NULL | [rls_fit_agg(y, x)] |
| rls_fit_agg | aggregate | Fits a Recursive Least Squares model and returns coefficients and fit statistics. | NULL | [rls_fit_agg(y, x, {'forgetting_factor': 0.99})] |
| rls_fit_predict | aggregate | Window aggregate: fits a Recursive Least Squares (RLS) regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use rls_fit_predict_agg. | NULL | [rls_fit_predict(y, x)] |
| rls_fit_predict | aggregate | Window aggregate: fits a Recursive Least Squares (RLS) regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use rls_fit_predict_agg. | NULL | [rls_fit_predict(y, x, {'null_policy': 'drop'})] |
| rls_fit_predict_agg | aggregate | Fits Robust LS regression on training rows with a MAP of options and predicts all rows. | NULL | [rls_fit_predict_agg(y, x, split_col, {'null_policy': 'drop'})] |
| rls_fit_predict_agg | aggregate | Fits Robust LS regression over a partition and returns per-row predictions. | NULL | [rls_fit_predict_agg(y, x)] |
| rls_fit_predict_agg | aggregate | Fits Robust LS regression over a partition with a MAP of options and returns per-row predictions. | NULL | [rls_fit_predict_agg(y, x, {'null_policy': 'drop'})] |
| rls_fit_predict_agg | aggregate | Fits Robust LS regression using only training rows (split_col='train') and predicts all rows. | NULL | [rls_fit_predict_agg(y, x, split_col)] |
| rls_fit_predict_by | table_macro | Table macro: fits a Recursive Least Squares (RLS) regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [rls_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| rls_glance_by | table_macro | Table macro: fits a recursive least squares regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [rls_glance_by('my_table', group_col, y, [x1, x2])] |
| rls_prediction_by | table_macro | Table macro: fits a recursive least squares regression per group of source (rls_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('rls'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [rls_prediction_by('sales', store, week, revenue, [price, promo])] |
| rls_tidy_by | table_macro | Table macro: fits a recursive least squares regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. The model has no coefficient inference. names := […] labels the terms. | NULL | [rls_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| roc_agg | aggregate | ROC curve of a binary classifier as a LIST of {threshold, fpr, tpr}, as scikit-learn roc_curve: the first point is (0, 0) at threshold +inf, tied scores form one point, and drop_intermediate (default true) drops collinear points. y_true is BOOLEAN or 0/1. | NULL | [roc_agg(y_true, score)] |
| roc_curve_by | table_macro | Table macro: computes the ROC curve (x = false positive rate, y = true positive rate; scikit-learn roc_curve, see roc_agg) per group of source and returns one row per point in curve order (the integration contract's curve schema): the group column, model_id, series, curve_type ('roc'), x, y, y_low, y_high, threshold, weight, n_censor. y_true_col is BOOLEAN or 0/1. |
NULL | [roc_curve_by('scored', model, label, score)] |
| shapiro_wilk_agg | aggregate | Performs the Shapiro-Wilk test for normality on a sample. | NULL | [shapiro_wilk_agg(value)] |
| spearman_agg | aggregate | Computes Spearman's rank correlation coefficient and tests its significance. | NULL | [spearman_agg(x, y)] |
| spearman_agg | aggregate | Computes Spearman's rank correlation coefficient and tests its significance. | NULL | [spearman_agg(x, y, {'alternative': 'two_sided'})] |
| t_test_agg | aggregate | Performs a two-sample t-test (Welch or Student) comparing values between two groups, using default options. | NULL | [t_test_agg(value, group_id)] |
| t_test_agg | aggregate | Performs a two-sample t-test (Welch or Student) comparing values between two groups. | NULL | [t_test_agg(value, group_id, {'alternative': 'two_sided'})] |
| theil_sen_fit | scalar | Fits a Theil-Sen regression model with optional MAP of settings (max_subpopulation, n_subsamples, max_iterations, tolerance, random_state, fit_intercept, compute_inference, confidence_level). | NULL | [theil_sen_fit(y, x, {'random_state': 42, 'max_subpopulation': 5000})] |
| theil_sen_fit | scalar | Fits a Theil-Sen robust regression model. Returns coefficients and fit statistics as a struct. | NULL | [theil_sen_fit(y, x)] |
| theil_sen_fit_agg | aggregate | Fits a Theil-Sen robust regression model and returns coefficients and fit statistics as a struct. | NULL | [theil_sen_fit_agg(y, x)] |
| theil_sen_fit_agg | aggregate | Fits a Theil-Sen robust regression model and returns coefficients and fit statistics as a struct. | NULL | [theil_sen_fit_agg(y, x, {'random_state': 42, 'max_subpopulation': 5000})] |
| theil_sen_fit_predict | aggregate | Window aggregate: fits a Theil-Sen regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use theil_sen_fit_predict_agg. | NULL | [theil_sen_fit_predict(y, x) OVER (PARTITION BY g ORDER BY t)] |
| theil_sen_fit_predict | aggregate | Window aggregate: fits a Theil-Sen regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use theil_sen_fit_predict_agg. | NULL | [theil_sen_fit_predict(y, x, {'random_state': 42}) OVER (…)] |
| theil_sen_fit_predict_agg | aggregate | Fits Theil-Sen on training rows with a MAP of options and predicts all rows. | NULL | [theil_sen_fit_predict_agg(y, x, split_col, {'random_state': 42})] |
| theil_sen_fit_predict_agg | aggregate | Fits Theil-Sen over a partition with a MAP of options and returns per-row predictions. | NULL | [theil_sen_fit_predict_agg(y, x, {'random_state': 42})] |
| theil_sen_fit_predict_agg | aggregate | Fits Theil-Sen using only training rows (split_col='train') and predicts all rows. | NULL | [theil_sen_fit_predict_agg(y, x, split_col)] |
| theil_sen_fit_predict_agg | aggregate | Fits a Theil-Sen robust regression over a partition and returns per-row predictions with prediction intervals. | NULL | [theil_sen_fit_predict_agg(y, x)] |
| theil_sen_fit_predict_by | table_macro | Table macro: fits a Theil-Sen regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [theil_sen_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| theil_sen_glance_by | table_macro | Table macro: fits a Theil-Sen regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [theil_sen_glance_by('my_table', group_col, y, [x1, x2])] |
| theil_sen_prediction_by | table_macro | Table macro: fits a Theil-Sen regression per group of source (theil_sen_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('theil_sen'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [theil_sen_prediction_by('sales', store, week, revenue, [price, promo])] |
| theil_sen_tidy_by | table_macro | Table macro: fits a Theil-Sen regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [theil_sen_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| tidy | scalar | One entry per model term (intercept first): term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value (the integration contract's terms schema). Unnest it to get a coefficient table; pass term names as a second argument. | NULL | [unnest(tidy(ols_fit_agg(y, [x1, x2], {'compute_inference': true})), recursive := true), tidy(model, ['price', 'promo'])] |
| tost_correlation_agg | aggregate | Tests equivalence of a correlation to a reference value using the TOST procedure, using default options. | NULL | [tost_correlation_agg(x, y)] |
| tost_correlation_agg | aggregate | Tests equivalence of a correlation to a reference value using the TOST procedure. | NULL | [tost_correlation_agg(x, y, {'delta': 0.1})] |
| tost_paired_agg | aggregate | Tests equivalence of paired measurements using the TOST procedure, using default options. | NULL | [tost_paired_agg(x, y)] |
| tost_paired_agg | aggregate | Tests equivalence of paired measurements using the TOST procedure. | NULL | [tost_paired_agg(x, y, {'delta': 0.5})] |
| tost_t_test_agg | aggregate | Tests equivalence of two groups using the Two One-Sided Tests (TOST) procedure with a t-test, using default options. | NULL | [tost_t_test_agg(value, group_id)] |
| tost_t_test_agg | aggregate | Tests equivalence of two groups using the Two One-Sided Tests (TOST) procedure with a t-test. | NULL | [tost_t_test_agg(value, group_id, {'delta': 1.0})] |
| tukey_hsd_agg | aggregate | Tukey's honest significant difference for all pairwise differences of group means (R TukeyHSD(aov(value ~ group))). Returns one row per pair with the simultaneous confidence interval (conf_low, conf_high) and family-wise p_adj. Options: confidence_level (default 0.95). | NULL | [tukey_hsd_agg(value, group, {'confidence_level': 0.95})] |
| tukey_hsd_by | table_macro | Table macro: runs Tukey's HSD (R TukeyHSD(aov(…))) between the levels of factor_col within each group of source and returns one row per pair (the integration contract's test schema): the group column, model_id, test_id (' |
NULL | [tukey_hsd_by('my_table', experiment, response, treatment)] |
| tweedie_augment_agg | aggregate | Fits a Tweedie GLM (log link) over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [tweedie_augment_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| tweedie_augment_agg | aggregate | Fits a Tweedie GLM (log link) over a partition (rows with y and every feature present) and returns one STRUCT per row, in frame order, with fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [tweedie_augment_agg(y, [x1, x2], {'power': 1.5}) OVER ()] |
| tweedie_augment_by | table_macro | Table macro: fits a Tweedie GLM (log link) per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted (response scale), residual (deviance), resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. Penalized fits (glm_lambda > 0 or a prior) are rejected. | NULL | [tweedie_augment_by('my_table', group_col, y, [x1, x2])] |
| tweedie_effects_by | table_macro | Table macro: marginal-effect grid of a Tweedie GLM per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of tweedie_tidy_by). |
NULL | [tweedie_effects_by('sales', store, revenue, [price, promo], focal := 1, n_points := 25, names := ['price', 'promo'])] |
| tweedie_fit_agg | aggregate | Fits a Tweedie GLM (log link, default power = 1.5 — compound Poisson-Gamma) and returns coefficients, deviance, AIC, dispersion (= phi), and fit statistics. | NULL | [tweedie_fit_agg(y, x)] |
| tweedie_fit_agg | aggregate | Fits a Tweedie GLM (log link, user-specified power 1 < p < 2 for compound Poisson-Gamma) and returns coefficients, deviance, AIC, dispersion (= phi), and fit statistics. Default power is 1.5. | NULL | [tweedie_fit_agg(y, x, {'power': 1.5, 'fit_intercept': true})] |
| tweedie_fit_predict_by | table_macro | Table macro: fits a Tweedie GLM per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [tweedie_fit_predict_by('my_table', group_col, y, [x1, x2])] |
| tweedie_glance_by | table_macro | Table macro: fits a Tweedie GLM per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [tweedie_glance_by('my_table', group_col, y, [x1, x2])] |
| tweedie_partial_residuals_agg | aggregate | Fits a Tweedie GLM (log link) over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots; the working residual), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots; NULL for GLMs). Rows not used for fitting get NULL residuals. | NULL | [tweedie_partial_residuals_agg(y, [x1, x2]) OVER (PARTITION BY g)] |
| tweedie_partial_residuals_by | table_macro | Table macro: fits a Tweedie GLM per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= working residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (NULL for GLMs). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [tweedie_partial_residuals_by('my_table', group_col, y, [x1, x2])] |
| tweedie_prediction_by | table_macro | Table macro: fits a Tweedie GLM per group of source (tweedie_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('tweedie'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [tweedie_prediction_by('sales', store, week, revenue, [price, promo])] |
| tweedie_tidy_by | table_macro | Table macro: fits a Tweedie GLM per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [tweedie_tidy_by('my_table', group_col, y, [x1, x2], names := ['x1', 'x2'])] |
| vif | scalar | Computes Variance Inflation Factor (VIF) for each column of a feature matrix to detect multicollinearity. | NULL | [vif(x)] |
| vif_agg | aggregate | Aggregate version of VIF: computes Variance Inflation Factor for each feature from a column of feature vectors. | NULL | [vif_agg(x)] |
| white_test_agg | aggregate | White's test for heteroskedasticity: the studentized Breusch-Pagan test against x, its squares and pairwise cross-products (R bptest(fit, ~ x1 * x2 + I(x1^2) + I(x2^2))). | NULL | [white_test_agg(resid, [x1, x2])] |
| wilcoxon_signed_rank_agg | aggregate | Performs the Wilcoxon signed-rank test for paired samples, using default options. | NULL | [wilcoxon_signed_rank_agg(x, y)] |
| wilcoxon_signed_rank_agg | aggregate | Performs the Wilcoxon signed-rank test for paired samples. | NULL | [wilcoxon_signed_rank_agg(x, y, {'alternative': 'two_sided'})] |
| wls_augment_agg | aggregate | Fits WLS over a partition (rows with y, every feature and a positive weight) and returns one STRUCT per row, in frame order, with fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). | NULL | [wls_augment_agg(y, [x1, x2], w) OVER (PARTITION BY g)] |
| wls_augment_agg | aggregate | Fits WLS over a partition (rows with y, every feature and a positive weight) and returns one STRUCT per row, in frame order, with fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training and n_params (broom augment). | NULL | [wls_augment_agg(y, [x1, x2], w, {'fit_intercept': true}) OVER ()] |
| wls_augment_by | table_macro | Table macro: fits a weighted least squares (WLS) regression per group of source (training rows: y_col NOT NULL, a positive weight and split NULL or 'train') and returns every source row with the per-observation diagnostics of the fit (broom augment, contract obs schema): model_id and model_name (the method; the group column is among the source columns), row_id, fitted, residual, resid_type, std_residual, stud_residual, leverage, cooks_d, dffits, weight, is_training, n_params. Non-training rows get the prediction as fitted and NULL diagnostics. | NULL | [wls_augment_by('my_table', group_col, y, [x1, x2], w)] |
| wls_effects_by | table_macro | Table macro: marginal-effect grid of a weighted least squares regression per group of source: the fitted mean over n_points values spanning the range of feature focal (1-based position in x_cols), with the other features at their group means over the fitted rows (or at at_values, a list with one value per feature), and its confidence band at level from predict(model, x, {'interval': 'confidence'}) (response scale for GLMs). Integration contract prediction schema: the group column, id, model_id, model_name, focal, x (the focal value), y (NULL), yhat, yhat_lower, yhat_upper, level, split (NULL), se_fit, focal_name (the focal feature's name: names[focal] when names := […] is given, else 'x' || focal, as the terms of wls_tidy_by). |
NULL | [wls_effects_by('sales', store, revenue, [price, promo], w, focal := 1, n_points := 25, names := ['price', 'promo'])] |
| wls_fit | scalar | Fits a WLS regression model with optional MAP of settings (fit_intercept, compute_inference, confidence_level, solver, hc_type, alias_tolerance). | NULL | [wls_fit(y, x, weights, {'compute_inference': true})] |
| wls_fit | scalar | Fits a Weighted Least Squares (WLS) regression model using per-observation weights. | NULL | [wls_fit(y, x, weights)] |
| wls_fit_agg | aggregate | Fits a Weighted Least Squares regression model and returns coefficients and fit statistics. | NULL | [wls_fit_agg(y, x, weight)] |
| wls_fit_agg | aggregate | Fits a Weighted Least Squares regression model and returns coefficients and fit statistics. | NULL | [wls_fit_agg(y, x, weight, {'fit_intercept': true})] |
| wls_fit_predict | aggregate | Window aggregate: fits a weighted least squares (WLS) regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use wls_fit_predict_agg. | NULL | [wls_fit_predict(y, x, weight)] |
| wls_fit_predict | aggregate | Window aggregate: fits a weighted least squares (WLS) regression on the rows of the window frame and returns the prediction (with interval) for the LAST row of the frame. Use frames ending at CURRENT ROW over a unique ordering; for per-row predictions over a whole group use wls_fit_predict_agg. | NULL | [wls_fit_predict(y, x, weight, {'null_policy': 'drop'})] |
| wls_fit_predict_agg | aggregate | Fits WLS regression on training rows with weights and a MAP of options and predicts all rows. | NULL | [wls_fit_predict_agg(y, x, weights, split_col, {'null_policy': 'drop'})] |
| wls_fit_predict_agg | aggregate | Fits WLS regression over a partition using weights and returns per-row predictions. | NULL | [wls_fit_predict_agg(y, x, weights)] |
| wls_fit_predict_agg | aggregate | Fits WLS regression over a partition using weights with a MAP of options and returns per-row predictions. | NULL | [wls_fit_predict_agg(y, x, weights, {'null_policy': 'drop'})] |
| wls_fit_predict_agg | aggregate | Fits WLS regression using only training rows (split_col='train') with weights and predicts all rows. | NULL | [wls_fit_predict_agg(y, x, weights, split_col)] |
| wls_fit_predict_by | table_macro | Table macro: fits a weighted least squares (WLS) regression per group of source (training rows: y_col NOT NULL and split NULL or 'train') and returns every source row with yhat (plus yhat_lower / yhat_upper prediction-interval bounds where the model provides them) and is_training appended. | NULL | [wls_fit_predict_by('my_table', group_col, y, [x1, x2], weight)] |
| wls_glance_by | table_macro | Table macro: fits a weighted least squares regression per group of source and returns its fit statistics in long form, one row per available metric: the group column, id (the group), model_id and model_name (the method), model_type, metric, value. | NULL | [wls_glance_by('my_table', group_col, y, [x1, x2], w)] |
| wls_partial_residuals_agg | aggregate | Fits WLS over a partition and returns, per row in frame order, a LIST with one STRUCT per fitted term: term_index (1-based position in x), x, partial_residual = residual + component (R residuals(type = 'partial'), car::crPlots), component = b_j (x_j - mean(x_j)), and the added-variable coordinates x_residual, y_residual (car::avPlots). Rows not used for fitting get NULL residuals. | NULL | [wls_partial_residuals_agg(y, [x1, x2], w) OVER (PARTITION BY g)] |
| wls_partial_residuals_by | table_macro | Table macro: fits a weighted least squares regression per group of source and returns one row per input row and fitted term with partial-residual (component-plus-residual, car::crPlots) and added-variable (car::avPlots) coordinates: the group column, id (the group), model_id and model_name (the method), row_id, term_index, term, x, partial_residual (= residual + component), component (b_j (x_j - mean(x_j))), x_residual, y_residual (x_j and y residualised on the other columns). Rows not used for fitting get NULL residuals. names := […] labels the terms. | NULL | [wls_partial_residuals_by('my_table', group_col, y, [x1, x2], w)] |
| wls_prediction_by | table_macro | Table macro: fits a weighted least squares regression per group of source (wls_fit_predict_by) and returns one row per input row in the integration contract's prediction schema: the group column, id, model_id, model_name ('wls'), x (x_col, the plot position and row order), y, yhat, yhat_lower, yhat_upper (the interval at level, default 0.95, overriding any confidence_level in options), level (NULL on rows without a band), split ('train' for fitted rows, 'future' for rows with a NULL y, 'test' for rows held out by split). |
NULL | [wls_prediction_by('sales', store, week, revenue, [price, promo], w)] |
| wls_rolling_tidy_by | table_macro | Table macro: fits a weighted least squares regression over a trailing window of window_size rows (ordered by order_col) within each group of source and returns the coefficients of every window as terms rows (integration contract): the group column, id (the group), model_id and model_name (the method), window_end (order_col of the window's last row), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name ('window_end'), index_value (the window's 1-based end position in its group) and n_window. Windows with fewer than min_obs rows (default window_size) are skipped. |
NULL | [wls_rolling_tidy_by('my_table', group_col, t, y, [x1, x2], w, window_size := 24)] |
| wls_tidy_by | table_macro | Table macro: fits a weighted least squares regression per group of source and returns one row per term (intercept first): the group column, id (the group), model_id and model_name (the method), term, estimate, std_error, statistic, p_value, conf_low, conf_high, conf_level, index_name, index_value. Inference is computed by default (compute_inference is merged under options). names := […] labels the terms. | NULL | [wls_tidy_by('my_table', group_col, y, [x1, x2], w, names := ['x1', 'x2'])] |
| yuen_agg | aggregate | Performs Yuen's trimmed-means t-test, robust to outliers and non-normality, using default options. | NULL | [yuen_agg(value, group_id)] |
| yuen_agg | aggregate | Performs Yuen's trimmed-means t-test, robust to outliers and non-normality. | NULL | [yuen_agg(value, group_id, {'trim': 0.2})] |
Overloaded Functions
This extension does not add any function overloads.
Added Types
This extension does not add any types.
Added Settings
| name | description | input_type | scope | aliases | typed_value |
|---|---|---|---|---|---|
| anofox_telemetry_enabled | Enable or disable anonymous usage telemetry | BOOLEAN | GLOBAL | [] | true |
| anofox_telemetry_key | PostHog API key for telemetry | VARCHAR | GLOBAL | [] | phc_t3wwRLtpyEmLHYaZCSszG0MqVr74J6wnCrj9D41zk2t |
| datazoo_banner | Show the DataZoo feedback banner when an extension is loaded in an interactive terminal (at most once a day per extension). | BOOLEAN | GLOBAL | [] | true |
| temp_directory | Set the directory to which temporary files are written. | VARCHAR | GLOBAL | [] | post.db.tmp |