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

tanml/config_templates/rules_one_model_one_dataset.yaml

@@ -1,143 +0,0 @@
-# ============================================================
-# TanML Validation Configuration File: Scenario A
-# ------------------------------------------------------------
-# 🧪 Scenario: One model, one cleaned dataset (no segmentation)
-#
-# ✅ Required:
-#   - Choose ONE set of paths (Option A or Option B)
-#   - Choose ONE model source block (Option A or Option B)
-#   - Fill in your feature names and target column
-#   - Adjust any thresholds or check options as needed
-# ============================================================
-
-
-# ------------------------------------------
-# REQUIRED: Model Input Schema
-# ------------------------------------------
-model:
-  features:
-    - feature_0     # 👉 replace with actual feature names used in your model
-    - feature_1
-    - feature_2
-    - feature_3
-    - feature_4
-  target: default_flag             # 👉 replace with actual target column
-
-# ------------------------------------------
-# OUTPUT: Report Path
-# ------------------------------------------
-output:
-  report_path: /mnt/c/Users/you/Desktop/tanml_output/scenario_a_report.docx  # 👉 customize as needed
-
-
-# ------------------------------------------
-# ✅ OPTION A — Use a Pretrained Model (.pkl)
-# ------------------------------------------
-# Use this option when you already have a trained model saved as a `.pkl` file.
-# You must provide the path to:
-#   - The cleaned dataset used during training
-#   - The raw dataset (optional, but recommended)
-#   - The trained model file via `paths.model`
-#
-# Be sure to:
-#   - Keep `from_pickle: true` in `model_source`
-#   - Match the `path` in `model_source` and `paths.model`
-#   - Comment out OPTION B block if using this
-# ------------------------------------------
-paths:
-  raw_data: /mnt/c/Users/your_name/Desktop/data/raw.csv      # 👉 optional — use null if raw data is not available
-  cleaned_data: data/cleaned_a.csv
-  model: models/logistic/model_a.pkl
-
-model_source:
-  from_pickle: true
-  
-
-# ------------------------------------------
-# 🔁 OPTION B — Retrain Model from Scratch
-# ------------------------------------------
-# Use this option if you want TanML to retrain the model for you
-# using the cleaned dataset and the specified algorithm + hyperparameters.
-#
-# You must provide:
-#   - Path to the raw dataset (optional)
-#   - Path to the cleaned dataset (required)
-#   - The full model definition: type, module, and hyperparameters
-#
-# Be sure to:
-#   - Set `from_pickle: false`
-#   - Omit or comment out the `paths.model` line
-#   - Comment out the OPTION A block above
-# ------------------------------------------
-# paths:
-#   raw_data: /mnt/c/Users/your_name/Desktop/data/raw.csv
-#   cleaned_data: data/cleaned_a.csv
-
-# model_source:
-#   from_pickle: false
-#   type: LogisticRegression
-#   module: sklearn.linear_model
-#   hyperparameters:
-#     penalty: "l2"
-#     C: 1.0
-#     solver: "liblinear"
-#     class_weight: "balanced"
-#     max_iter: 100
-#     random_state: 42
-
-# ------------------------------------------
-# PERFORMANCE THRESHOLDS
-# ------------------------------------------
-auc_roc:
-  min: 0.60
-
-f1:
-  min: 0.60
-
-ks:
-  min: 0.20
-
-# ------------------------------------------
-# VALIDATION CHECKS
-# ------------------------------------------
-
-EDACheck:
-  enabled: true
-  max_plots: -1             # -1 = all numeric; or set number of columns
-
-correlation:
-  enabled: true
-
-VIFCheck:
-  enabled: true
-  
-raw_data_check:
-  enabled: true
-
-model_meta:
-  enabled: true
-
-# ------------------------------------------
-# STRESS TESTING (Robustness Check)
-# ------------------------------------------
-StressTestCheck:
-  enabled: true
-  epsilon: 0.01             # ➜ 1% noise
-  perturb_fraction: 0.2     # ➜ 20% of rows
-
-# ------------------------------------------
-# INPUT CLUSTER COVERAGE
-# ------------------------------------------
-InputClusterCoverageCheck:
-  enabled: true
-  n_clusters: 5             # ➜ fixed clusters for coverage bar chart
-  max_k: 10                 # ➜ elbow method search (if needed)
-
-# ------------------------------------------
-# EXPLAINABILITY
-# ------------------------------------------
-explainability:
-  shap:
-    enabled: true
-    background_sample_size: 100   # ➜ SHAP explainer training background
-    test_sample_size: 200         # ➜ test rows to explain

tanml/engine/segmentation_agent.py

@@ -1,118 +0,0 @@
-from __future__ import annotations
-
-import os
-import joblib
-import importlib
-from tanml.utils.sas_loader import SASLogisticModel
-from tanml.utils.r_loader import RLogisticModel
-from tanml.engine.validation_agent import SegmentValidator
-from tanml.utils.data_loader import load_dataframe
-
-
-def handle_segmentation(segment_config, rule_config, args=None, report_output=None):
-    global_raw_path = rule_config.get("paths", {}).get("raw_data")
-    segment_col = segment_config.get("column")  # ✅ only required for Scenario C
-    report_template = report_output  # e.g., "reports/report_{segment}.docx"
-
-    print("🔍 Detected segmentation setup in rules.yaml. Running each segment run separately...")
-
-    for name, run_cfg in segment_config["runs"].items():
-        print(f"\n🔹 Validating segment: {name}")
-        model_path = run_cfg["model"]
-
-        # CASE 1: Retrain model from cleaned data (model: train)
-        if isinstance(model_path, str) and model_path.lower() == "train":
-            print(f"🛠️ Retraining model from cleaned data for segment: {name}")
-
-            if "cleaned" in run_cfg:
-                cleaned_df_run = load_dataframe(run_cfg["cleaned"])
-            else:
-                full_cleaned = load_dataframe(rule_config["paths"]["cleaned_data"])
-                if segment_col:
-                    cleaned_df_run = full_cleaned[full_cleaned[segment_col] == name]
-                else:
-                    raise ValueError("Missing segment column for slicing cleaned data.")
-
-            X = cleaned_df_run[rule_config["model"]["features"]]
-            y = cleaned_df_run[rule_config["model"]["target"]]
-
-            model_source = rule_config.get("model_source", {})
-            model_type = model_source.get("type")
-            model_module = model_source.get("module")
-            model_params = model_source.get("hyperparameters", {})
-
-            if not model_type or not model_module:
-                raise ValueError("❌ 'model_source.type' and 'model_source.module' must be defined for retraining.")
-
-            model_class = getattr(importlib.import_module(model_module), model_type)
-            model = model_class(**model_params)
-            print(f"📦 Using model: {model}")
-
-            model.fit(X, y)
-            print(f"✅ Retrained {model_type} for segment '{name}'")
-
-        elif isinstance(model_path, str) and "r_logistic" in model_path.lower():
-            model = RLogisticModel(model_path)
-
-        elif isinstance(model_path, str) and model_path.endswith(".pkl"):
-            model = joblib.load(model_path)
-
-        elif isinstance(model_path, str) and model_path.endswith(".csv"):
-            base = os.path.splitext(model_path)[0]
-            model = SASLogisticModel(
-                coeffs_path=model_path,
-                intercept_path=base + "_intercept.txt",
-                feature_order_path=base + "_features.txt"
-            )
-
-        else:
-            raise ValueError(f"❌ Unsupported model format for segment '{name}': {model_path}")
-
-        # Load and optionally slice raw data
-        raw_df_run = None
-        if global_raw_path and os.path.exists(global_raw_path):
-            full_raw = load_dataframe(global_raw_path)
-            if segment_col:
-                raw_df_run = full_raw[full_raw[segment_col] == name]
-            else:
-                raw_df_run = full_raw
-
-        print(f"[DEBUG] raw_df_run for {name}: {type(raw_df_run)}, rows = {len(raw_df_run) if raw_df_run is not None else 'None'}")
-
-        # Load cleaned data
-        if "cleaned" in run_cfg:
-            cleaned_df_run = load_dataframe(run_cfg["cleaned"])
-        else:
-            full_cleaned = load_dataframe(rule_config["paths"]["cleaned_data"])
-            if segment_col:
-                cleaned_df_run = full_cleaned[full_cleaned[segment_col] == name]
-            else:
-                cleaned_df_run = full_cleaned
-
-        # Format output path
-        report_base = report_template.format(segment=name)
-
-        # Run validation
-        validator = SegmentValidator(
-            segment_column=segment_col,
-            segment_values=[name],
-            model=model,
-            raw_df=raw_df_run,
-            cleaned_df=cleaned_df_run,
-            target_col=rule_config.get("model", {}).get("target"),
-            config=rule_config,
-            segment_name=name,
-            report_base=report_base
-        )
-        results = validator.run()
-
-        # Extract report path from SegmentValidator result
-        report_base_path = report_template.format(segment=name)
-        report_path = os.path.join(report_base_path, f"report_{name}.docx")
-
-        print(f"📄 Report saved: {report_path}")
-        print(f"✅ Segment '{name}' validated.")
-
-
-    print("✅ All segment runs completed.")
-    return True

tanml/engine/validation_agent.py

@@ -1,91 +0,0 @@
-from __future__ import annotations
-from importlib.resources import files 
-from datetime import datetime
-import tzlocal
-import json
-from pathlib import Path
-
-from tanml.engine.core_engine_agent import ValidationEngine
-from tanml.report.report_builder import ReportBuilder
-from tanml.engine.check_agent_registry import CHECK_RUNNER_REGISTRY
-
-
-class SegmentValidator:
-    def __init__(
-        self,
-        model,
-        raw_df,
-        cleaned_df,
-        config,
-        target_col=None,
-        segment_column=None,
-        segment_values=None,
-        segment_name=None,
-        report_base="reports"
-    ):
-        self.model = model
-        self.raw_df = raw_df
-        self.cleaned_df = cleaned_df
-        self.config = config
-        self.target_col = target_col
-        self.segment_column = segment_column
-        self.segment_values = segment_values
-        self.segment_name = segment_name
-        self.report_base = report_base
-
-    def run(self):
-        if self.segment_name:
-            return self._run_single(self.cleaned_df, self.segment_name)
-
-        if not self.segment_column:
-            raise ValueError("Segmentation column not specified in rules.yaml")
-
-        results = {}
-        for segment in self.segment_values:
-            segment_df = self.cleaned_df[self.cleaned_df[self.segment_column] == segment]
-            print(f"🔹 Running validation for segment value: {segment}")
-            result = self._run_single(segment_df, segment)
-            results[segment] = result
-
-        return results
-
-    def _run_single(self, segment_df, segment_name):
-        if self.target_col is None or self.target_col not in segment_df.columns:
-            raise ValueError(f"❌ Target column '{self.target_col}' missing in cleaned data for segment '{segment_name}'")
-
-        y = segment_df[self.target_col]
-        cols_to_drop = [c for c in (self.target_col, self.segment_column) if c in segment_df.columns]
-        X = segment_df.drop(columns=cols_to_drop)
-
-        # Pass raw_df to ValidationEngine so CleaningReproCheck works
-        engine = ValidationEngine(self.model, X, X, y, y, self.config, segment_df, self.raw_df)
-        results = engine.run_all_checks()
-
-        local_tz = tzlocal.get_localzone()
-        now = datetime.now(local_tz)
-        results["validation_date"] = now.strftime("%Y-%m-%d %H:%M:%S %Z (UTC%z)")
-        results["model_path"] = self.model.__class__.__name__
-        results["validated_by"] = "TanML Automated Validator"
-        results["rules"] = self.config
-
-        report_base_formatted = self.report_base.format(segment=segment_name) if "{segment}" in self.report_base else self.report_base
-        output_dir = Path(report_base_formatted)
-        output_dir.mkdir(parents=True, exist_ok=True)
-
-        tpl_cfg = self.config.get("output", {}).get("template_path")     # may be None
-        template_path = (
-            Path(tpl_cfg).expanduser() if tpl_cfg
-            else files("tanml.report.templates").joinpath("report_template.docx")
-        )
-
-        output_path = output_dir / f"report_{segment_name}.docx"
-
-        builder = ReportBuilder(results, template_path, output_path)
-        builder.build()
-
-        print(f"📄 Report saved for segment '{segment_name}': {output_path}")
-        print(json.dumps(results, indent=2, default=str))
-        return results
-
-
-__all__ = ["SegmentValidator", "CHECK_RUNNER_REGISTRY"]

tanml/utils/model_loader.py

@@ -1,35 +0,0 @@
-# tanml/utils/model_loader.py
-
-import os
-import joblib
-from tanml.utils.sas_loader import SASLogisticModel
-from tanml.utils.r_loader import RLogisticModel
-
-def load_model(model_path):
-    """
-    Load a model from path. Supports:
-    - sklearn/xgboost .pkl
-    - SAS .csv with _intercept.txt and _features.txt
-    - R exported logistic CSV
-    """
-    if not model_path:
-        raise ValueError("❌ No model path provided.")
-
-    if "r_logistic" in model_path.lower():
-        print("✅ Detected R Logistic Regression model")
-        return RLogisticModel(model_path)
-
-    elif model_path.endswith(".pkl"):
-        print(f"✅ Loading sklearn/XGB model from {model_path}")
-        return joblib.load(model_path)
-
-    elif model_path.endswith(".csv"):
-        base = os.path.splitext(model_path)[0]
-        return SASLogisticModel(
-            coeffs_path=model_path,
-            intercept_path=base + "_intercept.txt",
-            feature_order_path=base + "_features.txt"
-        )
-
-    else:
-        raise ValueError("❌ Unsupported model format. Use .pkl, .csv, or R model CSV")

tanml/utils/r_loader.py

@@ -1,30 +0,0 @@
-import pandas as pd
-import numpy as np
-
-class RLogisticModel:
-    """
-    Wrapper for logistic regression models exported from R.
-    Assumes CSV with columns: ID, y_true, y_pred_proba
-    """
-
-    def __init__(self, model_path: str):
-        self.model_path = model_path
-        self.df = pd.read_csv(model_path)
-
-        # Check required columns exist
-        expected_cols = {'y_true', 'y_pred_proba'}
-        if not expected_cols.issubset(set(self.df.columns)):
-            raise ValueError(f"R model CSV must contain columns: {expected_cols}")
-
-        self.y_true = self.df['y_true'].values
-        self.y_pred_proba = self.df['y_pred_proba'].values
-
-    def predict_proba(self, X=None):
-        """
-        Mimics sklearn’s predict_proba format: n_samples x 2
-        """
-        proba = self.y_pred_proba.reshape(-1, 1)
-        return np.hstack([1 - proba, proba])
-
-    def get_true_labels(self):
-        return self.y_true

tanml/utils/sas_loader.py

@@ -1,50 +0,0 @@
-# File: tanml/utils/sas_loader.py
-
-import pandas as pd
-import numpy as np         
-
-
-class SASLogisticModel:
-    def __init__(self, coeffs_path, intercept_path, feature_order_path):
-        self.coeffs_path = coeffs_path
-        self.intercept_path = intercept_path
-        self.feature_order_path = feature_order_path
-
-        self.coefficients = self._load_coefficients()
-        self.intercept = self._load_intercept()
-        self.feature_order = self._load_feature_order()
-
-    def _load_coefficients(self):
-        return pd.read_csv(self.coeffs_path, index_col=0).squeeze("columns")
-
-    def _load_intercept(self):
-        with open(self.intercept_path) as f:
-            return float(f.read().strip())
-
-    def _load_feature_order(self):
-        with open(self.feature_order_path) as f:
-            return [line.strip() for line in f.readlines()]
-
-    def predict_proba(self, X):
-        """
-        Return a NumPy array shaped (n_samples, 2) like sklearn:
-        [:, 0] = P(class 0), [:, 1] = P(class 1)
-        """
-        X = X[self.feature_order]
-        logits = X.dot(self.coefficients) + self.intercept
-
-        # numeric stability clamp
-        logits = logits.clip(-700, 700)
-
-        proba_1 = 1 / (1 + np.exp(-logits))
-        proba_0 = 1 - proba_1
-        return np.vstack([proba_0, proba_1]).T  # shape (n, 2)
-
-    def predict(self, X):
-        """
-        Return class labels (0/1) based on 0.5 threshold.
-        Works with the NumPy array returned by predict_proba().
-        """
-        proba_1 = self.predict_proba(X)[:, 1]   # probability of class 1
-        return (proba_1 >= 0.5).astype(int)
-

tanml/utils/yaml_generator.py

@@ -1,34 +0,0 @@
-from pathlib import Path
-import shutil
-
-def generate_rules_yaml(
-    scenario: str = "A",
-    dest_path: str = "rules.yaml",
-    overwrite: bool = False
-):
-
-    scenario = scenario.upper()
-    template_map = {
-        "A": "rules_one_model_one_dataset.yaml",
-        "B": "rules_multiple_models_datasets.yaml",
-        "C": "rules_one_dataset_segment_column.yaml"
-    }
-
-    if scenario not in template_map:
-        raise ValueError("Invalid scenario. Must be 'A', 'B', or 'C'.")
-
-    src = Path(__file__).parent.parent / "config_templates" / template_map[scenario]
-    if not src.exists():
-        raise FileNotFoundError(f"Template not found at {src}")
-
-    dst = Path(dest_path)
-    if dst.exists() and not overwrite:
-        raise FileExistsError(f"{dst} already exists. Use --overwrite to replace it.")
-
-    if dst.parent and not dst.parent.exists():
-        dst.parent.mkdir(parents=True, exist_ok=True)
-
-    shutil.copyfile(src, dst)
-
-    print(f"✅ Created: {dst.resolve()} for Scenario {scenario}")
-    print("👉 Now edit this YAML to fill in your model, data, and feature details.")

tanml/utils/yaml_loader.py

@@ -1,5 +0,0 @@
-import yaml
-
-def load_yaml_config(path):
-    with open(path, "r") as f:
-        return yaml.safe_load(f)