diff --git "a/notebooks/03_Churn_Prediction.ipynb" "b/notebooks/03_Churn_Prediction.ipynb" new file mode 100644--- /dev/null +++ "b/notebooks/03_Churn_Prediction.ipynb" @@ -0,0 +1,1713 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "id": "477c2720", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from xgboost import XGBClassifier\n", + "from sklearn.metrics import classification_report, confusion_matrix\n" + ] + }, + { + "cell_type": "markdown", + "id": "a37d1c58", + "metadata": {}, + "source": [ + "# Load the CLEAN transactional data (Not the RFM data, the raw clean transactions)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "173e1c19", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "df = pd.read_csv('../data/processed/online_retail_clean.csv')\n" + ] + }, + { + "cell_type": "markdown", + "id": "3cea0124", + "metadata": {}, + "source": [ + "# Ensure Date is datetime\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "910b1455", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data Range: 2009-12-01 07:45:00 to 2010-12-09 20:01:00\n" + ] + } + ], + "source": [ + "\n", + "df['InvoiceDate'] = pd.to_datetime(df['InvoiceDate'])\n", + "\n", + "print(f\"Data Range: {df['InvoiceDate'].min()} to {df['InvoiceDate'].max()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0a4b85bf", + "metadata": {}, + "source": [ + "# 1. Define the \"Cutoff Date\"\n", + "# We take the last 90 days as the \"Target Period\" (Test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9d81e3b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Data (X): Before 2010-09-10 20:01:00\n", + "Target Data (y): After 2010-09-10 20:01:00\n" + ] + } + ], + "source": [ + "\n", + "cutoff_date = df['InvoiceDate'].max() - pd.DateOffset(days=90)\n", + "print(f\"Training Data (X): Before {cutoff_date}\")\n", + "print(f\"Target Data (y): After {cutoff_date}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "97c90c45", + "metadata": {}, + "source": [ + "# 2. Split Data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ad5b635a", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "train_data = df[df['InvoiceDate'] < cutoff_date]\n", + "test_target_data = df[df['InvoiceDate'] >= cutoff_date]\n" + ] + }, + { + "cell_type": "markdown", + "id": "3cf4cc9c", + "metadata": {}, + "source": [ + "\n", + "# 3. Create the Target (y)\n", + "# Who purchased in the Test Period?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c3c56159", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "active_customers = test_target_data['Customer ID'].unique()\n" + ] + }, + { + "cell_type": "markdown", + "id": "0a8464e6", + "metadata": {}, + "source": [ + "\n", + "# 4. Feature Engineering on TRAINING Data only (To prevent Data Leakage)\n", + "# We calculate RFM based on behavior BEFORE the cutoff" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7dc8d4da", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "train_features = train_data.groupby('Customer ID').agg({\n", + " 'InvoiceDate': lambda x: (cutoff_date - x.max()).days, # Recency (at cutoff)\n", + " 'Invoice': 'nunique', # Frequency\n", + " 'Total Price': 'sum' # Monetary\n", + "}).reset_index()\n", + "\n", + "train_features.rename(columns={\n", + " 'InvoiceDate': 'Recency',\n", + " 'Invoice': 'Frequency',\n", + " 'Total Price': 'Monetary'\n", + "}, inplace=True)\n" + ] + }, + { + "cell_type": "markdown", + "id": "8dbe187f", + "metadata": {}, + "source": [ + "\n", + "# 5. Assign Labels (1 = Churned, 0 = Retained)\n", + "# If Customer is NOT in 'active_customers', they Churned" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5e160ded", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Churn Distribution:\n", + "Is_Churn\n", + "0 0.575067\n", + "1 0.424933\n", + "Name: proportion, dtype: float64\n" + ] + } + ], + "source": [ + "\n", + "train_features['Is_Churn'] = train_features['Customer ID'].apply(\n", + " lambda x: 0 if x in active_customers else 1\n", + ")\n", + "\n", + "print(\"\\nChurn Distribution:\")\n", + "print(train_features['Is_Churn'].value_counts(normalize=True))\n" + ] + }, + { + "cell_type": "markdown", + "id": "9407655d", + "metadata": {}, + "source": [ + "# Additional features from training data" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c348b111", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "extra_features = train_data.groupby('Customer ID').agg({\n", + " 'Quantity': 'mean', # Average basket size\n", + " 'Total Price': 'mean', # Average spend per transaction\n", + "}).reset_index()\n", + "\n", + "extra_features.rename(columns={'Total Price': 'Avg_Spend_Per_Order'}, inplace=True)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "6c4790a2", + "metadata": {}, + "source": [ + "# Merge with main features\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bb39f0a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Customer IDRecencyFrequencyMonetaryIs_ChurnQuantityAvg_Spend_Per_Order
0123467411372.8612.12121211.298788
11234911521268.52010.08510626.989787
2123551121488.21113.77272722.191364
3123589521697.93016.85714348.512286
4123598052012.03010.19767423.395698
\n", + "
" + ], + "text/plain": [ + " Customer ID Recency Frequency Monetary Is_Churn Quantity \\\n", + "0 12346 74 11 372.86 1 2.121212 \n", + "1 12349 115 2 1268.52 0 10.085106 \n", + "2 12355 112 1 488.21 1 13.772727 \n", + "3 12358 95 2 1697.93 0 16.857143 \n", + "4 12359 80 5 2012.03 0 10.197674 \n", + "\n", + " Avg_Spend_Per_Order \n", + "0 11.298788 \n", + "1 26.989787 \n", + "2 22.191364 \n", + "3 48.512286 \n", + "4 23.395698 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_df = pd.merge(train_features, extra_features, on='Customer ID', how='left')\n", + "\n", + "display(model_df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "4dbb0f00", + "metadata": {}, + "source": [ + "# 1. Prepare X and y\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "52f7023a", + "metadata": {}, + "outputs": [], + "source": [ + "X = model_df.drop(['Customer ID', 'Is_Churn'], axis=1)\n", + "y = model_df['Is_Churn']\n" + ] + }, + { + "cell_type": "markdown", + "id": "b1b29713", + "metadata": {}, + "source": [ + "# 2. Split into Train/Test for Validation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0139e127", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1695e57b", + "metadata": {}, + "source": [ + "\n", + "# 3. Train Model (Using Random Forest with Class Weights)\n", + "# class_weight='balanced' handles the imbalance automatically" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "49de0abf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Training Complete.\n" + ] + } + ], + "source": [ + "\n", + "rf_model = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42)\n", + "rf_model.fit(X_train, y_train)\n", + "\n", + "print(\"Model Training Complete.\")" + ] + }, + { + "cell_type": "markdown", + "id": "ea4b2375", + "metadata": {}, + "source": [ + "# Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bd218513", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "y_pred = rf_model.predict(X_test)\n" + ] + }, + { + "cell_type": "markdown", + "id": "c98c84d6", + "metadata": {}, + "source": [ + "\n", + "# Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fc3ab036", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Classification Report:\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.71 0.73 0.72 397\n", + " 1 0.60 0.58 0.59 279\n", + "\n", + " accuracy 0.67 676\n", + " macro avg 0.66 0.66 0.66 676\n", + "weighted avg 0.67 0.67 0.67 676\n", + "\n" + ] + } + ], + "source": [ + "\n", + "print(\"\\nClassification Report:\\n\")\n", + "print(classification_report(y_test, y_pred))\n" + ] + }, + { + "cell_type": "markdown", + "id": "e2fdb53f", + "metadata": {}, + "source": [ + "\n", + "# Confusion Matrix Heatmap" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e61e2fb1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.figure(figsize=(6, 4))\n", + "sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')\n", + "plt.title('Confusion Matrix (0=Retained, 1=Churned)')\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "75f9fb10", + "metadata": {}, + "outputs": [], + "source": [ + "from xgboost import XGBClassifier\n", + "from xgboost import plot_importance\n" + ] + }, + { + "cell_type": "markdown", + "id": "6de94cf6", + "metadata": {}, + "source": [ + "\n", + "# 1. Initialize XGBoost\n", + "# We use scale_pos_weight to handle the imbalance (roughly ratio of Retained / Churned)\n", + "# This forces the model to pay more attention to the \"1\"s (Churners)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f8295847", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "xgb_model = XGBClassifier(\n", + " n_estimators=150, \n", + " learning_rate=0.05, \n", + " max_depth=5, \n", + " scale_pos_weight=1.5, # Penalize missing a churner!\n", + " random_state=42\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "54764f6c", + "metadata": {}, + "source": [ + "# 2. Train" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "9a998a16", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              feature_weights=None, gamma=None, grow_policy=None,\n",
+       "              importance_type=None, interaction_constraints=None,\n",
+       "              learning_rate=0.05, max_bin=None, max_cat_threshold=None,\n",
+       "              max_cat_to_onehot=None, max_delta_step=None, max_depth=5,\n",
+       "              max_leaves=None, min_child_weight=None, missing=nan,\n",
+       "              monotone_constraints=None, multi_strategy=None, n_estimators=150,\n",
+       "              n_jobs=None, num_parallel_tree=None, ...)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "XGBClassifier(base_score=None, booster=None, callbacks=None,\n", + " colsample_bylevel=None, colsample_bynode=None,\n", + " colsample_bytree=None, device=None, early_stopping_rounds=None,\n", + " enable_categorical=False, eval_metric=None, feature_types=None,\n", + " feature_weights=None, gamma=None, grow_policy=None,\n", + " importance_type=None, interaction_constraints=None,\n", + " learning_rate=0.05, max_bin=None, max_cat_threshold=None,\n", + " max_cat_to_onehot=None, max_delta_step=None, max_depth=5,\n", + " max_leaves=None, min_child_weight=None, missing=nan,\n", + " monotone_constraints=None, multi_strategy=None, n_estimators=150,\n", + " n_jobs=None, num_parallel_tree=None, ...)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "\n", + "xgb_model.fit(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "id": "04eac662", + "metadata": {}, + "source": [ + "\n", + "# 3. Predict" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "57b3b86e", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "y_pred_xgb = xgb_model.predict(X_test)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1945f2eb", + "metadata": {}, + "source": [ + "\n", + "# 4. Compare Results" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "1b8c6824", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "XGBoost Classification Report:\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.75 0.57 0.65 397\n", + " 1 0.55 0.73 0.62 279\n", + "\n", + " accuracy 0.64 676\n", + " macro avg 0.65 0.65 0.64 676\n", + "weighted avg 0.67 0.64 0.64 676\n", + "\n" + ] + } + ], + "source": [ + "\n", + "print(\"XGBoost Classification Report:\\n\")\n", + "print(classification_report(y_test, y_pred_xgb))\n" + ] + }, + { + "cell_type": "markdown", + "id": "b0e1294e", + "metadata": {}, + "source": [ + "# 5. Visualizing Feature Importance (CRITICAL for Business Insight)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "53159afa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.figure(figsize=(10,6))\n", + "sorted_idx = xgb_model.feature_importances_.argsort()\n", + "plt.barh(X.columns[sorted_idx], xgb_model.feature_importances_[sorted_idx])\n", + "plt.xlabel(\"XGBoost Feature Importance\")\n", + "plt.title(\"What drives Customer Churn?\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0ea27fba", + "metadata": {}, + "source": [ + "# 🚀 Executive Summary: Churn Prediction Model\n", + "\n", + "### 1. Model Performance\n", + "Our XGBoost model prioritized **Recall (73%)** over precision. This ensures we capture the vast majority of at-risk customers, allowing the marketing team to intervene before it's too late.\n", + "\n", + "### 2. Key Driver Analysis\n", + "Using Feature Importance analysis, we discovered a critical insight:\n", + "* **Primary Driver: Purchase Frequency.**\n", + " * *Interpretation:* The number of times a user interacts with the platform is the strongest predictor of loyalty—far more than how much they spend (Monetary) or how recently they visited (Recency).\n", + " * *Risk:* \"One-time buyers\" are our highest risk segment.\n", + "\n", + "### 3. Recommended Retention Strategy\n", + "| Feature Driver | Insight | Recommended Action |\n", + "| :--- | :--- | :--- |\n", + "| **Low Frequency** | Users with 1-2 purchases are likely to drop. | **Action:** Implement a \"Second Purchase Bonus.\" Send a targeted offer immediately after the first delivery is received to encourage habit formation. |\n", + "| **High Monetary / High Risk** | High spenders flagged as churning are critical losses. | **Action:** VIP Outreach. Account managers should manually review these 100-200 high-value flags. |\n", + "| **High Recency** | Users silent for >60 days. | **Action:** Automated Re-engagement campaign (We miss you email). |" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "140f55d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model saved successfully to ../models/churn_xgb_model.pkl\n" + ] + } + ], + "source": [ + "import joblib\n", + "\n", + "# Define path\n", + "model_path = '../models/churn_xgb_model.pkl'\n", + "\n", + "# Save the trained XGBoost model\n", + "joblib.dump(xgb_model, model_path)\n", + "\n", + "print(f\"Model saved successfully to {model_path}\")" + ] + } + ], + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}