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

tanml/checks/stress_test.py

@@ -1,64 +1,168 @@
-from sklearn.metrics import roc_auc_score, accuracy_score
+from __future__ import annotations
+from typing import Any, Dict, List, Tuple
 import numpy as np
 import pandas as pd
+from pandas.api.types import is_bool_dtype, is_numeric_dtype
+
+from sklearn.metrics import (
+    accuracy_score, roc_auc_score,
+    mean_squared_error, r2_score
+)
+
+def _infer_task_type(model, y) -> str:
+    # 1) model hint
+    if hasattr(model, "_estimator_type"):
+        if model._estimator_type == "classifier":
+            return "classification"
+        if model._estimator_type == "regressor":
+            return "regression"
+    # 2) label-based fallback
+    try:
+        s = pd.Series(y).dropna()
+        if pd.api.types.is_numeric_dtype(s):
+            return "classification" if s.nunique() <= 10 else "regression"
+        return "classification"
+    except Exception:
+        return "classification"
+
+def _scores_for_classification(model, X) -> np.ndarray:
+    # Prefer probabilities
+    if hasattr(model, "predict_proba"):
+        p = model.predict_proba(X)
+        return p[:, 1] if p.ndim == 2 and p.shape[1] > 1 else np.ravel(p)
+    # Fall back to decision scores
+    if hasattr(model, "decision_function"):
+        return np.ravel(model.decision_function(X))
+    # Last resort: hard predictions (will be used directly for acc; AUC may be NaN)
+    return np.ravel(model.predict(X))
+
+def _bin_pred_from_score(score: np.ndarray) -> np.ndarray:
+    # If looks like probability in [0,1], threshold at 0.5; else at 0.0
+    if np.all(np.isfinite(score)):
+        smin, smax = float(np.min(score)), float(np.max(score))
+        if 0.0 <= smin <= 1.0 and 0.0 <= smax <= 1.0:
+            return (score >= 0.5).astype(int)
+        return (score >= 0.0).astype(int)
+    # fallback
+    return (score >= 0.5).astype(int)
+
+def _cls_metrics(y_true, y_score, y_pred) -> Tuple[float, float]:
+    acc = float(accuracy_score(y_true, y_pred))
+    try:
+        auc = float(roc_auc_score(y_true, y_score)) if len(np.unique(y_true)) > 1 else np.nan
+    except Exception:
+        auc = np.nan
+    return acc, auc
+
+def _reg_metrics(y_true, y_pred) -> Tuple[float, float]:
+    rmse = float(np.sqrt(mean_squared_error(y_true, y_pred)))
+    r2 = float(r2_score(y_true, y_pred))
+    return rmse, r2
 
 class StressTestCheck:
-    def __init__(self, model, X, y, epsilon=0.01, perturb_fraction=0.2):
+    """
+    Task-aware stress test:
+      - Classification: accuracy, auc, delta_accuracy, delta_auc
+      - Regression:     rmse, r2,  delta_rmse,     delta_r2
+
+    For each numeric feature, perturb a random subset of rows by (1 ± epsilon).
+    """
+
+    def __init__(self, model, X, y, epsilon: float = 0.01, perturb_fraction: float = 0.2, random_state: int = 42):
         self.model = model
-        self.X = X.copy()
-        self.y = y
-        self.epsilon = epsilon
-        self.perturb_fraction = perturb_fraction
+        self.X = pd.DataFrame(X, columns=getattr(X, "columns", None))
+        self.y = np.asarray(y)
+        self.epsilon = float(epsilon)
+        self.perturb_fraction = float(perturb_fraction)
+        self.rng = np.random.default_rng(int(random_state))
+
+        # 🔧 Cast ALL numeric columns to float once to avoid int64→float assignment warnings
+        num_cols = [c for c in self.X.columns if is_numeric_dtype(self.X[c]) and not is_bool_dtype(self.X[c])]
+        if num_cols:
+            self.X[num_cols] = self.X[num_cols].astype("float64")
+
+    def _numeric_cols(self) -> List[str]:
+        return [c for c in self.X.columns if is_numeric_dtype(self.X[c]) and not is_bool_dtype(self.X[c])]
+
+    def _perturb_scaled(self, X: pd.DataFrame, col: str, sign: int) -> pd.DataFrame:
+        """Scale a random subset of column 'col' by (1 + sign*epsilon)."""
+        Xp = X.copy(deep=True)
+        if Xp.empty:
+            return Xp
+        n = len(Xp)
+        k = max(1, int(self.perturb_fraction * n))
+        idx = self.rng.choice(Xp.index, size=k, replace=False)
+        factor = 1.0 + sign * self.epsilon
+
+        # Use a float numpy view for assignment — no dtype warnings
+        vals = Xp.loc[idx, col].to_numpy(dtype="float64", copy=False)
+        Xp.loc[idx, col] = vals * float(factor)
+        return Xp
 
     def run(self):
-        np.random.seed(42)
-        results = []
-
-        # Compute baseline metrics
-        try:
-            base_proba = self.model.predict_proba(self.X)[:, 1]
-            base_pred = (base_proba >= 0.5).astype(int)
-            base_auc = roc_auc_score(self.y, base_proba)
-            base_acc = accuracy_score(self.y, base_pred)
-        except Exception as e:
-            print(f"⚠️ Error computing baseline metrics: {e}")
-            return []
-
-        # Perturb each numeric feature
-        for col in self.X.columns:
-            if not pd.api.types.is_numeric_dtype(self.X[col]):
-                continue  # skip non-numeric features
+        task_type = _infer_task_type(self.model, self.y)
+        results: List[Dict[str, Any]] = []
 
+        # ---------- Baseline ----------
+        if task_type == "regression":
+            y_pred_base = np.ravel(self.model.predict(self.X))
+            rmse_base, r2_base = _reg_metrics(self.y, y_pred_base)
+        else:
+            y_score_base = _scores_for_classification(self.model, self.X)
+            # If scores are probs/decision, bin properly; else use model.predict
             try:
-                n_perturb = int(self.perturb_fraction * len(self.X))
-                idx = np.random.choice(self.X.index, size=n_perturb, replace=False)
-
-                X_perturbed = self.X.copy()
-                X_perturbed.loc[idx, col] += self.epsilon
-
-                perturbed_proba = self.model.predict_proba(X_perturbed)[:, 1]
-                perturbed_pred = (perturbed_proba >= 0.5).astype(int)
-
-                pert_auc = roc_auc_score(self.y, perturbed_proba)
-                pert_acc = accuracy_score(self.y, perturbed_pred)
-
-                results.append({
-                    "feature": col,
-                    "perturbation": f"±{round(self.epsilon * 100, 2)}%",
-                    "accuracy": round(pert_acc, 4),
-                    "auc": round(pert_auc, 4),
-                    "delta_accuracy": round(pert_acc - base_acc, 4),
-                    "delta_auc": round(pert_auc - base_auc, 4),
-                })
-
-            except Exception as e:
-                results.append({
-                    "feature": col,
-                    "perturbation": f"±{round(self.epsilon * 100, 2)}%",
-                    "accuracy": "error",
-                    "auc": "error",
-                    "delta_accuracy": f"Error: {e}",
-                    "delta_auc": f"Error: {e}",
-                })
+                y_pred_base = _bin_pred_from_score(y_score_base)
+            except Exception:
+                y_pred_base = np.ravel(self.model.predict(self.X))
+            acc_base, auc_base = _cls_metrics(self.y, y_score_base, y_pred_base)
+
+        # ---------- Per-feature perturbations ----------
+        for col in self._numeric_cols():
+            for sign, lab in [(+1, f"+{round(self.epsilon * 100, 2)}%"),
+                              (-1, f"-{round(self.epsilon * 100, 2)}%")]:
+                try:
+                    Xp = self._perturb_scaled(self.X, col, sign)
+
+                    if task_type == "regression":
+                        y_pred_p = np.ravel(self.model.predict(Xp))
+                        rmse_p, r2_p = _reg_metrics(self.y, y_pred_p)
+                        results.append({
+                            "feature": col,
+                            "perturbation": lab,
+                            "rmse": round(rmse_p, 4),
+                            "r2": round(r2_p, 4),
+                            "delta_rmse": round(rmse_p - rmse_base, 4),
+                            "delta_r2": round(r2_p - r2_base, 4),
+                        })
+                    else:
+                        y_score_p = _scores_for_classification(self.model, Xp)
+                        try:
+                            y_pred_p = _bin_pred_from_score(y_score_p)
+                        except Exception:
+                            y_pred_p = np.ravel(self.model.predict(Xp))
+                        acc_p, auc_p = _cls_metrics(self.y, y_score_p, y_pred_p)
+                        results.append({
+                            "feature": col,
+                            "perturbation": lab,
+                            "accuracy": round(acc_p, 4),
+                            "auc": round(auc_p, 4) if auc_p == auc_p else np.nan,
+                            "delta_accuracy": round(acc_p - acc_base, 4),
+                            "delta_auc": round((auc_p - auc_base), 4) if (auc_base == auc_base and auc_p == auc_p) else np.nan,
+                        })
+
+                # Robust error row in either mode
+                except Exception as e:
+                    if task_type == "regression":
+                        results.append({
+                            "feature": col, "perturbation": lab,
+                            "rmse": "error", "r2": "error",
+                            "delta_rmse": f"Error: {e}", "delta_r2": f"Error: {e}",
+                        })
+                    else:
+                        results.append({
+                            "feature": col, "perturbation": lab,
+                            "accuracy": "error", "auc": "error",
+                            "delta_accuracy": f"Error: {e}", "delta_auc": f"Error: {e}",
+                        })
 
         return pd.DataFrame(results)

tanml/cli/main.py

@@ -1,27 +1,99 @@
-import argparse
-from tanml.cli.validate_cmd import run_validate
-from tanml.cli.init_cmd import run_init
-
-def main():
-    parser = argparse.ArgumentParser(prog="tanml")
-    subparsers = parser.add_subparsers(dest="command")
-
-    # tanml validate --rules path.yaml
-    validate_parser = subparsers.add_parser("validate", help="Run model validation")
-    validate_parser.add_argument("--rules", required=True, help="Path to rules/config YAML")
-
-    # tanml init --scenario B
-    init_parser = subparsers.add_parser("init", help="Initialize rules YAML template")
-    init_parser.add_argument("--scenario", choices=["A", "B", "C"], required=True, help="Scenario type")
-    init_parser.add_argument("--overwrite", action="store_true", help="Overwrite existing rules.yaml if it exists")
-    init_parser.add_argument("--output", default="rules.yaml", help="Path where rules.yaml should be saved (default: rules.yaml)")
-
-    args = parser.parse_args()
-
-    if args.command == "validate":
-        run_validate(args.rules)
-    elif args.command == "init":
-           run_init(args.scenario, dest_path=args.output, overwrite=args.overwrite)
-
-    else:
-        parser.print_help()
+# tanml/cli/main.py
+from __future__ import annotations
+import sys, os, subprocess, argparse, importlib.util
+
+def _parse_args(argv):
+    p = argparse.ArgumentParser(prog="tanml ui", add_help=False)
+    p.add_argument("--public", action="store_true", help="Bind on 0.0.0.0 for LAN access")
+    p.add_argument("--headless", action="store_true", help="Run without opening a browser")
+    p.add_argument("--port", type=int, help="Port to serve on (default 8501)")
+    p.add_argument("--max-mb", type=int, help="Max upload/message size in MB (default 1024)")
+    p.add_argument("--no-telemetry", action="store_true", help="Disable Streamlit usage stats")
+    p.add_argument("--address", type=str, help="Explicit bind address (overrides --public)")
+    p.add_argument("-h", "--help", action="store_true", help="Show help")
+    args, _ = p.parse_known_args(argv)
+    if args.help:
+        p.print_help()
+        sys.exit(0)
+    return args
+
+def _env_bool(name, default=False):
+    v = os.environ.get(name)
+    if v is None:
+        return default
+    return str(v).strip().lower() in {"1", "true", "yes", "on"}
+
+def _module_file(modname: str) -> str:
+    """Return module file path WITHOUT importing it (avoids early st.* calls)."""
+    spec = importlib.util.find_spec(modname)
+    if spec is None or not spec.origin:
+        print(f"Could not locate module: {modname}", file=sys.stderr)
+        sys.exit(1)
+    return os.path.abspath(spec.origin)
+
+def _launch_ui(argv):
+    # ---- Resolve app path WITHOUT importing tanml.ui.app ----
+    app_path = _module_file("tanml.ui.app")
+
+    # ---- Resolve config: CLI > ENV > defaults ----
+    args = _parse_args(argv)
+
+    default_address = "127.0.0.1"
+    env_address = os.environ.get("TANML_SERVER_ADDRESS")
+    address = args.address or ("0.0.0.0" if args.public else (env_address or default_address))
+
+    default_headless = _env_bool("TANML_HEADLESS", False)
+    headless = args.headless or default_headless
+
+    default_port = int(os.environ.get("TANML_PORT", "8501"))
+    port = args.port if args.port is not None else default_port
+
+    default_max_mb = int(os.environ.get("TANML_MAX_MB", "1024"))
+    max_mb = args.max_mb if args.max_mb is not None else default_max_mb
+
+    default_no_telemetry = _env_bool("TANML_NO_TELEMETRY", True)  # default OFF
+    no_telemetry = args.no_telemetry or default_no_telemetry
+
+    # ---- Environment for the child process (the Streamlit runner)
+    env = os.environ.copy()
+    env.setdefault("STREAMLIT_SERVER_MAX_UPLOAD_SIZE", str(max_mb))
+    env.setdefault("STREAMLIT_SERVER_MAX_MESSAGE_SIZE", str(max_mb))
+    if no_telemetry:
+        env["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+    # Optional: reduce auto-reruns in production (cuts stale-media churn)
+    env.setdefault("STREAMLIT_SERVER_FILE_WATCHER_TYPE", "none")
+
+    # ---- Hand off to the official runner (prevents ScriptRunContext warnings)
+    cmd = [
+        sys.executable, "-m", "streamlit", "run", app_path,
+        f"--server.port={port}",
+        f"--server.address={address}",
+    ]
+    # Keep flags too (these mirror the env, fine to be redundant)
+    cmd += [
+        f"--server.maxUploadSize={max_mb}",
+        f"--server.maxMessageSize={max_mb}",
+    ]
+    if headless:
+        cmd.append("--server.headless=true")
+    if no_telemetry:
+        cmd.append("--browser.gatherUsageStats=false")
+
+    return subprocess.call(cmd, env=env)
+
+def main():
+    argv = sys.argv[1:]
+    if not argv or argv[0] in {"-h", "--help"}:
+        print(
+            "Usage:\n"
+            "  tanml ui [--public] [--headless] [--port N] [--max-mb N] [--no-telemetry]\n"
+            "Env vars:\n"
+            "  TANML_SERVER_ADDRESS, TANML_HEADLESS, TANML_PORT, TANML_MAX_MB, TANML_NO_TELEMETRY\n"
+        )
+        sys.exit(0)
+    if argv[0] == "ui":
+        sys.exit(_launch_ui(argv[1:]))
+    else:
+        print(f"Unknown command: {argv[0]}\nTry: tanml ui --help")
+        sys.exit(2)

tanml/engine/check_agent_registry.py

@@ -1,4 +1,4 @@
-from tanml.check_runners.performance_runner import run_performance_check
+#from tanml.check_runners.performance_runner import run_performance_check
 from tanml.check_runners.data_quality_runner import run_data_quality_check
 from tanml.check_runners.stress_test_runner import run_stress_test_check
 from tanml.check_runners.input_cluster_runner import run_input_cluster_check
@@ -12,6 +12,10 @@ from tanml.check_runners.explainability_runner import run_shap_check
 from tanml.check_runners.vif_runner import VIFCheckRunner
 from tanml.check_runners.rule_engine_runner import RuleEngineCheckRunner
 
+from tanml.check_runners.regression_metrics_runner import RegressionMetricsCheckRunner
+
+from tanml.check_runners.performance_runner import PerformanceCheckRunner
+
 
 # Wrapper for InputClusterCheck to inject expected_features from model
 def input_cluster_wrapper(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
@@ -25,18 +29,24 @@ def input_cluster_wrapper(model, X_train, X_test, y_train, y_test, rule_config,
     )
 
 CHECK_RUNNER_REGISTRY = {
-    "PerformanceCheck": run_performance_check,
+    #"PerformanceCheck": run_performance_check,
+    "RawDataCheck": run_raw_data_check,
     "DataQualityCheck": run_data_quality_check,
-    "StressTestCheck": run_stress_test_check,
-    "InputClusterCheck": input_cluster_wrapper,  
+    "EDACheck": EDACheckRunner,  
+    "CorrelationCheck": CorrelationCheckRunner, 
+    "VIFCheck": VIFCheckRunner,
+    "InputClusterCheck": input_cluster_wrapper, 
+    "ModelMetaCheck": ModelMetaCheckRunner, 
+    "PerformanceCheck": PerformanceCheckRunner,
+    "RegressionMetricsCheck": RegressionMetricsCheckRunner,
     "LogisticStatsCheck": run_logistic_stats_check,
-    "RawDataCheck": run_raw_data_check,
+    "StressTestCheck": run_stress_test_check,
+  
+  
     #"CleaningReproCheck": run_cleaning_repro_check,
-    "ModelMetaCheck": ModelMetaCheckRunner,  
-    "CorrelationCheck": CorrelationCheckRunner, 
-    "EDACheck": EDACheckRunner,  
+    
     "SHAPCheck": run_shap_check,
-    "VIFCheck": VIFCheckRunner,
-    "RuleEngineCheck": RuleEngineCheckRunner, 
+    
+    "RuleEngineCheck": RuleEngineCheckRunner,   
 
 }