tanml 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

tanml/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.1"
+__version__ = "0.1.7"

tanml/check_runners/cleaning_repro_runner.py

@@ -3,12 +3,12 @@ from tanml.checks.cleaning_repro import CleaningReproCheck
 
 def run_cleaning_repro_check(model, X_train, X_test, y_train, y_test,
                              config, cleaned_data, *args, **kwargs):
-    # honour rules.yaml toggle
+    
     if not config.get("rules", {}).get("CleaningReproCheck", {}).get("enabled", True):
         print("ℹ️ CleaningReproCheck skipped (disabled in rules.yaml)")
         return None
 
-    # raw_df can come from rules.yaml *or* via kwargs (passed by ValidationEngine)
+    
     raw_data = config.get("raw_data") or kwargs.get("raw_df")
     if raw_data is None:
         print("⚠️ Skipping CleaningReproCheck — raw_data missing in config and kwargs")

tanml/check_runners/correlation_runner.py

@@ -1,15 +1,52 @@
-from tanml.checks.correlation import CorrelationCheck
+# tanml/check_runners/correlation_runner.py
+from __future__ import annotations
+import os
+from typing import Any, Dict, List
+import pandas as pd
 
-def CorrelationCheckRunner(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
-    try:
-        cfg = rule_config.get("CorrelationCheck", {})
-        if not cfg.get("enabled", True):
-            print("ℹ️ CorrelationCheck skipped (disabled in rules.yaml)")
-            return None
+from tanml.checks.correlation import CorrelationCheck  
 
-        check = CorrelationCheck(cleaned_df)
-        return check.run()
+def _resolve_outdir(config: Dict[str, Any]) -> str:
+    base = (config.get("options") or {}).get("save_artifacts_dir") or "reports"
+    outdir = os.path.join(base, "correlation")
+    os.makedirs(outdir, exist_ok=True)
+    return outdir
 
-    except Exception as e:
-        print(f"⚠️ CorrelationCheck failed: {e}")
-        return {"CorrelationCheck": {"error": str(e)}}
+def _df_features_only(cleaned_df: pd.DataFrame) -> pd.DataFrame:
+    if cleaned_df is None or cleaned_df.empty:
+        return cleaned_df
+    cols = list(cleaned_df.columns)
+    if len(cols) >= 2:
+        return cleaned_df[cols[:-1]]
+    return cleaned_df
+
+def CorrelationCheckRunner(
+    model,
+    X_train,
+    X_test,
+    y_train,
+    y_test,
+    config: Dict[str, Any],
+    cleaned_df: pd.DataFrame,
+    raw_df: pd.DataFrame | None = None,
+):
+    ui_block: Dict[str, Any] = (config.get("CorrelationCheck") or {})
+    legacy: Dict[str, Any] = (config.get("correlation") or {})
+    if not bool(ui_block.get("enabled", legacy.get("enabled", True))):
+        return None
+
+    df = _df_features_only(cleaned_df)
+    cfg: Dict[str, Any] = {
+        "method": ui_block.get("method", "pearson"),
+        "high_corr_threshold": float(ui_block.get("high_corr_threshold", 0.8)),
+        "heatmap_max_features_default": int(ui_block.get("heatmap_max_features_default", 20)),
+        "heatmap_max_features_limit": int(ui_block.get("heatmap_max_features_limit", 60)),
+        "subset_strategy": ui_block.get("subset_strategy", "cluster"),
+        "sample_rows": int(ui_block.get("sample_rows", 150_000)),
+        "seed": int(ui_block.get("seed", 42)),
+        "save_csv": True,
+        "save_fig": True,
+        "appendix_csv_cap": ui_block.get("appendix_csv_cap", None),
+    }
+    outdir = _resolve_outdir(config)
+    return CorrelationCheck(cleaned_data=df, cfg=cfg, output_dir=outdir).run()

tanml/check_runners/explainability_runner.py

@@ -1,28 +1,18 @@
-# tanml/check_runners/explainability_runner.py
-
+# explainability runner
 from tanml.checks.explainability.shap_check import SHAPCheck
 
-def run_shap_check(
-    model, X_train, X_test, y_train, y_test,
-    rule_config, cleaned_df, *args, **kwargs
-):
+def run_shap_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
     try:
-        cfg = rule_config.get("SHAPCheck", {})
-        if not cfg.get("enabled", True):
-            print("ℹ️ SHAPCheck skipped (disabled in rules.yaml)")
-            return None
-
-        check = SHAPCheck(
-            model=model,
-            X_train=X_train,
-            X_test=X_test,
-            y_train=y_train,
-            y_test=y_test,
-            rule_config=rule_config,
-            cleaned_df=cleaned_df,
-        )
-        return check.run()
+        cfg_shapcheck = (rule_config or {}).get("SHAPCheck", {}) or {}
+        cfg_expl = (rule_config or {}).get("explainability", {}).get("shap", {}) or {}
+        enabled = cfg_shapcheck.get("enabled", cfg_expl.get("enabled", True))
+        if not enabled:
+            print("ℹ️ SHAPCheck skipped (disabled)")
+            return {"SHAPCheck": {"skipped": True}}
 
+        check = SHAPCheck(model, X_train, X_test, y_train, y_test, rule_config=rule_config, cleaned_df=cleaned_df)
+        result = check.run()
+        return {"SHAPCheck": result}
     except Exception as e:
         print(f"⚠️ SHAPCheck failed: {e}")
-        return {"SHAPCheck": {"error": str(e)}}
+        return {"SHAPCheck": {"status": "error", "error": str(e)}}

tanml/check_runners/logistic_stats_runner.py

@@ -1,28 +1,207 @@
-from tanml.checks.logit_stats import LogisticStatsCheck
-from sklearn.linear_model import LogisticRegression
+# tanml/check_runners/logistic_stats_runner.py
+from __future__ import annotations
 
-def run_logistic_stats_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+from typing import Any, Dict
+from tanml.checks.logit_stats import _prep_design_matrix_df  
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from sklearn.linear_model import LogisticRegression 
+from sklearn.metrics import (
+    roc_auc_score,
+    roc_curve,
+    precision_recall_fscore_support,
+    accuracy_score,
+    average_precision_score,
+    brier_score_loss,
+)
+
+
+def _is_binary_series(y: pd.Series) -> bool:
     try:
-        # Check if model is a LogisticRegression or statsmodels object
-        is_logistic = isinstance(model, LogisticRegression) or (
-            hasattr(model, "llf") and hasattr(model, "params") and hasattr(model, "summary")
+        u = pd.unique(pd.Series(y).dropna())
+        return len(u) == 2
+    except Exception:
+        return False
+
+
+def _prep_design_matrix(
+    X_like: Any, ref_columns: pd.Index | None, add_const: bool = True
+) -> pd.DataFrame:
+    """
+    1) Convert to DataFrame
+    2) One-hot encode (drop_first=True)
+    3) Align to ref_columns (if given), filling missing cols with 0 and dropping extras
+    4) Coerce to numeric & sanitize
+    5) Optionally add constant
+    """
+    Xd = X_like if isinstance(X_like, pd.DataFrame) else pd.DataFrame(X_like)
+    Xd = pd.get_dummies(Xd, drop_first=True)
+
+    if ref_columns is not None:
+        ref_wo_const = [c for c in ref_columns if c != "const"]
+        Xd = Xd.reindex(columns=ref_wo_const, fill_value=0.0)
+
+    for c in Xd.columns:
+        Xd[c] = pd.to_numeric(Xd[c], errors="coerce")
+    Xd = Xd.replace([np.inf, -np.inf], np.nan).fillna(0.0)
+
+    if add_const:
+        Xd = sm.add_constant(Xd, has_constant="add")
+
+    return Xd
+
+
+def run_logistic_stats_check(
+    model,
+    X_train,
+    X_test,
+    y_train,
+    y_test,
+    rule_config: Dict[str, Any],
+    cleaned_df,
+    *args,
+    **kwargs,
+) -> Dict[str, Any]:
+    """
+    Logistic challenger (stats-only):
+
+    - Fits a statsmodels Logit on a one-hot design of X_train (with intercept)
+    - Produces: summary_text and coefficient table with CIs
+    - Computes baseline classification metrics on the test set (NO plots/CSVs)
+
+    Returns:
+    {
+      "LogitStats": {
+        "summary_text": str,
+        "coef_table_headers": ["feature","coef","std err","z","P>|z|","ci_low","ci_high"],
+        "coef_table_rows": [ {...}, ... ],
+        "baseline_metrics": { "summary": {...} },  # rounded, no 'plots'/'tables'
+        "baseline_note": "..."
+      }
+    }
+    """
+    try:
+        # 1) Skip if model is obviously not logistic-like
+        is_logistic_like = (
+            isinstance(model, LogisticRegression)
+            or getattr(model, "__class__", type("X", (object,), {})).__name__.lower().startswith("logit")
+            or hasattr(model, "predict_proba")
+        )
+        if not is_logistic_like:
+            print("ℹ️ LogisticStatsCheck skipped — model not logistic-like")
+            return {"LogitStats": {"skipped": True}}
+
+        # 2) Ensure binary target
+        y_train_s = pd.Series(y_train)
+        if not _is_binary_series(y_train_s):
+            print("ℹ️ LogisticStatsCheck skipped — target is not binary")
+            return {"LogitStats": {"skipped": True}}
+
+        # Robust 0/1 encoding (majority -> 0, minority -> 1)
+        counts = y_train_s.value_counts().sort_values(ascending=False).index.tolist()
+        enc_map = {counts[0]: 0, counts[1]: 1}
+        yb_train = y_train_s.map(enc_map).astype(int)
+
+        # 3) Train design matrix (with intercept)
+        Xd_train = _prep_design_matrix_df(X_train, ref_columns=None, add_const=True)  
+
+        # 4) Fit statsmodels Logit (MLE)
+        res = sm.Logit(yb_train, Xd_train).fit(disp=0, method="lbfgs", maxiter=1000)
+
+        # 5) Summary text (human-readable)
+        try:
+            summary_text = res.summary2().as_text()
+        except Exception:
+            summary_text = str(res.summary())
+
+        # 6) Coefficient table (const first)
+        params = res.params
+        bse = res.bse
+        # Avoid divide-by-zero in z; replace zeros with NaN then fill after rounding
+        zvals = params / bse.replace(0, np.nan)
+        pvals = res.pvalues
+        ci = res.conf_int(alpha=0.05)
+        ci.columns = ["ci_low", "ci_high"]
+
+        coef_df = pd.DataFrame(
+            {
+                "feature": params.index,
+                "coef": params.values,
+                "std err": bse.values,
+                "z": zvals.values,
+                "P>|z|": pvals.values,
+                "ci_low": ci["ci_low"].values,
+                "ci_high": ci["ci_high"].values,
+            }
         )
 
-        if not is_logistic:
-            print("ℹ️ LogisticStatsCheck skipped — model is not logistic or not recognized")
-            return None
+        if "const" in coef_df["feature"].values:
+            coef_df = pd.concat(
+                [
+                    coef_df.loc[coef_df["feature"] == "const"],
+                    coef_df.loc[coef_df["feature"] != "const"],
+                ],
+                ignore_index=True,
+            )
+
+        for c in ["coef", "std err", "z", "P>|z|", "ci_low", "ci_high"]:
+            coef_df[c] = pd.to_numeric(coef_df[c], errors="coerce").round(4)
+
+        # 7) Test-set baseline metrics (NO PLOTS/CSVs)
+        #    Build test matrix aligned to the training design columns.
+        Xd_test = _prep_design_matrix_df(X_test, ref_columns=Xd_train.columns, add_const=True)  
 
-        # Use training data only for fitting stats
-        check = LogisticStatsCheck(model, X_train, y_train, rule_config)
-        output = check.run()
+        # Statsmodels Logit returns probability for class "1"
+        y_score = res.predict(Xd_test)  # shape (n_test,)
+
+        # Threshold policy (aligned with PerformanceCheck if present)
+        threshold = (rule_config.get("PerformanceCheck", {}) or {}).get("threshold", 0.5)
+        try:
+            thr = float(threshold)
+        except Exception:
+            thr = 0.5
+
+        y_pred = (y_score >= thr).astype(int)
+
+        yb_test = pd.Series(y_test).map(enc_map).astype(int).to_numpy()
+
+        has_posneg = len(np.unique(yb_test)) > 1
+        auc = roc_auc_score(yb_test, y_score) if has_posneg else np.nan
+        fpr, tpr, _ = roc_curve(yb_test, y_score) if has_posneg else (np.array([]), np.array([]), None)
+        ks = float(np.max(np.abs(tpr - fpr))) if len(fpr) else np.nan
+        ap = average_precision_score(yb_test, y_score) if has_posneg else np.nan
+        brier = brier_score_loss(yb_test, y_score)
+        precision, recall, f1, _ = precision_recall_fscore_support(
+            yb_test, y_pred, average="binary", pos_label=1, zero_division=0
+        )
+        acc = accuracy_score(yb_test, y_pred)
+        gini = 2 * auc - 1 if (auc == auc) else np.nan  # handle NaN
+
+        baseline_metrics = {
+            "summary": {
+                "auc": None if auc != auc else round(float(auc), 2),
+                "ks": None if ks != ks else round(float(ks), 2),
+                "accuracy": round(float(acc), 2),
+                "precision": round(float(precision), 2),
+                "recall": round(float(recall), 2),
+                "f1": round(float(f1), 2),
+                "pr_auc": None if ap != ap else round(float(ap), 2),
+                "brier": round(float(brier), 2),
+                "gini": None if gini != gini else round(float(gini), 2),
+            }
+        }
 
         return {
-            "LogisticStatsCheck": output["table"],
-            "LogisticStatsFit": output["fit"],
-            "LogisticStatsSummary": output["summary"],
-            "LogisticStatsCheck_obj": output["object"]
+            "LogitStats": {
+                "summary_text": summary_text,
+                "coef_table_headers": ["feature", "coef", "std err", "z", "P>|z|", "ci_low", "ci_high"],
+                "coef_table_rows": coef_df.to_dict(orient="records"),
+                "baseline_metrics": baseline_metrics,  # <-- metrics only; no plots/tables
+                "baseline_note": f"Computed on the same test split and preprocessing as the primary model; threshold={thr}.",
+            }
         }
 
     except Exception as e:
         print(f"⚠️ LogisticStatsCheck failed: {e}")
-        return {"LogisticStatsCheck": {"error": str(e)}}
+        return {"LogitStats": {"error": str(e)}}

tanml/check_runners/performance_runner.py

@@ -1,28 +1,84 @@
-from tanml.checks.performance import PerformanceCheck
-
-def run_performance_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
-    perf_cfg = rule_config.get("PerformanceCheck", {})
-    if not perf_cfg.get("enabled", True):
-        print("ℹ️ Skipping PerformanceCheck (disabled in rules.yaml)")
-        return {"PerformanceCheck": {"skipped": True}}
-
-    if X_test is None or y_test is None or len(X_test) == 0 or len(y_test) == 0:
-        print("⚠️ Skipping PerformanceCheck due to empty test data.")
-        return {"PerformanceCheck": {"error": "Test data is empty :skipping performance evaluation."}}
-
-    try:
-        check = PerformanceCheck(
-            model=model,
-            X_train=X_train,
-            X_test=X_test,
-            y_train=y_train,
-            y_test=y_test,
-            rule_config=perf_cfg,
-            cleaned_data=cleaned_df
+from __future__ import annotations
+import os
+from typing import Any, Dict
+import numpy as np
+from tanml.checks.performance_classification import compute_classification_report
+
+def _resolve_outdir(config: Dict[str, Any]) -> str:
+    base = (config.get("paths") or {}).get("artifacts_dir") \
+        or (config.get("options") or {}).get("save_artifacts_dir") \
+        or "reports"
+    outdir = os.path.join(base, "performance")
+    os.makedirs(outdir, exist_ok=True)
+    return outdir
+
+def PerformanceCheckRunner(
+    model,
+    X_train, X_test, y_train, y_test,
+    config: Dict[str, Any],
+    cleaned_df,
+    raw_df=None,
+    ctx=None,
+):
+    outdir = _resolve_outdir(config)
+    task_type = ((config.get("model") or {}).get("type") or "binary_classification").lower()
+
+    payload: Dict[str, Any] = {}
+
+    if "class" in task_type: 
+        # --- build scores ---
+        def _scores(m, X):
+            if hasattr(m, "predict_proba"):
+                p = m.predict_proba(X)
+                return p[:, 1] if p.ndim == 2 and p.shape[1] > 1 else p.ravel()
+            if hasattr(m, "decision_function"):
+                return m.decision_function(X).ravel()
+            return m.predict(X).ravel()
+
+        y_score = _scores(model, X_test)
+        y_pred  = getattr(model, "predict")(X_test)
+
+        cls_dir = os.path.join(outdir, "classification")
+        os.makedirs(cls_dir, exist_ok=True)
+
+        results_cls = compute_classification_report(
+            y_true=np.asarray(y_test),
+            y_score=np.asarray(y_score),
+            y_pred=np.asarray(y_pred),
+            outdir=cls_dir,
+            pos_label=1,
+            title_prefix=(config.get("model") or {}).get("name", "Model"),
         )
-        result = check.run()
-        return {"PerformanceCheck": result}
 
-    except Exception as e:
-        print(f"⚠️ PerformanceCheck failed: {e}")
-        return {"PerformanceCheck": {"error": str(e)}}
+        payload = {
+            "performance": {
+                "classification": results_cls
+            },
+            "task_type": "classification",
+        }
+
+    else:
+       
+        # payload = {"performance": {"regression": results_reg}, "task_type": "regression"}
+        payload = {"task_type": "regression"}
+
+    return payload
+
+# ---- Back-compat alias so registry can import old name ----
+def run_performance_check(
+    model,
+    X_train, X_test, y_train, y_test,
+    config,
+    cleaned_df,
+    raw_df=None,
+    ctx=None,
+):
+    return PerformanceCheckRunner(
+        model=model,
+        X_train=X_train, X_test=X_test,
+        y_train=y_train, y_test=y_test,
+        config=config,
+        cleaned_df=cleaned_df,
+        raw_df=raw_df,
+        ctx=ctx,
+    )

tanml/check_runners/raw_data_runner.py

@@ -1,27 +1,43 @@
-from tanml.checks.raw_data import RawDataCheck
+from __future__ import annotations
+
+import os
 import pandas as pd
 
-def run_raw_data_check(model, X_train, X_test, y_train, y_test,
-                       rule_config, cleaned_data, *args, **kwargs):
+from tanml.checks.raw_data import RawDataCheck
+from tanml.utils.data_loader import load_dataframe
+
+
+def run_raw_data_check(
+    model,
+    X_train,
+    X_test,
+    y_train,
+    y_test,
+    rule_config,
+    cleaned_data,
+    *args,
+    **kwargs
+):
     try:
-        # ---- locate raw data (DF or path) -------------
+        # Locate raw data from config
         raw_obj = (
-            rule_config.get("raw_data") or
-            rule_config.get("paths", {}).get("raw_data")
+            rule_config.get("raw_data")
+            or (rule_config.get("paths", {}) or {}).get("raw_data")
+            or (rule_config.get("paths", {}) or {}).get("raw")
         )
+
         if raw_obj is None:
             print("ℹ️ RawDataCheck skipped — raw_data not provided in config.")
             return None
 
-        # CSV path → load once
-        if isinstance(raw_obj, (str, bytes)):
-            raw_obj = pd.read_csv(raw_obj)
+        if isinstance(raw_obj, (str, bytes, os.PathLike)):
+            raw_obj = load_dataframe(raw_obj)
 
         if not isinstance(raw_obj, pd.DataFrame):
-            print("ℹ️ RawDataCheck skipped — raw_data is not a DataFrame.")
+            print("ℹ️ RawDataCheck skipped — raw_data is not a DataFrame or loadable path.")
             return None
 
-        # ---- run the check -----------------------------
+        # Run the check
         check = RawDataCheck(
             model=model,
             X_train=X_train,
@@ -32,9 +48,8 @@ def run_raw_data_check(model, X_train, X_test, y_train, y_test,
             cleaned_data=cleaned_data,
             raw_data=raw_obj
         )
-
-        stats = check.run()           
-        return stats["RawDataCheck"]   # hand the inner dict to ValidationEngine
+        stats = check.run()
+        return stats.get("RawDataCheck", stats)
 
     except Exception as e:
         print(f"⚠️ RawDataCheck failed: {e}")