churnkit 0.75.0a1__py3-none-any.whl

customer_retention/stages/cleaning/outlier_handler.py

@@ -0,0 +1,204 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+import numpy as np
+
+from customer_retention.core.compat import Series
+
+
+class OutlierDetectionMethod(str, Enum):
+    IQR = "iqr"
+    ZSCORE = "zscore"
+    MODIFIED_ZSCORE = "modified_zscore"
+    PERCENTILE = "percentile"
+
+
+class OutlierTreatmentStrategy(str, Enum):
+    NONE = "none"
+    CAP_IQR = "cap_iqr"
+    CAP_PERCENTILE = "cap_percentile"
+    WINSORIZE = "winsorize"
+    CLIP = "clip"
+    LOG_TRANSFORM = "log_transform"
+    SQRT_TRANSFORM = "sqrt_transform"
+    DROP = "drop"
+    INDICATOR = "indicator"
+
+
+@dataclass
+class OutlierResult:
+    series: Series
+    method_used: OutlierDetectionMethod
+    strategy_used: OutlierTreatmentStrategy
+    outliers_detected: int
+    outliers_treated: int
+    lower_bound: Optional[float]
+    upper_bound: Optional[float]
+    outlier_mask: Optional[Series] = None
+    indicator_column: Optional[Series] = None
+    rows_dropped: int = 0
+    drop_mask: Optional[list[bool]] = None
+
+
+class OutlierHandler:
+    def __init__(
+        self,
+        detection_method: OutlierDetectionMethod = OutlierDetectionMethod.IQR,
+        treatment_strategy: OutlierTreatmentStrategy = OutlierTreatmentStrategy.CAP_IQR,
+        iqr_multiplier: float = 1.5,
+        zscore_threshold: float = 3.0,
+        percentile_lower: float = 1,
+        percentile_upper: float = 99,
+        clip_min: Optional[float] = None,
+        clip_max: Optional[float] = None
+    ):
+        self.detection_method = detection_method
+        self.treatment_strategy = treatment_strategy
+        self.iqr_multiplier = iqr_multiplier
+        self.zscore_threshold = zscore_threshold
+        self.percentile_lower = percentile_lower
+        self.percentile_upper = percentile_upper
+        self.clip_min = clip_min
+        self.clip_max = clip_max
+        self._lower_bound: Optional[float] = None
+        self._upper_bound: Optional[float] = None
+        self._is_fitted = False
+
+    def detect(self, series: Series) -> OutlierResult:
+        clean = series.dropna()
+        lower, upper = self._compute_bounds(clean)
+        mask = (series < lower) | (series > upper)
+        mask = mask.fillna(False)
+
+        return OutlierResult(
+            series=series, method_used=self.detection_method,
+            strategy_used=self.treatment_strategy,
+            outliers_detected=int(mask.sum()), outliers_treated=0,
+            lower_bound=lower, upper_bound=upper, outlier_mask=mask
+        )
+
+    def fit(self, series: Series) -> "OutlierHandler":
+        clean = series.dropna()
+        self._lower_bound, self._upper_bound = self._compute_bounds(clean)
+        self._is_fitted = True
+        return self
+
+    def transform(self, series: Series) -> OutlierResult:
+        if not self._is_fitted:
+            raise ValueError("Handler not fitted. Call fit() or fit_transform() first.")
+        return self._apply_treatment(series, self._lower_bound, self._upper_bound)
+
+    def fit_transform(self, series: Series) -> OutlierResult:
+        self.fit(series)
+        return self._apply_treatment(series, self._lower_bound, self._upper_bound)
+
+    def _compute_bounds(self, clean: Series) -> tuple[float, float]:
+        if self.detection_method == OutlierDetectionMethod.IQR:
+            q1 = clean.quantile(0.25)
+            q3 = clean.quantile(0.75)
+            iqr = q3 - q1
+            return q1 - self.iqr_multiplier * iqr, q3 + self.iqr_multiplier * iqr
+
+        if self.detection_method == OutlierDetectionMethod.ZSCORE:
+            mean, std = clean.mean(), clean.std()
+            return mean - self.zscore_threshold * std, mean + self.zscore_threshold * std
+
+        if self.detection_method == OutlierDetectionMethod.MODIFIED_ZSCORE:
+            median = clean.median()
+            mad = np.abs(clean - median).median()
+            k = 1.4826
+            return median - 3.5 * k * mad, median + 3.5 * k * mad
+
+        if self.detection_method == OutlierDetectionMethod.PERCENTILE:
+            return clean.quantile(self.percentile_lower / 100), clean.quantile(self.percentile_upper / 100)
+
+        return clean.min(), clean.max()
+
+    def _apply_treatment(self, series: Series, lower: float, upper: float) -> OutlierResult:
+        mask = ((series < lower) | (series > upper)) & series.notna()
+        outliers_detected = int(mask.sum())
+        result_series = series.copy()
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.NONE:
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=0,
+                lower_bound=lower, upper_bound=upper, outlier_mask=mask
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.INDICATOR:
+            indicator = mask.astype(int)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=0,
+                lower_bound=lower, upper_bound=upper, outlier_mask=mask,
+                indicator_column=indicator
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.DROP:
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=outliers_detected,
+                lower_bound=lower, upper_bound=upper, outlier_mask=mask,
+                rows_dropped=outliers_detected, drop_mask=mask.tolist()
+            )
+
+        if self.treatment_strategy in [OutlierTreatmentStrategy.CAP_IQR, OutlierTreatmentStrategy.WINSORIZE]:
+            result_series = result_series.clip(lower=lower, upper=upper)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=outliers_detected,
+                lower_bound=lower, upper_bound=upper, outlier_mask=mask
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.CAP_PERCENTILE:
+            result_series = result_series.clip(lower=lower, upper=upper)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=outliers_detected,
+                lower_bound=lower, upper_bound=upper, outlier_mask=mask
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.CLIP:
+            clip_lower = self.clip_min if self.clip_min is not None else lower
+            clip_upper = self.clip_max if self.clip_max is not None else upper
+            result_series = result_series.clip(lower=clip_lower, upper=clip_upper)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=outliers_detected, outliers_treated=outliers_detected,
+                lower_bound=clip_lower, upper_bound=clip_upper, outlier_mask=mask
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.LOG_TRANSFORM:
+            if (series.dropna() < 0).any():
+                raise ValueError("Log transform requires non-negative values")
+            result_series = np.log1p(series)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=0, outliers_treated=0,
+                lower_bound=None, upper_bound=None
+            )
+
+        if self.treatment_strategy == OutlierTreatmentStrategy.SQRT_TRANSFORM:
+            result_series = np.sqrt(series)
+            return OutlierResult(
+                series=result_series, method_used=self.detection_method,
+                strategy_used=self.treatment_strategy,
+                outliers_detected=0, outliers_treated=0,
+                lower_bound=None, upper_bound=None
+            )
+
+        return OutlierResult(
+            series=result_series, method_used=self.detection_method,
+            strategy_used=self.treatment_strategy,
+            outliers_detected=outliers_detected, outliers_treated=0,
+            lower_bound=lower, upper_bound=upper, outlier_mask=mask
+        )

customer_retention/stages/deployment/__init__.py

@@ -0,0 +1,28 @@
+from .batch_scorer import BatchScorer, RiskSegment, ScoringConfig, ScoringResult
+from .champion_challenger import (
+    ChampionChallenger,
+    ComparisonResult,
+    ModelRole,
+    PromotionCriteria,
+    RollbackManager,
+    RollbackPlan,
+    RollbackResult,
+)
+from .model_registry import ModelMetadata, ModelRegistry, ModelStage, RegistrationResult, ValidationResult
+from .retraining_trigger import (
+    EvaluationResult,
+    RetrainingConfig,
+    RetrainingDecision,
+    RetrainingTrigger,
+    RetrainingTriggerType,
+    TriggerPriority,
+)
+
+__all__ = [
+    "ModelRegistry", "ModelStage", "ModelMetadata", "RegistrationResult", "ValidationResult",
+    "BatchScorer", "ScoringConfig", "ScoringResult", "RiskSegment",
+    "RetrainingTrigger", "RetrainingTriggerType", "TriggerPriority", "RetrainingDecision",
+    "RetrainingConfig", "EvaluationResult",
+    "ChampionChallenger", "ModelRole", "ComparisonResult", "PromotionCriteria",
+    "RollbackManager", "RollbackPlan", "RollbackResult"
+]

customer_retention/stages/deployment/batch_scorer.py

@@ -0,0 +1,106 @@
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, List, Optional
+
+from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.components.enums import RiskSegment
+
+
+@dataclass
+class ScoringConfig:
+    model_name: str
+    model_stage: str = "Production"
+    feature_table: str = "customer_features"
+    output_table: str = "churn_predictions"
+    batch_size: int = 10000
+    parallelism: int = 8
+
+
+@dataclass
+class ScoringResult:
+    predictions: DataFrame
+    total_scored: int
+    scoring_duration_seconds: float
+    model_version: Optional[str] = None
+    feature_table_version: Optional[str] = None
+    errors: List[str] = field(default_factory=list)
+
+
+class BatchScorer:
+    def __init__(self, model: Any, scaler: Any = None, threshold: float = 0.5,
+                 model_version: Optional[str] = None, batch_size: int = 10000,
+                 handle_nulls: str = "raise"):
+        self.model = model
+        self.scaler = scaler
+        self.threshold = threshold
+        self.model_version = model_version
+        self.batch_size = batch_size
+        self.handle_nulls = handle_nulls
+        self._segment_thresholds = {
+            RiskSegment.CRITICAL: 0.75,
+            RiskSegment.HIGH: 0.50,
+            RiskSegment.MEDIUM: 0.25,
+            RiskSegment.LOW: 0.0
+        }
+
+    def score(self, data: DataFrame, feature_columns: List[str],
+              id_column: str) -> ScoringResult:
+        start_time = time.time()
+        errors = []
+        missing_cols = [col for col in feature_columns if col not in data.columns]
+        if missing_cols:
+            raise ValueError(f"Missing feature columns: {missing_cols}")
+        features = data[feature_columns].copy()
+        if features.isnull().any().any():
+            if self.handle_nulls == "raise":
+                raise ValueError("Null values found in features")
+            elif self.handle_nulls == "fill_zero":
+                features = features.fillna(0)
+            elif self.handle_nulls == "fill_mean":
+                features = features.fillna(features.mean())
+        if self.scaler is not None:
+            features_scaled = self.scaler.transform(features)
+        else:
+            features_scaled = features.values
+        all_predictions = []
+        n_batches = (len(data) + self.batch_size - 1) // self.batch_size
+        for batch_idx in range(n_batches):
+            start_idx = batch_idx * self.batch_size
+            end_idx = min((batch_idx + 1) * self.batch_size, len(data))
+            batch_features = features_scaled[start_idx:end_idx]
+            batch_ids = data[id_column].iloc[start_idx:end_idx]
+            try:
+                probabilities = self.model.predict_proba(batch_features)[:, 1]
+            except Exception as e:
+                errors.append(f"Batch {batch_idx} error: {str(e)}")
+                continue
+            batch_df = pd.DataFrame({
+                "customer_id": batch_ids.values,
+                "churn_probability": probabilities,
+                "risk_segment": [self._assign_risk_segment(p) for p in probabilities],
+                "predicted_churn": (probabilities >= self.threshold).astype(int),
+                "score_timestamp": datetime.now()
+            })
+            if self.model_version:
+                batch_df["model_version"] = self.model_version
+            all_predictions.append(batch_df)
+        predictions_df = pd.concat(all_predictions, ignore_index=True) if all_predictions else pd.DataFrame()
+        duration = time.time() - start_time
+        return ScoringResult(
+            predictions=predictions_df,
+            total_scored=len(predictions_df),
+            scoring_duration_seconds=duration,
+            model_version=self.model_version,
+            errors=errors
+        )
+
+    def _assign_risk_segment(self, probability: float) -> str:
+        if probability >= self._segment_thresholds[RiskSegment.CRITICAL]:
+            return RiskSegment.CRITICAL.value
+        elif probability >= self._segment_thresholds[RiskSegment.HIGH]:
+            return RiskSegment.HIGH.value
+        elif probability >= self._segment_thresholds[RiskSegment.MEDIUM]:
+            return RiskSegment.MEDIUM.value
+        else:
+            return RiskSegment.LOW.value

customer_retention/stages/deployment/champion_challenger.py

@@ -0,0 +1,299 @@
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+from sklearn.metrics import auc, precision_recall_curve, precision_score, recall_score, roc_auc_score
+
+from customer_retention.core.compat import DataFrame, Series
+
+
+class ModelRole(Enum):
+    CHAMPION = "champion"
+    CHALLENGER = "challenger"
+    SHADOW = "shadow"
+
+
+@dataclass
+class PromotionCriteria:
+    min_pr_auc_improvement: float = 0.02
+    max_fairness_regression: float = 0.0
+    max_latency_ratio: float = 2.0
+    requires_validation_pass: bool = True
+    requires_business_approval: bool = True
+    requires_rollback_plan: bool = True
+
+
+@dataclass
+class ComparisonResult:
+    champion_metrics: Dict[str, Any]
+    challenger_metrics: Dict[str, Any]
+    pr_auc_improvement: float
+    recommendation: str
+    meets_promotion_criteria: bool
+    weighted_score_champion: Optional[float] = None
+    weighted_score_challenger: Optional[float] = None
+    fairness_comparison: Optional[Dict] = None
+    latency_comparison: Optional[Dict] = None
+    comparison_timestamp: datetime = field(default_factory=datetime.now)
+
+
+@dataclass
+class RollbackPlan:
+    current_model_name: str
+    current_version: str
+    rollback_model_name: str
+    rollback_version: str
+    estimated_duration_minutes: float = 5.0
+    steps: List[str] = field(default_factory=list)
+
+
+@dataclass
+class RollbackResult:
+    success: bool
+    from_version: str
+    to_version: str
+    duration_seconds: float
+    error: Optional[str] = None
+
+
+class ChampionChallenger:
+    def __init__(self, weights: Optional[Dict[str, float]] = None,
+                 promotion_criteria: Optional[PromotionCriteria] = None):
+        self.weights = weights or {
+            "pr_auc": 0.40,
+            "stability": 0.20,
+            "business_roi": 0.25,
+            "latency": 0.10,
+            "fairness": 0.05
+        }
+        self.promotion_criteria = promotion_criteria or PromotionCriteria()
+        self.champion = None
+        self.champion_name = None
+        self.champion_version = None
+        self.challenger = None
+        self.challenger_name = None
+        self.challenger_version = None
+        self.shadow_models: List[Dict] = []
+        self._comparison_history: List[ComparisonResult] = []
+
+    def set_champion(self, model: Any, model_name: str, version: str):
+        self.champion = model
+        self.champion_name = model_name
+        self.champion_version = version
+
+    def set_challenger(self, model: Any, model_name: str, version: str):
+        self.challenger = model
+        self.challenger_name = model_name
+        self.challenger_version = version
+
+    def add_shadow(self, model: Any, model_name: str, version: str):
+        self.shadow_models.append({
+            "model": model,
+            "name": model_name,
+            "version": version
+        })
+
+    def compare(self, X: DataFrame, y: Series,
+                protected_attribute: Optional[Series] = None,
+                include_stability: bool = False,
+                include_latency: bool = False) -> ComparisonResult:
+        champion_metrics = self._evaluate_model(self.champion, X, y, include_latency)
+        challenger_metrics = self._evaluate_model(self.challenger, X, y, include_latency)
+        if include_stability:
+            champion_metrics["cv_std"] = self._compute_stability(self.champion, X, y)
+            challenger_metrics["cv_std"] = self._compute_stability(self.challenger, X, y)
+        pr_auc_improvement = challenger_metrics["pr_auc"] - champion_metrics["pr_auc"]
+        fairness_comparison = None
+        if protected_attribute is not None:
+            fairness_comparison = self._compare_fairness(X, y, protected_attribute)
+            champion_metrics["fairness_metrics"] = fairness_comparison.get("champion")
+            challenger_metrics["fairness_metrics"] = fairness_comparison.get("challenger")
+        latency_comparison = None
+        if include_latency:
+            latency_comparison = {
+                "champion_ms": champion_metrics.get("latency_ms"),
+                "challenger_ms": challenger_metrics.get("latency_ms")
+            }
+        weighted_champion = self._compute_weighted_score(champion_metrics)
+        weighted_challenger = self._compute_weighted_score(challenger_metrics)
+        meets_criteria = self._check_promotion_criteria(
+            pr_auc_improvement, fairness_comparison, latency_comparison, champion_metrics, challenger_metrics
+        )
+        if meets_criteria and pr_auc_improvement >= self.promotion_criteria.min_pr_auc_improvement:
+            recommendation = "promote_challenger"
+        else:
+            recommendation = "keep_champion"
+        result = ComparisonResult(
+            champion_metrics=champion_metrics,
+            challenger_metrics=challenger_metrics,
+            pr_auc_improvement=pr_auc_improvement,
+            recommendation=recommendation,
+            meets_promotion_criteria=meets_criteria,
+            weighted_score_champion=weighted_champion,
+            weighted_score_challenger=weighted_challenger,
+            fairness_comparison=fairness_comparison,
+            latency_comparison=latency_comparison
+        )
+        self._comparison_history.append(result)
+        return result
+
+    def _evaluate_model(self, model: Any, X: DataFrame, y: Series,
+                        include_latency: bool = False) -> Dict[str, Any]:
+        start_time = time.time()
+        y_prob = model.predict_proba(X)[:, 1]
+        latency_ms = (time.time() - start_time) * 1000
+        y_pred = (y_prob >= 0.5).astype(int)
+        precision, recall, _ = precision_recall_curve(y, y_prob)
+        pr_auc = auc(recall, precision)
+        roc_auc = roc_auc_score(y, y_prob)
+        metrics = {
+            "pr_auc": pr_auc,
+            "roc_auc": roc_auc,
+            "precision": precision_score(y, y_pred),
+            "recall": recall_score(y, y_pred)
+        }
+        if include_latency:
+            metrics["latency_ms"] = latency_ms
+        return metrics
+
+    def _compute_stability(self, model: Any, X: DataFrame, y: Series, n_splits: int = 5) -> float:
+        from sklearn.model_selection import cross_val_score
+        scores = cross_val_score(model, X, y, cv=n_splits, scoring="roc_auc")
+        return scores.std()
+
+    def _compare_fairness(self, X: DataFrame, y: Series,
+                          protected: Series) -> Dict:
+        champion_probs = self.champion.predict_proba(X)[:, 1]
+        challenger_probs = self.challenger.predict_proba(X)[:, 1]
+        groups = protected.unique()
+        champion_fairness = {}
+        challenger_fairness = {}
+        for group in groups:
+            mask = protected == group
+            champion_fairness[group] = np.mean(champion_probs[mask])
+            challenger_fairness[group] = np.mean(challenger_probs[mask])
+        return {
+            "champion": champion_fairness,
+            "challenger": challenger_fairness
+        }
+
+    def _compute_weighted_score(self, metrics: Dict[str, Any]) -> float:
+        score = 0.0
+        if "pr_auc" in metrics:
+            score += self.weights.get("pr_auc", 0) * metrics["pr_auc"]
+        if "cv_std" in metrics:
+            stability_score = 1 - min(metrics["cv_std"] * 10, 1)
+            score += self.weights.get("stability", 0) * stability_score
+        return score
+
+    def _check_promotion_criteria(self, pr_auc_improvement: float,
+                                   fairness_comparison: Optional[Dict],
+                                   latency_comparison: Optional[Dict],
+                                   champion_metrics: Dict,
+                                   challenger_metrics: Dict) -> bool:
+        if pr_auc_improvement < self.promotion_criteria.min_pr_auc_improvement:
+            return False
+        if latency_comparison:
+            champ_latency = latency_comparison.get("champion_ms", 1)
+            chall_latency = latency_comparison.get("challenger_ms", 1)
+            if champ_latency and chall_latency:
+                if chall_latency > champ_latency * self.promotion_criteria.max_latency_ratio:
+                    return False
+        return True
+
+    def score_with_shadow(self, X: DataFrame) -> Dict[str, Any]:
+        champion_preds = self.champion.predict_proba(X)[:, 1]
+        shadow_preds = {}
+        for shadow in self.shadow_models:
+            shadow_preds[shadow["name"]] = shadow["model"].predict_proba(X)[:, 1]
+        return {
+            "champion_predictions": champion_preds,
+            "shadow_predictions": shadow_preds,
+            "active_predictions": champion_preds
+        }
+
+    def get_comparison_history(self) -> List[ComparisonResult]:
+        return self._comparison_history.copy()
+
+    def generate_report(self) -> str:
+        if not self._comparison_history:
+            return "No comparisons performed"
+        latest = self._comparison_history[-1]
+        report = f"""Champion vs Challenger Report
+=============================
+Champion Metrics:
+  PR-AUC: {latest.champion_metrics.get('pr_auc', 'N/A'):.4f}
+  ROC-AUC: {latest.champion_metrics.get('roc_auc', 'N/A'):.4f}
+
+Challenger Metrics:
+  PR-AUC: {latest.challenger_metrics.get('pr_auc', 'N/A'):.4f}
+  ROC-AUC: {latest.challenger_metrics.get('roc_auc', 'N/A'):.4f}
+
+PR-AUC Improvement: {latest.pr_auc_improvement:.4f}
+Meets Promotion Criteria: {latest.meets_promotion_criteria}
+Recommendation: {latest.recommendation}
+"""
+        return report
+
+
+class RollbackManager:
+    def __init__(self, notify_on_rollback: bool = True):
+        self.notify_on_rollback = notify_on_rollback
+
+    def create_plan(self, current_model_name: str, current_version: str,
+                    rollback_model_name: str, rollback_version: str) -> RollbackPlan:
+        steps = [
+            "1. Stop scoring with current model",
+            "2. Load rollback model from registry",
+            "3. Validate rollback model",
+            "4. Switch production pointer to rollback model",
+            "5. Notify stakeholders",
+            "6. Document incident"
+        ]
+        return RollbackPlan(
+            current_model_name=current_model_name,
+            current_version=current_version,
+            rollback_model_name=rollback_model_name,
+            rollback_version=rollback_version,
+            estimated_duration_minutes=5.0,
+            steps=steps
+        )
+
+    def execute_rollback(self, model_name: str, from_version: str,
+                         to_version: str) -> RollbackResult:
+        start_time = time.time()
+        try:
+            from customer_retention.stages.deployment.model_registry import ModelRegistry, ModelStage
+            registry = ModelRegistry()
+            registry.transition_stage(model_name, to_version, ModelStage.PRODUCTION)
+            registry.transition_stage(model_name, from_version, ModelStage.ARCHIVED)
+            if self.notify_on_rollback:
+                from customer_retention.stages.monitoring.alert_manager import Alert, AlertLevel, AlertManager
+                alert_manager = AlertManager()
+                alert = Alert(
+                    alert_id=f"rollback_{datetime.now().strftime('%Y%m%d%H%M%S')}",
+                    condition_id="ROLLBACK",
+                    level=AlertLevel.CRITICAL,
+                    message=f"Model rollback executed: {model_name} from v{from_version} to v{to_version}",
+                    timestamp=datetime.now()
+                )
+                alert_manager.send_alert(alert)
+            duration = time.time() - start_time
+            return RollbackResult(
+                success=True,
+                from_version=from_version,
+                to_version=to_version,
+                duration_seconds=duration
+            )
+        except Exception as e:
+            duration = time.time() - start_time
+            return RollbackResult(
+                success=False,
+                from_version=from_version,
+                to_version=to_version,
+                duration_seconds=duration,
+                error=str(e)
+            )