churnkit 0.75.0a1__py3-none-any.whl

churnkit-0.75.0a1.data/data/share/churnkit/exploration_notebooks/03_quality_assessment.ipynb

@@ -0,0 +1,1639 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ca3d0652",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004405,
+     "end_time": "2026-02-02T13:03:07.649756",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:07.645351",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Chapter 3: Quality Assessment\n",
+    "\n",
+    "**Purpose:** Deep dive into data quality issues with actionable remediation strategies.\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to analyze missing value patterns (MCAR vs MAR vs MNAR)\n",
+    "- How to detect and handle outliers using IQR method\n",
+    "- How to validate date sequences and binary fields\n",
+    "- How to implement data cleanup strategies\n",
+    "\n",
+    "**Outputs:**\n",
+    "- Missing value analysis with correlation patterns\n",
+    "- Outlier detection with visualization\n",
+    "- Date logic validation results\n",
+    "- Binary field validation\n",
+    "- Cleanup code examples ready to use\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Quality Assessment Framework\n",
+    "\n",
+    "| Issue Type | Detection Method | Common Solutions |\n",
+    "|------------|-----------------|------------------|\n",
+    "| Missing Values | Null counts, pattern analysis | Impute (mean/median/mode), drop, flag |\n",
+    "| Outliers | IQR, Z-score, isolation forest | Cap/clip, winsorize, transform, keep (if valid) |\n",
+    "| Date Logic | Sequence validation | Set placeholders to NULL, exclude invalid |\n",
+    "| Duplicates | Key uniqueness | Drop exact, keep most recent |\n",
+    "| Invalid Values | Range/domain checks | Correct, flag, exclude |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1f1da83",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003187,
+     "end_time": "2026-02-02T13:03:07.656354",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:07.653167",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.1 Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "535ea851",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:07.663333Z",
+     "iopub.status.busy": "2026-02-02T13:03:07.663186Z",
+     "iopub.status.idle": "2026-02-02T13:03:09.560231Z",
+     "shell.execute_reply": "2026-02-02T13:03:09.559246Z"
+    },
+    "papermill": {
+     "duration": 1.901811,
+     "end_time": "2026-02-02T13:03:09.561381",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:07.659570",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"03_quality_assessment.ipynb\")\n",
+    "\n",
+    "from customer_retention.analysis.auto_explorer import ExplorationFindings, RecommendationRegistry\n",
+    "from customer_retention.analysis.visualization import ChartBuilder, display_figure, display_table\n",
+    "from customer_retention.core.config.column_config import ColumnType\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": "cc3eca88",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:09.567940Z",
+     "iopub.status.busy": "2026-02-02T13:03:09.567768Z",
+     "iopub.status.idle": "2026-02-02T13:03:09.911965Z",
+     "shell.execute_reply": "2026-02-02T13:03:09.910742Z"
+    },
+    "papermill": {
+     "duration": 0.349377,
+     "end_time": "2026-02-02T13:03:09.913686",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.564309",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === CONFIGURATION ===\n",
+    "# Option 1: Set the exact path from notebook 01 output\n",
+    "# FINDINGS_PATH = \"../experiments/findings/customer_retention_retail_abc123_findings.yaml\"\n",
+    "\n",
+    "# Option 2: Auto-discover the most recent findings file\n",
+    "from pathlib import Path\n",
+    "import yaml\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",
+    "print(f\"Loaded data from: {data_source}\")\n",
+    "print(f\"Shape: {df.shape}\")\n",
+    "\n",
+    "charts = ChartBuilder()\n",
+    "\n",
+    "# Load or initialize recommendation registry\n",
+    "RECOMMENDATIONS_PATH = FINDINGS_PATH.replace(\"_findings.yaml\", \"_recommendations.yaml\")\n",
+    "if Path(RECOMMENDATIONS_PATH).exists():\n",
+    "    with open(RECOMMENDATIONS_PATH, \"r\") as f:\n",
+    "        registry = RecommendationRegistry.from_dict(yaml.safe_load(f))\n",
+    "    print(f\"Loaded existing recommendations from: {RECOMMENDATIONS_PATH}\")\n",
+    "else:\n",
+    "    registry = RecommendationRegistry()\n",
+    "    registry.init_bronze(findings.source_path)\n",
+    "    if findings.target_column:\n",
+    "        registry.init_gold(findings.target_column)\n",
+    "    entity_col = next((name for name, col in findings.columns.items() if col.inferred_type == ColumnType.IDENTIFIER), None)\n",
+    "    if entity_col:\n",
+    "        registry.init_silver(entity_col)\n",
+    "    print(f\"Initialized new recommendation registry\")\n",
+    "\n",
+    "print(f\"\\nLoaded findings for {findings.column_count} columns\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59b3ad0b",
+   "metadata": {
+    "papermill": {
+     "duration": 0.013553,
+     "end_time": "2026-02-02T13:03:09.939162",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.925609",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.2 Duplicate Analysis\n",
+    "\n",
+    "**📖 Why This Matters:**\n",
+    "- Duplicate records can skew statistics and model training\n",
+    "- Key column duplicates may indicate data quality issues or event-level data\n",
+    "- Value conflicts (same key, different values) require investigation\n",
+    "\n",
+    "**What to Watch For:**\n",
+    "- **Exact duplicates**: Identical rows that should be deduplicated\n",
+    "- **Key duplicates**: Same identifier with different values (may indicate updates or errors)\n",
+    "- **Value conflicts**: Same key with conflicting values in important columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f9cfd2a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:09.946458Z",
+     "iopub.status.busy": "2026-02-02T13:03:09.946297Z",
+     "iopub.status.idle": "2026-02-02T13:03:09.974018Z",
+     "shell.execute_reply": "2026-02-02T13:03:09.973191Z"
+    },
+    "papermill": {
+     "duration": 0.032066,
+     "end_time": "2026-02-02T13:03:09.974707",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.942641",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.validation import DataValidator\n",
+    "\n",
+    "validator = DataValidator()\n",
+    "\n",
+    "# Auto-detect potential key columns\n",
+    "potential_keys = [name for name, col in findings.columns.items() \n",
+    "                  if col.inferred_type.value in ('identifier', 'id') or 'id' in name.lower()]\n",
+    "KEY_COLUMN = potential_keys[0] if potential_keys else None\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"DUPLICATE ANALYSIS\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "if KEY_COLUMN:\n",
+    "    dup_result = validator.check_duplicates(df, key_column=KEY_COLUMN, check_value_conflicts=True)\n",
+    "    print(f\"\\nKey Column: {KEY_COLUMN}\")\n",
+    "    print(f\"Total Rows: {dup_result.total_rows:,}\")\n",
+    "    print(f\"Unique Keys: {dup_result.unique_keys:,}\")\n",
+    "    print(f\"Duplicate Keys: {dup_result.duplicate_keys:,} ({dup_result.duplicate_percentage:.2f}%)\")\n",
+    "    \n",
+    "    # Exact duplicates\n",
+    "    if dup_result.exact_duplicate_rows > 0:\n",
+    "        print(f\"\\n⚠️ Exact duplicate rows: {dup_result.exact_duplicate_rows:,}\")\n",
+    "        dup_mask = df.duplicated(keep=False)\n",
+    "        dup_examples = df[dup_mask].head(6)\n",
+    "        if len(dup_examples) > 0:\n",
+    "            print(\"\\nExample duplicate rows:\")\n",
+    "            display(dup_examples)\n",
+    "        \n",
+    "        # Add deduplication recommendation for exact duplicates\n",
+    "        registry.add_bronze_deduplication(\n",
+    "            key_column=KEY_COLUMN, strategy=\"drop_exact_duplicates\",\n",
+    "            rationale=f\"{dup_result.exact_duplicate_rows} exact duplicate rows detected\",\n",
+    "            source_notebook=\"03_quality_assessment\"\n",
+    "        )\n",
+    "    else:\n",
+    "        print(\"\\n✓ No exact duplicate rows\")\n",
+    "    \n",
+    "    # Value conflicts\n",
+    "    if dup_result.has_value_conflicts:\n",
+    "        print(f\"\\n⚠️ Value conflicts detected in: {', '.join(dup_result.conflict_columns[:5])}\")\n",
+    "        if findings.target_column and findings.target_column in dup_result.conflict_columns:\n",
+    "            print(f\"   🔴 CRITICAL: Target '{findings.target_column}' has conflicting values!\")\n",
+    "        \n",
+    "        # Show examples of conflicting records\n",
+    "        key_counts = df[KEY_COLUMN].value_counts()\n",
+    "        dup_keys = key_counts[key_counts > 1].head(3).index.tolist()\n",
+    "        if dup_keys:\n",
+    "            print(\"\\nExample records with duplicate keys:\")\n",
+    "            conflict_examples = df[df[KEY_COLUMN].isin(dup_keys)].sort_values(KEY_COLUMN).head(10)\n",
+    "            display(conflict_examples)\n",
+    "        \n",
+    "        # Add deduplication recommendation for value conflicts\n",
+    "        registry.add_bronze_deduplication(\n",
+    "            key_column=KEY_COLUMN, strategy=\"keep_first\",\n",
+    "            rationale=f\"Value conflicts in {len(dup_result.conflict_columns)} columns\",\n",
+    "            source_notebook=\"03_quality_assessment\",\n",
+    "            conflict_columns=dup_result.conflict_columns[:5]\n",
+    "        )\n",
+    "    else:\n",
+    "        print(\"\\n✓ No value conflicts\")\n",
+    "    \n",
+    "    # Duplicate frequency distribution\n",
+    "    if dup_result.duplicate_keys > 0:\n",
+    "        key_counts = df[KEY_COLUMN].value_counts()\n",
+    "        dup_distribution = key_counts[key_counts > 1].value_counts().sort_index()\n",
+    "        if len(dup_distribution) > 0:\n",
+    "            print(\"\\nDuplicate frequency distribution:\")\n",
+    "            for count, num_keys in dup_distribution.head(5).items():\n",
+    "                print(f\"   Keys appearing {count}x: {num_keys:,}\")\n",
+    "        \n",
+    "        # Recommendations\n",
+    "        print(\"\\n💡 RECOMMENDATIONS:\")\n",
+    "        if dup_result.exact_duplicate_rows > 0:\n",
+    "            print(\"   • Remove exact duplicates: df.drop_duplicates()\")\n",
+    "        if dup_result.has_value_conflicts:\n",
+    "            print(\"   • For value conflicts, decide strategy:\")\n",
+    "            print(\"     - Keep most recent (if you have a timestamp)\")\n",
+    "            print(\"     - Keep first occurrence: df.drop_duplicates(subset=[KEY_COLUMN], keep='first')\")\n",
+    "            print(\"     - Aggregate values (for numeric columns)\")\n",
+    "else:\n",
+    "    print(\"\\n⚠️ No key column detected.\")\n",
+    "    print(\"   Set KEY_COLUMN above to enable duplicate analysis.\")\n",
+    "    print(f\"   Available columns: {list(findings.columns.keys())[:10]}...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d721d97",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002453,
+     "end_time": "2026-02-02T13:03:09.979923",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.977470",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.3 Overall Quality Score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07cf69d3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:09.985987Z",
+     "iopub.status.busy": "2026-02-02T13:03:09.985856Z",
+     "iopub.status.idle": "2026-02-02T13:03:09.988654Z",
+     "shell.execute_reply": "2026-02-02T13:03:09.988009Z"
+    },
+    "papermill": {
+     "duration": 0.006462,
+     "end_time": "2026-02-02T13:03:09.989094",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.982632",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(f\"Overall Quality Score: {findings.overall_quality_score:.1f}/100\")\n",
+    "\n",
+    "if findings.overall_quality_score >= 90:\n",
+    "    print(\"Excellent: Data is high quality and ready for modeling.\")\n",
+    "elif findings.overall_quality_score >= 70:\n",
+    "    print(\"Good: Minor quality issues that should be addressed.\")\n",
+    "elif findings.overall_quality_score >= 50:\n",
+    "    print(\"Fair: Significant quality issues require attention.\")\n",
+    "else:\n",
+    "    print(\"Poor: Major quality issues must be resolved before modeling.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09263313",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002372,
+     "end_time": "2026-02-02T13:03:09.994362",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.991990",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.4 Target Variable Analysis\n",
+    "\n",
+    "Understanding target distribution is critical for:\n",
+    "- **Class imbalance** affects model training and evaluation metrics\n",
+    "- **Business context** helps interpret what we're trying to predict\n",
+    "- **Sampling strategies** depend on imbalance severity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d56ad81",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.000690Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.000575Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.039386Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.038940Z"
+    },
+    "papermill": {
+     "duration": 0.042715,
+     "end_time": "2026-02-02T13:03:10.039982",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:09.997267",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"=\" * 60)\n",
+    "print(f\"TARGET VARIABLE DISTRIBUTION: {findings.target_column}\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "if findings.target_column and findings.target_column in df.columns:\n",
+    "    target_series = df[findings.target_column]\n",
+    "    target_counts = target_series.value_counts().sort_index()\n",
+    "    \n",
+    "    # Create distribution table\n",
+    "    dist_data = []\n",
+    "    for val, count in target_counts.items():\n",
+    "        pct = count / len(df) * 100\n",
+    "        dist_data.append({\n",
+    "            findings.target_column: val,\n",
+    "            \"count\": count,\n",
+    "            \"percentage\": f\"{pct:.3f}\"\n",
+    "        })\n",
+    "    \n",
+    "    dist_df = pd.DataFrame(dist_data)\n",
+    "    display(dist_df)\n",
+    "    \n",
+    "    # Calculate imbalance metrics\n",
+    "    if len(target_counts) == 2:\n",
+    "        majority = target_counts.max()\n",
+    "        minority = target_counts.min()\n",
+    "        minority_class = target_counts.idxmin()\n",
+    "        imbalance_ratio = majority / minority\n",
+    "        retention_rate = target_counts.get(1, 0) / len(df) * 100\n",
+    "        \n",
+    "        print(f\"\\nImbalance ratio: {imbalance_ratio:.2f}:1 (minority class: {minority_class})\")\n",
+    "        print(f\"Retention rate: {retention_rate:.1f}%\")\n",
+    "        \n",
+    "        # Business context\n",
+    "        if retention_rate > 70:\n",
+    "            print(f\"\\n📊 Business Context: {retention_rate:.0f}% retention is healthy!\")\n",
+    "            print(\"   Churned customers are the minority class we want to predict.\")\n",
+    "        elif retention_rate > 50:\n",
+    "            print(f\"\\n📊 Business Context: {retention_rate:.0f}% retention is moderate.\")\n",
+    "            print(\"   Balanced focus on both retention and churn prediction.\")\n",
+    "        else:\n",
+    "            print(f\"\\n⚠️ Business Context: {retention_rate:.0f}% retention is concerning!\")\n",
+    "            print(\"   High churn rate requires urgent attention.\")\n",
+    "        \n",
+    "        # Modeling recommendations based on imbalance\n",
+    "        print(\"\\n⚠️  Class imbalance considerations for modeling:\")\n",
+    "        print(\"   - Use stratified sampling for train/test splits\")\n",
+    "        print(\"   - Consider class weights in model training\")\n",
+    "        print(\"   - Evaluate with Precision-Recall AUC (not just ROC-AUC)\")\n",
+    "        print(\"   - Focus on recall for churned class (catch at-risk customers)\")\n",
+    "        \n",
+    "        # Add imbalance strategy recommendation\n",
+    "        if imbalance_ratio < 3:\n",
+    "            strategy = \"stratified_sampling\"\n",
+    "            rationale = f\"Mild imbalance ({imbalance_ratio:.2f}:1) - stratified sampling sufficient\"\n",
+    "            print(\"   - SMOTE not needed (imbalance is mild)\")\n",
+    "        elif imbalance_ratio < 5:\n",
+    "            strategy = \"class_weights\"\n",
+    "            rationale = f\"Moderate imbalance ({imbalance_ratio:.2f}:1) - use class weights\"\n",
+    "            print(\"   - SMOTE may not be necessary (imbalance is moderate)\")\n",
+    "        else:\n",
+    "            strategy = \"smote\"\n",
+    "            rationale = f\"Severe imbalance ({imbalance_ratio:.2f}:1) - consider SMOTE\"\n",
+    "            print(\"   - Consider SMOTE or undersampling (imbalance is severe)\")\n",
+    "        \n",
+    "        registry.add_bronze_imbalance_strategy(\n",
+    "            target_column=findings.target_column,\n",
+    "            imbalance_ratio=imbalance_ratio,\n",
+    "            minority_class=minority_class,\n",
+    "            strategy=strategy,\n",
+    "            rationale=rationale,\n",
+    "            source_notebook=\"03_quality_assessment\"\n",
+    "        )\n",
+    "        \n",
+    "        # Visualization\n",
+    "        fig = make_subplots(rows=1, cols=2, specs=[[{\"type\": \"pie\"}, {\"type\": \"bar\"}]],\n",
+    "                           subplot_titles=[\"Class Distribution\", \"Count Comparison\"])\n",
+    "        \n",
+    "        labels = [f\"{'Retained' if v == 1 else 'Churned'} ({v})\" for v in target_counts.index]\n",
+    "        fig.add_trace(go.Pie(labels=labels, values=target_counts.values, hole=0.4,\n",
+    "                            marker_colors=[\"#2ecc71\", \"#e74c3c\"]), row=1, col=1)\n",
+    "        fig.add_trace(go.Bar(x=labels, y=target_counts.values,\n",
+    "                            marker_color=[\"#e74c3c\", \"#2ecc71\"]), row=1, col=2)\n",
+    "        \n",
+    "        fig.update_layout(height=350, title_text=\"Target Variable Distribution\",\n",
+    "                         showlegend=False, template=\"plotly_white\")\n",
+    "        display_figure(fig)\n",
+    "    else:\n",
+    "        print(f\"\\nMulticlass target with {len(target_counts)} classes\")\n",
+    "        \n",
+    "        fig = go.Figure(go.Bar(x=[str(v) for v in target_counts.index], y=target_counts.values,\n",
+    "                               marker_color=px.colors.qualitative.Set2[:len(target_counts)]))\n",
+    "        fig.update_layout(height=350, title_text=\"Target Variable Distribution\",\n",
+    "                         xaxis_title=findings.target_column, yaxis_title=\"Count\",\n",
+    "                         template=\"plotly_white\")\n",
+    "        display_figure(fig)\n",
+    "else:\n",
+    "    print(\"\\n⚠️ No target column detected or specified.\")\n",
+    "    print(\"   Set target_hint parameter in DataExplorer.explore() or\")\n",
+    "    print(\"   manually specify in findings.target_column\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baab5f1d",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004319,
+     "end_time": "2026-02-02T13:03:10.048550",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.044231",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.5 Missing Value Analysis\n",
+    "\n",
+    "**📖 Interpretation Guide:**\n",
+    "- **MCAR (Missing Completely at Random)**: Missing values have no pattern - safe to impute with mean/median\n",
+    "- **MAR (Missing at Random)**: Missingness depends on other observed variables - use regression imputation\n",
+    "- **MNAR (Missing Not at Random)**: Missingness depends on the missing value itself - create missing indicator\n",
+    "\n",
+    "**⚠️ What to Watch For:**\n",
+    "- Columns with >50% missing may need to be dropped\n",
+    "- Highly correlated missing patterns suggest MAR\n",
+    "- ID columns with missing values indicate data integrity issues"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee46fd0c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.058874Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.058751Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.072668Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.072279Z"
+    },
+    "papermill": {
+     "duration": 0.019481,
+     "end_time": "2026-02-02T13:03:10.073214",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.053733",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "missing_data = []\n",
+    "for col_name, col_info in findings.columns.items():\n",
+    "    null_count = col_info.universal_metrics.get(\"null_count\", 0)\n",
+    "    null_pct = col_info.universal_metrics.get(\"null_percentage\", 0)\n",
+    "    if null_count > 0:\n",
+    "        missing_data.append({\n",
+    "            \"Column\": col_name,\n",
+    "            \"Missing Count\": null_count,\n",
+    "            \"Missing %\": f\"{null_pct:.2f}%\"\n",
+    "        })\n",
+    "\n",
+    "if missing_data:\n",
+    "    missing_df = pd.DataFrame(missing_data).sort_values(\"Missing Count\", ascending=False)\n",
+    "    print(\"Columns with Missing Values:\")\n",
+    "    display(missing_df)\n",
+    "    \n",
+    "    fig = charts.bar_chart(\n",
+    "        missing_df[\"Column\"].tolist(),\n",
+    "        [float(x.replace(\"%\", \"\")) for x in missing_df[\"Missing %\"].tolist()],\n",
+    "        title=\"Missing Value Percentage by Column\"\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "else:\n",
+    "    print(\"No missing values detected.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c921e28e",
+   "metadata": {
+    "papermill": {
+     "duration": 0.011155,
+     "end_time": "2026-02-02T13:03:10.090497",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.079342",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.6 Missing Value Patterns\n",
+    "\n",
+    "**📖 How to Read the Correlation Heatmap:**\n",
+    "- **Correlation = 1.0**: Columns always missing together (same rows)\n",
+    "- **Correlation > 0.5**: Strong pattern - investigate the relationship\n",
+    "- **Correlation ≈ 0**: Independent missing patterns (MCAR likely)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c48c133b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.118334Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.118209Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.167892Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.167167Z"
+    },
+    "papermill": {
+     "duration": 0.059538,
+     "end_time": "2026-02-02T13:03:10.168456",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.108918",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "missing_matrix = df.isnull()\n",
+    "missing_correlations = missing_matrix.corr()\n",
+    "\n",
+    "cols_with_missing = [col for col in df.columns if df[col].isnull().any()]\n",
+    "if len(cols_with_missing) > 1:\n",
+    "    print(\"Missing Value Correlations (MCAR vs MAR analysis):\")\n",
+    "    fig = charts.heatmap(\n",
+    "        missing_correlations.loc[cols_with_missing, cols_with_missing].values,\n",
+    "        x_labels=cols_with_missing,\n",
+    "        y_labels=cols_with_missing,\n",
+    "        title=\"Missing Value Pattern Correlation\"\n",
+    "    )\n",
+    "    display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c56db113",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00733,
+     "end_time": "2026-02-02T13:03:10.183880",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.176550",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.7 Segment-Aware Outlier Analysis\n",
+    "\n",
+    "**📖 Why Segment Before Detecting Outliers?**\n",
+    "\n",
+    "Global outlier detection can produce **false positives** when data contains natural segments:\n",
+    "- **Retail vs Enterprise customers**: Order values of $5K may be outliers for retail but normal for enterprise\n",
+    "- **New vs Established accounts**: Activity patterns differ dramatically by customer tenure\n",
+    "- **Geographic segments**: Regional price differences can appear as outliers globally\n",
+    "\n",
+    "**⚠️ The Risk:**\n",
+    "If you remove \"outliers\" that are actually valid data from a different segment, you lose critical patterns needed for accurate modeling.\n",
+    "\n",
+    "**📊 What This Analysis Does:**\n",
+    "1. Detects natural data segments (using clustering or explicit segment columns)\n",
+    "2. Compares global outliers vs segment-specific outliers\n",
+    "3. Identifies \"false outliers\" - values flagged globally but normal within their segment\n",
+    "4. Recommends whether segment-specific outlier treatment is beneficial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74cff73c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.199709Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.199576Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.536146Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.535137Z"
+    },
+    "papermill": {
+     "duration": 0.345634,
+     "end_time": "2026-02-02T13:03:10.537088",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.191454",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.profiling import SegmentAwareOutlierAnalyzer\n",
+    "\n",
+    "print(\"=\" * 80)\n",
+    "print(\"SEGMENT-AWARE OUTLIER ANALYSIS\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "# Get numeric columns for analysis\n",
+    "numeric_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]\n",
+    "    and name not in TEMPORAL_METADATA_COLS\n",
+    "]\n",
+    "\n",
+    "# === CONFIGURATION ===\n",
+    "# Option 1: Specify an explicit segment column if you have one (e.g., customer_type, region)\n",
+    "SEGMENT_COL = None  # e.g., \"customer_segment\", \"account_type\"\n",
+    "\n",
+    "# Option 2: Load from findings metadata if saved in previous notebook\n",
+    "if SEGMENT_COL is None and \"segment_column\" in findings.metadata:\n",
+    "    SEGMENT_COL = findings.metadata[\"segment_column\"]\n",
+    "    print(f\"Using segment column from findings: {SEGMENT_COL}\")\n",
+    "\n",
+    "if numeric_cols:\n",
+    "    analyzer = SegmentAwareOutlierAnalyzer(max_segments=5)\n",
+    "    \n",
+    "    # Run segment-aware analysis\n",
+    "    segment_result = analyzer.analyze(\n",
+    "        df,\n",
+    "        feature_cols=numeric_cols,\n",
+    "        segment_col=SEGMENT_COL,\n",
+    "        target_col=findings.target_column\n",
+    "    )\n",
+    "    \n",
+    "    print(f\"\\n📊 SEGMENTATION RESULTS:\")\n",
+    "    print(f\"   Segments detected: {segment_result.n_segments}\")\n",
+    "    \n",
+    "    if segment_result.n_segments > 1:\n",
+    "        print(f\"\\n📈 GLOBAL VS SEGMENT OUTLIER COMPARISON:\")\n",
+    "        print(\"-\" * 60)\n",
+    "        \n",
+    "        comparison_data = []\n",
+    "        for col in numeric_cols:\n",
+    "            global_outliers = segment_result.global_analysis[col].outliers_detected\n",
+    "            segment_outliers = sum(\n",
+    "                seg[col].outliers_detected \n",
+    "                for seg in segment_result.segment_analysis.values()\n",
+    "                if col in seg\n",
+    "            )\n",
+    "            false_outliers = segment_result.false_outliers.get(col, 0)\n",
+    "            \n",
+    "            if global_outliers > 0:\n",
+    "                reduction_pct = (global_outliers - segment_outliers) / global_outliers * 100\n",
+    "                false_pct = false_outliers / global_outliers * 100\n",
+    "            else:\n",
+    "                reduction_pct = 0\n",
+    "                false_pct = 0\n",
+    "            \n",
+    "            comparison_data.append({\n",
+    "                \"Feature\": col,\n",
+    "                \"Global Outliers\": global_outliers,\n",
+    "                \"Segment Outliers\": segment_outliers,\n",
+    "                \"False Outliers\": false_outliers,\n",
+    "                \"Reduction\": f\"{reduction_pct:.1f}%\"\n",
+    "            })\n",
+    "        \n",
+    "        comparison_df = pd.DataFrame(comparison_data)\n",
+    "        display(comparison_df)\n",
+    "        \n",
+    "        # Show false outlier analysis\n",
+    "        has_false_outliers = any(segment_result.false_outliers.get(col, 0) > 0 for col in numeric_cols)\n",
+    "        \n",
+    "        if has_false_outliers:\n",
+    "            print(\"\\n⚠️ FALSE OUTLIERS DETECTED:\")\n",
+    "            print(\"   (Global outliers that are normal within their segment)\")\n",
+    "            for col, count in segment_result.false_outliers.items():\n",
+    "                if count > 0:\n",
+    "                    global_count = segment_result.global_analysis[col].outliers_detected\n",
+    "                    pct = count / global_count * 100 if global_count > 0 else 0\n",
+    "                    print(f\"   • {col}: {count} false outliers ({pct:.1f}% of global)\")\n",
+    "        \n",
+    "        # Recommendations\n",
+    "        print(\"\\n💡 RECOMMENDATIONS:\")\n",
+    "        if segment_result.segmentation_recommended:\n",
+    "            print(\"   ✅ SEGMENT-SPECIFIC OUTLIER TREATMENT RECOMMENDED\")\n",
+    "            for rec in segment_result.recommendations:\n",
+    "                print(f\"      • {rec}\")\n",
+    "            \n",
+    "            # Add outlier recommendations for columns with high false outlier rate\n",
+    "            for col, count in segment_result.false_outliers.items():\n",
+    "                if count > 0:\n",
+    "                    global_count = segment_result.global_analysis[col].outliers_detected\n",
+    "                    false_pct = count / global_count * 100 if global_count > 0 else 0\n",
+    "                    if false_pct > 50:  # High false outlier rate\n",
+    "                        registry.add_bronze_outlier(\n",
+    "                            column=col, action=\"segment_aware_cap\",\n",
+    "                            parameters={\"method\": \"segment_iqr\", \"n_segments\": segment_result.n_segments},\n",
+    "                            rationale=f\"{false_pct:.0f}% of global outliers are segment-normal\",\n",
+    "                            source_notebook=\"03_quality_assessment\"\n",
+    "                        )\n",
+    "        else:\n",
+    "            print(\"   ℹ️ Global outlier treatment is appropriate for this data\")\n",
+    "        \n",
+    "        # Rationale\n",
+    "        print(\"\\n📋 RATIONALE:\")\n",
+    "        for rationale in segment_result.rationale:\n",
+    "            print(f\"   • {rationale}\")\n",
+    "        \n",
+    "        # Visualization: Compare outlier counts\n",
+    "        cols_with_diff = [\n",
+    "            row[\"Feature\"] for _, row in comparison_df.iterrows()\n",
+    "            if row[\"Global Outliers\"] > 0 and row[\"Global Outliers\"] != row[\"Segment Outliers\"]\n",
+    "        ]\n",
+    "        \n",
+    "        if cols_with_diff and len(cols_with_diff) <= 8:\n",
+    "            fig = go.Figure()\n",
+    "            \n",
+    "            global_counts = [comparison_df[comparison_df[\"Feature\"] == c][\"Global Outliers\"].values[0] for c in cols_with_diff]\n",
+    "            segment_counts = [comparison_df[comparison_df[\"Feature\"] == c][\"Segment Outliers\"].values[0] for c in cols_with_diff]\n",
+    "            \n",
+    "            fig.add_trace(go.Bar(name=\"Global Outliers\", x=cols_with_diff, y=global_counts, marker_color=\"#e74c3c\"))\n",
+    "            fig.add_trace(go.Bar(name=\"Segment Outliers\", x=cols_with_diff, y=segment_counts, marker_color=\"#2ecc71\"))\n",
+    "            \n",
+    "            fig.update_layout(\n",
+    "                barmode=\"group\",\n",
+    "                title=\"Global vs Segment-Specific Outlier Detection\",\n",
+    "                xaxis_title=\"Feature\",\n",
+    "                yaxis_title=\"Outlier Count\",\n",
+    "                template=\"plotly_white\",\n",
+    "                height=400\n",
+    "            )\n",
+    "            display_figure(fig)\n",
+    "    else:\n",
+    "        print(\"\\n   ℹ️ Data appears homogeneous (single segment)\")\n",
+    "        print(\"   → Proceeding with standard global outlier detection\")\n",
+    "    \n",
+    "    # Store result in findings metadata for use in later notebooks\n",
+    "    findings.metadata[\"segment_aware_analysis\"] = {\n",
+    "        \"n_segments\": segment_result.n_segments,\n",
+    "        \"segmentation_recommended\": segment_result.segmentation_recommended,\n",
+    "        \"recommendations\": segment_result.recommendations\n",
+    "    }\n",
+    "else:\n",
+    "    print(\"\\nNo numeric columns to analyze for outliers.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6472d7a4",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008068,
+     "end_time": "2026-02-02T13:03:10.552669",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.544601",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.8 Global Outlier Detection\n",
+    "\n",
+    "**📖 IQR Method Explained:**\n",
+    "- **Q1** = 25th percentile, **Q3** = 75th percentile\n",
+    "- **IQR** = Q3 - Q1 (the middle 50% of data)\n",
+    "- **Lower Bound** = Q1 - 1.5 × IQR\n",
+    "- **Upper Bound** = Q3 + 1.5 × IQR\n",
+    "- Values outside these bounds are considered outliers\n",
+    "\n",
+    "**⚠️ Important Considerations:**\n",
+    "- Review section 3.7 above to determine if global or segment-specific outlier treatment is appropriate\n",
+    "- Outliers in rate fields (>100%) are likely errors → Cap at 100\n",
+    "- Outliers in amount fields may be valid high-value customers → Keep but consider capping for modeling\n",
+    "- High outlier % (>10%) suggests heavy-tailed distribution → Consider log transform instead of capping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4029d109",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.570427Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.570253Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.633647Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.629513Z"
+    },
+    "papermill": {
+     "duration": 0.078553,
+     "end_time": "2026-02-02T13:03:10.638719",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.560166",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"=\" * 80)\n",
+    "print(\"OUTLIER DETECTION (IQR Method)\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "numeric_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]\n",
+    "    and name not in TEMPORAL_METADATA_COLS\n",
+    "]\n",
+    "\n",
+    "# Build comprehensive outlier table\n",
+    "outlier_data = []\n",
+    "for col_name in numeric_cols:\n",
+    "    series = df[col_name].dropna()\n",
+    "    q1 = series.quantile(0.25)\n",
+    "    q3 = series.quantile(0.75)\n",
+    "    iqr = q3 - q1\n",
+    "    lower_bound = q1 - 1.5 * iqr\n",
+    "    upper_bound = q3 + 1.5 * iqr\n",
+    "    \n",
+    "    outliers_low = (series < lower_bound).sum()\n",
+    "    outliers_high = (series > upper_bound).sum()\n",
+    "    total_outliers = outliers_low + outliers_high\n",
+    "    \n",
+    "    outlier_data.append({\n",
+    "        \"feature\": col_name,\n",
+    "        \"Q1\": q1,\n",
+    "        \"Q3\": q3,\n",
+    "        \"IQR\": iqr,\n",
+    "        \"lower_bound\": lower_bound,\n",
+    "        \"upper_bound\": upper_bound,\n",
+    "        \"outliers_low\": outliers_low,\n",
+    "        \"outliers_high\": outliers_high,\n",
+    "        \"total_outliers\": total_outliers,\n",
+    "        \"outlier_pct\": total_outliers / len(series) * 100\n",
+    "    })\n",
+    "\n",
+    "outlier_df = pd.DataFrame(outlier_data)\n",
+    "\n",
+    "# Display IQR bounds table\n",
+    "print(\"\\n📊 IQR BOUNDS TABLE:\")\n",
+    "bounds_display = outlier_df[[\"feature\", \"Q1\", \"Q3\", \"IQR\", \"lower_bound\", \"upper_bound\", \n",
+    "                              \"outliers_low\", \"outliers_high\"]].copy()\n",
+    "for col in [\"Q1\", \"Q3\", \"IQR\", \"lower_bound\", \"upper_bound\"]:\n",
+    "    bounds_display[col] = bounds_display[col].apply(lambda x: f\"{x:.2f}\")\n",
+    "display(bounds_display)\n",
+    "\n",
+    "# Outlier summary for columns with issues\n",
+    "cols_with_outliers = outlier_df[outlier_df[\"total_outliers\"] > 0].copy()\n",
+    "if len(cols_with_outliers) > 0:\n",
+    "    print(\"\\n⚠️ COLUMNS WITH OUTLIERS:\")\n",
+    "    for _, row in cols_with_outliers.iterrows():\n",
+    "        severity = \"🔴 HIGH\" if row[\"outlier_pct\"] > 10 else \"🟡 MEDIUM\" if row[\"outlier_pct\"] > 5 else \"🟢 LOW\"\n",
+    "        print(f\"\\n  {row['feature']}: {row['total_outliers']:,} outliers ({row['outlier_pct']:.2f}%) {severity}\")\n",
+    "        print(f\"     Lower bound: {row['lower_bound']:.2f} | Upper bound: {row['upper_bound']:.2f}\")\n",
+    "        if row[\"outliers_low\"] > 0:\n",
+    "            print(f\"     Below lower: {row['outliers_low']:,}\")\n",
+    "        if row[\"outliers_high\"] > 0:\n",
+    "            print(f\"     Above upper: {row['outliers_high']:,}\")\n",
+    "        \n",
+    "        # Determine action and add recommendation (skip if segment-aware already added)\n",
+    "        col_name = row['feature']\n",
+    "        existing_outlier_recs = [r for r in registry.bronze.outlier_handling if r.target_column == col_name]\n",
+    "        \n",
+    "        if not existing_outlier_recs and row[\"outlier_pct\"] > 5:  # Only add if significant and not already handled\n",
+    "            if row[\"outlier_pct\"] > 10:\n",
+    "                action = \"log_transform\"\n",
+    "                rationale = f\"{row['outlier_pct']:.1f}% outliers - heavy tails require log transform\"\n",
+    "                print(\"     → Consider log transform or RobustScaler\")\n",
+    "            else:\n",
+    "                action = \"winsorize\"\n",
+    "                rationale = f\"{row['outlier_pct']:.1f}% outliers - winsorize to 1st/99th percentile\"\n",
+    "                print(\"     → Consider Winsorization (clip to 1st/99th percentile)\")\n",
+    "            \n",
+    "            registry.add_bronze_outlier(\n",
+    "                column=col_name, action=action,\n",
+    "                parameters={\"method\": \"iqr\", \"lower_bound\": row[\"lower_bound\"], \"upper_bound\": row[\"upper_bound\"]},\n",
+    "                rationale=rationale,\n",
+    "                source_notebook=\"03_quality_assessment\"\n",
+    "            )\n",
+    "        elif row[\"outlier_pct\"] <= 5:\n",
+    "            print(\"     → Minor issue, can cap at IQR bounds if needed\")\n",
+    "else:\n",
+    "    print(\"\\n✅ No significant outliers detected in numeric columns\")\n",
+    "\n",
+    "# Box plots for columns with outliers\n",
+    "if len(cols_with_outliers) > 0 and len(cols_with_outliers) <= 6:\n",
+    "    outlier_cols = cols_with_outliers[\"feature\"].tolist()\n",
+    "    \n",
+    "    fig = make_subplots(rows=1, cols=len(outlier_cols), subplot_titles=outlier_cols)\n",
+    "    \n",
+    "    for i, col in enumerate(outlier_cols, 1):\n",
+    "        fig.add_trace(\n",
+    "            go.Box(y=df[col].dropna(), name=col, boxpoints=\"outliers\",\n",
+    "                  marker_color=\"#3498db\", showlegend=False),\n",
+    "            row=1, col=i\n",
+    "        )\n",
+    "    \n",
+    "    fig.update_layout(height=400, title_text=\"Outlier Distribution (Box Plots)\",\n",
+    "                     template=\"plotly_white\")\n",
+    "    display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d39c9ea",
+   "metadata": {
+    "papermill": {
+     "duration": 0.011699,
+     "end_time": "2026-02-02T13:03:10.667247",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.655548",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.9 Date Logic Validation\n",
+    "\n",
+    "**📖 What This Checks:**\n",
+    "- Date ranges and suspicious placeholder dates (e.g., 1/1/1900, 1/1/2004)\n",
+    "- Date sequence violations if `DATE_SEQUENCE` is configured below\n",
+    "\n",
+    "**⚠️ Common Issues:**\n",
+    "- Very old dates (pre-2005): Often placeholder values → Set to NULL\n",
+    "- Sequence violations (e.g., `last_purchase < first_purchase`): Data entry errors → Flag for review\n",
+    "\n",
+    "**💡 Configuration:**\n",
+    "Set `DATE_SEQUENCE` below to validate that dates occur in expected chronological order."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a4d5ce7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.686601Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.686469Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.692184Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.691521Z"
+    },
+    "papermill": {
+     "duration": 0.016241,
+     "end_time": "2026-02-02T13:03:10.692788",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.676547",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === DATE SEQUENCE CONFIGURATION ===\n",
+    "# Define expected chronological order of date columns (earliest to latest)\n",
+    "# Example: [\"account_created\", \"first_purchase\", \"last_purchase\"]\n",
+    "# Set to None or empty list to skip sequence validation\n",
+    "\n",
+    "# Option 1: Override here\n",
+    "DATE_SEQUENCE = None  # e.g., [\"created\", \"firstorder\", \"lastorder\"]\n",
+    "\n",
+    "# Option 2: Load from findings (saved in notebook 01)\n",
+    "if DATE_SEQUENCE is None and \"date_sequence\" in findings.metadata:\n",
+    "    DATE_SEQUENCE = findings.metadata[\"date_sequence\"]\n",
+    "    print(f\"Loaded date sequence from findings: {DATE_SEQUENCE}\")\n",
+    "\n",
+    "# Detect date columns from findings\n",
+    "date_cols = [name for name, col in findings.columns.items() \n",
+    "             if col.inferred_type == ColumnType.DATETIME]\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"DATE LOGIC VALIDATION\")\n",
+    "print(\"=\" * 60)\n",
+    "print(f\"\\nDetected date columns: {date_cols}\")\n",
+    "\n",
+    "if date_cols:\n",
+    "    df_dates = df.copy()\n",
+    "    for col in date_cols:\n",
+    "        df_dates[col] = pd.to_datetime(df_dates[col], errors='coerce', format='mixed')\n",
+    "    \n",
+    "    # Date ranges\n",
+    "    print(\"\\n📅 DATE RANGES:\")\n",
+    "    for col in date_cols:\n",
+    "        print(f\"  {col}: {df_dates[col].min()} to {df_dates[col].max()}\")\n",
+    "    \n",
+    "    # Placeholder detection\n",
+    "    print(\"\\n🕵️ PLACEHOLDER DATE DETECTION:\")\n",
+    "    for col in date_cols:\n",
+    "        old_dates = (df_dates[col] < '2005-01-01').sum()\n",
+    "        if old_dates > 0:\n",
+    "            print(f\"  {col}: {old_dates:,} dates before 2005 (possible placeholders)\")\n",
+    "        else:\n",
+    "            print(f\"  {col}: No suspicious early dates\")\n",
+    "    \n",
+    "    # Sequence validation\n",
+    "    if DATE_SEQUENCE and len(DATE_SEQUENCE) >= 2:\n",
+    "        valid_sequence_cols = [c for c in DATE_SEQUENCE if c in date_cols]\n",
+    "        if len(valid_sequence_cols) >= 2:\n",
+    "            print(f\"\\n🔗 DATE SEQUENCE VALIDATION:\")\n",
+    "            print(f\"  Expected order: {' ≤ '.join(valid_sequence_cols)}\")\n",
+    "            \n",
+    "            total_violations = 0\n",
+    "            for i in range(len(valid_sequence_cols) - 1):\n",
+    "                col1, col2 = valid_sequence_cols[i], valid_sequence_cols[i + 1]\n",
+    "                # Check where col2 < col1 (violation)\n",
+    "                mask = df_dates[col1].notna() & df_dates[col2].notna()\n",
+    "                violations = (df_dates.loc[mask, col2] < df_dates.loc[mask, col1]).sum()\n",
+    "                total_violations += violations\n",
+    "                \n",
+    "                if violations > 0:\n",
+    "                    pct = violations / mask.sum() * 100\n",
+    "                    print(f\"  ⚠️ {col2} < {col1}: {violations:,} violations ({pct:.2f}%)\")\n",
+    "                else:\n",
+    "                    print(f\"  ✓ {col1} ≤ {col2}: No violations\")\n",
+    "            \n",
+    "            if total_violations == 0:\n",
+    "                print(\"\\n  ✅ All date sequences valid\")\n",
+    "            else:\n",
+    "                print(f\"\\n  ⚠️ Total sequence violations: {total_violations:,}\")\n",
+    "        else:\n",
+    "            print(f\"\\n⚠️ DATE_SEQUENCE columns not found in data: {DATE_SEQUENCE}\")\n",
+    "            print(f\"   Available date columns: {date_cols}\")\n",
+    "    else:\n",
+    "        print(\"\\n💡 TIP: Set DATE_SEQUENCE above or in notebook 01 to enable sequence validation\")\n",
+    "        if len(date_cols) >= 2:\n",
+    "            print(f\"   Available date columns: {date_cols}\")\n",
+    "else:\n",
+    "    print(\"\\nNo date columns detected.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4ba09b9",
+   "metadata": {
+    "papermill": {
+     "duration": 0.010265,
+     "end_time": "2026-02-02T13:03:10.710981",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.700716",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.10 Binary Field Validation\n",
+    "\n",
+    "Binary fields should contain only 0 and 1 values. Any other values indicate data quality issues."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f796b6a4",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.728169Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.728054Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.735906Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.735438Z"
+    },
+    "papermill": {
+     "duration": 0.017183,
+     "end_time": "2026-02-02T13:03:10.736484",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.719301",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "binary_cols = [name for name, col in findings.columns.items() \n",
+    "               if col.inferred_type == ColumnType.BINARY\n",
+    "               and name not in TEMPORAL_METADATA_COLS]\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"BINARY FIELD VALIDATION\")\n",
+    "print(\"=\" * 60)\n",
+    "print(f\"\\nDetected binary columns: {binary_cols}\")\n",
+    "\n",
+    "if binary_cols:\n",
+    "    binary_results = []\n",
+    "    for col in binary_cols:\n",
+    "        unique_vals = sorted(df[col].dropna().unique())\n",
+    "        is_valid = set(unique_vals).issubset({0, 1, 0.0, 1.0})\n",
+    "        count_0 = (df[col] == 0).sum()\n",
+    "        count_1 = (df[col] == 1).sum()\n",
+    "        total = count_0 + count_1\n",
+    "        \n",
+    "        binary_results.append({\n",
+    "            'column': col,\n",
+    "            'unique_values': unique_vals,\n",
+    "            'is_valid': is_valid,\n",
+    "            'count_0': count_0,\n",
+    "            'count_1': count_1,\n",
+    "            'pct_1': count_1 / total * 100 if total > 0 else 0\n",
+    "        })\n",
+    "        \n",
+    "        status = \"✓\" if is_valid else \"⚠️\"\n",
+    "        print(f\"\\n{status} {col}:\")\n",
+    "        print(f\"   Unique values: {unique_vals}\")\n",
+    "        print(f\"   0 (No): {count_0:,} ({count_0/total*100:.1f}%)\")\n",
+    "        print(f\"   1 (Yes): {count_1:,} ({count_1/total*100:.1f}%)\")\n",
+    "        \n",
+    "        if not is_valid:\n",
+    "            invalid_vals = [v for v in unique_vals if v not in [0, 1, 0.0, 1.0]]\n",
+    "            print(f\"   ⚠️ Invalid values found: {invalid_vals}\")\n",
+    "\n",
+    "    if len(binary_cols) <= 6:\n",
+    "        n_cols = len(binary_cols)\n",
+    "        fig = make_subplots(rows=1, cols=n_cols, subplot_titles=binary_cols)\n",
+    "        \n",
+    "        for i, col in enumerate(binary_cols, 1):\n",
+    "            counts = df[col].value_counts().sort_index()\n",
+    "            fig.add_trace(\n",
+    "                go.Bar(x=['No (0)', 'Yes (1)'], y=[counts.get(0, 0), counts.get(1, 0)],\n",
+    "                       marker_color=['#d62728', '#2ca02c'], showlegend=False),\n",
+    "                row=1, col=i\n",
+    "            )\n",
+    "        \n",
+    "        fig.update_layout(height=350, title_text=\"Binary Field Distributions\",\n",
+    "                          template='plotly_white')\n",
+    "        display_figure(fig)\n",
+    "else:\n",
+    "    print(\"\\nNo binary columns detected.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86ff0afa",
+   "metadata": {
+    "papermill": {
+     "duration": 0.007937,
+     "end_time": "2026-02-02T13:03:10.752592",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.744655",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.11 Data Consistency Checks\n",
+    "\n",
+    "Check for case variants, leading/trailing spaces, and other string inconsistencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3639dacf",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.769450Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.769328Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.777257Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.776709Z"
+    },
+    "papermill": {
+     "duration": 0.017719,
+     "end_time": "2026-02-02T13:03:10.777906",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.760187",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "consistency_issues = []\n",
+    "\n",
+    "for col_name in df.select_dtypes(include=['object']).columns:\n",
+    "    if col_name in TEMPORAL_METADATA_COLS:\n",
+    "        continue\n",
+    "    unique_vals = df[col_name].dropna().unique()\n",
+    "    case_variants = {}\n",
+    "    for val in unique_vals:\n",
+    "        lower_val = str(val).lower().strip()\n",
+    "        if lower_val not in case_variants:\n",
+    "            case_variants[lower_val] = []\n",
+    "        case_variants[lower_val].append(val)\n",
+    "    \n",
+    "    for lower_val, variants in case_variants.items():\n",
+    "        if len(variants) > 1:\n",
+    "            consistency_issues.append({\n",
+    "                \"Column\": col_name,\n",
+    "                \"Issue\": \"Case/Spacing Variants\",\n",
+    "                \"Details\": str(variants[:5]),\n",
+    "                \"variants\": variants\n",
+    "            })\n",
+    "\n",
+    "if consistency_issues:\n",
+    "    print(\"Data Consistency Issues:\")\n",
+    "    display(pd.DataFrame([{k: v for k, v in issue.items() if k != \"variants\"} for issue in consistency_issues]))\n",
+    "    \n",
+    "    # Add consistency recommendations\n",
+    "    for issue in consistency_issues:\n",
+    "        registry.add_bronze_consistency(\n",
+    "            column=issue[\"Column\"],\n",
+    "            issue_type=\"case_variants\",\n",
+    "            action=\"normalize_lower\",\n",
+    "            variants=issue[\"variants\"][:5],\n",
+    "            rationale=f\"{len(issue['variants'])} case/spacing variants detected\",\n",
+    "            source_notebook=\"03_quality_assessment\"\n",
+    "        )\n",
+    "else:\n",
+    "    print(\"No consistency issues detected.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a3c2f34",
+   "metadata": {
+    "papermill": {
+     "duration": 0.007977,
+     "end_time": "2026-02-02T13:03:10.793870",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.785893",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.12 Quality Improvement Recommendations\n",
+    "\n",
+    "Automated recommendations based on the issues detected above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9ba7d76",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.811120Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.810941Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.824714Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.823869Z"
+    },
+    "papermill": {
+     "duration": 0.023502,
+     "end_time": "2026-02-02T13:03:10.825506",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.802004",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.auto_explorer import RecommendationEngine\n",
+    "\n",
+    "recommender = RecommendationEngine()\n",
+    "cleaning_recs = recommender.recommend_cleaning(findings)\n",
+    "\n",
+    "print(\"=\" * 80)\n",
+    "print(\"QUALITY IMPROVEMENT RECOMMENDATIONS\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "if cleaning_recs:\n",
+    "    # Group by severity\n",
+    "    high_severity = [r for r in cleaning_recs if r.severity == \"high\"]\n",
+    "    medium_severity = [r for r in cleaning_recs if r.severity == \"medium\"]\n",
+    "    low_severity = [r for r in cleaning_recs if r.severity == \"low\"]\n",
+    "    \n",
+    "    if high_severity:\n",
+    "        print(\"\\n🔴 HIGH PRIORITY (must fix before modeling):\")\n",
+    "        print(\"-\" * 60)\n",
+    "        for rec in high_severity:\n",
+    "            print(f\"\\n  📌 {rec.column_name}\")\n",
+    "            print(f\"     Issue: {rec.description}\")\n",
+    "            print(f\"     Strategy: {rec.strategy_label}\")\n",
+    "            print(f\"     Impact: {rec.problem_impact}\")\n",
+    "            if rec.action_steps:\n",
+    "                print(\"     Action Steps:\")\n",
+    "                for step in rec.action_steps:\n",
+    "                    print(f\"       • {step}\")\n",
+    "    \n",
+    "    if medium_severity:\n",
+    "        print(\"\\n🟡 MEDIUM PRIORITY (recommended fixes):\")\n",
+    "        print(\"-\" * 60)\n",
+    "        for rec in medium_severity:\n",
+    "            print(f\"\\n  📌 {rec.column_name}\")\n",
+    "            print(f\"     Issue: {rec.description}\")\n",
+    "            print(f\"     Strategy: {rec.strategy_label}\")\n",
+    "            print(f\"     Impact: {rec.problem_impact}\")\n",
+    "            if rec.action_steps:\n",
+    "                print(\"     Action Steps:\")\n",
+    "                for step in rec.action_steps:\n",
+    "                    print(f\"       • {step}\")\n",
+    "    \n",
+    "    if low_severity:\n",
+    "        print(\"\\n🟢 LOW PRIORITY (nice to have):\")\n",
+    "        print(\"-\" * 60)\n",
+    "        for rec in low_severity:\n",
+    "            print(f\"\\n  📌 {rec.column_name}\")\n",
+    "            print(f\"     Issue: {rec.description}\")\n",
+    "            print(f\"     Strategy: {rec.strategy_label}\")\n",
+    "            print(f\"     Impact: {rec.problem_impact}\")\n",
+    "    \n",
+    "    # Persist cleaning recommendations to registry\n",
+    "    for rec in cleaning_recs:\n",
+    "        # Check if not already added by previous sections\n",
+    "        existing_null = [r for r in registry.bronze.null_handling if r.target_column == rec.column_name]\n",
+    "        existing_outlier = [r for r in registry.bronze.outlier_handling if r.target_column == rec.column_name]\n",
+    "        \n",
+    "        if rec.issue_type in [\"null_values\", \"missing_values\"] and not existing_null:\n",
+    "            strategy = \"median\" if \"median\" in rec.strategy.lower() else \"mode\" if \"mode\" in rec.strategy.lower() else \"drop\"\n",
+    "            registry.add_bronze_null(\n",
+    "                column=rec.column_name,\n",
+    "                strategy=strategy,\n",
+    "                rationale=rec.description,\n",
+    "                source_notebook=\"03_quality_assessment\"\n",
+    "            )\n",
+    "        elif rec.issue_type == \"outliers\" and not existing_outlier:\n",
+    "            registry.add_bronze_outlier(\n",
+    "                column=rec.column_name,\n",
+    "                action=\"winsorize\" if \"winsor\" in rec.strategy.lower() else \"cap\",\n",
+    "                parameters={\"severity\": rec.severity, \"affected_rows\": rec.affected_rows},\n",
+    "                rationale=rec.description,\n",
+    "                source_notebook=\"03_quality_assessment\"\n",
+    "            )\n",
+    "    \n",
+    "    # Summary table\n",
+    "    print(\"\\n\" + \"=\" * 80)\n",
+    "    print(\"CLEANUP SUMMARY\")\n",
+    "    print(\"=\" * 80)\n",
+    "    \n",
+    "    summary_data = []\n",
+    "    for rec in cleaning_recs:\n",
+    "        summary_data.append({\n",
+    "            \"Column\": rec.column_name,\n",
+    "            \"Issue\": rec.issue_type.replace(\"_\", \" \").title(),\n",
+    "            \"Severity\": rec.severity.upper(),\n",
+    "            \"Recommended Action\": rec.strategy_label,\n",
+    "            \"Affected Rows\": f\"{rec.affected_rows:,}\"\n",
+    "        })\n",
+    "    \n",
+    "    summary_df = pd.DataFrame(summary_data)\n",
+    "    display(summary_df)\n",
+    "    \n",
+    "    # Total impact\n",
+    "    total_affected = sum(r.affected_rows for r in cleaning_recs)\n",
+    "    unique_affected = min(total_affected, len(df))  # Can't exceed total rows\n",
+    "    print(f\"\\nTotal potentially affected: {total_affected:,} cell values\")\n",
+    "    print(f\"Columns needing attention: {len(cleaning_recs)}\")\n",
+    "else:\n",
+    "    print(\"\\n✅ No cleaning recommendations - data quality is excellent!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b623adb2",
+   "metadata": {
+    "papermill": {
+     "duration": 0.009966,
+     "end_time": "2026-02-02T13:03:10.844511",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.834545",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3.13 Save Updated Findings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d98d70d7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:10.893014Z",
+     "iopub.status.busy": "2026-02-02T13:03:10.892883Z",
+     "iopub.status.idle": "2026-02-02T13:03:10.987017Z",
+     "shell.execute_reply": "2026-02-02T13:03:10.986626Z"
+    },
+    "papermill": {
+     "duration": 0.116089,
+     "end_time": "2026-02-02T13:03:10.987834",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.871745",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Save updated findings back to the same file\n",
+    "findings.save(FINDINGS_PATH)\n",
+    "print(f\"Updated findings saved to: {FINDINGS_PATH}\")\n",
+    "\n",
+    "# Save recommendations registry\n",
+    "registry.save(RECOMMENDATIONS_PATH)\n",
+    "print(f\"Recommendations saved to: {RECOMMENDATIONS_PATH}\")\n",
+    "\n",
+    "# Summary of recommendations\n",
+    "all_recs = registry.all_recommendations\n",
+    "print(f\"\\n📋 Recommendations Summary:\")\n",
+    "print(f\"   Bronze layer: {len(registry.get_by_layer('bronze'))} recommendations\")\n",
+    "if registry.silver:\n",
+    "    print(f\"   Silver layer: {len(registry.get_by_layer('silver'))} recommendations\")\n",
+    "if registry.gold:\n",
+    "    print(f\"   Gold layer: {len(registry.get_by_layer('gold'))} recommendations\")\n",
+    "print(f\"   Total: {len(all_recs)} recommendations\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "278956b0",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008829,
+     "end_time": "2026-02-02T13:03:11.005721",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:10.996892",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Summary: What We Learned\n",
+    "\n",
+    "In this notebook, we performed a comprehensive quality assessment:\n",
+    "\n",
+    "1. **Duplicate Analysis** - Identified key-based duplicates, exact duplicates, and value conflicts\n",
+    "2. **Target Variable** - Analyzed class distribution and imbalance for modeling guidance\n",
+    "3. **Missing Values** - Analyzed patterns (MCAR/MAR/MNAR) and correlations\n",
+    "4. **Segment-Aware Outliers** - Detected natural data segments to avoid false positive outliers\n",
+    "5. **Global Outliers** - Detected using IQR method with bounds and percentages\n",
+    "6. **Date Logic** - Validated temporal sequences and detected placeholders\n",
+    "7. **Binary Fields** - Verified 0/1 encoding and distributions\n",
+    "8. **Consistency** - Checked for case variants and spacing issues\n",
+    "9. **Recommendations** - Generated automated cleaning strategies\n",
+    "\n",
+    "## Key Insights\n",
+    "\n",
+    "**Duplicate Analysis:**\n",
+    "- Exact duplicates should be removed before modeling\n",
+    "- Key duplicates with value conflicts require investigation and a resolution strategy\n",
+    "- High duplicate percentages may indicate event-level data requiring aggregation\n",
+    "\n",
+    "**Segment-Aware Analysis:**\n",
+    "- If segments were detected, some global \"outliers\" may actually be valid data from different customer segments\n",
+    "- Enterprise vs retail customers, new vs established accounts often have legitimately different value ranges\n",
+    "- Use segment-specific outlier treatment when recommended to preserve important patterns\n",
+    "\n",
+    "## Key Cleanup Actions for This Dataset\n",
+    "\n",
+    "Based on the analysis above:\n",
+    "- **Duplicates**: Review key duplicates and resolve value conflicts\n",
+    "- **Missing Values**: Low (0.06%) - can drop or impute with mode\n",
+    "- **Outliers**: Check segment-aware analysis results - some may be false positives\n",
+    "- **Date Issues**: Check for placeholder dates before lastorder\n",
+    "- **Binary Fields**: All valid with 0/1 encoding\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "Continue to **04_relationship_analysis.ipynb** to:\n",
+    "- Explore correlations between features\n",
+    "- Analyze feature-target relationships\n",
+    "- Identify potential feature interactions\n",
+    "- Detect multicollinearity issues"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81f5fb41",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008798,
+     "end_time": "2026-02-02T13:03:11.022834",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:11.014036",
+     "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": 6.749412,
+   "end_time": "2026-02-02T13:03:13.648240",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/03_quality_assessment.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/03_quality_assessment.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:03:06.898828",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}