openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/mixture_changepoint_cmds.py

@@ -0,0 +1,166 @@
+"""Mixture models and changepoint detection."""
+
+from __future__ import annotations
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("mixture", usage="mixture <col> [--k=3] [--covariance=full]")
+def cmd_mixture(session: Session, args: str) -> str:
+    """Gaussian Mixture Model clustering / density estimation.
+
+    Options:
+      --k=<n>              number of components (default: 3)
+      --covariance=<type>  full, tied, diag, spherical (default: full)
+      --maxiter=<n>        max EM iterations (default: 200)
+      --assign             add component assignment column to data
+
+    Examples:
+      mixture income --k=3
+      mixture income --k=4 --covariance=diag --assign
+    """
+    try:
+        from sklearn.mixture import GaussianMixture
+    except ImportError:
+        return "scikit-learn required. Install: pip install scikit-learn"
+
+    import numpy as np
+    import polars as pl
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: mixture <col> [--k=3]"
+
+    col = ca.positional[0]
+    k = int(ca.options.get("k", 3))
+    cov_type = ca.options.get("covariance", "full")
+    max_iter = int(ca.options.get("maxiter", 200))
+    assign = "assign" in ca.flags
+
+    try:
+        df = session.require_data()
+        if col not in df.columns:
+            return f"Column not found: {col}"
+
+        X = df[col].drop_nulls().to_numpy().reshape(-1, 1)
+        if len(X) < k * 2:
+            return f"Too few observations ({len(X)}) for {k} components."
+
+        gm = GaussianMixture(n_components=k, covariance_type=cov_type,
+                             max_iter=max_iter, random_state=42)
+        gm.fit(X)
+
+        lines = [f"Gaussian Mixture Model — {col} (k={k}, cov={cov_type})", ""]
+        lines.append(f"  Log-likelihood : {gm.lower_bound_:.4f}")
+        lines.append(f"  BIC            : {gm.bic(X):.4f}")
+        lines.append(f"  AIC            : {gm.aic(X):.4f}")
+        lines.append(f"  Converged      : {gm.converged_}")
+        lines.append("")
+        lines.append(f"  {'Component':<12} {'Weight':>10} {'Mean':>12} {'Std':>12}")
+        lines.append("  " + "-" * 50)
+        for i in range(k):
+            w = gm.weights_[i]
+            mu = gm.means_[i, 0]
+            if cov_type == "full":
+                sigma = float(np.sqrt(gm.covariances_[i, 0, 0]))
+            elif cov_type == "tied":
+                sigma = float(np.sqrt(gm.covariances_[0, 0]))
+            elif cov_type == "diag":
+                sigma = float(np.sqrt(gm.covariances_[i, 0]))
+            else:
+                sigma = float(np.sqrt(gm.covariances_[i]))
+            lines.append(f"  {i+1:<12} {w:>10.4f} {mu:>12.4f} {sigma:>12.4f}")
+
+        if assign:
+            all_X = df[col].to_numpy().reshape(-1, 1)
+            labels = gm.predict(all_X)
+            session.df = df.with_columns(
+                pl.Series(f"{col}_component", labels.astype(int))
+            )
+            lines.append(f"\nComponent assignments added as '{col}_component'.")
+
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "mixture")
+
+
+@command("changepoint", usage="changepoint <col> [--model=rbf] [--n=5] [--pen=10]")
+def cmd_changepoint(session: Session, args: str) -> str:
+    """Change point detection in time series.
+
+    Uses the ruptures library to detect structural breaks in a variable.
+
+    Options:
+      --model=<m>   cost model: rbf, l1, l2, normal, ar (default: rbf)
+      --n=<k>       number of change points to find (default: 5)
+      --pen=<p>     penalty for automatic detection via PELT (overrides --n)
+      --algo=<a>    algorithm: pelt, binseg, dynp, window (default: pelt if --pen, else binseg)
+
+    Examples:
+      changepoint price --n=3
+      changepoint gdp --pen=5 --model=l2
+      changepoint returns --algo=binseg --n=4
+    """
+    try:
+        import ruptures as rpt
+    except ImportError:
+        return "ruptures required. Install: pip install ruptures"
+
+    import numpy as np
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: changepoint <col> [--model=rbf] [--n=5]"
+
+    col = ca.positional[0]
+    model = ca.options.get("model", "rbf")
+    n_bkps = int(ca.options.get("n", 5))
+    pen = ca.options.get("pen")
+    algo_name = ca.options.get("algo", "pelt" if pen else "binseg")
+
+    try:
+        df = session.require_data()
+        if col not in df.columns:
+            return f"Column not found: {col}"
+
+        signal = df[col].drop_nulls().to_numpy().astype(float)
+        if len(signal) < 10:
+            return f"Need at least 10 observations (got {len(signal)})."
+
+        # Select algorithm
+        algos = {"pelt": rpt.Pelt, "binseg": rpt.Binseg,
+                 "dynp": rpt.Dynp, "window": rpt.Window}
+        AlgoClass = algos.get(algo_name.lower(), rpt.Binseg)
+        algo = AlgoClass(model=model).fit(signal)
+
+        if pen is not None:
+            breakpoints = algo.predict(pen=float(pen))
+        else:
+            breakpoints = algo.predict(n_bkps=n_bkps)
+
+        # Remove the last element (= length of signal, not a real break)
+        breaks = [b for b in breakpoints if b < len(signal)]
+
+        lines = [f"Change Point Detection — {col}", ""]
+        lines.append(f"  Algorithm : {algo_name}")
+        lines.append(f"  Model     : {model}")
+        lines.append(f"  Signal length: {len(signal)}")
+        lines.append(f"  Change points found: {len(breaks)}")
+        lines.append("")
+
+        if breaks:
+            lines.append(f"  {'#':<6} {'Index':>8} {'Segment mean':>14} {'Segment std':>12}")
+            lines.append("  " + "-" * 45)
+            prev = 0
+            for i, bp in enumerate(breaks + [len(signal)], 1):
+                seg = signal[prev:bp]
+                lines.append(
+                    f"  {i:<6} {bp:>8} {seg.mean():>14.4f} {seg.std():>12.4f}"
+                )
+                prev = bp
+        else:
+            lines.append("  No change points detected.")
+
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "changepoint")

openstat/commands/ml_adv_cmds.py

@@ -0,0 +1,147 @@
+"""Advanced ML commands: randomforest, gbm, svm, tsne."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _fmt_imp(feat_imp: dict, top: int = 10) -> str:
+    sorted_imp = sorted(feat_imp.items(), key=lambda x: -x[1])[:top]
+    lines = ["\n  Feature Importances:"]
+    for feat, imp in sorted_imp:
+        bar = "█" * int(imp * 40)
+        lines.append(f"    {feat:<20} {imp:.4f} {bar}")
+    return "\n".join(lines)
+
+
+@command("randomforest", usage="randomforest dep var1 var2 ... [n(100) depth(none) task(regression)]")
+def cmd_randomforest(session: Session, args: str) -> str:
+    """Random Forest regression or classification."""
+    try:
+        import sklearn
+    except ImportError:
+        return "sklearn not installed. Run: pip install scikit-learn"
+    from openstat.stats.ml_advanced import fit_random_forest
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: randomforest dep var1 [var2 ...] [n(100) depth(5) task(regression)]"
+    dep = positional[0]
+    indeps = [c for c in positional[1:] if c in df.columns]
+    n_est = int(opts.get("n", 100))
+    max_depth = int(opts["depth"]) if "depth" in opts else None
+    task = opts.get("task", "regression")
+    try:
+        r = fit_random_forest(df, dep, indeps, n_estimators=n_est, max_depth=max_depth, task=task)
+        session._last_model = r
+        metric = "r_squared" if task == "regression" else "accuracy"
+        lines = [f"\nRandom Forest ({task})", "=" * 50]
+        lines.append(f"  Dep: {dep}, N: {r['n_obs']}, Trees: {n_est}")
+        lines.append(f"  {metric.replace('_', ' ').title()}: {r.get(metric, 'N/A'):.4f}")
+        lines.append(_fmt_imp(r["feature_importances"]))
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"randomforest error: {exc}"
+
+
+@command("gbm", usage="gbm dep var1 var2 ... [n(100) lr(0.1) depth(3) task(regression)]")
+def cmd_gbm(session: Session, args: str) -> str:
+    """Gradient Boosting Machine."""
+    try:
+        import sklearn
+    except ImportError:
+        return "sklearn not installed. Run: pip install scikit-learn"
+    from openstat.stats.ml_advanced import fit_gradient_boosting
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: gbm dep var1 [var2 ...] [n(100) lr(0.1) depth(3) task(regression)]"
+    dep = positional[0]
+    indeps = [c for c in positional[1:] if c in df.columns]
+    n_est = int(opts.get("n", 100))
+    lr = float(opts.get("lr", 0.1))
+    depth = int(opts.get("depth", 3))
+    task = opts.get("task", "regression")
+    try:
+        r = fit_gradient_boosting(df, dep, indeps, n_estimators=n_est, learning_rate=lr, max_depth=depth, task=task)
+        session._last_model = r
+        metric = "r_squared" if task == "regression" else "accuracy"
+        lines = [f"\nGradient Boosting ({task})", "=" * 50]
+        lines.append(f"  Dep: {dep}, N: {r['n_obs']}, Trees: {n_est}, LR: {lr}")
+        lines.append(f"  {metric.replace('_', ' ').title()}: {r.get(metric, 'N/A'):.4f}")
+        lines.append(_fmt_imp(r["feature_importances"]))
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"gbm error: {exc}"
+
+
+@command("svm", usage="svm dep var1 var2 ... [kernel(rbf) C(1.0) task(regression)]")
+def cmd_svm(session: Session, args: str) -> str:
+    """Support Vector Machine."""
+    try:
+        import sklearn
+    except ImportError:
+        return "sklearn not installed. Run: pip install scikit-learn"
+    from openstat.stats.ml_advanced import fit_svm
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: svm dep var1 [var2 ...] [kernel(rbf) C(1.0) task(regression)]"
+    dep = positional[0]
+    indeps = [c for c in positional[1:] if c in df.columns]
+    kernel = opts.get("kernel", "rbf")
+    C = float(opts.get("c", 1.0))
+    task = opts.get("task", "regression")
+    try:
+        r = fit_svm(df, dep, indeps, kernel=kernel, C=C, task=task)
+        session._last_model = r
+        metric = "r_squared" if task == "regression" else "accuracy"
+        lines = [f"\nSVM ({task}, kernel={kernel})", "=" * 50]
+        lines.append(f"  Dep: {dep}, N: {r['n_obs']}, C: {C}")
+        lines.append(f"  {metric.replace('_', ' ').title()}: {r.get(metric, 'N/A'):.4f}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"svm error: {exc}"
+
+
+@command("tsne", usage="tsne var1 var2 ... [components(2) perplexity(30) gen(tsne)]")
+def cmd_tsne(session: Session, args: str) -> str:
+    """t-SNE dimensionality reduction. Adds embedding columns to data."""
+    try:
+        from sklearn.manifold import TSNE
+    except ImportError:
+        return "sklearn not installed. Run: pip install scikit-learn"
+    from openstat.stats.ml_advanced import fit_tsne
+    import polars as pl
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    cols = [c for c in positional if c in df.columns]
+    if len(cols) < 2:
+        return "tsne requires at least 2 variables."
+    n_comp = int(opts.get("components", 2))
+    perp = float(opts.get("perplexity", 30.0))
+    prefix = opts.get("gen", "tsne")
+    session.snapshot()
+    try:
+        r = fit_tsne(df, cols, n_components=n_comp, perplexity=perp)
+        emb = r["embedding"]
+        new_df = df
+        for i in range(n_comp):
+            col_name = f"{prefix}{i+1}"
+            new_df = new_df.with_columns(pl.Series(col_name, [row[i] for row in emb]))
+        session.df = new_df
+        return f"t-SNE complete. Added columns: {[f'{prefix}{i+1}' for i in range(n_comp)]}"
+    except Exception as exc:
+        return f"tsne error: {exc}"

openstat/commands/ml_cmds.py

@@ -0,0 +1,178 @@
+"""Machine learning commands: lasso, ridge, elasticnet, cart, crossval."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _parse_varlist(args: str, df_cols: list[str]) -> tuple[str, list[str], dict]:
+    """Parse 'dep indeps [, opts]' from raw args."""
+    positional, opts = _stata_opts(args)
+    dep = positional[0] if positional else ""
+    indeps = [c for c in positional[1:] if c in df_cols]
+    return dep, indeps, opts
+
+
+def _ml_table(result: dict) -> str:
+    method = result.get("method", "")
+    dep = result.get("dep", "")
+    lines = [f"\n{method}: {dep}", "=" * 55]
+    coef = result.get("coefficients", {})
+    if coef:
+        lines.append(f"  {'Variable':<25}  {'Coefficient':>12}")
+        lines.append("  " + "-" * 40)
+        for var, val in coef.items():
+            lines.append(f"  {var:<25}  {val:>12.6f}")
+        lines.append("")
+    for key in ("intercept", "alpha", "l1_ratio", "r_squared", "mse", "rmse",
+                "n_obs", "n_nonzero", "n_zeroed", "accuracy"):
+        if key in result:
+            v = result[key]
+            lines.append(f"  {key:<25}  {v!s:>12}" if not isinstance(v, float)
+                         else f"  {key:<25}  {v:>12.6f}")
+    lines.append("=" * 55)
+    return "\n".join(lines)
+
+
+@command("lasso", usage="lasso depvar indepvars [, alpha(0.1) cv(5)]")
+def cmd_lasso(session: Session, args: str) -> str:
+    """Lasso regression with optional CV-tuned penalty."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_varlist(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: lasso depvar indepvar1 indepvar2 ... [, alpha(0.1) cv(5)]"
+    alpha_raw = opts.get("alpha")
+    alpha = float(alpha_raw) if alpha_raw else None
+    cv = int(opts.get("cv", 5))
+    try:
+        from openstat.stats.ml import fit_lasso
+        result = fit_lasso(df, dep, indeps, alpha=alpha, cv=cv)
+        session._last_model = result
+        return _ml_table(result)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"lasso error: {exc}"
+
+
+@command("ridge", usage="ridge depvar indepvars [, alpha(1.0) cv(5)]")
+def cmd_ridge(session: Session, args: str) -> str:
+    """Ridge regression with optional CV-tuned penalty."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_varlist(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: ridge depvar indepvar1 ... [, alpha(1.0) cv(5)]"
+    alpha_raw = opts.get("alpha")
+    alpha = float(alpha_raw) if alpha_raw else None
+    cv = int(opts.get("cv", 5))
+    try:
+        from openstat.stats.ml import fit_ridge
+        result = fit_ridge(df, dep, indeps, alpha=alpha, cv=cv)
+        session._last_model = result
+        return _ml_table(result)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"ridge error: {exc}"
+
+
+@command("elasticnet", usage="elasticnet depvar indepvars [, alpha(1.0) l1ratio(0.5)]")
+def cmd_elasticnet(session: Session, args: str) -> str:
+    """Elastic Net regression."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_varlist(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: elasticnet depvar indepvar1 ... [, alpha(1.0) l1ratio(0.5)]"
+    alpha_raw = opts.get("alpha")
+    alpha = float(alpha_raw) if alpha_raw else None
+    l1 = float(opts.get("l1ratio", 0.5))
+    cv = int(opts.get("cv", 5))
+    try:
+        from openstat.stats.ml import fit_elasticnet
+        result = fit_elasticnet(df, dep, indeps, alpha=alpha, l1_ratio=l1, cv=cv)
+        session._last_model = result
+        return _ml_table(result)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"elasticnet error: {exc}"
+
+
+@command("cart", usage="cart depvar indepvars [, depth(5) task(regression|classification)]")
+def cmd_cart(session: Session, args: str) -> str:
+    """CART decision tree (regression or classification)."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_varlist(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: cart depvar indepvar1 ... [, depth(5) task(regression)]"
+    depth_raw = opts.get("depth")
+    max_depth = int(depth_raw) if depth_raw else 5
+    task = opts.get("task", "regression")
+    min_leaf = int(opts.get("minleaf", 5))
+    try:
+        from openstat.stats.ml import fit_cart
+        result = fit_cart(df, dep, indeps, task=task, max_depth=max_depth,
+                          min_samples_leaf=min_leaf)
+        session._last_model = result
+        lines = [f"\nCART ({task}): {dep}", "=" * 55]
+        lines.append(f"  {'max_depth':<25}  {max_depth!s:>12}")
+        lines.append(f"  {'n_leaves':<25}  {result['n_leaves']:>12}")
+        lines.append(f"  {'n_obs':<25}  {result['n_obs']:>12}")
+        metric = "r_squared" if task == "regression" else "accuracy"
+        lines.append(f"  {metric:<25}  {result[metric]:>12.4f}")
+        lines.append("\nFeature Importances:")
+        for feat, imp in sorted(result["feature_importances"].items(),
+                                key=lambda x: -x[1]):
+            lines.append(f"  {feat:<25}  {imp:>12.4f}")
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"cart error: {exc}"
+
+
+@command("crossval", usage="crossval depvar indepvars [, method(ols) k(5) scoring(r2)]")
+def cmd_crossval(session: Session, args: str) -> str:
+    """K-fold cross-validation for regression models."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_varlist(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: crossval depvar indepvar1 ... [, method(ols) k(5) scoring(r2)]"
+    method = opts.get("method", "ols")
+    k = int(opts.get("k", 5))
+    alpha = float(opts.get("alpha", 1.0))
+    scoring = opts.get("scoring", "r2")
+    try:
+        from openstat.stats.ml import cross_validate_model
+        result = cross_validate_model(df, dep, indeps, method=method, k=k,
+                                      alpha=alpha, scoring=scoring)
+        lines = [f"\nCross-Validation ({k}-fold): {method}", "=" * 55]
+        lines.append(f"  {'Dependent':<25}  {dep}")
+        lines.append(f"  {'Scoring':<25}  {scoring}")
+        lines.append(f"  {'Mean score':<25}  {result['mean_score']:>12.4f}")
+        lines.append(f"  {'Std score':<25}  {result['std_score']:>12.4f}")
+        lines.append(f"  {'Min score':<25}  {result['min_score']:>12.4f}")
+        lines.append(f"  {'Max score':<25}  {result['max_score']:>12.4f}")
+        lines.append(f"  {'N obs':<25}  {result['n_obs']:>12}")
+        lines.append("\nFold scores:")
+        for i, s in enumerate(result["scores"], 1):
+            lines.append(f"  Fold {i:<3}  {s:.4f}")
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"crossval error: {exc}"

openstat/commands/model_eval_cmds.py

@@ -0,0 +1,142 @@
+"""Model evaluation commands: roc, confmatrix, calibration, shap."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+@command("roc", usage="roc outcome score_col")
+def cmd_roc(session: Session, args: str) -> str:
+    """ROC curve and AUC for binary classification."""
+    from openstat.stats.model_eval import roc_auc
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: roc outcome score_col"
+    outcome, score = positional[0], positional[1]
+    for v in (outcome, score):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    try:
+        r = roc_auc(df, outcome, score)
+        session._last_model = r
+        lines = ["\nROC Analysis", "=" * 50]
+        lines.append(f"  {'Outcome':<30} {outcome}")
+        lines.append(f"  {'Score':<30} {score}")
+        lines.append(f"  {'AUC':<30} {r['auc']:.4f}")
+        lines.append(f"  {'Optimal threshold':<30} {r['optimal_threshold']:.4f}")
+        lines.append(f"  {'N observations':<30} {r['n_obs']}")
+        lines.append(f"  {'Prevalence':<30} {r['prevalence']:.4f}")
+        lines.append(f"\n  Interpretation:")
+        auc = r['auc']
+        if auc >= 0.9:
+            interp = "Excellent (≥0.90)"
+        elif auc >= 0.8:
+            interp = "Good (0.80–0.89)"
+        elif auc >= 0.7:
+            interp = "Fair (0.70–0.79)"
+        elif auc >= 0.6:
+            interp = "Poor (0.60–0.69)"
+        else:
+            interp = "Fail (<0.60)"
+        lines.append(f"  {'AUC interpretation':<30} {interp}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"roc error: {exc}"
+
+
+@command("confmatrix", usage="confmatrix outcome predicted [threshold(0.5)]")
+def cmd_confmatrix(session: Session, args: str) -> str:
+    """Confusion matrix and classification metrics."""
+    from openstat.stats.model_eval import confusion_matrix
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: confmatrix outcome predicted [threshold(0.5)]"
+    outcome, predicted = positional[0], positional[1]
+    for v in (outcome, predicted):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    threshold = float(opts.get("threshold", 0.5))
+    try:
+        r = confusion_matrix(df, outcome, predicted, threshold=threshold)
+        lines = ["\nConfusion Matrix", "=" * 50]
+        lines.append(f"\n  Predicted →    Positive   Negative")
+        lines.append(f"  Actual Positive  {r['tp']:>8}   {r['fn']:>8}")
+        lines.append(f"  Actual Negative  {r['fp']:>8}   {r['tn']:>8}")
+        lines.append("\n  Metrics:")
+        for k in ["accuracy", "precision", "recall_sensitivity", "specificity", "f1_score", "npv", "mcc"]:
+            lines.append(f"  {k.replace('_', ' ').title():<30} {r[k]:.4f}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"confmatrix error: {exc}"
+
+
+@command("calibration", usage="calibration outcome score [bins(10)]")
+def cmd_calibration(session: Session, args: str) -> str:
+    """Calibration curve (reliability diagram) and Brier score."""
+    from openstat.stats.model_eval import calibration_curve
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: calibration outcome score [bins(10)]"
+    outcome, score = positional[0], positional[1]
+    for v in (outcome, score):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    n_bins = int(opts.get("bins", 10))
+    try:
+        r = calibration_curve(df, outcome, score, n_bins=n_bins)
+        lines = ["\nCalibration Analysis", "=" * 55]
+        lines.append(f"  {'Brier score':<35} {r['brier_score']:.6f}")
+        lines.append(f"  {'N observations':<35} {r['n_obs']}")
+        lines.append(f"\n  {'Bin Center':>10}  {'Mean Pred':>10}  {'Frac Pos':>10}")
+        lines.append("  " + "-" * 35)
+        for bc, mp, fp in zip(r["bin_centers"], r["mean_predicted"], r["fraction_positive"]):
+            lines.append(f"  {bc:>10.3f}  {mp:>10.3f}  {fp:>10.3f}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"calibration error: {exc}"
+
+
+@command("shap", usage="shap dep var1 var2 ...")
+def cmd_shap(session: Session, args: str) -> str:
+    """Compute SHAP values for linear regression (exact for OLS)."""
+    from openstat.stats.model_eval import compute_shap_linear
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: shap dep var1 var2 ..."
+    dep = positional[0]
+    indeps = [c for c in positional[1:] if c in df.columns]
+    if not indeps:
+        return "No valid predictor variables found."
+    if dep not in df.columns:
+        return f"Column '{dep}' not found."
+    try:
+        r = compute_shap_linear(df, dep, indeps)
+        session._last_model = r
+        lines = ["\nSHAP Values (Linear)", "=" * 50]
+        lines.append(f"  Dep: {dep}, N: {r['n_obs']}")
+        lines.append(f"\n  {'Feature':<20} {'Mean |SHAP|':>12}  Bar")
+        lines.append("  " + "-" * 50)
+        max_shap = max(r["mean_abs_shap"].values()) if r["mean_abs_shap"] else 1
+        for feat in r["feature_ranking"]:
+            val = r["mean_abs_shap"][feat]
+            bar = "█" * int(val / max_shap * 30)
+            lines.append(f"  {feat:<20} {val:>12.4f}  {bar}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"shap error: {exc}"