openstat-cli 1.0.0__py3-none-any.whl

openstat/stats/manova.py

@@ -0,0 +1,124 @@
+"""MANOVA and two-way ANOVA."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+from scipy import stats as sp_stats
+
+
+# ── Two-way ANOVA ─────────────────────────────────────────────────────────
+
+def twoway_anova(
+    df: pl.DataFrame,
+    dep: str,
+    factor1: str,
+    factor2: str,
+    *,
+    interaction: bool = True,
+) -> dict:
+    """Two-way ANOVA with optional interaction term.
+
+    Uses OLS approach (type III sums of squares via statsmodels).
+    """
+    import statsmodels.formula.api as smf
+
+    formula = f"Q('{dep}') ~ C(Q('{factor1}')) + C(Q('{factor2}'))"
+    if interaction:
+        formula += f" + C(Q('{factor1}')):C(Q('{factor2}'))"
+
+    pdf = df.select([dep, factor1, factor2]).drop_nulls().to_pandas()
+    # rename cols to safe names for formula
+    pdf.columns = ["dep", "f1", "f2"]
+    formula = "dep ~ C(f1) + C(f2)"
+    if interaction:
+        formula += " + C(f1):C(f2)"
+
+    model = smf.ols(formula, data=pdf).fit()
+
+    from statsmodels.stats.anova import anova_lm
+    anova_table = anova_lm(model, typ=3)
+
+    rows = []
+    for source, row in anova_table.iterrows():
+        rows.append({
+            "source": str(source).replace("C(f1)", factor1).replace("C(f2)", factor2),
+            "df": int(row.get("df", 0)),
+            "SS": float(row.get("sum_sq", float("nan"))),
+            "MS": float(row.get("mean_sq", float("nan"))),
+            "F": float(row.get("F", float("nan"))),
+            "p_value": float(row.get("PR(>F)", float("nan"))),
+        })
+
+    return {
+        "test": "Two-way ANOVA",
+        "dep": dep,
+        "factor1": factor1,
+        "factor2": factor2,
+        "interaction": interaction,
+        "n_obs": int(pdf.shape[0]),
+        "r_squared": float(model.rsquared),
+        "table": rows,
+    }
+
+
+# ── MANOVA ─────────────────────────────────────────────────────────────────
+
+def fit_manova(
+    df: pl.DataFrame,
+    dep_vars: list[str],
+    group: str,
+) -> dict:
+    """
+    One-way MANOVA via statsmodels.
+
+    Tests whether group means differ on a set of dependent variables.
+    """
+    try:
+        from statsmodels.multivariate.manova import MANOVA
+
+        dep_str = " + ".join(f"Q('{d}')" for d in dep_vars)
+        pdf = df.select(dep_vars + [group]).drop_nulls().to_pandas()
+        # safe column names
+        safe_deps = [f"y{i}" for i in range(len(dep_vars))]
+        safe_group = "group_var"
+        mapping = dict(zip(dep_vars + [group], safe_deps + [safe_group]))
+        pdf.rename(columns=mapping, inplace=True)
+        dep_formula = " + ".join(safe_deps)
+        formula = f"{dep_formula} ~ C({safe_group})"
+
+        mv = MANOVA.from_formula(formula, data=pdf)
+        res = mv.mv_test()
+
+        # Extract Wilks' Lambda from the test
+        stats_dict = {}
+        for effect, effect_res in res.results.items():
+            for stat_name, vals in effect_res["stat"].items():
+                stats_dict[f"{effect}_{stat_name}"] = vals
+
+        # Build a clean summary
+        effects = []
+        for effect_name, effect_res in res.results.items():
+            stat_df = effect_res["stat"]
+            for test_name in stat_df.index:
+                effects.append({
+                    "effect": str(effect_name),
+                    "test": str(test_name),
+                    "statistic": float(stat_df.loc[test_name, "Value"]),
+                    "F": float(stat_df.loc[test_name, "F Value"]),
+                    "num_df": float(stat_df.loc[test_name, "Num DF"]),
+                    "den_df": float(stat_df.loc[test_name, "Den DF"]),
+                    "p_value": float(stat_df.loc[test_name, "Pr > F"]),
+                })
+
+        return {
+            "test": "MANOVA",
+            "dep_vars": dep_vars,
+            "group": group,
+            "n_obs": len(pdf),
+            "n_groups": int(pdf[safe_group].nunique()),
+            "effects": effects,
+        }
+
+    except Exception as exc:
+        raise RuntimeError(f"MANOVA failed: {exc}") from exc

openstat/stats/mixed.py

@@ -0,0 +1,128 @@
+"""Mixed / hierarchical linear models: random intercepts, random slopes, ICC."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+import statsmodels.api as sm
+from statsmodels.regression.mixed_linear_model import MixedLM
+from scipy import stats as sp_stats
+
+from openstat.stats.models import FitResult
+
+
+def _mixed_to_fit_result(result, dep: str, fixed: list[str], group_var: str, re_vars: list[str]) -> FitResult:
+    """Convert statsmodels MixedLMResults to FitResult."""
+    fe_params = result.fe_params
+    bse = result.bse_fe
+    tvalues = result.tvalues
+    pvalues = result.pvalues
+
+    var_names = list(fe_params.index)
+    params = {name: float(fe_params[name]) for name in var_names}
+    std_errors = {name: float(bse[name]) for name in var_names}
+    t_vals = {name: float(tvalues[name]) for name in var_names}
+    p_vals = {name: float(pvalues[name]) for name in var_names}
+    ci = result.conf_int()
+    conf_low = {name: float(ci.loc[name, 0]) for name in var_names}
+    conf_high = {name: float(ci.loc[name, 1]) for name in var_names}
+
+    warnings_list: list[str] = []
+    warnings_list.append(f"Group variable: {group_var}")
+    n_groups = result.model.n_groups if hasattr(result.model, 'n_groups') else "?"
+    warnings_list.append(f"Number of groups: {n_groups}")
+
+    # Random effects variance
+    re_cov = result.cov_re
+    if re_cov is not None and re_cov.size > 0:
+        if hasattr(re_cov, 'iloc'):
+            re_var = float(re_cov.iloc[0, 0])
+        else:
+            re_var = float(re_cov[0, 0]) if re_cov.ndim > 1 else float(re_cov[0])
+        warnings_list.append(f"Random intercept variance: {re_var:.4f}")
+        resid_var = float(result.scale)
+        icc = re_var / (re_var + resid_var)
+        warnings_list.append(f"ICC: {icc:.4f}")
+
+    re_desc = "Random intercept" if not re_vars else f"Random intercept + slopes: {', '.join(re_vars)}"
+    warnings_list.append(re_desc)
+
+    return FitResult(
+        model_type="Mixed LM",
+        formula=f"{dep} ~ {' + '.join(fixed)} || {group_var}: {' + '.join(re_vars) if re_vars else '(intercept)'}",
+        dep_var=dep,
+        indep_vars=var_names,
+        n_obs=int(result.nobs),
+        params=params,
+        std_errors=std_errors,
+        t_values=t_vals,
+        p_values=p_vals,
+        conf_int_low=conf_low,
+        conf_int_high=conf_high,
+        log_likelihood=float(result.llf),
+        aic=float(result.aic),
+        bic=float(result.bic),
+        warnings=warnings_list,
+    )
+
+
+def fit_mixed(
+    df: pl.DataFrame,
+    dep: str,
+    fixed: list[str],
+    group_var: str,
+    re_vars: list[str] | None = None,
+) -> tuple[FitResult, object]:
+    """Fit a mixed/hierarchical linear model.
+
+    Args:
+        dep: Dependent variable name.
+        fixed: Fixed effect variable names.
+        group_var: Grouping variable name for random effects.
+        re_vars: Variables with random slopes. Empty = random intercept only.
+    """
+    all_cols = list(dict.fromkeys([dep] + fixed + [group_var] + (re_vars or [])))
+    pdf = df.select(all_cols).to_pandas().dropna()
+
+    endog = pdf[dep]
+    exog = sm.add_constant(pdf[fixed])
+    groups = pdf[group_var]
+
+    if re_vars:
+        exog_re = pdf[re_vars]
+    else:
+        exog_re = None  # random intercept only
+
+    model = MixedLM(endog, exog, groups, exog_re=exog_re)
+    result = model.fit(reml=True)
+
+    fit = _mixed_to_fit_result(result, dep, ["const"] + fixed, group_var, re_vars or [])
+    return fit, result
+
+
+def compute_icc(result) -> float:
+    """Compute Intraclass Correlation Coefficient from mixed model result."""
+    re_cov = result.cov_re
+    if hasattr(re_cov, 'iloc'):
+        re_var = float(re_cov.iloc[0, 0])
+    else:
+        re_var = float(re_cov[0, 0]) if re_cov.ndim > 1 else float(re_cov[0])
+    resid_var = float(result.scale)
+    return re_var / (re_var + resid_var)
+
+
+def lr_test(result_restricted, result_full) -> dict:
+    """Likelihood ratio test between nested mixed models.
+
+    Returns dict with statistic, df, p_value.
+    """
+    ll_r = result_restricted.llf
+    ll_f = result_full.llf
+    lr_stat = 2 * (ll_f - ll_r)
+    df_r = result_restricted.df_modelwc
+    df_f = result_full.df_modelwc
+    df_diff = df_f - df_r
+    if df_diff <= 0:
+        df_diff = 1
+    p_value = float(1 - sp_stats.chi2.cdf(lr_stat, df_diff))
+    return {"lr_stat": float(lr_stat), "df": int(df_diff), "p_value": p_value}

openstat/stats/ml.py

@@ -0,0 +1,275 @@
+"""Machine learning / penalized regression and decision trees."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+
+try:
+    from sklearn.linear_model import (  # type: ignore[import]
+        Lasso, Ridge, ElasticNet, LassoCV, RidgeCV, ElasticNetCV,
+    )
+    from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor  # type: ignore[import]
+    from sklearn.model_selection import cross_val_score, KFold  # type: ignore[import]
+    from sklearn.preprocessing import StandardScaler  # type: ignore[import]
+    from sklearn.metrics import r2_score, mean_squared_error  # type: ignore[import]
+    _HAS_SKLEARN = True
+except ImportError:
+    _HAS_SKLEARN = False
+
+
+def _require_sklearn():
+    if not _HAS_SKLEARN:
+        raise ImportError(
+            "scikit-learn is required for ML commands.\n"
+            "Install: pip install scikit-learn"
+        )
+
+
+def _prep(df: pl.DataFrame, dep: str, indeps: list[str]):
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy().astype(float)
+    X = sub.select(indeps).to_numpy().astype(float)
+    scaler = StandardScaler()
+    X_s = scaler.fit_transform(X)
+    return y, X_s, X, scaler
+
+
+# ── Lasso ─────────────────────────────────────────────────────────────────
+
+def fit_lasso(
+    df: pl.DataFrame,
+    dep: str,
+    indeps: list[str],
+    *,
+    alpha: float | None = None,
+    cv: int = 5,
+) -> dict:
+    """Lasso regression with optional cross-validated alpha selection."""
+    _require_sklearn()
+    y, X_s, X_raw, scaler = _prep(df, dep, indeps)
+
+    if alpha is None:
+        model = LassoCV(cv=cv, max_iter=10000)
+        model.fit(X_s, y)
+        alpha = float(model.alpha_)
+    else:
+        model = Lasso(alpha=alpha, max_iter=10000)
+        model.fit(X_s, y)
+
+    coef = model.coef_
+    y_pred = model.predict(X_s)
+    r2 = float(r2_score(y, y_pred))
+    mse = float(mean_squared_error(y, y_pred))
+    n_nonzero = int(np.sum(coef != 0))
+
+    return {
+        "method": "Lasso",
+        "dep": dep,
+        "indeps": indeps,
+        "alpha": alpha,
+        "coefficients": dict(zip(indeps, coef.tolist())),
+        "intercept": float(model.intercept_),
+        "r_squared": r2,
+        "mse": mse,
+        "rmse": float(np.sqrt(mse)),
+        "n_obs": len(y),
+        "n_nonzero": n_nonzero,
+        "n_zeroed": len(indeps) - n_nonzero,
+        "_model": model,
+        "_scaler": scaler,
+        "_indeps": indeps,
+    }
+
+
+# ── Ridge ─────────────────────────────────────────────────────────────────
+
+def fit_ridge(
+    df: pl.DataFrame,
+    dep: str,
+    indeps: list[str],
+    *,
+    alpha: float | None = None,
+    cv: int = 5,
+) -> dict:
+    """Ridge regression with optional cross-validated alpha selection."""
+    _require_sklearn()
+    y, X_s, X_raw, scaler = _prep(df, dep, indeps)
+
+    if alpha is None:
+        alphas = np.logspace(-3, 5, 50)
+        model = RidgeCV(alphas=alphas, cv=cv)
+        model.fit(X_s, y)
+        alpha = float(model.alpha_)
+    else:
+        model = Ridge(alpha=alpha)
+        model.fit(X_s, y)
+
+    coef = model.coef_
+    y_pred = model.predict(X_s)
+    r2 = float(r2_score(y, y_pred))
+    mse = float(mean_squared_error(y, y_pred))
+
+    return {
+        "method": "Ridge",
+        "dep": dep,
+        "indeps": indeps,
+        "alpha": alpha,
+        "coefficients": dict(zip(indeps, coef.tolist())),
+        "intercept": float(model.intercept_),
+        "r_squared": r2,
+        "mse": mse,
+        "rmse": float(np.sqrt(mse)),
+        "n_obs": len(y),
+        "_model": model,
+        "_scaler": scaler,
+        "_indeps": indeps,
+    }
+
+
+# ── Elastic Net ────────────────────────────────────────────────────────────
+
+def fit_elasticnet(
+    df: pl.DataFrame,
+    dep: str,
+    indeps: list[str],
+    *,
+    alpha: float | None = None,
+    l1_ratio: float = 0.5,
+    cv: int = 5,
+) -> dict:
+    """Elastic Net regression."""
+    _require_sklearn()
+    y, X_s, X_raw, scaler = _prep(df, dep, indeps)
+
+    if alpha is None:
+        model = ElasticNetCV(l1_ratio=[0.1, 0.5, 0.7, 0.9, 0.95, 1.0], cv=cv, max_iter=10000)
+        model.fit(X_s, y)
+        alpha = float(model.alpha_)
+        l1_ratio = float(model.l1_ratio_)
+    else:
+        model = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, max_iter=10000)
+        model.fit(X_s, y)
+
+    coef = model.coef_
+    y_pred = model.predict(X_s)
+    r2 = float(r2_score(y, y_pred))
+    mse = float(mean_squared_error(y, y_pred))
+
+    return {
+        "method": "ElasticNet",
+        "dep": dep,
+        "indeps": indeps,
+        "alpha": alpha,
+        "l1_ratio": l1_ratio,
+        "coefficients": dict(zip(indeps, coef.tolist())),
+        "intercept": float(model.intercept_),
+        "r_squared": r2,
+        "mse": mse,
+        "rmse": float(np.sqrt(mse)),
+        "n_obs": len(y),
+        "_model": model,
+        "_scaler": scaler,
+        "_indeps": indeps,
+    }
+
+
+# ── Decision Tree ──────────────────────────────────────────────────────────
+
+def fit_cart(
+    df: pl.DataFrame,
+    dep: str,
+    indeps: list[str],
+    *,
+    task: str = "regression",
+    max_depth: int | None = 5,
+    min_samples_leaf: int = 5,
+) -> dict:
+    """CART: decision tree for regression or classification."""
+    _require_sklearn()
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy()
+    X = sub.select(indeps).to_numpy().astype(float)
+
+    if task == "classification":
+        y = y.astype(str)
+        model = DecisionTreeClassifier(max_depth=max_depth, min_samples_leaf=min_samples_leaf)
+        model.fit(X, y)
+        score = float(model.score(X, y))
+        metric_name = "accuracy"
+    else:
+        y = y.astype(float)
+        model = DecisionTreeRegressor(max_depth=max_depth, min_samples_leaf=min_samples_leaf)
+        model.fit(X, y)
+        y_pred = model.predict(X)
+        score = float(r2_score(y, y_pred))
+        metric_name = "r_squared"
+
+    importances = dict(zip(indeps, model.feature_importances_.tolist()))
+
+    return {
+        "method": "CART",
+        "task": task,
+        "dep": dep,
+        "indeps": indeps,
+        "max_depth": max_depth,
+        "n_leaves": int(model.get_n_leaves()),
+        "n_obs": len(y),
+        metric_name: score,
+        "feature_importances": importances,
+        "_model": model,
+        "_indeps": indeps,
+    }
+
+
+# ── Cross-validation ───────────────────────────────────────────────────────
+
+def cross_validate_model(
+    df: pl.DataFrame,
+    dep: str,
+    indeps: list[str],
+    *,
+    method: str = "ols",
+    k: int = 5,
+    alpha: float = 1.0,
+    scoring: str = "r2",
+) -> dict:
+    """K-fold cross-validation for various models."""
+    _require_sklearn()
+    y, X_s, X_raw, scaler = _prep(df, dep, indeps)
+
+    method_lower = method.lower()
+    if method_lower == "lasso":
+        model = Lasso(alpha=alpha, max_iter=10000)
+        X_fit = X_s
+    elif method_lower == "ridge":
+        model = Ridge(alpha=alpha)
+        X_fit = X_s
+    elif method_lower == "elasticnet":
+        model = ElasticNet(alpha=alpha, max_iter=10000)
+        X_fit = X_s
+    elif method_lower == "cart":
+        model = DecisionTreeRegressor(max_depth=5)
+        X_fit = X_raw
+    else:
+        # OLS via sklearn-compatible wrapper
+        from sklearn.linear_model import LinearRegression
+        model = LinearRegression()
+        X_fit = X_s
+
+    kf = KFold(n_splits=k, shuffle=True, random_state=42)
+    scores = cross_val_score(model, X_fit, y, cv=kf, scoring=scoring)
+
+    return {
+        "method": method,
+        "dep": dep,
+        "indeps": indeps,
+        "k_folds": k,
+        "scoring": scoring,
+        "scores": scores.tolist(),
+        "mean_score": float(scores.mean()),
+        "std_score": float(scores.std()),
+        "min_score": float(scores.min()),
+        "max_score": float(scores.max()),
+        "n_obs": len(y),
+    }

openstat/stats/ml_advanced.py

@@ -0,0 +1,117 @@
+"""Advanced ML: RandomForest, GradientBoosting, SVM, t-SNE."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+
+
+def fit_random_forest(df: pl.DataFrame, dep: str, indeps: list[str],
+                      n_estimators: int = 100, max_depth: int | None = None,
+                      task: str = "regression", seed: int = 42) -> dict:
+    """Random Forest regressor or classifier."""
+    sklearn = __import__("sklearn.ensemble", fromlist=["RandomForestRegressor", "RandomForestClassifier"])
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy()
+    X = sub.select(indeps).to_numpy().astype(float)
+    if task == "classification":
+        clf = sklearn.RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=seed)
+        clf.fit(X, y)
+        score = float(clf.score(X, y))
+        metric = "accuracy"
+    else:
+        clf = sklearn.RandomForestRegressor(n_estimators=n_estimators, max_depth=max_depth, random_state=seed)
+        clf.fit(X, y.astype(float))
+        score = float(clf.score(X, y.astype(float)))
+        metric = "r_squared"
+    feat_imp = {col: float(imp) for col, imp in zip(indeps, clf.feature_importances_)}
+    return {
+        "method": f"Random Forest ({task})",
+        "dep": dep, "indeps": indeps,
+        "n_estimators": n_estimators,
+        "max_depth": max_depth,
+        metric: score,
+        "feature_importances": feat_imp,
+        "n_obs": len(y),
+        "_model": clf,
+    }
+
+
+def fit_gradient_boosting(df: pl.DataFrame, dep: str, indeps: list[str],
+                           n_estimators: int = 100, learning_rate: float = 0.1,
+                           max_depth: int = 3, task: str = "regression", seed: int = 42) -> dict:
+    """Gradient Boosting regressor or classifier."""
+    sklearn = __import__("sklearn.ensemble", fromlist=["GradientBoostingRegressor", "GradientBoostingClassifier"])
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy()
+    X = sub.select(indeps).to_numpy().astype(float)
+    if task == "classification":
+        clf = sklearn.GradientBoostingClassifier(n_estimators=n_estimators, learning_rate=learning_rate,
+                                                   max_depth=max_depth, random_state=seed)
+        clf.fit(X, y)
+        score = float(clf.score(X, y))
+        metric = "accuracy"
+    else:
+        clf = sklearn.GradientBoostingRegressor(n_estimators=n_estimators, learning_rate=learning_rate,
+                                                 max_depth=max_depth, random_state=seed)
+        clf.fit(X, y.astype(float))
+        score = float(clf.score(X, y.astype(float)))
+        metric = "r_squared"
+    feat_imp = {col: float(imp) for col, imp in zip(indeps, clf.feature_importances_)}
+    return {
+        "method": f"Gradient Boosting ({task})",
+        "dep": dep, "indeps": indeps,
+        "n_estimators": n_estimators,
+        "learning_rate": learning_rate,
+        metric: score,
+        "feature_importances": feat_imp,
+        "n_obs": len(y),
+        "_model": clf,
+    }
+
+
+def fit_svm(df: pl.DataFrame, dep: str, indeps: list[str],
+            kernel: str = "rbf", C: float = 1.0,
+            task: str = "regression", seed: int = 42) -> dict:
+    """Support Vector Machine regressor or classifier."""
+    sklearn_svm = __import__("sklearn.svm", fromlist=["SVR", "SVC"])
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy()
+    X = sub.select(indeps).to_numpy().astype(float)
+    if task == "classification":
+        clf = sklearn_svm.SVC(kernel=kernel, C=C, random_state=seed)
+        clf.fit(X, y)
+        score = float(clf.score(X, y))
+        metric = "accuracy"
+    else:
+        clf = sklearn_svm.SVR(kernel=kernel, C=C)
+        clf.fit(X, y.astype(float))
+        score = float(clf.score(X, y.astype(float)))
+        metric = "r_squared"
+    return {
+        "method": f"SVM ({task}, kernel={kernel})",
+        "dep": dep, "indeps": indeps,
+        "kernel": kernel, "C": C,
+        metric: score,
+        "n_obs": len(y),
+        "_model": clf,
+    }
+
+
+def fit_tsne(df: pl.DataFrame, cols: list[str], n_components: int = 2,
+             perplexity: float = 30.0, seed: int = 42) -> dict:
+    """t-SNE dimensionality reduction."""
+    from sklearn.manifold import TSNE
+    sub = df.select(cols).drop_nulls()
+    X = sub.to_numpy().astype(float)
+    tsne = TSNE(n_components=n_components, perplexity=min(perplexity, len(X) - 1),
+                random_state=seed)
+    embedding = tsne.fit_transform(X)
+    return {
+        "method": "t-SNE",
+        "cols": cols,
+        "n_components": n_components,
+        "perplexity": perplexity,
+        "embedding": embedding.tolist(),
+        "n_obs": len(X),
+    }