churnkit 0.75.0a1__py3-none-any.whl

customer_retention/generators/notebook_generator/stages/s05_feature_engineering.py

@@ -0,0 +1,115 @@
+from typing import List
+
+import nbformat
+
+from ..base import NotebookStage
+from .base_stage import StageGenerator
+
+
+class FeatureEngineeringStage(StageGenerator):
+    @property
+    def stage(self) -> NotebookStage:
+        return NotebookStage.FEATURE_ENGINEERING
+
+    @property
+    def title(self) -> str:
+        return "05 - Feature Engineering"
+
+    @property
+    def description(self) -> str:
+        return "Create derived features, interactions, and aggregations."
+
+    def generate_local_cells(self) -> List[nbformat.NotebookNode]:
+        return self.header_cells() + [
+            self.cb.section("Imports"),
+            self.cb.from_imports_cell({
+                "customer_retention.stages.features": ["FeatureEngineer", "FeatureEngineerConfig"],
+                "customer_retention.stages.features.temporal_features": ["TemporalFeatureGenerator", "ReferenceDateSource"],
+                "customer_retention.stages.temporal": ["PointInTimeJoiner", "SnapshotManager"],
+                "pathlib": ["Path"],
+                "pandas": ["pd"],
+                "numpy": ["np"],
+            }),
+            self.cb.section("Load Latest Training Snapshot"),
+            self.cb.code('''snapshot_manager = SnapshotManager(Path("./experiments/data"))
+latest_snapshot = snapshot_manager.get_latest_snapshot()
+if latest_snapshot:
+    df, metadata = snapshot_manager.load_snapshot(latest_snapshot)
+    print(f"Loaded snapshot: {latest_snapshot}")
+    print(f"Rows: {len(df)}, Features: {len(df.columns)}")
+else:
+    from customer_retention.integrations.adapters.factory import get_delta
+    storage = get_delta(force_local=True)
+    df = storage.read("./experiments/data/silver/customers_transformed")
+    print(f"No snapshot found, loaded transformed data: {df.shape}")'''),
+            self.cb.section("Point-in-Time Feature Engineering"),
+            self.cb.markdown('''**Important**: All temporal features are calculated relative to `feature_timestamp` to prevent data leakage.'''),
+            self.cb.code('''if "feature_timestamp" in df.columns:
+    temporal_gen = TemporalFeatureGenerator(
+        reference_date_source=ReferenceDateSource.FEATURE_TIMESTAMP,
+        created_column="signup_date" if "signup_date" in df.columns else None,
+        last_order_column="last_activity" if "last_activity" in df.columns else None,
+    )
+    df = temporal_gen.fit_transform(df)
+    print(f"Created temporal features: {temporal_gen.generated_features}")
+else:
+    print("Warning: No feature_timestamp column found. Using current date (may cause leakage).")
+    if "signup_date" in df.columns:
+        df["tenure_days"] = (pd.Timestamp.now() - pd.to_datetime(df["signup_date"])).dt.days'''),
+            self.cb.section("Validate Point-in-Time Correctness"),
+            self.cb.code('''if "feature_timestamp" in df.columns:
+    pit_report = PointInTimeJoiner.validate_temporal_integrity(df)
+    if pit_report["valid"]:
+        print("Point-in-time validation PASSED")
+    else:
+        print("Point-in-time validation FAILED:")
+        for issue in pit_report["issues"]:
+            print(f"  - {issue['type']}: {issue['message']}")'''),
+            self.cb.section("Create Interaction Features"),
+            self.cb.code('''numeric_cols = [c for c in df.select_dtypes(include=[np.number]).columns
+               if c not in ["target", "entity_id"]]
+if len(numeric_cols) >= 2:
+    for i, col1 in enumerate(numeric_cols[:3]):
+        for col2 in numeric_cols[i+1:4]:
+            df[f"{col1}_x_{col2}"] = df[col1] * df[col2]
+    print(f"Created interaction features")'''),
+            self.cb.section("Create Ratio Features"),
+            self.cb.code('''if "total_spend" in df.columns and "num_transactions" in df.columns:
+    df["avg_transaction_value"] = df["total_spend"] / (df["num_transactions"] + 1)
+    print("Created avg_transaction_value feature")'''),
+            self.cb.section("Save to Gold Layer"),
+            self.cb.code('''from customer_retention.integrations.adapters.factory import get_delta
+storage = get_delta(force_local=True)
+storage.write(df, "./experiments/data/gold/customers_features")
+print(f"Gold layer saved: {df.shape}")'''),
+        ]
+
+    def generate_databricks_cells(self) -> List[nbformat.NotebookNode]:
+        catalog = self.config.feature_store.catalog
+        schema = self.config.feature_store.schema
+        return self.header_cells() + [
+            self.cb.section("Load Transformed Data"),
+            self.cb.code(f'''df = spark.table("{catalog}.{schema}.silver_transformed")'''),
+            self.cb.section("Create Derived Features"),
+            self.cb.code('''from pyspark.sql.functions import datediff, current_date, col
+
+if "signup_date" in df.columns:
+    df = df.withColumn("tenure_days", datediff(current_date(), col("signup_date")))
+    print("Created tenure_days feature")
+
+if "last_activity" in df.columns:
+    df = df.withColumn("recency_days", datediff(current_date(), col("last_activity")))
+    print("Created recency_days feature")'''),
+            self.cb.section("Create Interaction Features"),
+            self.cb.code('''numeric_cols = [f.name for f in df.schema.fields if str(f.dataType) in ["IntegerType()", "DoubleType()", "FloatType()"]]
+if len(numeric_cols) >= 2:
+    df = df.withColumn(f"{numeric_cols[0]}_x_{numeric_cols[1]}", col(numeric_cols[0]) * col(numeric_cols[1]))
+    print("Created interaction features")'''),
+            self.cb.section("Create Ratio Features"),
+            self.cb.code('''if "total_spend" in df.columns and "num_transactions" in df.columns:
+    df = df.withColumn("avg_transaction_value", col("total_spend") / (col("num_transactions") + 1))
+    print("Created avg_transaction_value feature")'''),
+            self.cb.section("Save to Gold Table"),
+            self.cb.code(f'''df.write.format("delta").mode("overwrite").saveAsTable("{catalog}.{schema}.gold_customers")
+print("Gold table created")'''),
+        ]

customer_retention/generators/notebook_generator/stages/s06_feature_selection.py

@@ -0,0 +1,97 @@
+from typing import List
+
+import nbformat
+
+from ..base import NotebookStage
+from .base_stage import StageGenerator
+
+
+class FeatureSelectionStage(StageGenerator):
+    @property
+    def stage(self) -> NotebookStage:
+        return NotebookStage.FEATURE_SELECTION
+
+    @property
+    def title(self) -> str:
+        return "06 - Feature Selection"
+
+    @property
+    def description(self) -> str:
+        return "Select best features using variance, correlation, and importance filters."
+
+    def generate_local_cells(self) -> List[nbformat.NotebookNode]:
+        target = self.get_target_column()
+        var_thresh = self.config.variance_threshold
+        corr_thresh = self.config.correlation_threshold
+        return self.header_cells() + [
+            self.cb.section("Imports"),
+            self.cb.from_imports_cell({
+                "customer_retention.stages.features": ["FeatureSelector"],
+                "pandas": ["pd"],
+                "numpy": ["np"],
+            }),
+            self.cb.section("Load Gold Data"),
+            self.cb.code('''df = pd.read_parquet("./experiments/data/gold/customers_features.parquet")
+print(f"Input shape: {df.shape}")'''),
+            self.cb.section("Identify Feature Columns"),
+            self.cb.code(f'''target_col = "{target}"
+id_cols = {self.get_identifier_columns()}
+feature_cols = [c for c in df.columns if c not in id_cols + [target_col]]
+X = df[feature_cols]
+y = df[target_col] if target_col in df.columns else None
+print(f"Feature columns: {{len(feature_cols)}}")'''),
+            self.cb.section("Variance Filter"),
+            self.cb.code(f'''variance_threshold = {var_thresh}
+variances = X.var()
+low_variance = variances[variances < variance_threshold].index.tolist()
+print(f"Low variance features ({{len(low_variance)}}): {{low_variance[:5]}}")
+X = X.drop(columns=low_variance)'''),
+            self.cb.section("Correlation Filter"),
+            self.cb.code(f'''correlation_threshold = {corr_thresh}
+corr_matrix = X.corr().abs()
+upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
+high_corr = [c for c in upper.columns if any(upper[c] > correlation_threshold)]
+print(f"High correlation features ({{len(high_corr)}}): {{high_corr[:5]}}")
+X = X.drop(columns=high_corr)'''),
+            self.cb.section("Save Selected Features"),
+            self.cb.code('''selected_df = df[[*id_cols, *X.columns, target_col]].dropna(subset=[target_col])
+selected_df.to_parquet("./experiments/data/gold/customers_selected.parquet", index=False)
+print(f"Selected {len(X.columns)} features, saved {len(selected_df)} rows")'''),
+        ]
+
+    def generate_databricks_cells(self) -> List[nbformat.NotebookNode]:
+        catalog = self.config.feature_store.catalog
+        schema = self.config.feature_store.schema
+        target = self.get_target_column()
+        return self.header_cells() + [
+            self.cb.section("Load Gold Data"),
+            self.cb.code(f'''df = spark.table("{catalog}.{schema}.gold_customers")'''),
+            self.cb.section("Compute Feature Correlations"),
+            self.cb.code(f'''from pyspark.ml.stat import Correlation
+from pyspark.ml.feature import VectorAssembler
+
+target_col = "{target}"
+numeric_cols = [f.name for f in df.schema.fields if str(f.dataType) in ["IntegerType()", "DoubleType()", "FloatType()"] and f.name != target_col]
+
+assembler = VectorAssembler(inputCols=numeric_cols, outputCol="features", handleInvalid="skip")
+df_vec = assembler.transform(df)
+corr_matrix = Correlation.corr(df_vec, "features").head()[0].toArray()
+print(f"Correlation matrix shape: {{corr_matrix.shape}}")'''),
+            self.cb.section("Remove Highly Correlated Features"),
+            self.cb.code(f'''import numpy as np
+
+correlation_threshold = {self.config.correlation_threshold}
+to_drop = set()
+for i in range(len(corr_matrix)):
+    for j in range(i+1, len(corr_matrix)):
+        if abs(corr_matrix[i,j]) > correlation_threshold:
+            to_drop.add(numeric_cols[j])
+
+selected_cols = [c for c in numeric_cols if c not in to_drop]
+print(f"Dropped {{len(to_drop)}} highly correlated features, keeping {{len(selected_cols)}}")'''),
+            self.cb.section("Save Selected Features"),
+            self.cb.code(f'''final_cols = {self.get_identifier_columns()} + selected_cols + [target_col]
+df_selected = df.select(final_cols)
+df_selected.write.format("delta").mode("overwrite").saveAsTable("{catalog}.{schema}.gold_selected")
+print("Selected features saved")'''),
+        ]

customer_retention/generators/notebook_generator/stages/s07_model_training.py

@@ -0,0 +1,176 @@
+from typing import List
+
+import nbformat
+
+from ..base import NotebookStage
+from .base_stage import StageGenerator
+
+
+class ModelTrainingStage(StageGenerator):
+    @property
+    def stage(self) -> NotebookStage:
+        return NotebookStage.MODEL_TRAINING
+
+    @property
+    def title(self) -> str:
+        return "07 - Model Training"
+
+    @property
+    def description(self) -> str:
+        return "Train baseline models with MLflow experiment tracking."
+
+    def generate_local_cells(self) -> List[nbformat.NotebookNode]:
+        target = self.get_target_column()
+        test_size = self.config.test_size
+        exp_name = self.config.mlflow.experiment_name
+        tracking_uri = self.config.mlflow.tracking_uri
+        return self.header_cells() + [
+            self.cb.section("Imports"),
+            self.cb.from_imports_cell({
+                "customer_retention.stages.modeling": ["BaselineTrainer", "ModelEvaluator", "DataSplitter"],
+                "customer_retention.integrations.adapters": ["get_mlflow"],
+                "customer_retention.analysis.visualization": ["ChartBuilder"],
+                "customer_retention.stages.temporal": ["SnapshotManager"],
+                "customer_retention.analysis.diagnostics": ["LeakageDetector"],
+                "pathlib": ["Path"],
+                "pandas": ["pd"],
+            }),
+            self.cb.section("Load Training Snapshot"),
+            self.cb.markdown('''**Important**: We load from a versioned snapshot to ensure reproducibility and prevent data leakage.'''),
+            self.cb.code('''snapshot_manager = SnapshotManager(Path("./experiments/data"))
+latest_snapshot = snapshot_manager.get_latest_snapshot()
+
+if latest_snapshot:
+    df, snapshot_metadata = snapshot_manager.load_snapshot(latest_snapshot)
+    print(f"Loaded snapshot: {latest_snapshot}")
+    print(f"Snapshot cutoff date: {snapshot_metadata.cutoff_date}")
+    print(f"Data hash: {snapshot_metadata.data_hash}")
+    print(f"Rows: {snapshot_metadata.row_count}")
+else:
+    from customer_retention.integrations.adapters.factory import get_delta
+    storage = get_delta(force_local=True)
+    df = storage.read("./experiments/data/gold/customers_selected")
+    snapshot_metadata = None
+    print(f"Warning: No snapshot found, loading from gold layer: {df.shape}")'''),
+            self.cb.section("Prepare Train/Test Split"),
+            self.cb.code(f'''target_col = "target" if "target" in df.columns else "{target}"
+id_cols = ["entity_id"] if "entity_id" in df.columns else {self.get_identifier_columns()}
+temporal_cols = ["feature_timestamp", "label_timestamp", "label_available_flag"]
+exclude_cols = id_cols + [target_col] + temporal_cols
+
+feature_cols = [c for c in df.columns if c not in exclude_cols]
+print(f"Using {{len(feature_cols)}} features (excluded: {{exclude_cols}})")
+
+X = df[feature_cols]
+y = df[target_col]
+
+splitter = DataSplitter(test_size={test_size}, stratify=True, random_state=42)
+X_train, X_test, y_train, y_test = splitter.split(X, y)
+print(f"Train: {{len(X_train)}}, Test: {{len(X_test)}}")'''),
+            self.cb.section("Run Leakage Detection"),
+            self.cb.code('''detector = LeakageDetector()
+leakage_result = detector.run_all_checks(X_train, y_train)
+
+if not leakage_result.passed:
+    print("WARNING: Leakage detected!")
+    for issue in leakage_result.critical_issues:
+        print(f"  CRITICAL: {issue.feature} - {issue.recommendation}")
+else:
+    print("Leakage check PASSED")'''),
+            self.cb.section("Setup MLflow Tracking"),
+            self.cb.code(f'''mlflow_adapter = get_mlflow(tracking_uri="{tracking_uri}", force_local=True)
+experiment_name = "{exp_name}"
+print(f"MLflow tracking URI: {tracking_uri}")
+
+snapshot_params = {{}}
+if snapshot_metadata:
+    snapshot_params = {{
+        "snapshot_id": snapshot_metadata.snapshot_id,
+        "snapshot_version": snapshot_metadata.version,
+        "snapshot_cutoff": str(snapshot_metadata.cutoff_date),
+        "snapshot_hash": snapshot_metadata.data_hash,
+    }}'''),
+            self.cb.section("Train Baseline Models"),
+            self.cb.code('''from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+
+models = {
+    "logistic_regression": LogisticRegression(class_weight="balanced", max_iter=1000),
+    "random_forest": RandomForestClassifier(class_weight="balanced", n_estimators=100, random_state=42),
+    "gradient_boosting": GradientBoostingClassifier(n_estimators=100, random_state=42),
+}
+
+results = {}
+for name, model in models.items():
+    mlflow_adapter.start_run(experiment_name, run_name=name)
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    y_prob = model.predict_proba(X_test)[:, 1] if hasattr(model, "predict_proba") else y_pred
+
+    evaluator = ModelEvaluator()
+    metrics = evaluator.evaluate(y_test, y_pred, y_prob)
+    results[name] = {"model": model, "metrics": metrics, "y_pred": y_pred, "y_prob": y_prob}
+
+    all_params = {**model.get_params(), **snapshot_params}
+    mlflow_adapter.log_params(all_params)
+    mlflow_adapter.log_metrics(metrics)
+    mlflow_adapter.log_model(model, "model")
+    mlflow_adapter.end_run()
+    print(f"{name}: AUC={metrics.get('roc_auc', 0):.4f}, F1={metrics.get('f1', 0):.4f}")'''),
+            self.cb.section("Compare Models"),
+            self.cb.code('''charts = ChartBuilder()
+fig = charts.model_comparison_grid(results, y_test)
+fig.show()'''),
+            self.cb.section("Save Best Model"),
+            self.cb.code('''best_model_name = max(results, key=lambda k: results[k]["metrics"].get("roc_auc", 0))
+best_model = results[best_model_name]["model"]
+import joblib
+joblib.dump(best_model, "./experiments/data/models/best_model.joblib")
+print(f"Best model: {best_model_name}")'''),
+        ]
+
+    def generate_databricks_cells(self) -> List[nbformat.NotebookNode]:
+        catalog = self.config.feature_store.catalog
+        schema = self.config.feature_store.schema
+        target = self.get_target_column()
+        exp_name = self.config.mlflow.experiment_name
+        model_name = self.config.mlflow.model_name
+        return self.header_cells() + [
+            self.cb.section("Load Selected Features"),
+            self.cb.code(f'''df = spark.table("{catalog}.{schema}.gold_selected")'''),
+            self.cb.section("Prepare Features Vector"),
+            self.cb.code(f'''from pyspark.ml.feature import VectorAssembler
+
+target_col = "{target}"
+feature_cols = [c for c in df.columns if c not in {self.get_identifier_columns()} + [target_col]]
+
+assembler = VectorAssembler(inputCols=feature_cols, outputCol="features", handleInvalid="skip")
+df_ml = assembler.transform(df).select("features", target_col)
+train_df, test_df = df_ml.randomSplit([0.8, 0.2], seed=42)
+print(f"Train: {{train_df.count()}}, Test: {{test_df.count()}}")'''),
+            self.cb.section("Setup MLflow"),
+            self.cb.code(f'''import mlflow
+mlflow.set_experiment("/Users/{{spark.conf.get('spark.databricks.notebook.username', 'default')}}/{exp_name}")'''),
+            self.cb.section("Train Gradient Boosted Trees"),
+            self.cb.code(f'''from pyspark.ml.classification import GBTClassifier
+from pyspark.ml.evaluation import BinaryClassificationEvaluator
+
+with mlflow.start_run(run_name="gbt_baseline"):
+    gbt = GBTClassifier(featuresCol="features", labelCol="{target}", maxIter=100)
+    model = gbt.fit(train_df)
+
+    predictions = model.transform(test_df)
+    evaluator = BinaryClassificationEvaluator(labelCol="{target}", metricName="areaUnderROC")
+    auc = evaluator.evaluate(predictions)
+
+    mlflow.log_param("maxIter", 100)
+    mlflow.log_metric("auc_roc", auc)
+    mlflow.spark.log_model(model, "model")
+
+    run_id = mlflow.active_run().info.run_id
+    print(f"AUC: {{auc:.4f}}, Run ID: {{run_id}}")'''),
+            self.cb.section("Register Model"),
+            self.cb.code(f'''model_uri = f"runs:/{{run_id}}/model"
+mlflow.register_model(model_uri, "{catalog}.{schema}.{model_name}")
+print(f"Model registered: {catalog}.{schema}.{model_name}")'''),
+        ]

customer_retention/generators/notebook_generator/stages/s08_deployment.py

@@ -0,0 +1,81 @@
+from typing import List
+
+import nbformat
+
+from ..base import NotebookStage
+from .base_stage import StageGenerator
+
+
+class DeploymentStage(StageGenerator):
+    @property
+    def stage(self) -> NotebookStage:
+        return NotebookStage.DEPLOYMENT
+
+    @property
+    def title(self) -> str:
+        return "08 - Model Deployment"
+
+    @property
+    def description(self) -> str:
+        return "Register model to registry and promote to production."
+
+    def generate_local_cells(self) -> List[nbformat.NotebookNode]:
+        tracking_uri = self.config.mlflow.tracking_uri
+        model_name = self.config.mlflow.model_name
+        return self.header_cells() + [
+            self.cb.section("Imports"),
+            self.cb.from_imports_cell({
+                "customer_retention.stages.deployment": ["ModelRegistry", "ModelStage"],
+                "customer_retention.integrations.adapters": ["get_mlflow"],
+            }),
+            self.cb.section("Initialize Registry"),
+            self.cb.code(f'''mlflow_adapter = get_mlflow(tracking_uri="{tracking_uri}", force_local=True)
+registry = ModelRegistry(tracking_uri="{tracking_uri}")
+model_name = "{model_name}"'''),
+            self.cb.section("List Model Versions"),
+            self.cb.code('''versions = registry.list_versions(model_name)
+for v in versions:
+    print(f"Version {v.version}: Stage={v.current_stage}, Run={v.run_id}")'''),
+            self.cb.section("Validate for Promotion"),
+            self.cb.code('''latest_version = max(versions, key=lambda v: int(v.version)).version if versions else "1"
+validation = registry.validate_for_promotion(
+    model_name=model_name,
+    version=latest_version,
+    required_metrics={"roc_auc": 0.6},
+)
+print(f"Validation passed: {validation.is_valid}")
+if not validation.is_valid:
+    print(f"Errors: {validation.errors}")'''),
+            self.cb.section("Promote to Production"),
+            self.cb.code('''if validation.is_valid:
+    registry.transition_stage(model_name, latest_version, ModelStage.PRODUCTION)
+    print(f"Model {model_name} v{latest_version} promoted to Production")
+else:
+    print("Model not promoted due to validation failure")'''),
+        ]
+
+    def generate_databricks_cells(self) -> List[nbformat.NotebookNode]:
+        catalog = self.config.feature_store.catalog
+        schema = self.config.feature_store.schema
+        model_name = self.config.mlflow.model_name
+        return self.header_cells() + [
+            self.cb.section("Initialize MLflow Client"),
+            self.cb.code('''import mlflow
+from mlflow.tracking import MlflowClient
+
+client = MlflowClient()'''),
+            self.cb.section("Get Model Versions"),
+            self.cb.code(f'''model_full_name = "{catalog}.{schema}.{model_name}"
+versions = client.search_model_versions(f"name='{{model_full_name}}'")
+for v in versions:
+    print(f"Version {{v.version}}: Status={{v.status}}")'''),
+            self.cb.section("Get Latest Version"),
+            self.cb.code('''latest = max(versions, key=lambda v: int(v.version))
+print(f"Latest version: {latest.version}")'''),
+            self.cb.section("Set Production Alias"),
+            self.cb.code('''client.set_registered_model_alias(model_full_name, "production", latest.version)
+print(f"Model {model_full_name} v{latest.version} aliased as 'production'")'''),
+            self.cb.section("Verify Production Model"),
+            self.cb.code('''prod_version = client.get_model_version_by_alias(model_full_name, "production")
+print(f"Production model version: {prod_version.version}")'''),
+        ]

customer_retention/generators/notebook_generator/stages/s09_monitoring.py

@@ -0,0 +1,112 @@
+from typing import List
+
+import nbformat
+
+from ..base import NotebookStage
+from .base_stage import StageGenerator
+
+
+class MonitoringStage(StageGenerator):
+    @property
+    def stage(self) -> NotebookStage:
+        return NotebookStage.MONITORING
+
+    @property
+    def title(self) -> str:
+        return "09 - Model Monitoring"
+
+    @property
+    def description(self) -> str:
+        return "Track model performance, detect drift, and set up alerts."
+
+    def generate_local_cells(self) -> List[nbformat.NotebookNode]:
+        return self.header_cells() + [
+            self.cb.section("Imports"),
+            self.cb.from_imports_cell({
+                "customer_retention.stages.monitoring": ["PerformanceMonitor", "DriftDetector"],
+                "customer_retention.analysis.visualization": ["ChartBuilder"],
+                "pandas": ["pd"],
+                "joblib": ["joblib"],
+            }),
+            self.cb.section("Load Production Model and Test Data"),
+            self.cb.code('''model = joblib.load("./experiments/data/models/best_model.joblib")
+df_test = pd.read_parquet("./experiments/data/gold/customers_selected.parquet").sample(n=1000, random_state=42)'''),
+            self.cb.section("Generate Predictions"),
+            self.cb.code(f'''target_col = "{self.get_target_column()}"
+id_cols = {self.get_identifier_columns()}
+feature_cols = [c for c in df_test.columns if c not in id_cols + [target_col]]
+
+X_test = df_test[feature_cols]
+y_test = df_test[target_col]
+y_prob = model.predict_proba(X_test)[:, 1]
+y_pred = (y_prob >= 0.5).astype(int)'''),
+            self.cb.section("Calculate Performance Metrics"),
+            self.cb.code('''from sklearn.metrics import roc_auc_score, precision_score, recall_score, f1_score
+
+current_metrics = {
+    "roc_auc": roc_auc_score(y_test, y_prob),
+    "precision": precision_score(y_test, y_pred),
+    "recall": recall_score(y_test, y_pred),
+    "f1": f1_score(y_test, y_pred),
+}
+for name, value in current_metrics.items():
+    print(f"{name}: {value:.4f}")'''),
+            self.cb.section("Compare to Baseline"),
+            self.cb.code('''baseline_metrics = {"roc_auc": 0.75, "precision": 0.60, "recall": 0.70, "f1": 0.65}
+monitor = PerformanceMonitor(baseline_metrics)
+result = monitor.evaluate(current_metrics)
+print(f"Status: {result.status}")
+for metric, change in result.changes.items():
+    print(f"  {metric}: {change:+.2%}")'''),
+            self.cb.section("Detect Feature Drift"),
+            self.cb.code('''df_reference = pd.read_parquet("./experiments/data/gold/customers_features.parquet").sample(n=1000, random_state=0)
+drift_detector = DriftDetector()
+for col in feature_cols[:5]:
+    result = drift_detector.detect(df_reference[col], df_test[col])
+    if result.has_drift:
+        print(f"DRIFT detected in {col}: PSI={result.psi:.4f}")'''),
+        ]
+
+    def generate_databricks_cells(self) -> List[nbformat.NotebookNode]:
+        catalog = self.config.feature_store.catalog
+        schema = self.config.feature_store.schema
+        model_name = self.config.mlflow.model_name
+        target = self.get_target_column()
+        return self.header_cells() + [
+            self.cb.section("Load Model and Data"),
+            self.cb.code(f'''import mlflow
+
+model = mlflow.pyfunc.load_model(f"models:/{catalog}.{schema}.{model_name}@production")
+df_test = spark.table("{catalog}.{schema}.gold_selected").sample(0.1)'''),
+            self.cb.section("Generate Predictions"),
+            self.cb.code(f'''from pyspark.sql.functions import pandas_udf
+import pandas as pd
+
+feature_cols = [c for c in df_test.columns if c not in {self.get_identifier_columns()} + ["{target}"]]
+
+@pandas_udf("double")
+def predict_udf(*cols):
+    df = pd.concat(cols, axis=1)
+    df.columns = feature_cols
+    return pd.Series(model.predict(df))
+
+df_predictions = df_test.withColumn("prediction", predict_udf(*[df_test[c] for c in feature_cols]))
+display(df_predictions.limit(10))'''),
+            self.cb.section("Calculate Metrics"),
+            self.cb.code(f'''from pyspark.ml.evaluation import BinaryClassificationEvaluator
+
+evaluator = BinaryClassificationEvaluator(labelCol="{target}", rawPredictionCol="prediction")
+auc = evaluator.evaluate(df_predictions)
+print(f"Current AUC: {{auc:.4f}}")'''),
+            self.cb.section("Check for Drift"),
+            self.cb.code(f'''df_reference = spark.table("{catalog}.{schema}.gold_customers").sample(0.1)
+
+for col in feature_cols[:5]:
+    ref_stats = df_reference.select(col).describe().collect()
+    cur_stats = df_test.select(col).describe().collect()
+    ref_mean = float(ref_stats[1][1]) if ref_stats[1][1] else 0
+    cur_mean = float(cur_stats[1][1]) if cur_stats[1][1] else 0
+    drift_pct = abs(ref_mean - cur_mean) / (ref_mean + 1e-10) * 100
+    if drift_pct > 10:
+        print(f"DRIFT in {{col}}: {{drift_pct:.1f}}% mean shift")'''),
+        ]