churnkit 0.75.0a1__py3-none-any.whl

churnkit-0.75.0a1.data/data/share/churnkit/exploration_notebooks/06_feature_opportunities.ipynb

@@ -0,0 +1,1624 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ceca3f3f",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003774,
+     "end_time": "2026-02-02T13:03:27.226665",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:27.222891",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Chapter 6: Feature Opportunities\n",
+    "\n",
+    "**Purpose:** Identify and implement feature engineering opportunities to improve model performance.\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to derive time-based features (tenure, recency, active period)\n",
+    "- How to create composite engagement scores\n",
+    "- How to segment customers based on behavior patterns\n",
+    "- How to encode categorical variables effectively\n",
+    "\n",
+    "**Outputs:**\n",
+    "- Derived feature recommendations with code examples\n",
+    "- Composite score formulas (engagement, service adoption)\n",
+    "- Customer segmentation rules\n",
+    "- Categorical encoding strategies\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Why Feature Engineering Matters\n",
+    "\n",
+    "| Feature Type | Business Meaning | Predictive Power |\n",
+    "|-------------|-----------------|------------------|\n",
+    "| **Tenure** | How long customer has been with us | Loyalty indicator |\n",
+    "| **Recency** | Days since last order | Engagement/churn signal |\n",
+    "| **Engagement Score** | Combined email metrics | Overall engagement level |\n",
+    "| **Segments** | High/Low value × Frequent/Infrequent | Risk stratification |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4dd512f5",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00238,
+     "end_time": "2026-02-02T13:03:27.232489",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:27.230109",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.1 Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "485495bd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:27.239137Z",
+     "iopub.status.busy": "2026-02-02T13:03:27.239011Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.003230Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.002430Z"
+    },
+    "papermill": {
+     "duration": 1.768958,
+     "end_time": "2026-02-02T13:03:29.004317",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:27.235359",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"06_feature_opportunities.ipynb\")\n",
+    "\n",
+    "from customer_retention.analysis.auto_explorer import ExplorationFindings, RecommendationEngine, RecommendationRegistry\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.features import CustomerSegmenter, SegmentationType\n",
+    "from customer_retention.stages.profiling import FeatureCapacityAnalyzer\n",
+    "import yaml\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\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f708610d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.021480Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.021296Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.486668Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.485969Z"
+    },
+    "papermill": {
+     "duration": 0.474341,
+     "end_time": "2026-02-02T13:03:29.487573",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.013232",
+     "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",
+    "\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",
+    "RECOMMENDATIONS_PATH = FINDINGS_PATH.replace(\"_findings.yaml\", \"_recommendations.yaml\")\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",
+    "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: {len(registry.all_recommendations)} total\")\n",
+    "else:\n",
+    "    registry = RecommendationRegistry()\n",
+    "    print(\"Initialized new recommendation registry\")\n",
+    "\n",
+    "# Ensure all layers are initialized (even if loaded from file)\n",
+    "if not registry.bronze:\n",
+    "    registry.init_bronze(findings.source_path)\n",
+    "if not registry.silver:\n",
+    "    registry.init_silver(findings.entity_column or \"entity_id\")\n",
+    "if not registry.gold:\n",
+    "    registry.init_gold(findings.target_column or \"target\")\n",
+    "    print(\"  Initialized gold layer for feature engineering recommendations\")\n",
+    "\n",
+    "print(f\"\\nLoaded {len(df):,} rows from: {data_source}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f934e52",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002793,
+     "end_time": "2026-02-02T13:03:29.493261",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.490468",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.2 Automated Feature Recommendations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48774e06",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.499317Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.499150Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.504187Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.503639Z"
+    },
+    "papermill": {
+     "duration": 0.008632,
+     "end_time": "2026-02-02T13:03:29.504689",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.496057",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "recommender = RecommendationEngine()\n",
+    "feature_recs = recommender.recommend_features(findings)\n",
+    "\n",
+    "print(f\"Found {len(feature_recs)} feature engineering opportunities:\\n\")\n",
+    "\n",
+    "for rec in feature_recs:\n",
+    "    print(f\"{rec.feature_name}\")\n",
+    "    print(f\"  Source: {rec.source_column}\")\n",
+    "    print(f\"  Type: {rec.feature_type}\")\n",
+    "    print(f\"  Priority: {rec.priority}\")\n",
+    "    print(f\"  Description: {rec.description}\")\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "414d93c2",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002979,
+     "end_time": "2026-02-02T13:03:29.510845",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.507866",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.3 Feature Capacity Analysis\n",
+    "\n",
+    "**📖 Understanding Feature-to-Data Ratios**\n",
+    "\n",
+    "Before creating new features, it's critical to understand how many features your data can reliably support. This analysis uses the **Events Per Variable (EPV)** principle:\n",
+    "\n",
+    "| EPV Level | Risk Level | Recommendations |\n",
+    "|-----------|------------|-----------------|\n",
+    "| **EPV ≥ 20** | Low risk | Stable coefficients, reliable inference |\n",
+    "| **EPV = 10-20** | Moderate | Standard practice, consider regularization |\n",
+    "| **EPV = 5-10** | Elevated | Strong regularization required (L1/Lasso) |\n",
+    "| **EPV < 5** | High risk | Reduce features or collect more data |\n",
+    "\n",
+    "**Key Assumptions:**\n",
+    "1. **Minority class drives capacity**: For classification, the smaller class limits feature count\n",
+    "2. **Correlated features are redundant**: Highly correlated features (r > 0.8) count as ~1 effective feature\n",
+    "3. **Model type matters**: Tree models are more flexible than linear models\n",
+    "4. **Regularization helps**: L1/L2 penalties allow more features with less data\n",
+    "\n",
+    "**📊 What This Analysis Provides:**\n",
+    "- Recommended feature counts (conservative/moderate/aggressive)\n",
+    "- Effective feature count after removing redundancy\n",
+    "- Model complexity guidance (linear vs tree-based)\n",
+    "- Segment-specific capacity for multi-model strategies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fceefe09",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.516821Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.516704Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.553252Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.548370Z"
+    },
+    "papermill": {
+     "duration": 0.040696,
+     "end_time": "2026-02-02T13:03:29.554085",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.513389",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Capacity Analysis\n",
+    "capacity_analyzer = FeatureCapacityAnalyzer()\n",
+    "\n",
+    "# Get all potential feature columns (excluding target and identifiers)\n",
+    "feature_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type in [\n",
+    "        ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE,\n",
+    "        ColumnType.CATEGORICAL_NOMINAL, ColumnType.CATEGORICAL_ORDINAL,\n",
+    "        ColumnType.BINARY\n",
+    "    ] and name != findings.target_column\n",
+    "    and name not in TEMPORAL_METADATA_COLS\n",
+    "]\n",
+    "\n",
+    "print(\"=\" * 80)\n",
+    "print(\"FEATURE CAPACITY ANALYSIS\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "if findings.target_column:\n",
+    "    # Analyze capacity with current features\n",
+    "    numeric_features = [\n",
+    "        name for name, col in findings.columns.items()\n",
+    "        if col.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]\n",
+    "        and name != findings.target_column\n",
+    "    ]\n",
+    "    \n",
+    "    capacity_result = capacity_analyzer.analyze(\n",
+    "        df,\n",
+    "        feature_cols=numeric_features,\n",
+    "        target_col=findings.target_column,\n",
+    "    )\n",
+    "    \n",
+    "    print(f\"\\n📊 DATA SUMMARY:\")\n",
+    "    print(f\"   Total samples: {capacity_result.total_samples:,}\")\n",
+    "    print(f\"   Minority class samples: {capacity_result.minority_class_samples:,}\")\n",
+    "    print(f\"   Minority class rate: {capacity_result.minority_class_samples/capacity_result.total_samples:.1%}\")\n",
+    "    print(f\"   Current numeric features: {capacity_result.total_features}\")\n",
+    "    \n",
+    "    print(f\"\\n📈 FEATURE CAPACITY METRICS:\")\n",
+    "    print(f\"   Events Per Variable (EPV): {capacity_result.events_per_variable:.1f}\")\n",
+    "    print(f\"   Samples Per Feature: {capacity_result.samples_per_feature:.1f}\")\n",
+    "    print(f\"   Capacity Status: {capacity_result.capacity_status.upper()}\")\n",
+    "    \n",
+    "    # Capacity status visualization\n",
+    "    status_colors = {\"adequate\": \"#2ecc71\", \"limited\": \"#f39c12\", \"inadequate\": \"#e74c3c\"}\n",
+    "    status_color = status_colors.get(capacity_result.capacity_status, \"#95a5a6\")\n",
+    "    \n",
+    "    print(f\"\\n🎯 RECOMMENDED FEATURE COUNTS:\")\n",
+    "    print(f\"   Conservative (EPV=20): {capacity_result.recommended_features_conservative} features\")\n",
+    "    print(f\"   Moderate (EPV=10):     {capacity_result.recommended_features_moderate} features\")\n",
+    "    print(f\"   Aggressive (EPV=5):    {capacity_result.recommended_features_aggressive} features\")\n",
+    "    \n",
+    "    # Effective features analysis\n",
+    "    if capacity_result.effective_features_result:\n",
+    "        eff = capacity_result.effective_features_result\n",
+    "        print(f\"\\n🔍 EFFECTIVE FEATURES (accounting for correlation):\")\n",
+    "        print(f\"   Total features analyzed: {eff.total_count}\")\n",
+    "        print(f\"   Effective independent features: {eff.effective_count:.1f}\")\n",
+    "        print(f\"   Redundant features identified: {len(eff.redundant_features)}\")\n",
+    "        \n",
+    "        if eff.redundant_features:\n",
+    "            print(f\"\\n   ⚠️ Redundant features (highly correlated):\")\n",
+    "            for feat in eff.redundant_features[:5]:\n",
+    "                print(f\"      • {feat}\")\n",
+    "        \n",
+    "        if eff.feature_clusters:\n",
+    "            print(f\"\\n   📦 Correlated feature clusters ({len(eff.feature_clusters)}):\")\n",
+    "            for i, cluster in enumerate(eff.feature_clusters[:3]):\n",
+    "                print(f\"      Cluster {i+1}: {', '.join(cluster[:4])}\")\n",
+    "                if len(cluster) > 4:\n",
+    "                    print(f\"                  ... and {len(cluster)-4} more\")\n",
+    "    \n",
+    "    # Persist feature capacity to registry\n",
+    "    registry.add_bronze_feature_capacity(\n",
+    "        epv=capacity_result.events_per_variable,\n",
+    "        capacity_status=capacity_result.capacity_status,\n",
+    "        recommended_features=capacity_result.recommended_features_moderate,\n",
+    "        current_features=capacity_result.total_features,\n",
+    "        rationale=f\"EPV={capacity_result.events_per_variable:.1f}, status={capacity_result.capacity_status}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "    print(f\"\\n✅ Persisted feature capacity recommendation to registry\")\n",
+    "    \n",
+    "    # Store capacity info in findings\n",
+    "    findings.metadata[\"feature_capacity\"] = capacity_result.to_dict()\n",
+    "else:\n",
+    "    print(\"\\n⚠️ No target column detected. Capacity analysis requires a target variable.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b522958",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00341,
+     "end_time": "2026-02-02T13:03:29.561633",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.558223",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 6.3.1 Model Complexity Guidance\n",
+    "\n",
+    "Based on your data capacity, here's guidance on model complexity and feature limits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a744f2a2",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.568292Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.568182Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.594267Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.593686Z"
+    },
+    "papermill": {
+     "duration": 0.030556,
+     "end_time": "2026-02-02T13:03:29.595093",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.564537",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Model Complexity Guidance\n",
+    "if findings.target_column and 'capacity_result' in dir():\n",
+    "    guidance = capacity_result.complexity_guidance\n",
+    "    \n",
+    "    print(\"=\" * 70)\n",
+    "    print(\"MODEL COMPLEXITY GUIDANCE\")\n",
+    "    print(\"=\" * 70)\n",
+    "    \n",
+    "    # Create visualization of feature limits by model type\n",
+    "    model_types = [\"Linear\\n(no regularization)\", \"Regularized\\n(L1/L2)\", \"Tree-based\\n(RF/XGBoost)\"]\n",
+    "    max_features = [guidance.max_features_linear, guidance.max_features_regularized, guidance.max_features_tree]\n",
+    "    current_features = capacity_result.total_features\n",
+    "    \n",
+    "    colors = ['#e74c3c' if m < current_features else '#2ecc71' for m in max_features]\n",
+    "    \n",
+    "    fig = go.Figure()\n",
+    "    \n",
+    "    fig.add_trace(go.Bar(\n",
+    "        x=model_types,\n",
+    "        y=max_features,\n",
+    "        marker_color=colors,\n",
+    "        text=[f\"{m}\" for m in max_features],\n",
+    "        textposition='outside',\n",
+    "        name='Max Features'\n",
+    "    ))\n",
+    "    \n",
+    "    # Add horizontal line for current feature count\n",
+    "    fig.add_hline(\n",
+    "        y=current_features,\n",
+    "        line_dash=\"dash\",\n",
+    "        line_color=\"#3498db\",\n",
+    "        annotation_text=f\"Current: {current_features}\",\n",
+    "        annotation_position=\"right\"\n",
+    "    )\n",
+    "    \n",
+    "    # Calculate y-axis range to fit labels\n",
+    "    max_val = max(max_features)\n",
+    "    fig.update_layout(\n",
+    "        title=\"Maximum Recommended Features by Model Type\",\n",
+    "        xaxis_title=\"Model Type\",\n",
+    "        yaxis_title=\"Max Features\",\n",
+    "        yaxis_range=[0, max_val * 1.15],  # Add 15% headroom for labels\n",
+    "        template='plotly_white',\n",
+    "        height=400,\n",
+    "        showlegend=False,\n",
+    "    )\n",
+    "    \n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    print(f\"\\n🎯 RECOMMENDED MODEL TYPE: {guidance.recommended_model_type.replace('_', ' ').title()}\")\n",
+    "    \n",
+    "    print(\"\\n📋 MODEL-SPECIFIC RECOMMENDATIONS:\")\n",
+    "    for rec in guidance.model_recommendations:\n",
+    "        print(f\"   • {rec}\")\n",
+    "    \n",
+    "    print(\"\\n💡 GENERAL GUIDANCE:\")\n",
+    "    for rec in guidance.recommendations:\n",
+    "        print(f\"   {rec}\")\n",
+    "    \n",
+    "    # Summary table\n",
+    "    print(\"\\n\" + \"-\" * 70)\n",
+    "    print(\"FEATURE BUDGET SUMMARY:\")\n",
+    "    print(\"-\" * 70)\n",
+    "    summary_data = {\n",
+    "        \"Model Type\": [\"Linear (no regularization)\", \"Regularized (L1/L2)\", \"Tree-based\"],\n",
+    "        \"Max Features\": [guidance.max_features_linear, guidance.max_features_regularized, guidance.max_features_tree],\n",
+    "        \"Current\": [current_features] * 3,\n",
+    "        \"Status\": [\n",
+    "            \"✅ OK\" if guidance.max_features_linear >= current_features else \"⚠️ Reduce\",\n",
+    "            \"✅ OK\" if guidance.max_features_regularized >= current_features else \"⚠️ Reduce\", \n",
+    "            \"✅ OK\" if guidance.max_features_tree >= current_features else \"⚠️ Reduce\"\n",
+    "        ]\n",
+    "    }\n",
+    "    display(pd.DataFrame(summary_data))\n",
+    "    \n",
+    "    # Persist model type recommendation to registry\n",
+    "    registry.add_bronze_model_type(\n",
+    "        model_type=guidance.recommended_model_type,\n",
+    "        max_features_linear=guidance.max_features_linear,\n",
+    "        max_features_regularized=guidance.max_features_regularized,\n",
+    "        max_features_tree=guidance.max_features_tree,\n",
+    "        rationale=f\"Recommended: {guidance.recommended_model_type}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "    print(f\"\\n✅ Persisted model type recommendation to registry: {guidance.recommended_model_type}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60d49437",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004153,
+     "end_time": "2026-02-02T13:03:29.604467",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.600314",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 6.3.2 Segment-Specific Capacity (for Multi-Model Strategy)\n",
+    "\n",
+    "When considering **separate models per customer segment**, each segment must have sufficient data to support the feature set. This analysis shows whether segmented modeling is viable.\n",
+    "\n",
+    "**📖 Single Model vs Segment Models:**\n",
+    "\n",
+    "| Approach | When to Use | Pros | Cons |\n",
+    "|----------|------------|------|------|\n",
+    "| **Single Model** | Small data, uniform segments | More data per model, simpler | May miss segment-specific patterns |\n",
+    "| **Segment Models** | Large data, distinct segments | Tailored patterns | Need sufficient data per segment |\n",
+    "| **Hybrid** | Mixed segment sizes | Best of both | More complex to maintain |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e953415",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.613878Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.613754Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.670977Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.670274Z"
+    },
+    "papermill": {
+     "duration": 0.062878,
+     "end_time": "2026-02-02T13:03:29.671675",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.608797",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Segment Capacity Analysis\n",
+    "categorical_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type in [ColumnType.CATEGORICAL_NOMINAL, ColumnType.CATEGORICAL_ORDINAL]\n",
+    "    and name not in TEMPORAL_METADATA_COLS\n",
+    "]\n",
+    "\n",
+    "print(\"=\" * 70)\n",
+    "print(\"SEGMENT CAPACITY ANALYSIS\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "if findings.target_column and categorical_cols and 'numeric_features' in dir():\n",
+    "    # Analyze the first categorical column as potential segment\n",
+    "    segment_col = categorical_cols[0]\n",
+    "    \n",
+    "    print(f\"\\n📊 Analyzing segments by: {segment_col}\")\n",
+    "    print(f\"   Features to evaluate: {len(numeric_features)}\")\n",
+    "    \n",
+    "    segment_result = capacity_analyzer.analyze_segment_capacity(\n",
+    "        df,\n",
+    "        feature_cols=numeric_features,\n",
+    "        target_col=findings.target_column,\n",
+    "        segment_col=segment_col,\n",
+    "    )\n",
+    "    \n",
+    "    print(f\"\\n🎯 RECOMMENDED STRATEGY: {segment_result.recommended_strategy.replace('_', ' ').title()}\")\n",
+    "    print(f\"   Reason: {segment_result.strategy_reason}\")\n",
+    "    \n",
+    "    # Segment details table\n",
+    "    segment_data = []\n",
+    "    for seg_name, cap in segment_result.segment_capacities.items():\n",
+    "        segment_data.append({\n",
+    "            \"Segment\": seg_name,\n",
+    "            \"Samples\": cap.total_samples,\n",
+    "            \"Minority Events\": cap.minority_class_samples,\n",
+    "            \"EPV\": f\"{cap.events_per_variable:.1f}\",\n",
+    "            \"Max Features (EPV=10)\": cap.recommended_features_moderate,\n",
+    "            \"Status\": cap.capacity_status.title()\n",
+    "        })\n",
+    "    \n",
+    "    segment_df = pd.DataFrame(segment_data)\n",
+    "    segment_df = segment_df.sort_values(\"Samples\", ascending=False)\n",
+    "    display(segment_df)\n",
+    "    \n",
+    "    # Visualization\n",
+    "    fig = go.Figure()\n",
+    "    \n",
+    "    max_events = 0\n",
+    "    for seg_name, cap in segment_result.segment_capacities.items():\n",
+    "        color = \"#2ecc71\" if cap.capacity_status == \"adequate\" else \"#f39c12\" if cap.capacity_status == \"limited\" else \"#e74c3c\"\n",
+    "        fig.add_trace(go.Bar(\n",
+    "            name=seg_name,\n",
+    "            x=[seg_name],\n",
+    "            y=[cap.minority_class_samples],\n",
+    "            marker_color=color,\n",
+    "            text=[f\"EPV={cap.events_per_variable:.1f}\"],\n",
+    "            textposition='outside'\n",
+    "        ))\n",
+    "        max_events = max(max_events, cap.minority_class_samples)\n",
+    "    \n",
+    "    # Add threshold line\n",
+    "    threshold_events = len(numeric_features) * 10  # EPV=10 threshold\n",
+    "    fig.add_hline(\n",
+    "        y=threshold_events,\n",
+    "        line_dash=\"dash\",\n",
+    "        line_color=\"#3498db\",\n",
+    "        annotation_text=f\"Min events for {len(numeric_features)} features (EPV=10)\",\n",
+    "        annotation_position=\"right\"\n",
+    "    )\n",
+    "    \n",
+    "    # Calculate y-axis range to fit labels\n",
+    "    y_max = max(max_events, threshold_events)\n",
+    "    fig.update_layout(\n",
+    "        title=f\"Minority Class Events by Segment ({segment_col})\",\n",
+    "        xaxis_title=\"Segment\",\n",
+    "        yaxis_title=\"Minority Class Events\",\n",
+    "        yaxis_range=[0, y_max * 1.15],  # Add 15% headroom for labels\n",
+    "        template='plotly_white',\n",
+    "        height=400,\n",
+    "        showlegend=False,\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    print(\"\\n📋 SEGMENT RECOMMENDATIONS:\")\n",
+    "    for rec in segment_result.recommendations:\n",
+    "        print(f\"   {rec}\")\n",
+    "    \n",
+    "    if segment_result.viable_segments:\n",
+    "        print(f\"\\n   ✅ Viable for separate models: {', '.join(segment_result.viable_segments)}\")\n",
+    "    if segment_result.insufficient_segments:\n",
+    "        print(f\"   ⚠️ Insufficient data: {', '.join(segment_result.insufficient_segments)}\")\n",
+    "    \n",
+    "    # Store in findings\n",
+    "    findings.metadata[\"segment_capacity\"] = segment_result.to_dict()\n",
+    "else:\n",
+    "    print(\"\\n⚠️ No categorical columns available for segment analysis.\")\n",
+    "    print(\"   Segment capacity analysis requires at least one categorical column.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ddaaacb",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006377,
+     "end_time": "2026-02-02T13:03:29.684180",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.677803",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 6.3.3 Feature Capacity Action Items\n",
+    "\n",
+    "Based on the analysis above, here are the key considerations for feature engineering:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0546a0e2",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.697042Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.696909Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.702192Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.701745Z"
+    },
+    "papermill": {
+     "duration": 0.012305,
+     "end_time": "2026-02-02T13:03:29.702706",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.690401",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Capacity Action Items Summary\n",
+    "if findings.target_column and 'capacity_result' in dir():\n",
+    "    print(\"=\" * 70)\n",
+    "    print(\"FEATURE CAPACITY ACTION ITEMS\")\n",
+    "    print(\"=\" * 70)\n",
+    "    \n",
+    "    print(\"\\n📋 BASED ON YOUR DATA CAPACITY:\")\n",
+    "    \n",
+    "    # Action items based on capacity status\n",
+    "    if capacity_result.capacity_status == \"adequate\":\n",
+    "        print(\"\\n✅ ADEQUATE CAPACITY - You have room to add features\")\n",
+    "        print(f\"   • Current features: {capacity_result.total_features}\")\n",
+    "        print(f\"   • Can add up to: {capacity_result.recommended_features_moderate - capacity_result.total_features} more features (EPV=10)\")\n",
+    "        print(f\"   • Consider: Creating derived features from datetime and categorical columns\")\n",
+    "    elif capacity_result.capacity_status == \"limited\":\n",
+    "        print(\"\\n⚠️ LIMITED CAPACITY - Be selective with new features\")\n",
+    "        print(f\"   • Current features: {capacity_result.total_features}\")\n",
+    "        print(f\"   • Recommended max: {capacity_result.recommended_features_moderate} features (EPV=10)\")\n",
+    "        print(f\"   • Action: Remove {max(0, capacity_result.total_features - capacity_result.recommended_features_moderate)} redundant features before adding new ones\")\n",
+    "        print(f\"   • Consider: Using regularization (L1/Lasso) if keeping all features\")\n",
+    "    else:\n",
+    "        print(\"\\n🔴 INADEQUATE CAPACITY - Reduce features or get more data\")\n",
+    "        print(f\"   • Current features: {capacity_result.total_features}\")\n",
+    "        print(f\"   • Recommended max: {capacity_result.recommended_features_moderate} features (EPV=10)\")\n",
+    "        print(f\"   • CRITICAL: Reduce to {capacity_result.recommended_features_conservative} features for stable estimates\")\n",
+    "        print(f\"   • Options: (1) Feature selection, (2) PCA, (3) Collect more data\")\n",
+    "    \n",
+    "    # Redundancy recommendations\n",
+    "    if capacity_result.effective_features_result and capacity_result.effective_features_result.redundant_features:\n",
+    "        redundant = capacity_result.effective_features_result.redundant_features\n",
+    "        print(f\"\\n🔄 REDUNDANT FEATURES TO CONSIDER REMOVING:\")\n",
+    "        print(f\"   These features are highly correlated with others and add little new information:\")\n",
+    "        for feat in redundant[:5]:\n",
+    "            print(f\"   • {feat}\")\n",
+    "        if len(redundant) > 5:\n",
+    "            print(f\"   ... and {len(redundant) - 5} more\")\n",
+    "    \n",
+    "    # New feature budget\n",
+    "    print(\"\\n💰 FEATURE BUDGET FOR NEW FEATURES:\")\n",
+    "    remaining_budget = capacity_result.recommended_features_moderate - capacity_result.total_features\n",
+    "    if remaining_budget > 0:\n",
+    "        print(f\"   You can safely add {remaining_budget} new features\")\n",
+    "        print(\"   Prioritize:\")\n",
+    "        print(\"   • Recency features (days_since_last_activity)\")\n",
+    "        print(\"   • Tenure features (days_since_created)\")\n",
+    "        print(\"   • Engagement composites (email_engagement_score)\")\n",
+    "    else:\n",
+    "        print(f\"   ⚠️ At or over capacity. Remove {-remaining_budget} features before adding new ones.\")\n",
+    "    \n",
+    "    # Model selection summary\n",
+    "    print(\"\\n🎯 RECOMMENDED MODELING APPROACH:\")\n",
+    "    if capacity_result.complexity_guidance:\n",
+    "        print(f\"   Model type: {capacity_result.complexity_guidance.recommended_model_type.replace('_', ' ').title()}\")\n",
+    "        if \"regularized\" in capacity_result.complexity_guidance.recommended_model_type:\n",
+    "            print(\"   → Use Lasso (L1) for automatic feature selection\")\n",
+    "            print(\"   → Use Ridge (L2) if you want to keep all features\")\n",
+    "        elif \"tree\" in capacity_result.complexity_guidance.recommended_model_type:\n",
+    "            print(\"   → Random Forest or XGBoost recommended\")\n",
+    "            print(\"   → Trees handle correlated features naturally\")\n",
+    "    \n",
+    "    print(\"\\n\" + \"=\" * 70)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa2dec27",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006408,
+     "end_time": "2026-02-02T13:03:29.715066",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.708658",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### 6.3.4 Feature Availability Issues\n",
+    "\n",
+    "Features with tracking changes (new systems, retired systems) require special handling before modeling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1dca7374",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.728363Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.728251Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.731861Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.731393Z"
+    },
+    "papermill": {
+     "duration": 0.010902,
+     "end_time": "2026-02-02T13:03:29.732323",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.721421",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Availability Analysis\n",
+    "from customer_retention.stages.features.feature_selector import FeatureSelector\n",
+    "\n",
+    "print(\"=\" * 70)\n",
+    "print(\"FEATURE AVAILABILITY ANALYSIS\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "unavailable_features = []\n",
+    "if findings.has_availability_issues:\n",
+    "    selector = FeatureSelector(target_column=findings.target_column)\n",
+    "    availability_recs = selector.get_availability_recommendations(findings.feature_availability)\n",
+    "    unavailable_features = [rec.column for rec in availability_recs]\n",
+    "    \n",
+    "    print(f\"\\n⚠️  {len(availability_recs)} feature(s) have tracking changes:\\n\")\n",
+    "    \n",
+    "    for rec in availability_recs:\n",
+    "        print(f\"📌 {rec.column}\")\n",
+    "        print(f\"   Issue: {rec.issue_type} | Coverage: {rec.coverage_pct:.0f}%\")\n",
+    "        print(f\"   Available: {rec.first_valid_date} → {rec.last_valid_date}\")\n",
+    "        print(f\"\\n   Remediation options:\")\n",
+    "        for opt in rec.options:\n",
+    "            marker = \"→\" if opt.get(\"recommended\") else \" \"\n",
+    "            print(f\"   {marker} [{opt['type']}] {opt['description']}\")\n",
+    "        print()\n",
+    "    \n",
+    "    print(\"-\" * 70)\n",
+    "    print(\"RECOMMENDED ACTION: Remove unavailable features before modeling\")\n",
+    "    print(\"-\" * 70)\n",
+    "    print(f\"\\nFeatures to exclude: {', '.join(unavailable_features)}\")\n",
+    "    print(\"\\nAlternative approaches (require additional implementation):\")\n",
+    "    print(\"  • segment_by_cohort: Train separate models for different time periods\")\n",
+    "    print(\"  • add_indicator: Create availability flags, impute missing values\")\n",
+    "    print(\"  • filter_window: Restrict training data to feature's available period\")\n",
+    "    \n",
+    "    findings.metadata[\"unavailable_features\"] = unavailable_features\n",
+    "    findings.metadata[\"availability_action\"] = \"exclude\"\n",
+    "else:\n",
+    "    print(\"\\n✅ All features have full temporal coverage - no availability issues.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8a17e0d",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006457,
+     "end_time": "2026-02-02T13:03:29.745087",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.738630",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.4 Datetime Feature Opportunities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22750047",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.758503Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.758383Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.761339Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.760856Z"
+    },
+    "papermill": {
+     "duration": 0.011094,
+     "end_time": "2026-02-02T13:03:29.762065",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.750971",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "datetime_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type == ColumnType.DATETIME\n",
+    "]\n",
+    "\n",
+    "if datetime_cols:\n",
+    "    print(\"Datetime Feature Opportunities:\")\n",
+    "    print(\"=\"*50)\n",
+    "    for col in datetime_cols:\n",
+    "        print(f\"\\n{col}:\")\n",
+    "        print(f\"  - {col}_year: Extract year\")\n",
+    "        print(f\"  - {col}_month: Extract month\")\n",
+    "        print(f\"  - {col}_day: Extract day of month\")\n",
+    "        print(f\"  - {col}_dayofweek: Extract day of week (0-6)\")\n",
+    "        print(f\"  - {col}_is_weekend: Is weekend flag\")\n",
+    "        print(f\"  - days_since_{col}: Days since date\")\n",
+    "else:\n",
+    "    print(\"No datetime columns found.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bf1a888",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006096,
+     "end_time": "2026-02-02T13:03:29.774279",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.768183",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.5 Business-Driven Derived Features\n",
+    "\n",
+    "These features are based on domain knowledge from the reference analysis (my_take Phase 1).\n",
+    "\n",
+    "**📖 Key Derived Features:**\n",
+    "- **Tenure Days**: Days from account creation to analysis date\n",
+    "- **Days Since Last Order**: Recency indicator (critical for churn)\n",
+    "- **Active Period Days**: Duration of customer activity\n",
+    "- **Email Engagement Score**: Composite of open rate and click rate\n",
+    "- **Click-to-Open Ratio**: Quality of email engagement\n",
+    "- **Service Adoption Score**: Sum of service flags (paperless, refill, doorstep)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4c81f6d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.787759Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.787565Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.797850Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.797421Z"
+    },
+    "papermill": {
+     "duration": 0.017788,
+     "end_time": "2026-02-02T13:03:29.798525",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.780737",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"=\" * 70)\n",
+    "print(\"CREATING DERIVED FEATURES\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "segmenter = CustomerSegmenter()\n",
+    "df_features = df.copy()\n",
+    "\n",
+    "datetime_cols = [name for name, col in findings.columns.items() \n",
+    "                 if col.inferred_type == ColumnType.DATETIME\n",
+    "                 and name not in TEMPORAL_METADATA_COLS]\n",
+    "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",
+    "numeric_cols = [name for name, col in findings.columns.items() \n",
+    "                if col.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]]\n",
+    "\n",
+    "for col in datetime_cols:\n",
+    "    df_features[col] = pd.to_datetime(df_features[col], errors='coerce', format='mixed')\n",
+    "\n",
+    "reference_date = pd.Timestamp.now()\n",
+    "if datetime_cols:\n",
+    "    last_dates = [df_features[col].max() for col in datetime_cols if df_features[col].notna().any()]\n",
+    "    if last_dates:\n",
+    "        reference_date = max(last_dates)\n",
+    "print(f\"\\nReference date: {reference_date}\")\n",
+    "\n",
+    "print(\"\\n📅 TIME-BASED FEATURES:\")\n",
+    "created_cols = [c for c in datetime_cols if 'creat' in c.lower() or 'signup' in c.lower() or 'register' in c.lower()]\n",
+    "if created_cols:\n",
+    "    created_col = created_cols[0]\n",
+    "    df_features = segmenter.create_tenure_features(df_features, created_column=created_col, reference_date=reference_date)\n",
+    "    print(f\"  ✓ tenure_days from {created_col}\")\n",
+    "    registry.add_silver_derived(\n",
+    "        column=\"tenure_days\",\n",
+    "        expression=f\"(reference_date - {created_col}).days\",\n",
+    "        feature_type=\"tenure\",\n",
+    "        rationale=f\"Customer tenure in days from {created_col}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "\n",
+    "activity_cols = [c for c in datetime_cols if 'last' in c.lower() or 'recent' in c.lower()]\n",
+    "if activity_cols:\n",
+    "    activity_col = activity_cols[0]\n",
+    "    df_features = segmenter.create_recency_features(df_features, last_activity_column=activity_col, \n",
+    "                                                     reference_date=reference_date, output_column='days_since_last_activity')\n",
+    "    print(f\"  ✓ days_since_last_activity from {activity_col}\")\n",
+    "    registry.add_silver_derived(\n",
+    "        column=\"days_since_last_activity\",\n",
+    "        expression=f\"(reference_date - {activity_col}).days\",\n",
+    "        feature_type=\"recency\",\n",
+    "        rationale=f\"Days since last activity from {activity_col}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "\n",
+    "print(\"\\n📧 ENGAGEMENT FEATURES:\")\n",
+    "rate_cols = [c for c in numeric_cols if 'rate' in c.lower() or 'pct' in c.lower() or 'percent' in c.lower()]\n",
+    "open_rate_cols = [c for c in rate_cols if 'open' in c.lower()]\n",
+    "click_rate_cols = [c for c in rate_cols if 'click' in c.lower()]\n",
+    "\n",
+    "if open_rate_cols and click_rate_cols:\n",
+    "    open_col, click_col = open_rate_cols[0], click_rate_cols[0]\n",
+    "    df_features = segmenter.create_engagement_score(df_features, open_rate_column=open_col, \n",
+    "                                                     click_rate_column=click_col, output_column='email_engagement_score')\n",
+    "    print(f\"  ✓ email_engagement_score from {open_col}, {click_col}\")\n",
+    "    registry.add_silver_derived(\n",
+    "        column=\"email_engagement_score\",\n",
+    "        expression=f\"0.6 * {open_col} + 0.4 * {click_col}\",\n",
+    "        feature_type=\"composite\",\n",
+    "        rationale=f\"Weighted engagement score from {open_col} and {click_col}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "    \n",
+    "    df_features['click_to_open_rate'] = np.where(df_features[open_col] > 0, df_features[click_col] / df_features[open_col], 0)\n",
+    "    print(f\"  ✓ click_to_open_rate\")\n",
+    "    registry.add_silver_ratio(\n",
+    "        column=\"click_to_open_rate\",\n",
+    "        numerator=click_col,\n",
+    "        denominator=open_col,\n",
+    "        rationale=f\"Click-to-open ratio: {click_col} / {open_col}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "\n",
+    "print(\"\\n🔧 SERVICE ADOPTION:\")\n",
+    "if binary_cols:\n",
+    "    service_binary = [c for c in binary_cols if c != findings.target_column]\n",
+    "    if service_binary:\n",
+    "        df_features['service_adoption_score'] = df_features[service_binary].sum(axis=1)\n",
+    "        print(f\"  ✓ service_adoption_score from {service_binary}\")\n",
+    "        registry.add_silver_derived(\n",
+    "            column=\"service_adoption_score\",\n",
+    "            expression=f\"sum([{', '.join(service_binary)}])\",\n",
+    "            feature_type=\"composite\",\n",
+    "            rationale=f\"Service adoption count from {len(service_binary)} binary flags\",\n",
+    "            source_notebook=\"06_feature_opportunities\"\n",
+    "        )\n",
+    "\n",
+    "print(\"\\n💰 VALUE FEATURES:\")\n",
+    "value_cols = [c for c in numeric_cols if 'order' in c.lower() or 'amount' in c.lower() or 'value' in c.lower() or 'avg' in c.lower()]\n",
+    "freq_cols = [c for c in numeric_cols if 'freq' in c.lower() or 'count' in c.lower()]\n",
+    "if value_cols and freq_cols:\n",
+    "    df_features['value_frequency_product'] = df_features[value_cols[0]] * df_features[freq_cols[0]]\n",
+    "    print(f\"  ✓ value_frequency_product from {value_cols[0]}, {freq_cols[0]}\")\n",
+    "    registry.add_silver_interaction(\n",
+    "        column=\"value_frequency_product\",\n",
+    "        features=[value_cols[0], freq_cols[0]],\n",
+    "        rationale=f\"Value-frequency interaction: {value_cols[0]} × {freq_cols[0]}\",\n",
+    "        source_notebook=\"06_feature_opportunities\"\n",
+    "    )\n",
+    "\n",
+    "new_cols = len(df_features.columns) - len(df.columns)\n",
+    "print(f\"\\n✓ Created {new_cols} new features (total: {len(df_features.columns)})\")\n",
+    "print(f\"✅ Persisted {len([c for c in ['tenure_days', 'days_since_last_activity', 'email_engagement_score', 'click_to_open_rate', 'service_adoption_score', 'value_frequency_product'] if c in df_features.columns])} derived feature recommendations to registry\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "534556db",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006703,
+     "end_time": "2026-02-02T13:03:29.811588",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.804885",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.6 Customer Segmentation Features\n",
+    "\n",
+    "Create business-meaningful segments for analysis and modeling.\n",
+    "\n",
+    "**📖 Segmentation Strategy:**\n",
+    "- **Value Dimension**: High vs Low (based on avgorder median)\n",
+    "- **Frequency Dimension**: Frequent vs Infrequent (based on ordfreq median)\n",
+    "- **Recency Buckets**: Active, Recent, Lapsing, Dormant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcd3b7d1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.824904Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.824788Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.830423Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.829634Z"
+    },
+    "papermill": {
+     "duration": 0.013189,
+     "end_time": "2026-02-02T13:03:29.831041",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.817852",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"=\" * 70)\n",
+    "print(\"CUSTOMER SEGMENTATION\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "print(\"\\n🎯 VALUE-FREQUENCY SEGMENTS:\")\n",
+    "value_cols = [c for c in numeric_cols if 'order' in c.lower() or 'amount' in c.lower() or 'value' in c.lower() or 'avg' in c.lower()]\n",
+    "freq_cols = [c for c in numeric_cols if 'freq' in c.lower() or 'count' in c.lower()]\n",
+    "\n",
+    "if value_cols and freq_cols:\n",
+    "    df_features, vf_result = segmenter.segment_by_value_frequency(\n",
+    "        df_features, value_column=value_cols[0], frequency_column=freq_cols[0])\n",
+    "    print(f\"  Using {value_cols[0]} × {freq_cols[0]}\")\n",
+    "    for seg in vf_result.segments:\n",
+    "        print(f\"    {seg.name}: {seg.count:,} ({seg.percentage:.1f}%)\")\n",
+    "else:\n",
+    "    print(\"  No suitable value/frequency columns found\")\n",
+    "\n",
+    "print(\"\\n📅 RECENCY SEGMENTS:\")\n",
+    "if 'days_since_last_activity' in df_features.columns:\n",
+    "    df_features, recency_result = segmenter.segment_by_recency(df_features, days_since_column='days_since_last_activity')\n",
+    "    for seg in recency_result.segments:\n",
+    "        print(f\"    {seg.name}: {seg.count:,} ({seg.percentage:.1f}%)\")\n",
+    "else:\n",
+    "    print(\"  No recency column available\")\n",
+    "\n",
+    "print(\"\\n📧 ENGAGEMENT SEGMENTS:\")\n",
+    "if 'email_engagement_score' in df_features.columns:\n",
+    "    max_score = df_features['email_engagement_score'].max()\n",
+    "    if max_score > 0:\n",
+    "        df_features['engagement_normalized'] = df_features['email_engagement_score'] / max_score\n",
+    "        df_features, eng_result = segmenter.segment_by_engagement(df_features, engagement_column='engagement_normalized')\n",
+    "        for seg in eng_result.segments:\n",
+    "            print(f\"    {seg.name}: {seg.count:,} ({seg.percentage:.1f}%)\")\n",
+    "        df_features = df_features.drop(columns=['engagement_normalized'])\n",
+    "else:\n",
+    "    print(\"  No engagement score available\")\n",
+    "\n",
+    "if 'customer_segment' in df_features.columns and findings.target_column and findings.target_column in df_features.columns:\n",
+    "    target = findings.target_column\n",
+    "    segment_retention = df_features.groupby('customer_segment')[target].mean() * 100\n",
+    "    \n",
+    "    max_rate = segment_retention.max()\n",
+    "    fig = go.Figure(go.Bar(\n",
+    "        x=segment_retention.index, y=segment_retention.values,\n",
+    "        marker_color=['#2ca02c' if r > 70 else '#ffbb00' if r > 50 else '#d62728' for r in segment_retention.values],\n",
+    "        text=[f'{r:.1f}%' for r in segment_retention.values], textposition='outside'))\n",
+    "    fig.update_layout(\n",
+    "        title='Retention Rate by Customer Segment', \n",
+    "        xaxis_title='Segment', \n",
+    "        yaxis_title='Retention Rate (%)',\n",
+    "        yaxis_range=[0, max_rate * 1.15],  # Add 15% headroom for labels\n",
+    "        template='plotly_white', \n",
+    "        height=400,\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "\n",
+    "segment_cols = [c for c in df_features.columns if 'segment' in c.lower() or 'bucket' in c.lower()]\n",
+    "print(f\"\\n✓ Created {len(segment_cols)} segmentation features\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59ec5a4e",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006712,
+     "end_time": "2026-02-02T13:03:29.845013",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.838301",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.7 Numeric Transformation Opportunities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ca081a4",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.859441Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.859325Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.869333Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.868693Z"
+    },
+    "papermill": {
+     "duration": 0.018433,
+     "end_time": "2026-02-02T13:03:29.869973",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.851540",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "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",
+    "transform_count = 0\n",
+    "if numeric_cols:\n",
+    "    print(\"Numeric Transformation Opportunities:\")\n",
+    "    print(\"=\"*50)\n",
+    "    \n",
+    "    for col_name in numeric_cols:\n",
+    "        col_info = findings.columns[col_name]\n",
+    "        series = df[col_name].dropna()\n",
+    "        skewness = series.skew()\n",
+    "        \n",
+    "        print(f\"\\n{col_name}:\")\n",
+    "        print(f\"  Skewness: {skewness:.2f}\")\n",
+    "        \n",
+    "        if abs(skewness) > 1:\n",
+    "            print(f\"  Recommendation: Apply log transform (highly skewed)\")\n",
+    "            registry.add_gold_transformation(\n",
+    "                column=col_name,\n",
+    "                transform=\"log\",\n",
+    "                parameters={\"skewness\": float(skewness), \"reason\": \"highly_skewed\"},\n",
+    "                rationale=f\"Log transform for highly skewed distribution (skewness={skewness:.2f})\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            transform_count += 1\n",
+    "        elif abs(skewness) > 0.5:\n",
+    "            print(f\"  Recommendation: Consider sqrt transform (moderately skewed)\")\n",
+    "            registry.add_gold_transformation(\n",
+    "                column=col_name,\n",
+    "                transform=\"sqrt\",\n",
+    "                parameters={\"skewness\": float(skewness), \"reason\": \"moderately_skewed\"},\n",
+    "                rationale=f\"Sqrt transform for moderately skewed distribution (skewness={skewness:.2f})\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            transform_count += 1\n",
+    "        else:\n",
+    "            print(f\"  Recommendation: Standard scaling sufficient\")\n",
+    "            registry.add_gold_scaling(\n",
+    "                column=col_name,\n",
+    "                method=\"standard\",\n",
+    "                rationale=f\"Standard scaling for normally distributed column (skewness={skewness:.2f})\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            transform_count += 1\n",
+    "        \n",
+    "        if col_info.inferred_type == ColumnType.NUMERIC_CONTINUOUS:\n",
+    "            print(f\"  Binning: Consider creating bins for {col_name}_binned\")\n",
+    "    \n",
+    "    print(f\"\\n✅ Persisted {transform_count} transformation recommendations to registry\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "013eb7ce",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006356,
+     "end_time": "2026-02-02T13:03:29.882881",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.876525",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.8 Categorical Encoding Opportunities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10f484f7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.896805Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.896685Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.901031Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.900122Z"
+    },
+    "papermill": {
+     "duration": 0.01235,
+     "end_time": "2026-02-02T13:03:29.901621",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.889271",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "categorical_cols = [\n",
+    "    name for name, col in findings.columns.items()\n",
+    "    if col.inferred_type in [ColumnType.CATEGORICAL_NOMINAL, ColumnType.CATEGORICAL_ORDINAL]\n",
+    "    and name not in TEMPORAL_METADATA_COLS\n",
+    "]\n",
+    "\n",
+    "encoding_count = 0\n",
+    "if categorical_cols:\n",
+    "    print(\"Categorical Encoding Recommendations:\")\n",
+    "    print(\"=\"*50)\n",
+    "    \n",
+    "    for col_name in categorical_cols:\n",
+    "        col_info = findings.columns[col_name]\n",
+    "        distinct = col_info.universal_metrics.get(\"distinct_count\", 0)\n",
+    "        \n",
+    "        print(f\"\\n{col_name}: ({distinct} unique values)\")\n",
+    "        \n",
+    "        if distinct <= 5:\n",
+    "            print(f\"  Recommendation: One-hot encoding\")\n",
+    "            registry.add_gold_encoding(\n",
+    "                column=col_name,\n",
+    "                method=\"onehot\",\n",
+    "                rationale=f\"One-hot encoding for low cardinality ({distinct} unique values)\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            encoding_count += 1\n",
+    "        elif distinct <= 20:\n",
+    "            print(f\"  Recommendation: Target encoding or one-hot with frequency threshold\")\n",
+    "            registry.add_gold_encoding(\n",
+    "                column=col_name,\n",
+    "                method=\"target\",\n",
+    "                rationale=f\"Target encoding for medium cardinality ({distinct} unique values)\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            encoding_count += 1\n",
+    "        else:\n",
+    "            print(f\"  Recommendation: Target encoding or embedding (high cardinality)\")\n",
+    "            registry.add_gold_encoding(\n",
+    "                column=col_name,\n",
+    "                method=\"target\",\n",
+    "                rationale=f\"Target encoding for high cardinality ({distinct} unique values)\",\n",
+    "                source_notebook=\"06_feature_opportunities\"\n",
+    "            )\n",
+    "            encoding_count += 1\n",
+    "        \n",
+    "        if col_info.inferred_type == ColumnType.CATEGORICAL_ORDINAL:\n",
+    "            print(f\"  Note: Consider ordinal encoding to preserve order\")\n",
+    "    \n",
+    "    print(f\"\\n✅ Persisted {encoding_count} encoding recommendations to registry\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83e8707f",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006628,
+     "end_time": "2026-02-02T13:03:29.915503",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.908875",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Summary: What We Learned\n",
+    "\n",
+    "In this notebook, we identified feature engineering opportunities and analyzed data capacity:\n",
+    "\n",
+    "### Feature Capacity Analysis\n",
+    "1. **Events Per Variable (EPV)** - Calculated the data's capacity to support features\n",
+    "2. **Effective Features** - Identified redundant features due to high correlation\n",
+    "3. **Model Complexity Guidance** - Determined appropriate model types based on data size\n",
+    "4. **Segment Capacity** - Evaluated whether segmented modeling is viable\n",
+    "\n",
+    "### Feature Engineering\n",
+    "5. **Automated Recommendations** - Framework suggested feature opportunities\n",
+    "6. **Time-Based Features** - Created tenure, recency, active period metrics\n",
+    "7. **Engagement Scores** - Built composite email engagement metrics\n",
+    "8. **Customer Segments** - Created value-frequency and recency-based segments\n",
+    "9. **Encoding Strategies** - Identified optimal encoding for each categorical\n",
+    "\n",
+    "## Feature Capacity Key Concepts\n",
+    "\n",
+    "| Metric | What It Means | Rule of Thumb |\n",
+    "|--------|---------------|---------------|\n",
+    "| **EPV ≥ 20** | Stable, reliable estimates | Conservative, regulatory-grade |\n",
+    "| **EPV = 10-20** | Standard practice | Use for most applications |\n",
+    "| **EPV = 5-10** | Limited capacity | Requires strong regularization |\n",
+    "| **EPV < 5** | High risk | Reduce features or get more data |\n",
+    "\n",
+    "## Key Derived Features Created\n",
+    "\n",
+    "| Feature | Formula | Business Meaning |\n",
+    "|---------|---------|-----------------|\n",
+    "| `tenure_days` | reference_date - created | Customer longevity |\n",
+    "| `days_since_last_order` | reference_date - lastorder | Recency/engagement |\n",
+    "| `email_engagement_score` | 0.6×openrate + 0.4×clickrate | Overall engagement |\n",
+    "| `service_adoption_score` | paperless + refill + doorstep | Service utilization |\n",
+    "| `customer_segment` | Value × Frequency quadrant | Customer type |\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "Continue to **07_modeling_readiness.ipynb** to:\n",
+    "- Validate data is ready for modeling\n",
+    "- Check for data leakage\n",
+    "- Assess class imbalance\n",
+    "- Review feature completeness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10135d83",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.929595Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.929481Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.932214Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.931785Z"
+    },
+    "papermill": {
+     "duration": 0.010581,
+     "end_time": "2026-02-02T13:03:29.932681",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.922100",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"Potential Interaction Features:\")\n",
+    "print(\"=\"*50)\n",
+    "\n",
+    "if len(numeric_cols) >= 2:\n",
+    "    print(\"\\nNumeric Interactions:\")\n",
+    "    for i, col1 in enumerate(numeric_cols[:3]):\n",
+    "        for col2 in numeric_cols[i+1:4]:\n",
+    "            print(f\"  - {col1}_x_{col2}: Multiplication\")\n",
+    "            print(f\"  - {col1}_div_{col2}: Division (if {col2} > 0)\")\n",
+    "\n",
+    "if categorical_cols and numeric_cols:\n",
+    "    print(\"\\nCategorical-Numeric Interactions:\")\n",
+    "    for cat_col in categorical_cols[:2]:\n",
+    "        for num_col in numeric_cols[:2]:\n",
+    "            print(f\"  - {num_col}_by_{cat_col}_mean: Group mean\")\n",
+    "            print(f\"  - {num_col}_by_{cat_col}_std: Group std\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fd5c408b",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006519,
+     "end_time": "2026-02-02T13:03:29.945809",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.939290",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 6.9 Feature Summary Table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91ae21da",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.959750Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.959602Z",
+     "iopub.status.idle": "2026-02-02T13:03:29.964357Z",
+     "shell.execute_reply": "2026-02-02T13:03:29.963917Z"
+    },
+    "papermill": {
+     "duration": 0.012698,
+     "end_time": "2026-02-02T13:03:29.964917",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.952219",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "feature_summary = []\n",
+    "for rec in feature_recs:\n",
+    "    feature_summary.append({\n",
+    "        \"Feature Name\": rec.feature_name,\n",
+    "        \"Source\": rec.source_column,\n",
+    "        \"Type\": rec.feature_type,\n",
+    "        \"Priority\": rec.priority\n",
+    "    })\n",
+    "\n",
+    "if feature_summary:\n",
+    "    summary_df = pd.DataFrame(feature_summary)\n",
+    "    display(summary_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc9d008e",
+   "metadata": {
+    "papermill": {
+     "duration": 0.006911,
+     "end_time": "2026-02-02T13:03:29.978469",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.971558",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "Continue to **07_modeling_readiness.ipynb** to validate data is ready for modeling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4628808a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:03:29.992359Z",
+     "iopub.status.busy": "2026-02-02T13:03:29.992067Z",
+     "iopub.status.idle": "2026-02-02T13:03:34.680434Z",
+     "shell.execute_reply": "2026-02-02T13:03:34.679976Z"
+    },
+    "papermill": {
+     "duration": 4.696712,
+     "end_time": "2026-02-02T13:03:34.681104",
+     "exception": false,
+     "start_time": "2026-02-02T13:03:29.984392",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Save recommendations\n",
+    "registry.save(RECOMMENDATIONS_PATH)\n",
+    "\n",
+    "print(f\"✅ Saved {len(registry.all_recommendations)} recommendations to {RECOMMENDATIONS_PATH}\")\n",
+    "print(f\"\\nRecommendations by layer:\")\n",
+    "for layer in [\"bronze\", \"silver\", \"gold\"]:\n",
+    "    recs = registry.get_by_layer(layer)\n",
+    "    print(f\"  {layer.upper()}: {len(recs)}\")\n",
+    "\n",
+    "from customer_retention.analysis.notebook_html_exporter import export_notebook_html\n",
+    "export_notebook_html(Path(\"06_feature_opportunities.ipynb\"), EXPERIMENTS_DIR / \"docs\")\n"
+   ]
+  }
+ ],
+ "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": 8.626387,
+   "end_time": "2026-02-02T13:03:35.105815",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/06_feature_opportunities.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/06_feature_opportunities.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:03:26.479428",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}