ai-critic 1.2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

ai_critic/ai_suggestions/predictor.py

@@ -0,0 +1,5 @@
+def predict_improvements(report_embedding):
+    return {
+        "risk_reduction": 0.23,
+        "suggested_action": "Remove top correlated feature"
+    }

ai_critic/ai_suggestions/rules.py

@@ -0,0 +1,3 @@
+def suggest(report):
+    if report["score"]["global"] < 60:
+        return "Reduce model complexity or audit features for leakage."

ai_critic/cli.py

@@ -0,0 +1,141 @@
+# ai_critic/critic.py
+
+from ai_critic.evaluators import (
+    robustness,
+    config,
+    data,
+    performance,
+    adapters
+)
+from ai_critic.evaluators.summary import HumanSummary
+from ai_critic.sessions import CriticSessionStore
+from ai_critic.evaluators.scoring import compute_scores
+
+from ai_critic.learning import (
+    extract_features,
+    CriticModel,
+    CriticTrainer,
+    policy_decision,
+    recommend_changes
+)
+from ai_critic.feedback import FeedbackStore
+
+
+class AICritic:
+    def __init__(
+        self,
+        model,
+        X,
+        y,
+        random_state=None,
+        session=None,
+        framework="sklearn",
+        adapter_kwargs=None
+    ):
+        adapter_kwargs = adapter_kwargs or {}
+        self.framework = framework.lower()
+
+        self.model = (
+            adapters.ModelAdapter(model, framework=self.framework, **adapter_kwargs)
+            if self.framework != "sklearn"
+            else model
+        )
+
+        self.X = X
+        self.y = y
+        self.session = session
+
+        self.ml_model = CriticModel()
+        try:
+            self.ml_model.load()
+        except Exception:
+            pass
+
+        self.trainer = CriticTrainer(self.ml_model)
+        self.feedback = FeedbackStore()
+        self._store = CriticSessionStore() if session else None
+
+    def evaluate(self, view="all", plot=False):
+        details = {}
+
+        details["data"] = data.evaluate(self.X, self.y, plot=plot)
+        details["config"] = config.evaluate(
+            self.model,
+            n_samples=details["data"]["n_samples"],
+            n_features=details["data"]["n_features"]
+        )
+        details["performance"] = performance.evaluate(
+            self.model, self.X, self.y, plot=plot
+        )
+        details["robustness"] = robustness.evaluate(
+            self.model,
+            self.X,
+            self.y,
+            leakage_suspected=details["data"]["data_leakage"]["suspected"],
+            plot=plot
+        )
+
+        human = HumanSummary().generate(details)
+
+        payload = {
+            "executive": human["executive_summary"],
+            "technical": human["technical_summary"],
+            "details": details,
+            "meta": {
+                "framework": self.framework,
+                "n_samples": details["data"]["n_samples"],
+                "n_features": details["data"]["n_features"],
+            }
+        }
+
+        payload["scores"] = compute_scores(payload)
+
+        if self.session:
+            self._store.save(self.session, payload)
+
+        return payload if view == "all" else payload.get(view)
+
+    def deploy_decision(self, success_feedback=None):
+        report = self.evaluate(view="all", plot=False)
+
+        rule_decision = self._rule_based_decision(report)
+        features = extract_features(report)
+        ml_score = self.ml_model.predict_proba(features)
+
+        decision = policy_decision(rule_decision, ml_score)
+        recommendations = recommend_changes(report)
+
+        # 🔁 FEEDBACK LOOP AUTOMÁTICO
+        if success_feedback is not None:
+            self.feedback.add(self.session, report, success_feedback)
+            self.trainer.add_feedback(report, success_feedback)
+
+        return {
+            "deploy": decision["deploy"],
+            "risk_level": rule_decision["risk_level"],
+            "ml_score": round(ml_score, 3),
+            "recommendations": recommendations,
+            "feedback_stats": self.feedback.stats()
+        }
+
+    def _rule_based_decision(self, report):
+        blocking = []
+        risk = "low"
+
+        if report["details"]["data"]["data_leakage"]["suspected"]:
+            blocking.append("Data leakage suspected")
+            risk = "high"
+
+        if report["details"]["performance"]["suspiciously_perfect"]:
+            blocking.append("Suspiciously perfect CV score")
+            risk = "medium"
+
+        if report["details"]["config"]["risk_level"] == "high":
+            blocking.append("High structural complexity")
+            risk = "medium"
+
+        return {
+            "deploy": len(blocking) == 0,
+            "risk_level": risk,
+            "blocking_issues": blocking
+        }

ai_critic/critic.py

@@ -1,112 +1,72 @@
+# ai_critic/critic.py
+
 from ai_critic.evaluators import (
     robustness,
     config,
     data,
     performance,
-    adapters  # <- novo import
+    adapters
 )
 from ai_critic.evaluators.summary import HumanSummary
 from ai_critic.sessions import CriticSessionStore
 from ai_critic.evaluators.scoring import compute_scores
 
+from ai_critic.learning import (
+    extract_features,
+    CriticModel,
+    CriticTrainer,
+    policy_decision,
+    recommend_changes
+)
+from ai_critic.feedback import FeedbackStore
 
-class AICritic:
-    """
-    Automated reviewer for scikit-learn, PyTorch, or TensorFlow models.
-
-    Produces a multi-layered risk assessment including:
-    - Data integrity analysis
-    - Model configuration sanity checks
-    - Performance evaluation (CV + learning curves)
-    - Robustness & leakage heuristics
-    - Human-readable executive and technical summaries
-    """
 
-    def __init__(self, model, X, y, random_state=None, session=None, framework="sklearn", adapter_kwargs=None):
-        """
-        Parameters
-        ----------
-        model : object
-            scikit-learn estimator, torch.nn.Module, or tf.keras.Model
-        X : np.ndarray
-            Feature matrix
-        y : np.ndarray
-            Target vector
-        random_state : int or None
-            Global seed for reproducibility (optional)
-        session : str or None
-            Optional session name for longitudinal comparison
-        framework : str
-            "sklearn" (default), "torch", or "tensorflow"
-        adapter_kwargs : dict
-            Extra kwargs para o adaptador (ex: epochs, lr, batch_size)
-        """
+class AICritic:
+    def __init__(
+        self,
+        model,
+        X,
+        y,
+        random_state=None,
+        session=None,
+        framework="sklearn",
+        adapter_kwargs=None
+    ):
         adapter_kwargs = adapter_kwargs or {}
         self.framework = framework.lower()
-        if self.framework != "sklearn":
-            self.model = adapters.ModelAdapter(model, framework=self.framework, **adapter_kwargs)
-        else:
-            self.model = model
+
+        self.model = (
+            adapters.ModelAdapter(model, framework=self.framework, **adapter_kwargs)
+            if self.framework != "sklearn"
+            else model
+        )
 
         self.X = X
         self.y = y
-        self.random_state = random_state
         self.session = session
-        self._store = CriticSessionStore() if session else None
 
-    def evaluate(self, view="all", plot=False):
-        """
-        Evaluate the model.
+        self.ml_model = CriticModel()
+        try:
+            self.ml_model.load()
+        except Exception:
+            pass
 
-        Parameters
-        ----------
-        view : str or list
-            - "all" : full payload (default)
-            - "executive" : executive summary only
-            - "technical" : technical summary only
-            - "details" : low-level evaluator outputs
-            - list : subset of views
-        plot : bool
-            - True : generate plots
-            - False : no plots
-        """
+        self.trainer = CriticTrainer(self.ml_model)
+        self.feedback = FeedbackStore()
+        self._store = CriticSessionStore() if session else None
 
-        # =========================
-        # Low-level evaluator outputs
-        # =========================
+    def evaluate(self, view="all", plot=False):
         details = {}
 
-        # -------------------------
-        # Data analysis
-        # -------------------------
-        details["data"] = data.evaluate(
-            self.X,
-            self.y,
-            plot=plot
-        )
-
-        # -------------------------
-        # Model configuration sanity
-        # -------------------------
+        details["data"] = data.evaluate(self.X, self.y, plot=plot)
         details["config"] = config.evaluate(
             self.model,
             n_samples=details["data"]["n_samples"],
             n_features=details["data"]["n_features"]
         )
-
-        # -------------------------
-        # Performance evaluation
-        # -------------------------
         details["performance"] = performance.evaluate(
-            self.model,
-            self.X,
-            self.y,
-            plot=plot
+            self.model, self.X, self.y, plot=plot
         )
-
-        # -------------------------
-        # Robustness evaluation
-        # -------------------------
         details["robustness"] = robustness.evaluate(
             self.model,
             self.X,
@@ -115,147 +75,67 @@ class AICritic:
             plot=plot
         )
 
-        # =========================
-        # Human summaries
-        # =========================
-        human_summary = HumanSummary().generate(details)
+        human = HumanSummary().generate(details)
 
         payload = {
-            "executive": human_summary["executive_summary"],
-            "technical": human_summary["technical_summary"],
+            "executive": human["executive_summary"],
+            "technical": human["technical_summary"],
             "details": details,
-            "performance": details["performance"],
+            "meta": {
+                "framework": self.framework,
+                "n_samples": details["data"]["n_samples"],
+                "n_features": details["data"]["n_features"],
+            }
         }
 
-        # =========================
-        # Session persistence (optional)
-        # =========================
+        payload["scores"] = compute_scores(payload)
+
         if self.session:
-            scores = compute_scores(payload)
-            payload["scores"] = scores
             self._store.save(self.session, payload)
 
-        # =========================
-        # View selector
-        # =========================
-        if view == "all":
-            return payload
-
-        if isinstance(view, list):
-            return {k: payload[k] for k in view if k in payload}
+        return payload if view == "all" else payload.get(view)
 
-        return payload.get(view)
-
-    def compare_with(self, previous_session: str) -> dict:
-        """
-        Compare current session with a previous one.
-        """
-
-        if not self.session:
-            raise ValueError("Current session name not set.")
-
-        current = self._store.load(self.session)
-        previous = self._store.load(previous_session)
+    def deploy_decision(self, success_feedback=None):
+        report = self.evaluate(view="all", plot=False)
 
-        if not previous:
-            raise FileNotFoundError(
-                f"Session '{previous_session}' not found."
-            )
+        rule_decision = self._rule_based_decision(report)
+        features = extract_features(report)
+        ml_score = self.ml_model.predict_proba(features)
 
-        diff = {
-            "global_score": {
-                "current": current["scores"]["global"],
-                "previous": previous["scores"]["global"],
-                "delta": current["scores"]["global"] - previous["scores"]["global"],
-            },
-            "components": {}
-        }
+        decision = policy_decision(rule_decision, ml_score)
+        recommendations = recommend_changes(report)
 
-        for key, value in current["scores"]["components"].items():
-            prev_value = previous["scores"]["components"].get(key)
-            if prev_value is not None:
-                diff["components"][key] = {
-                    "current": value,
-                    "previous": prev_value,
-                    "delta": value - prev_value
-                }
+        # 🔁 FEEDBACK LOOP AUTOMÁTICO
+        if success_feedback is not None:
+            self.feedback.add(self.session, report, success_feedback)
+            self.trainer.add_feedback(report, success_feedback)
 
         return {
-            "current_session": self.session,
-            "previous_session": previous_session,
-            "score_diff": diff,
-            "note": (
-                "Score deltas indicate changes in risk profile, "
-                "not absolute model quality."
-            )
+            "deploy": decision["deploy"],
+            "risk_level": rule_decision["risk_level"],
+            "ml_score": round(ml_score, 3),
+            "recommendations": recommendations,
+            "feedback_stats": self.feedback.stats()
         }
 
-    def deploy_decision(self):
-        """
-        Final deployment gate.
-        """
-
-        report = self.evaluate(view="all", plot=False)
-
-        data_risk = report["details"]["data"]["data_leakage"]["suspected"]
-        perfect_cv = report["details"]["performance"]["suspiciously_perfect"]
-        robustness_verdict = report["details"]["robustness"]["verdict"]
-        structural_warnings = report["details"]["config"]["structural_warnings"]
-
-        blocking_issues = []
-        risk_level = "low"
-
-        # Hard blockers
-        if data_risk and perfect_cv:
-            blocking_issues.append(
-                "Data leakage combined with suspiciously perfect CV score"
-            )
-            risk_level = "high"
-
-        if robustness_verdict == "misleading":
-            blocking_issues.append(
-                "Robustness results are misleading due to inflated baseline performance"
-            )
-            risk_level = "high"
-
-        if data_risk:
-            blocking_issues.append(
-                "Suspected target leakage in feature set"
-            )
-            risk_level = "high"
-
-        # Soft blockers
-        if risk_level != "high":
-            if robustness_verdict == "fragile":
-                blocking_issues.append(
-                    "Model performance degrades significantly under noise"
-                )
-                risk_level = "medium"
-
-            if perfect_cv:
-                blocking_issues.append(
-                    "Suspiciously perfect cross-validation score"
-                )
-                risk_level = "medium"
+    def _rule_based_decision(self, report):
+        blocking = []
+        risk = "low"
 
-            if structural_warnings:
-                blocking_issues.append(
-                    "Structural complexity risks detected in model configuration"
-                )
-                risk_level = "medium"
+        if report["details"]["data"]["data_leakage"]["suspected"]:
+            blocking.append("Data leakage suspected")
+            risk = "high"
 
-        deploy = len(blocking_issues) == 0
+        if report["details"]["performance"]["suspiciously_perfect"]:
+            blocking.append("Suspiciously perfect CV score")
+            risk = "medium"
 
-        confidence = 1.0
-        confidence -= 0.35 if data_risk else 0
-        confidence -= 0.25 if perfect_cv else 0
-        confidence -= 0.25 if robustness_verdict in ("fragile", "misleading") else 0
-        confidence -= 0.15 if structural_warnings else 0
-        confidence = max(0.0, round(confidence, 2))
+        if report["details"]["config"]["risk_level"] == "high":
+            blocking.append("High structural complexity")
+            risk = "medium"
 
         return {
-            "deploy": deploy,
-            "risk_level": risk_level,
-            "blocking_issues": blocking_issues,
-            "confidence": confidence
+            "deploy": len(blocking) == 0,
+            "risk_level": risk,
+            "blocking_issues": blocking
         }

ai_critic/evaluators/config.py

@@ -1,22 +1,33 @@
+# evaluators/config.py
 import math
 
+
 def evaluate(model, n_samples=None, n_features=None):
-    params = model.get_params()
+    """
+    Evaluates model configuration for structural risks and complexity.
+    Outputs only metadata-safe signals (telemetry-ready).
+    """
+
+    params = model.get_params() if hasattr(model, "get_params") else {}
     model_type = type(model).__name__
 
     report = {
         "model_type": model_type,
         "n_params": len(params),
-        "uses_random_state": "random_state" in params
+        "uses_random_state": "random_state" in params,
+        "complexity_score": 0,
+        "risk_level": "low",
     }
 
-    # 🧠 Structural overfitting heuristics
     warnings = []
 
-    if n_samples and hasattr(model, "max_depth"):
+    # =========================
+    # Tree depth heuristic
+    # =========================
+    if n_samples and "max_depth" in params:
         max_depth = params.get("max_depth")
         if max_depth is not None:
-            recommended_depth = math.log2(n_samples)
+            recommended_depth = math.log2(max(2, n_samples))
             if max_depth > recommended_depth:
                 warnings.append({
                     "issue": "structural_overfitting_risk",
@@ -24,12 +35,25 @@ def evaluate(model, n_samples=None, n_features=None):
                     "recommended_max_depth": int(recommended_depth),
                     "message": "Tree depth may be too high for dataset size."
                 })
+                report["complexity_score"] += 1
 
+    # =========================
+    # Feature / sample ratio
+    # =========================
     if n_samples and n_features and n_features > n_samples:
         warnings.append({
             "issue": "high_feature_sample_ratio",
             "message": "More features than samples can cause instability."
         })
+        report["complexity_score"] += 1
+
+    # =========================
+    # Risk aggregation
+    # =========================
+    if report["complexity_score"] >= 2:
+        report["risk_level"] = "high"
+    elif report["complexity_score"] == 1:
+        report["risk_level"] = "medium"
 
     report["structural_warnings"] = warnings
     return report

ai_critic/feedback/__init__.py

@@ -0,0 +1,3 @@
+from .store import FeedbackStore
+
+__all__ = ["FeedbackStore"]

ai_critic/feedback/store.py

@@ -0,0 +1,23 @@
+class FeedbackStore:
+    def __init__(self):
+        self.storage = []
+
+    def add(self, session_id, report, success: bool):
+        self.storage.append({
+            "session": session_id,
+            "success": success,
+            "report": report
+        })
+
+    def stats(self):
+        positives = sum(1 for x in self.storage if x["success"])
+        negatives = sum(1 for x in self.storage if not x["success"])
+
+        return {
+            "total": len(self.storage),
+            "positives": positives,
+            "negatives": negatives
+        }
+
+    def all(self):
+        return self.storage

ai_critic/learning/__init__.py

@@ -0,0 +1,13 @@
+from .features import extract_features
+from .critic_model import CriticModel
+from .trainer import CriticTrainer
+from .policy import policy_decision
+from .recommender import recommend_changes
+
+__all__ = [
+    "extract_features",
+    "CriticModel",
+    "CriticTrainer",
+    "policy_decision",
+    "recommend_changes",
+]

ai_critic/learning/critic_model.py

@@ -0,0 +1,25 @@
+import joblib
+from sklearn.linear_model import LogisticRegression
+import numpy as np
+
+class CriticModel:
+    def __init__(self, path="critic_model.joblib"):
+        self.path = path
+        self.model = LogisticRegression()
+        self.is_trained = False
+
+    def train(self, X, y):
+        self.model.fit(X, y)
+        self.is_trained = True
+        joblib.dump(self.model, self.path)
+
+    def load(self):
+        self.model = joblib.load(self.path)
+        self.is_trained = True
+
+    def predict_proba(self, features: dict) -> float:
+        if not self.is_trained:
+            return 0.5  # neutro
+
+        X = np.array([list(features.values())])
+        return float(self.model.predict_proba(X)[0][1])

ai_critic/learning/features.py

@@ -0,0 +1,15 @@
+def extract_features(report: dict) -> dict:
+    data = report["details"]["data"]
+    perf = report["details"]["performance"]
+    robust = report["details"]["robustness"]
+    config = report["details"]["config"]
+
+    return {
+        "n_samples": report["meta"]["n_samples"],
+        "n_features": report["meta"]["n_features"],
+        "data_leakage": int(data["data_leakage"]["suspected"]),
+        "perfect_cv": int(perf["suspiciously_perfect"]),
+        "robustness_fragile": int(robust["verdict"] == "fragile"),
+        "robustness_misleading": int(robust["verdict"] == "misleading"),
+        "structural_risk_high": int(config["risk_level"] == "high"),
+    }

ai_critic/learning/policy.py

@@ -0,0 +1,20 @@
+def policy_decision(rule_decision: dict, ml_score: float):
+    if rule_decision["risk_level"] == "high":
+        return {
+            "deploy": False,
+            "reason": "Blocked by rules",
+            "ml_score": ml_score
+        }
+
+    if ml_score < 0.4:
+        return {
+            "deploy": False,
+            "reason": "ML predicts failure",
+            "ml_score": ml_score
+        }
+
+    return {
+        "deploy": True,
+        "reason": "Approved by ML + rules",
+        "ml_score": ml_score
+    }