Session 22: Customer Retention & Churn Analytics

1. The Economics of Insurance Churn

Churn — policyholders not renewing their insurance policies — is the single most important driver of long-term insurance profitability. The cost of acquiring a new customer is 5–10× the cost of retaining an existing one, and a retained customer's profitability increases over time as acquisition costs are recovered and cross-sell revenue accumulates. In life insurance, where a policy's value is back-loaded (acquisition costs are recovered over 3–5 years), improving retention by even a few percentage points can double the value of new business written.

1.1 The Cost of Churn — A Numerical Example

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (classification_report, confusion_matrix, roc_auc_score,
                             precision_recall_curve, average_precision_score)
from sklearn.linear_model import LogisticRegression
import warnings
warnings.filterwarnings('ignore')

# Churn economics simulation
acquisition_cost = 2500    # Cost to acquire one new customer (₹)
annual_premium = 8500      # Average annual premium per customer
loss_ratio = 0.68          # Loss ratio
variable_expense_ratio = 0.15  # Variable expenses (claims + commissions + service)
profit_margin = 1 - loss_ratio - variable_expense_ratio  # ~17%
annual_profit = annual_premium * profit_margin

retention_rates = [0.50, 0.60, 0.70, 0.75, 0.80, 0.85, 0.90]
years = 10

print("=" * 75)
print("CHURN ECONOMICS — IMPACT OF RETENTION ON CUSTOMER VALUE")
print("=" * 75)
print(f"Assumptions:")
print(f"  Annual premium:           ₹{annual_premium:,.0f}")
print(f"  Profit margin:            {profit_margin*100:.0f}%")
print(f"  Annual profit/customer:   ₹{annual_profit:,.0f}")
print(f"  Acquisition cost:         ₹{acquisition_cost:,.0f}")
print(f"\nCustomer Lifetime Value by Retention Rate:")
print(f"{'Retention':12s} {'Avg Tenure':12s} {'CLV':15s} {'CLV w/o acq':15s} {'Value Lift':15s}")
print("-" * 69)

baseline_clv = 0
for ret in retention_rates:
    tenure_years = 1 / (1 - ret) if ret < 1 else years
    # CLV = Σ (profit per year × retention_prob) − acquisition cost
    clv = 0
    retention_prob = 1.0
    for yr in range(1, int(min(tenure_years, years)) + 1):
        if yr > 1:
            retention_prob *= ret
        clv += annual_profit * retention_prob
    clv -= acquisition_cost
    clv_w_o_acq = clv + acquisition_cost  # CLV ignoring acquisition cost

    if ret == 0.75:
        baseline_clv = clw

    value_lift = (clv - baseline_clv) / basseline_clv * 100 if basseline_clv != 0 else 0
    print(f"{ret*100:>5.0f}%      {tenure_years:>5.1f} years    ₹{clv:>7,.0f}       ₹{clv_w_o_acq:>7,.0f}     {'+' if value_lift > 0 else ''}{value_lift:>5.1f}%")

print(f"\nKey insight: Improving retention from 75% to 85% increases CLV by")
print(f"approximately 80% — because the customer stays twice as long and")
print(f"the acquisition cost is amortised over more years.")

2. Defining and Measuring Churn

Before we can predict churn, we must define it precisely. In insurance, "churn" is not a single event — it is the policyholder's failure to renew their policy when it expires. The operational definition of churn depends on the line of business and the policy term. For annual policies (most general insurance), a policy is "churned" if it has not been renewed within 60 days of its expiry date. For multi-year life insurance, churn is measured by "persistency" — the percentage of policies still in force at specific milestones (13 months, 25 months, 37 months, 61 months post-sale).

2.1 Churn Metrics Framework

2.2 Creating the Churn Label

# Load the insurance dataset
df = pd.read_csv('data/insurance_cleaned.csv')

# Create policy-level data with churn label
policy_data = df.groupby(['policy_id', 'customer_id']).agg(
    age=('age', 'first'),
    income=('income', 'first'),
    credit_score=('credit_score', 'first'),
    gender=('gender', 'first'),
    location=('location', 'first'),
    occupation=('occupation', 'first'),
    premium=('premium', 'first'),
    sum_assured=('sum_assured', 'first'),
    policy_type=('policy_type', 'first'),
    channel=('channel', 'first'),
    tenure_months=('tenure_months', 'first'),
    start_date=('start_date', 'first'),
    end_date=('end_date', 'first') if 'end_date' in df.columns else ('start_date', 'first'),
    claim_count=('claim_id', 'count'),
    total_claim_amount=('claim_amount', 'sum'),
    fraud_flag=('fraud_flag', 'max')
).reset_index()

# Create the churn label
# For this dataset, we simulate churn based on:
# 1. Whether the customer has a claim (fewer claims = higher churn)
# 2. Whether credit score is below a threshold
# 3. Random variation to create realistic distribution

np.random.seed(42)

# Base churn factors
no_claim_factor = (policy_data['claim_count'] == 0).astype(float) * 0.15  # 15% baseline churn for non-claimants
low_credit_factor = (policy_data['credit_score'] < 650).astype(float) * 0.10  # Additional churn risk
premium_factor = np.clip(policy_data['premium'] / policy_data['premium'].median() - 0.5, 0, 0.10)  # Higher premium = higher churn

# Combined churn probability
churn_prob = 0.10 + no_claim_factor + low_credit_factor + premium_factor + np.random.uniform(-0.05, 0.05, len(policy_data))
churn_prob = np.clip(churn_prob, 0.01, 0.60)

policy_data['churn_prob'] = churn_prob
policy_data['churned'] = (np.random.uniform(0, 1, len(policy_data)) < churn_prob).astype(int)

# Class balance
churn_rate = policy_data['churned'].mean() * 100
print(f"Policy-level dataset: {len(policy_data):,} policies")
print(f"Churn rate: {churn_rate:.1f}%")
print(f"  Retained (0): {(policy_data['churned']==0).sum():,}")
print(f"  Churned (1):  {(policy_data['churned']==1).sum():,}")
print(f"  Imbalance: {1/churn_rate*100:.1f}:1")

# Analyse churn by policy type
print(f"\nChurn rate by policy type:")
for ptype in policy_data['policy_type'].unique():
    subset = policy_data[policy_data['policy_type'] == ptype]
    rate = subset['churned'].mean() * 100
    print(f"  {ptype:15s}: {rate:.1f}% churn rate ({len(subset):,} policies)")

3. Feature Engineering for Churn

Churn prediction features fall into three categories: policy behaviour (premium changes, tenure, claims), customer characteristics (demographics, credit, channel preference), and interaction features (combinations that capture specific risk patterns). The best churn models use features from all three categories.

3.1 Creating Churn Features

# ==========================================
# CHURN FEATURE ENGINEERING
# ==========================================

# 1. Policy Behaviour Features
# ─────────────────────────

# Tenure: how long has the customer been with the insurer?
policy_data['tenure_years'] = policy_data['tenure_months'] / 12

# Premium change from previous year (simulated: compare premium to mean of same policy type)
mean_premium = policy_data.groupby('policy_type')['premium'].transform('mean')
policy_data['premium_vs_mean'] = (policy_data['premium'] - mean_premium) / mean_premium

# Has the customer ever filed a claim?
policy_data['had_claim'] = (policy_data['claim_count'] > 0).astype(int)

# Claim frequency per year of tenure
policy_data['claims_per_year'] = policy_data['claim_count'] / (policy_data['tenure_years'] + 0.5)

# Is the claim amount high relative to premium?
policy_data['claim_to_premium_ratio'] = policy_data['total_claim_amount'] / (policy_data['premium'] + 1)

# 2. Demographics & Customer Profile
# ────────────────────────────────

# Age group
policy_data['senior'] = (policy_data['age'] >= 60).astype(int)
policy_data['young'] = (policy_data['age'] <= 30).astype(int)

# Credit tier
policy_data['credit_tier'] = pd.cut(policy_data['credit_score'],
                                     bins=[0, 600, 700, 800, 900],
                                     labels=['Low', 'Fair', 'Good', 'Excellent'])

# Income relative to peers
median_income = policy_data['income'].median()
policy_data['income_above_median'] = (policy_data['income'] > median_income).astype(int)

# 3. Interaction Features
# ────────────────────

# Interaction: young + no claim (likely to churn — young customers with no claims
# may feel insurance is unnecessary)
policy_data['young_no_claim'] = (policy_data['young'] & (policy_data['claim_count'] == 0)).astype(int)

# Interaction: high premium + no claim (dissatisfaction — paying high premium for nothing)
policy_data['high_prem_no_claim'] = (
    (policy_data['premium_vs_mean'] > 0.2) & (policy_data['claim_count'] == 0)
).astype(int)

# Interaction: low credit + senior (most vulnerable segment)
policy_data['low_credit_senior'] = (
    (policy_data['credit_tier'] == 'Low') & (policy_data['senior'] == 1)
).astype(int)

# Interaction: digital channel × tenure < 1 year (early digital segment)
policy_data['new_digital'] = (
    (policy_data['channel'].isin(['Online', 'Aggregator'])) &
    (policy_data['tenure_years'] < 1)
).astype(int)

new_features = ['tenure_years', 'premium_vs_mean', 'had_claim', 'claims_per_year',
                'claim_to_premium_ratio', 'senior', 'young', 'credit_tier',
                'income_above_median', 'young_no_claim', 'high_prem_no_claim',
                'low_credit_senior', 'new_digital',
                'churned'  # skip — this is our target
                ]

print("Featured created — checking for data quality:")
for feat in new_features:
    if feat in policy_data.columns:
        nulls = policy_data[feat].isna().sum()
        if nulls > 0:
            policy_data[feat] = policy_data[feat].fillna(policy_data[feat].mode()[0] if
                policy_data[feat].dtype == 'object' else policy_data[feat].median())
        print(f"  ✓ {feat:25s} — {nulls} nulls filled")

# Count total features after one-hot encoding
feature_cols = [c for c in policy_data.columns if c not in ['policy_id', 'customer_id',
                'start_date', 'end_date', 'churn_prob', 'churned']]
print(f"\nTotal features: {len(feature_cols)} (including categoricals for encoding)")

4. Churn Prediction Model

Churn prediction is a binary classification problem with class imbalance (typically 70–85% retained vs. 15–30% churned). As with fraud detection, accuracy is a misleading metric — a model that predicts "everyone stays" achieves 70–85% accuracy but catches zero churn. We evaluate churn models on precision, recall, and particularly the ability to rank customers by churn probability so that retention efforts target the highest-risk customers first.

4.1 Training the Churn Classifier

# Define features and target
X = policy_data[feature_cols]
y = policy_data['churned']

# Identify column types
cat_cols_churn = X.select_dtypes(include=['object', 'category']).columns.tolist()
num_cols_churn = X.select_dtypes(include=[np.number]).columns.tolist()

# Preprocessor
preprocessor_churn = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), num_cols_churn),
        ('cat', OneHotEncoder(drop='first', handle_unknown='ignore', sparse_output=False), cat_cols_churn)
    ])

# Split
X_train_c, X_test_c, y_train_c, y_test_c = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

# XGBoost with scale_pos_weight
import xgboost as xgb
churn_ratio = (y_train_c == 0).sum() / (y_train_c == 1).sum()

xgb_churn = xgb.XGBClassifier(
    n_estimators=200, max_depth=5, learning_rate=0.05,
    scale_pos_weight=churn_ratio,
    subsample=0.8, colsample_bytree=0.8,
    reg_alpha=0.1, reg_lambda=1.0,
    random_state=42, n_jobs=-1, eval_metric='auc'
)

churn_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor_churn),
    ('classifier', xgb_churn)
])

churn_pipeline.fit(X_train_c, y_train_c)

# Predict
y_prob_churn = churn_pipeline.predict_proba(X_test_c)[:, 1]
y_pred_churn = (y_prob_churn >= 0.30).astype(int)  # Lower threshold to catch more churn

# Evaluate
print("=" * 60)
print("CHURN PREDICTION MODEL — XGBoost Results")
print("=" * 60)
print(f"Churn ratio (class_weight): {churn_ratio:.1f}:1")
print(f"\nClassification Report (threshold = 0.30):")
print(classification_report(y_test_c, y_pred_churn, target_names=['Retained', 'Churned']))

roc_auc = roc_auc_score(y_test_c, y_prob_churn)
pr_auc = average_precision_score(y_test_c, y_prob_churn)
print(f"ROC-AUC: {roc_auc:.3f}")
print(f"PR-AUC:  {pr_auc:.3f}")

# At this lower threshold, we catch more churners (higher recall)
# but at the cost of more false positives (wasted retention effort)
cm = confusion_matrix(y_test_c, y_pred_churn)
print(f"\nConfusion Matrix:")
print(f"                     Predicted Retained  Predicted Churned")
print(f"Actual Retained          {cm[0,0]:>6,d}          {cm[0,1]:>6,d}")
print(f"Actual Churned           {cm[1,0]:>6,d}          {cm[1,1]:>6,d}")
print(f"\nAt threshold = 0.30:")
print(f"  Recall (churn caught): {cm[1,1]/(cm[1,0]+cm[1,1])*100:.0f}%")
print(f"  Precision (efficiency): {cm[1,1]/(cm[0,1]+cm[1,1])*100:.0f}%")
print(f"  Would contact: {cm[0,1]+cm[1,1]:,} customers")

4.2 Finding the Optimal Threshold — Cost-Based

# Cost-benefit analysis for threshold selection
retention_offer_cost = 200  # Cost of a retention offer (discount, call centre, etc.)
clv_retained = annual_profit / (1 - 0.75)  # CLV of a retained customer at 75% retention
clv_saved_if_prevent_churn = clv_retained * 0.30  # Assume 30% of churners can be saved with intervention

thresholds = np.arange(0.05, 0.65, 0.05)
results = []

for threshold in thresholds:
    pred = (y_prob_churn >= threshold).astype(int)
    cm = confusion_matrix(y_test_c, pred)
    tp = cm[1, 1]  # Correctly identified churners — intervened, some retained
    fp = cm[0, 1]  # False positives — cost of unnecessary retention offer

    # Value: customers saved × CLV saved per customer
    customers_saved = tp * 0.30  # 30% of contacted churners are persuaded to stay
    value_saved = customers_saved * clv_saved_if_prevent_churn

    # Cost: contact everyone predicted to churn
    total_contact_cost = (tp + fp) * retention_offer_cost

    net_value = value_saved - total_contact_cost
    results.append({'threshold': threshold, 'net_value': net_value,
                    'customers_contacted': tp + fp, 'customers_saved': customers_saved})

results_df = pd.DataFrame(results)
optimal = results_df.loc[results_df['net_value'].idxmax()]

print(f"{'Threshold':12s} {'Contacted':12s} {'Saved':12s} {'Net Value':15s}")
print("-" * 51)
for _, row in results_df.iterrows():
    marker = '← OPTIMAL' if row['threshold'] == optimal['threshold'] else ''
    print(f"{row['threshold']:.2f}       {row['customers_contacted']:>5,.0f}     {row['customers_saved']:>5,.0f}     ₹{row['net_value']/1e5:.1f}L  {marker}")

print(f"\nOptimal threshold: {optimal['threshold']:.2f}")
print(f"At this threshold:")
print(f"  Contact {optimal['customers_contacted']:,} customers with retention offer")
print(f"  Expected to save {optimal['customers_saved']:.0f} customers")
print(f"  Net value: ₹{optimal['net_value']:,.0f}")
print(f"  ROI: {(optimal['net_value'] / (optimal['customers_contacted'] * retention_offer_cost) - 1)*100:.0f}%")

4.3 Feature Importance for Churn

# Extract feature importance
trained_model = churn_pipeline.named_steps['classifier']

# Get feature names
preprocessor_trained = churn_pipeline.named_steps['preprocessor']
cat_encoder = preprocessor_trained.named_transformers_['cat']
cat_feature_names_churn = cat_encoder.get_feature_names_out(cat_cols_churn).tolist() if len(cat_cols_churn) > 0 else []
all_features_churn = num_cols_churn + cat_feature_names_churn

importances = trained_model.feature_importances_
fi_churn = pd.DataFrame({
    'feature': all_features_churn[:len(importances)],
    'importance': importances
}).sort_values('importance', ascending=False)

print("=" * 55)
print("TOP CHURN PREDICTORS — FEATURE IMPORTANCE")
print("=" * 55)
for _, row in fi_churn.head(10).iterrows():
    pct = row['importance'] / fi_churn['importance'].sum() * 100
    bar = '█' * int(pct * 0.5)
    print(f"{row['feature']:30s} {pct:>5.1f}%  {bar}")

print(f"\nInterpretation:")
print(f"The top 3 features account for approximately ")
print(f"{fi_churn.head(3)['importance'].sum() / fi_churn['importance'].sum() * 100:.0f}% of")
print(f"the model's predictive power. These are the drivers of churn that")
print(f"retention strategies should address first.")

5. Retention Strategy Design

A churn prediction model is only useful if it leads to a retention action. The model identifies which customers are at risk — but the retention strategy determines what to do about it. The most important concept in retention strategy design is the distinction between voluntary churn (the customer actively decides to leave) and involuntary churn (the customer forgets to renew, changes their credit card, or their policy inadvertently lapses). Involuntary churn accounts for 20–40% of total churn in many insurance portfolios — and it is often the easiest to fix with operational improvements like automatic renewal and multiple payment reminders.

5.1 The Retention Action Framework

5.2 The "Persuadable" Segment

Not all customers predicted to churn are worth contacting. Some will leave no matter what you offer (the "lost causes"). Some will stay even without intervention (the "loyal" — your model flagged them as at-risk but they were actually not going to churn). The segment worth investing in is the persuadable — customers who will stay if given the right incentive but will leave without it. Uplift modelling — which directly predicts the incremental impact of a retention action on a specific customer — is the advanced technique for identifying the persuadable segment. For a simpler approach, segment predicted churners by their estimated CLV and contact only those above a CLV threshold:

# Apply churn probabilities to the portfolio
all_prob = churn_pipeline.predict_proba(X)[:, 1]
policy_data['churn_prob_score'] = all_prob

# Estimate CLV for each customer
policy_data['estimated_clv'] = (
    annual_profit * (1 / (1 - 0.75)) - acquisition_cost
) * (1 + 0.05 * policy_data['tenure_years'])  # CLV increases with tenure

# Segment for retention action
policy_data['retention_priority'] = pd.cut(
    policy_data['churn_prob_score'],
    bins=[0, 0.15, 0.30, 0.50, 1.0],
    labels=['Low Risk', 'Medium Risk', 'High Risk — Persuadable', 'High Risk — Lost Cause']
)

# Target: High Risk — Persuadable with CLV above threshold
target_for_retention = policy_data[
    (policy_data['retention_priority'] == 'High Risk — Persuadable') &
    (policy_data['estimated_clv'] > acquisition_cost)
]

print("=" * 60)
print("RETENTION TARGETING — SEGMENTATION")
print("=" * 60)
print(f"{'Segment':30s} {'Customers':>12s} {'CLV (avg)':>15s}")
print("-" * 57)
for tier in ['Low Risk', 'Medium Risk', 'High Risk — Persuadable', 'High Risk — Lost Cause']:
    subset = policy_data[policy_data['retention_priority'] == tier]
    if len(subset) > 0:
        print(f"{tier:30s} {len(subset):>8,d}   ₹{subset['estimated_clv'].mean():>8,.0f}")

print(f"\n{'─' * 57}")
print(f"RETENTION TARGET: '{target_for_retention['retention_priority'].iloc[0]}'")
print(f"  Customers to contact: {len(target_for_retention):,}")
print(f"  Average CLV:          ₹{target_for_retention['estimated_clv'].mean():,.0f}")
print(f"  Retention offer cost: ₹{retention_offer_cost}/customer")
print(f"  Total programme cost: ₹{len(target_for_retention) * retention_offer_cost:,.0f}")
print(f"  Estimated ROI: ~₹{(target_for_retention['estimated_clv'].sum() * 0.30 - len(target_for_retention) * retention_offer_cost) / max(len(target_for_retention) * retention_offer_cost, 1) * 100:.0f}%")

6. ROI of Retention

Retention programmes have a cost — discounts, call centre time, technology, management attention. Every retention rupee spent must be justified by a measurable reduction in churn. The ROI calculation compares the cost of the retention programme to the value of customers retained who would otherwise have churned.

6.1 The Retention ROI Model

# Retention ROI simulation
customers_targeted = len(target_for_retention)
avg_clv = target_for_retention['estimated_clv'].mean()
offer_cost_per_customer = 200  # ₹200 per customer contacted
expected_save_rate = 0.30      # 30% of targeted customers are persuaded to stay

# Programme costs
total_programme_cost = customers_targeted * offer_cost_per_customer

# Direct benefit
customers_saved = customers_targeted * expected_save_rate
total_value_saved = customers_saved * avg_clv

# Indirect benefit — "do not contact" savings
# Every customer we correctly identify as low-risk avoids a retention call they don't need
low_risk_count = len(policy_data[policy_data['retention_priority'] == 'Low Risk'])
do_not_contact_savings = low_risk_count * offer_cost_per_customer  # Not spending on these

net_roi = (total_value_saved - total_programme_cost) / total_programme_cost

print("=" * 60)
print("RETENTION PROGRAMME — ROI ANALYSIS")
print("=" * 60)
print(f"{'Metric':35s} {'Value':15s}")
print("-" * 50)
print(f"{'Customers targeted':35s} {customers_targeted:>8,d}")
print(f"{'Average CLV per customer':35s} ₹{avg_clv:>8,.0f}")
print(f"{'Offer cost per customer':35s} ₹{offer_cost_per_customer:>8,.0f}")
print(f"{'Expected save rate':35s} {expected_save_rate*100:.0f}%")
print(f"{'Customers expected to save':35s} {customers_saved:>8,.0f}")
print(f"{'Total programme cost':35s} ₹{total_programme_cost:>8,.0f}")
print(f"{'Total value saved':35s} ₹{total_value_saved:>8,.0f}")
print(f"{'Do-not-contact savings':35s} ₹{do_not_contact_savings:>8,.0f}")
print(f"{'─' * 50}")
print(f"{'NET ROI':35s} {net_roi*100:.0f}%")
print(f"{'Net benefit (₹)':35s} ₹{total_value_saved - total_programme_cost:>8,.0f}")

# Sensitivity analysis — varying save rate
save_rates = np.arange(0.10, 0.55, 0.05)
print(f"\nSensitivity Analysis — Save Rate → ROI:")
for sr in save_rates:
    saved = customers_targeted * sr
    value = saved * avg_clv
    cost = customers_targeted * offer_cost_per_customer
    roi = (value - cost) / cost
    print(f"  Save rate {sr*100:.0f}% → {saved:.0f} customers saved → ₹{value:,.0f} value → ROI {roi*100:.0f}%")

print(f"\nBreak-even save rate: {total_programme_cost / (avg_clv * customers_targeted) * 100:.1f}%")
print(f"(If the save rate falls below this, the programme destroys value.)")

7. KNIME Churn Workflow

KNIME Analytics Platform enables the churn scoring workflow to be built and operated by analysts who may not code in Python. The visual workflow is also valuable for auditability — the compliance team can see exactly how churn scores are generated, which features are used, and how the retention list is prioritised.

7.1 The KNIME Churn Scoring Workflow

KNIME WORKFLOW: CHURN_SCORING_V1

┌────────────────────────────┐
│ CSV Reader                 │
│ (insurance_cleaned.csv)    │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ GroupBy                    │
│ (Aggregate to policy level:│
│  premium, claim_count,     │
│  tenure_months, etc.)      │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ Rule Engine (Feature       │
│  Engineering)              │
│ tenure_years = tenure_m/12 │
│ had_claim = claim_ct > 0   │
│ premium_vs_mean = ...      │
│ young = age ≤ 30           │
│ senior = age ≥ 60          │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ Partitioning               │
│ (70% Train / 30% Test)    │
└─────────────┬──────────────┘
              │
    ┌─────────┴─────────┐
    │                   │
    ▼                   ▼
┌──────────────┐  ┌──────────────┐
│ XGBoost      │  │ (Test data   │
│ Learner      │  │  — no churn  │
│ scale_pos =  │  │  label)      │
│ weight       │  │              │
└──────┬───────┘  └──────┬───────┘
       │                  │
       ▼                  ▼
┌────────────────────────────┐
│ XGBoost Predictor          │
│ (Score test + new data)    │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ Scorer + Confusion Matrix  │
│ (Precision, Recall, F1,   │
│  ROC-AUC for validation)   │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ Rule Engine — Threshold    │
│ (Apply optimal threshold   │
│  from cost-benefit         │
│  analysis, e.g., ≥0.30)   │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ Sorter + Top K Selector    │
│ (Sort by churn_prob DESC, │
│  keep top 5,000 for        │
│  retention campaign)       │
└─────────────┬──────────────┘
              │
              ▼
┌────────────────────────────┐
│ CSV Writer                 │
│ (Retention list: customer_ │
│  id, phone, churn_prob,   │
│  estimated_clv, priority)  │
└────────────────────────────┘

7.2 KNIME vs. Python for Churn — Practical Comparison