churnkit 0.75.0a1__py3-none-any.whl

churnkit-0.75.0a1.data/data/share/churnkit/exploration_notebooks/07_modeling_readiness.ipynb

@@ -0,0 +1,780 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "aed6419c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002447,
+     "end_time": "2026-02-02T13:03:35.667377",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:35.664930",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Chapter 7: Modeling Readiness\n",
+    "\n",
+    "**Purpose:** Validate that data is ready for machine learning and identify potential pitfalls.\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to assess if your data is ready for modeling\n",
+    "- How to detect potential data leakage before it ruins your model\n",
+    "- How to handle class imbalance in binary classification\n",
+    "- What preprocessing steps are needed before training\n",
+    "\n",
+    "**Outputs:**\n",
+    "- Pre-modeling validation checklist with pass/fail status\n",
+    "- Detailed leakage risk assessment (including temporal leakage)\n",
+    "- Class imbalance analysis with strategy recommendations\n",
+    "- Overall readiness score\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Why Modeling Readiness Matters\n",
+    "\n",
+    "| Issue | Impact | Detection |\n",
+    "|-------|--------|-----------|\n",
+    "| **Data Leakage** | Overly optimistic results that fail in production | High correlation with target, future information |\n",
+    "| **Class Imbalance** | Model ignores minority class | Ratio > 3:1 between classes |\n",
+    "| **Missing Values** | Model failures or bias | >50% missing in any column |\n",
+    "| **Insufficient Data** | Overfitting, poor generalization | <100 rows for simple models |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "449360f6",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002167,
+     "end_time": "2026-02-02T13:03:35.671795",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:35.669628",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.1 Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f691e37e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:35.676385Z",
+     "iopub.status.busy": "2026-02-02T13:03:35.676255Z",
+     "iopub.status.idle": "2026-02-02T13:03:37.921967Z",
+     "shell.execute_reply": "2026-02-02T13:03:37.921217Z"
+    },
+    "papermill": {
+     "duration": 2.248892,
+     "end_time": "2026-02-02T13:03:37.922664",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:35.673772",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"07_modeling_readiness.ipynb\")\n",
+    "\n",
+    "from customer_retention.analysis.auto_explorer import ExplorationFindings\n",
+    "from customer_retention.analysis.visualization import ChartBuilder, display_figure, display_table\n",
+    "from customer_retention.core.config.column_config import ColumnType\n",
+    "from customer_retention.stages.modeling import ImbalanceRecommender, ImbalanceHandler, ImbalanceStrategy\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import plotly.graph_objects as go\n",
+    "import plotly.express as px\n",
+    "from plotly.subplots import make_subplots\n",
+    "from customer_retention.core.config.experiments import FINDINGS_DIR, EXPERIMENTS_DIR, OUTPUT_DIR, setup_experiments_structure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a3b408e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:37.927421Z",
+     "iopub.status.busy": "2026-02-02T13:03:37.927148Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.207116Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.206590Z"
+    },
+    "papermill": {
+     "duration": 0.283322,
+     "end_time": "2026-02-02T13:03:38.207772",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:37.924450",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === CONFIGURATION ===\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# FINDINGS_DIR imported from customer_retention.core.config.experiments\n",
+    "\n",
+    "findings_files = [f for f in FINDINGS_DIR.glob(\"*_findings.yaml\") if \"multi_dataset\" not in f.name]\n",
+    "if not findings_files:\n",
+    "    raise FileNotFoundError(f\"No findings files found in {FINDINGS_DIR}. Run notebook 01 first.\")\n",
+    "\n",
+    "# Prefer aggregated findings (from 01d) over event-level findings\n",
+    "# Pattern: *_aggregated* in filename indicates aggregated data\n",
+    "aggregated_files = [f for f in findings_files if \"_aggregated\" in f.name]\n",
+    "non_aggregated_files = [f for f in findings_files if \"_aggregated\" not in f.name]\n",
+    "\n",
+    "if aggregated_files:\n",
+    "    # Use most recent aggregated file\n",
+    "    aggregated_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)\n",
+    "    FINDINGS_PATH = str(aggregated_files[0])\n",
+    "    print(f\"Found {len(aggregated_files)} aggregated findings file(s)\")\n",
+    "    print(f\"Using: {FINDINGS_PATH}\")\n",
+    "    if non_aggregated_files:\n",
+    "        print(f\"   (Skipping {len(non_aggregated_files)} event-level findings)\")\n",
+    "else:\n",
+    "    # Fall back to most recent non-aggregated file\n",
+    "    non_aggregated_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)\n",
+    "    FINDINGS_PATH = str(non_aggregated_files[0])\n",
+    "    print(f\"Found {len(findings_files)} findings file(s)\")\n",
+    "    print(f\"Using: {FINDINGS_PATH}\")\n",
+    "\n",
+    "findings = ExplorationFindings.load(FINDINGS_PATH)\n",
+    "\n",
+    "# Load data - handle aggregated vs standard paths\n",
+    "from customer_retention.stages.temporal import load_data_with_snapshot_preference, TEMPORAL_METADATA_COLS\n",
+    "\n",
+    "# For aggregated data, load directly from the parquet source\n",
+    "if \"_aggregated\" in FINDINGS_PATH and findings.source_path.endswith('.parquet'):\n",
+    "    source_path = Path(findings.source_path)\n",
+    "    # Handle relative path from notebook directory\n",
+    "    if not source_path.is_absolute():\n",
+    "        # The source_path in findings is relative to project root\n",
+    "        if str(source_path).startswith(\"experiments\"):\n",
+    "            source_path = Path(\"..\") / source_path\n",
+    "        else:\n",
+    "            source_path = FINDINGS_DIR / source_path.name\n",
+    "    df = pd.read_parquet(source_path)\n",
+    "    data_source = f\"aggregated:{source_path.name}\"\n",
+    "else:\n",
+    "    # Standard loading for event-level or entity-level data\n",
+    "    df, data_source = load_data_with_snapshot_preference(findings, output_dir=str(FINDINGS_DIR))\n",
+    "\n",
+    "charts = ChartBuilder()\n",
+    "\n",
+    "print(f\"\\nLoaded {len(df):,} rows from: {data_source}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b06f1920",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002205,
+     "end_time": "2026-02-02T13:03:38.211956",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.209751",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.2 Modeling Readiness Checklist"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5e2c1373",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.216137Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.216008Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.223092Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.222694Z"
+    },
+    "papermill": {
+     "duration": 0.00999,
+     "end_time": "2026-02-02T13:03:38.223767",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.213777",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "checklist = []\n",
+    "\n",
+    "has_target = findings.target_column is not None\n",
+    "checklist.append({\"Check\": \"Target column identified\", \"Status\": \"Pass\" if has_target else \"Fail\"})\n",
+    "\n",
+    "has_features = len([c for c in findings.columns.values() \n",
+    "                   if c.inferred_type not in [ColumnType.IDENTIFIER, ColumnType.TARGET]]) > 0\n",
+    "checklist.append({\"Check\": \"Feature columns available\", \"Status\": \"Pass\" if has_features else \"Fail\"})\n",
+    "\n",
+    "high_missing = any(c.universal_metrics.get(\"null_percentage\", 0) > 50 \n",
+    "                   for c in findings.columns.values())\n",
+    "checklist.append({\"Check\": \"No columns with >50% missing\", \"Status\": \"Fail\" if high_missing else \"Pass\"})\n",
+    "\n",
+    "good_quality = findings.overall_quality_score >= 70\n",
+    "checklist.append({\"Check\": \"Quality score >= 70\", \"Status\": \"Pass\" if good_quality else \"Warn\"})\n",
+    "\n",
+    "sufficient_rows = findings.row_count >= 100\n",
+    "checklist.append({\"Check\": \"Sufficient sample size (>=100)\", \"Status\": \"Pass\" if sufficient_rows else \"Fail\"})\n",
+    "\n",
+    "print(\"Modeling Readiness Checklist:\")\n",
+    "print(\"=\"*50)\n",
+    "checklist_df = pd.DataFrame(checklist)\n",
+    "display(checklist_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e7b9faa",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001522,
+     "end_time": "2026-02-02T13:03:38.227106",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.225584",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.3 Class Imbalance Analysis\n",
+    "\n",
+    "**📖 Understanding Class Imbalance:**\n",
+    "- **Ratio < 3:1** - Mild imbalance, standard methods work\n",
+    "- **Ratio 3:1 to 10:1** - Moderate imbalance, use stratified sampling + class weights\n",
+    "- **Ratio > 10:1** - Severe imbalance, consider SMOTE, undersampling, or focal loss\n",
+    "\n",
+    "**⚠️ Why It Matters:**\n",
+    "- Imbalanced data causes models to predict the majority class\n",
+    "- Accuracy is misleading (80% accuracy when 80% is majority = useless model)\n",
+    "- Use F1-score, Precision, Recall, and AUC instead of accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b9d7edc",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.231909Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.231790Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.248222Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.247617Z"
+    },
+    "papermill": {
+     "duration": 0.020094,
+     "end_time": "2026-02-02T13:03:38.248940",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.228846",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if findings.target_column:\n",
+    "    target = findings.target_column\n",
+    "    target_series = df[target]\n",
+    "    \n",
+    "    print(\"=\" * 70)\n",
+    "    print(\"CLASS IMBALANCE ANALYSIS\")\n",
+    "    print(\"=\" * 70)\n",
+    "    \n",
+    "    print(f\"\\nTarget Column: {target}\")\n",
+    "    print(f\"Target Type: {findings.target_type}\")\n",
+    "    print(f\"Missing Values: {target_series.isnull().sum()}\")\n",
+    "    \n",
+    "    if findings.target_type == \"binary\":\n",
+    "        value_counts = target_series.value_counts()\n",
+    "        majority_class = value_counts.idxmax()\n",
+    "        minority_class = value_counts.idxmin()\n",
+    "        majority_count = value_counts.max()\n",
+    "        minority_count = value_counts.min()\n",
+    "        \n",
+    "        print(f\"\\n📊 CLASS DISTRIBUTION:\")\n",
+    "        print(f\"  Majority Class ({majority_class}): {majority_count:,} ({majority_count/len(df)*100:.1f}%)\")\n",
+    "        print(f\"  Minority Class ({minority_class}): {minority_count:,} ({minority_count/len(df)*100:.1f}%)\")\n",
+    "        \n",
+    "        # Use framework recommender for strategy recommendations\n",
+    "        recommender = ImbalanceRecommender()\n",
+    "        rec = recommender.recommend(target_series, n_samples=len(df))\n",
+    "        rec.print_recommendation()\n",
+    "        \n",
+    "        # Visualize\n",
+    "        severity_colors = {\"low\": \"#2ca02c\", \"moderate\": \"#ffbb00\", \"high\": \"#ff7f0e\", \"severe\": \"#d62728\"}\n",
+    "        fig = go.Figure(go.Bar(\n",
+    "            x=['Churned (0)', 'Retained (1)'],\n",
+    "            y=[value_counts.get(0, 0), value_counts.get(1, 0)],\n",
+    "            marker_color=['#d62728', '#2ca02c'],\n",
+    "            text=[f'{value_counts.get(0, 0):,}<br>({value_counts.get(0, 0)/len(df)*100:.1f}%)',\n",
+    "                  f'{value_counts.get(1, 0):,}<br>({value_counts.get(1, 0)/len(df)*100:.1f}%)'],\n",
+    "            textposition='outside'\n",
+    "        ))\n",
+    "        fig.update_layout(\n",
+    "            title=f'Target Class Distribution ({rec.severity.upper()} imbalance: {rec.ratio:.1f}:1)',\n",
+    "            xaxis_title='Class', yaxis_title='Count',\n",
+    "            template='plotly_white', height=400\n",
+    "        )\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        # Show sklearn class weights\n",
+    "        print(f\"\\n💡 SKLEARN CLASS WEIGHTS:\")\n",
+    "        weight_minority = len(df) / (2 * minority_count)\n",
+    "        weight_majority = len(df) / (2 * majority_count)\n",
+    "        print(f\"  class_weight={{0: {weight_majority:.3f}, 1: {weight_minority:.3f}}}\")\n",
+    "        print(f\"  Or use class_weight='balanced'\")\n",
+    "        \n",
+    "        # Store recommendation for later use\n",
+    "        imbalance_recommendation = rec\n",
+    "else:\n",
+    "    print(\"ERROR: No target column identified. Please set one in findings.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9451b433",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003069,
+     "end_time": "2026-02-02T13:03:38.255316",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.252247",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.4 Data Leakage Risk Assessment\n",
+    "\n",
+    "**📖 Types of Leakage:**\n",
+    "- **Target Leakage**: Feature contains information about the target that wouldn't be available at prediction time\n",
+    "- **Train-Test Leakage**: Information from test set leaks into training (e.g., scaling before split)\n",
+    "- **Temporal Leakage**: Using future information to predict past events\n",
+    "\n",
+    "**⚠️ Warning Signs:**\n",
+    "- Correlation > 0.9 with target (suspiciously predictive)\n",
+    "- Column names containing 'future', 'outcome', 'result'\n",
+    "- Date columns that come after the target determination date"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3574ad19",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.262810Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.262698Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.279246Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.278657Z"
+    },
+    "papermill": {
+     "duration": 0.021268,
+     "end_time": "2026-02-02T13:03:38.280069",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.258801",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "leakage_risks = []\n",
+    "\n",
+    "if findings.target_column:\n",
+    "    target = findings.target_column\n",
+    "    \n",
+    "    for col_name, col_info in findings.columns.items():\n",
+    "        if col_name == target or col_info.inferred_type == ColumnType.IDENTIFIER or col_name in TEMPORAL_METADATA_COLS:\n",
+    "            continue\n",
+    "        \n",
+    "        if col_info.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]:\n",
+    "            corr = df[[col_name, target]].corr().iloc[0, 1]\n",
+    "            if abs(corr) > 0.9:\n",
+    "                leakage_risks.append({\n",
+    "                    \"Column\": col_name,\n",
+    "                    \"Risk\": \"High\",\n",
+    "                    \"Reason\": f\"Very high correlation ({corr:.3f}) - potential leakage\"\n",
+    "                })\n",
+    "        \n",
+    "        if any(kw in col_name.lower() for kw in ['future', 'outcome', 'result', 'after']):\n",
+    "            leakage_risks.append({\n",
+    "                \"Column\": col_name,\n",
+    "                \"Risk\": \"Medium\",\n",
+    "                \"Reason\": \"Name suggests post-prediction information\"\n",
+    "            })\n",
+    "\n",
+    "if leakage_risks:\n",
+    "    print(\"Potential Leakage Risks:\")\n",
+    "    display(pd.DataFrame(leakage_risks))\n",
+    "else:\n",
+    "    print(\"No obvious leakage risks detected.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f2a31f3",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003132,
+     "end_time": "2026-02-02T13:03:38.287171",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.284039",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.5 Feature Type Summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "defee56e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.294240Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.294128Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.296979Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.296492Z"
+    },
+    "papermill": {
+     "duration": 0.007292,
+     "end_time": "2026-02-02T13:03:38.297588",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.290296",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "type_summary = {}\n",
+    "for col_info in findings.columns.values():\n",
+    "    col_type = col_info.inferred_type.value\n",
+    "    type_summary[col_type] = type_summary.get(col_type, 0) + 1\n",
+    "\n",
+    "print(\"Feature Type Distribution:\")\n",
+    "for col_type, count in sorted(type_summary.items()):\n",
+    "    print(f\"  {col_type}: {count}\")\n",
+    "\n",
+    "usable_features = sum(1 for c in findings.columns.values() \n",
+    "                      if c.inferred_type not in [ColumnType.IDENTIFIER, ColumnType.TARGET])\n",
+    "print(f\"\\nUsable features for modeling: {usable_features}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e611b0f7",
+   "metadata": {
+    "papermill": {
+     "duration": 0.04253,
+     "end_time": "2026-02-02T13:03:38.343412",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.300882",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.6 Readiness Score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1ea6872",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.351535Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.351409Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.354295Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.353563Z"
+    },
+    "papermill": {
+     "duration": 0.007388,
+     "end_time": "2026-02-02T13:03:38.354961",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.347573",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "scores = []\n",
+    "\n",
+    "scores.append(25 if has_target else 0)\n",
+    "scores.append(25 if has_features else 0)\n",
+    "scores.append(25 if not high_missing else 10)\n",
+    "scores.append(25 if good_quality else 15)\n",
+    "\n",
+    "readiness_score = sum(scores)\n",
+    "\n",
+    "print(f\"\\nModeling Readiness Score: {readiness_score}/100\")\n",
+    "\n",
+    "if readiness_score >= 90:\n",
+    "    print(\"Status: READY - Proceed to modeling.\")\n",
+    "elif readiness_score >= 70:\n",
+    "    print(\"Status: MOSTLY READY - Address minor issues before modeling.\")\n",
+    "elif readiness_score >= 50:\n",
+    "    print(\"Status: NEEDS WORK - Significant issues to resolve.\")\n",
+    "else:\n",
+    "    print(\"Status: NOT READY - Major issues must be fixed first.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e24b56c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002984,
+     "end_time": "2026-02-02T13:03:38.361310",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.358326",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.7 Feature Availability Status\n",
+    "\n",
+    "Features with tracking changes (identified in notebook 06) will be excluded from modeling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d70e8643",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.368589Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.368474Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.371508Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.371048Z"
+    },
+    "papermill": {
+     "duration": 0.007445,
+     "end_time": "2026-02-02T13:03:38.372190",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.364745",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Availability Status Report\n",
+    "print(\"=\" * 70)\n",
+    "print(\"FEATURE AVAILABILITY STATUS\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "unavailable_features = findings.metadata.get(\"unavailable_features\", [])\n",
+    "if findings.has_availability_issues:\n",
+    "    print(f\"\\n⚠️  {len(findings.problematic_availability_columns)} features with tracking changes:\")\n",
+    "    for col in findings.problematic_availability_columns[:10]:\n",
+    "        info = findings.get_feature_availability(col)\n",
+    "        if info:\n",
+    "            print(f\"   • {col} ({info.availability_type}, {info.coverage_pct:.0f}% coverage)\")\n",
+    "    if len(findings.problematic_availability_columns) > 10:\n",
+    "        print(f\"   ... and {len(findings.problematic_availability_columns) - 10} more\")\n",
+    "    \n",
+    "    action = findings.metadata.get(\"availability_action\", \"exclude\")\n",
+    "    print(f\"\\n📋 Action: {action.upper()}\")\n",
+    "    print(f\"   These features will be excluded in notebook 08.\")\n",
+    "else:\n",
+    "    print(\"\\n✅ All features have full temporal coverage.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b483740",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003681,
+     "end_time": "2026-02-02T13:03:38.379463",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.375782",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Summary: What We Learned\n",
+    "\n",
+    "In this notebook, we validated modeling readiness:\n",
+    "\n",
+    "1. **Pre-modeling Checklist** - Verified target, features, missing values, and sample size\n",
+    "2. **Class Imbalance** - Analyzed distribution and provided mitigation strategies\n",
+    "3. **Leakage Assessment** - Checked for suspicious correlations and temporal issues\n",
+    "4. **Feature Summary** - Reviewed usable features by type\n",
+    "\n",
+    "## Key Actions Before Modeling\n",
+    "\n",
+    "| Action | Priority | Implementation |\n",
+    "|--------|----------|----------------|\n",
+    "| Use stratified splits | High | `train_test_split(..., stratify=y)` |\n",
+    "| Handle imbalance | High | `class_weight='balanced'` or SMOTE |\n",
+    "| Scale features | Medium | `StandardScaler` (fit on train only!) |\n",
+    "| Encode categoricals | Medium | One-hot or target encoding |\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "Continue to **08_baseline_experiments.ipynb** to:\n",
+    "- Train baseline models with proper handling\n",
+    "- Compare model performance\n",
+    "- Analyze feature importance\n",
+    "- Evaluate with appropriate metrics (not just accuracy!)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "172b0b13",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003265,
+     "end_time": "2026-02-02T13:03:38.385925",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.382660",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7.X Final Leakage Validation\n",
+    "\n",
+    "**CRITICAL:** Run comprehensive leakage checks before model training.\n",
+    "\n",
+    "This validates:\n",
+    "- No target column in features (LD052)\n",
+    "- No target-derived columns (LD052)\n",
+    "- No domain-pattern columns with high correlation (LD053)\n",
+    "- No suspiciously perfect correlations (LD001)\n",
+    "- Temporal train/test split if applicable (LD061)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60fb86d5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:38.393401Z",
+     "iopub.status.busy": "2026-02-02T13:03:38.393233Z",
+     "iopub.status.idle": "2026-02-02T13:03:38.402284Z",
+     "shell.execute_reply": "2026-02-02T13:03:38.401776Z"
+    },
+    "papermill": {
+     "duration": 0.013548,
+     "end_time": "2026-02-02T13:03:38.402821",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.389273",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Final leakage validation before model training\n",
+    "from customer_retention.analysis.diagnostics import LeakageDetector\n",
+    "\n",
+    "if 'X' in dir() and 'y' in dir():\n",
+    "    detector = LeakageDetector()\n",
+    "    result = detector.run_all_checks(X, y, include_pit=False)\n",
+    "    \n",
+    "    print(\"=\" * 70)\n",
+    "    print(\"FINAL LEAKAGE VALIDATION\")\n",
+    "    print(\"=\" * 70)\n",
+    "    \n",
+    "    if result.passed:\n",
+    "        print(\"\\n✅ PASSED: No critical leakage issues\")\n",
+    "        print(f\"   Checks run: {len(result.checks)}\")\n",
+    "        \n",
+    "        # Show warnings for HIGH severity issues\n",
+    "        high_issues = [c for c in result.checks if c.severity.value == 'high']\n",
+    "        if high_issues:\n",
+    "            print(f\"\\n⚠️ {len(high_issues)} HIGH severity warnings (review recommended):\")\n",
+    "            for issue in high_issues[:3]:\n",
+    "                print(f\"   • {issue.feature}: {issue.recommendation[:80]}...\")\n",
+    "    else:\n",
+    "        print(\"\\n❌ CRITICAL LEAKAGE DETECTED - DO NOT TRAIN MODEL\")\n",
+    "        for issue in result.critical_issues:\n",
+    "            print(f\"\\n   [{issue.check_id}] {issue.feature}\")\n",
+    "            print(f\"   {issue.recommendation}\")\n",
+    "        raise ValueError(f\"Cannot proceed: {len(result.critical_issues)} critical leakage issues\")\n",
+    "else:\n",
+    "    print(\"X and y not yet defined - run feature preparation first\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cb6819c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002913,
+     "end_time": "2026-02-02T13:03:38.409033",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:38.406120",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "> **Save Reminder:** Save this notebook (Ctrl+S / Cmd+S) before running the next one.\n",
+    "> The next notebook will automatically export this notebook's HTML documentation from the saved file."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 5.906739,
+   "end_time": "2026-02-02T13:03:41.029412",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/07_modeling_readiness.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/07_modeling_readiness.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:03:35.122673",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}