AI Personalized Retention Offers System

Developing an AI-Powered Personalized Customer Retention System

Personalized retention offers are ML-systems that determine when and which customers should receive which offer to prevent churn. Not "send a 10% discount to everyone who hasn't purchased in 30 days," but rather "offer a 15% discount to the customer for whom price is a barrier, and propose expanded service to one leaving due to lack of features."

Churn Risk Prediction + Reasons

import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.multioutput import MultiOutputClassifier
from anthropic import Anthropic
import shap

class ChurnRiskModel:
    def __init__(self):
        self.churn_model = GradientBoostingClassifier(
            n_estimators=200, learning_rate=0.05,
            max_depth=5, random_state=42
        )
        # Multi-class model for churn reasons
        self.reason_model = MultiOutputClassifier(
            GradientBoostingClassifier(n_estimators=100, random_state=42)
        )
        self.llm = Anthropic()
        self.explainer = None

    def fit(self, users_df: pd.DataFrame, labels: pd.Series,
             churn_reasons: pd.DataFrame = None):
        """
        users_df: behavioral and transactional features
        labels: 1=churned, 0=retained
        churn_reasons: multi-label for reasons (price, features, competitor, quality, support)
        """
        X = users_df.fillna(0)
        self.churn_model.fit(X, labels)
        self.explainer = shap.TreeExplainer(self.churn_model)
        self.feature_names = users_df.columns.tolist()

        if churn_reasons is not None:
            self.reason_model.fit(X, churn_reasons)

    def predict_churn_risk(self, user_features: dict) -> dict:
        """Churn risk + reasons + SHAP explanation"""
        X = pd.DataFrame([user_features])[self.feature_names].fillna(0)
        churn_prob = self.churn_model.predict_proba(X)[0][1]

        # SHAP values for explanation
        shap_values = self.explainer.shap_values(X)
        if isinstance(shap_values, list):
            shap_vals = shap_values[1][0]
        else:
            shap_vals = shap_values[0]

        # Top risk factors
        top_factors = sorted(
            zip(self.feature_names, shap_vals),
            key=lambda x: abs(x[1]), reverse=True
        )[:5]

        return {
            'churn_probability': float(churn_prob),
            'risk_level': 'high' if churn_prob > 0.7 else 'medium' if churn_prob > 0.35 else 'low',
            'top_risk_factors': [
                {'feature': name, 'impact': float(impact), 'direction': 'increase' if impact > 0 else 'decrease'}
                for name, impact in top_factors
            ]
        }


class RetentionOfferEngine:
    """Selecting optimal retention offers"""

    def __init__(self, churn_model: ChurnRiskModel):
        self.churn_model = churn_model
        self.llm = Anthropic()
        self.offers = {
            'discount_10': {'type': 'discount', 'value': 10, 'cost': 0.1, 'segment': 'price_sensitive'},
            'discount_20': {'type': 'discount', 'value': 20, 'cost': 0.2, 'segment': 'high_risk'},
            'feature_unlock': {'type': 'feature', 'duration_days': 30, 'cost': 0.05, 'segment': 'power_users'},
            'personal_manager': {'type': 'service', 'cost': 0.15, 'segment': 'enterprise'},
            'loyalty_bonus': {'type': 'points', 'value': 500, 'cost': 0.03, 'segment': 'loyal'},
            'winback_survey': {'type': 'survey', 'cost': 0.01, 'segment': 'churned'},
        }

    def select_offer(self, user: dict, churn_risk: dict) -> dict:
        """Personalized offer selection"""
        risk_factors = {f['feature']: f['impact'] for f in churn_risk['top_risk_factors']}

        # Determine risk reason
        if risk_factors.get('days_since_last_purchase', 0) > 0 and \
           risk_factors.get('avg_order_value', 0) < 0:
            # Declining average order value = price sensitivity
            offer_key = 'discount_10' if churn_risk['churn_probability'] < 0.6 else 'discount_20'

        elif risk_factors.get('support_tickets_last_30d', 0) > 0:
            # Service issues
            offer_key = 'personal_manager'

        elif risk_factors.get('feature_usage_depth', 0) < 0:
            # Not using product
            offer_key = 'feature_unlock'

        elif user.get('total_orders', 0) > 20:
            # Loyal customer
            offer_key = 'loyalty_bonus'

        else:
            offer_key = 'discount_10'

        offer = self.offers[offer_key].copy()
        offer['offer_id'] = offer_key

        # Personalized message
        offer['message'] = self._personalize_message(user, offer, churn_risk)

        return offer

    def _personalize_message(self, user: dict, offer: dict, risk: dict) -> str:
        risk_factors_str = ", ".join([
            f['feature'] for f in risk['top_risk_factors'][:3]
        ])

        response = self.llm.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=100,
            messages=[{
                "role": "user",
                "content": f"""Write a personalized retention message (2 sentences max, warm tone).

User: {user.get('first_name', 'Customer')}, {user.get('tenure_months', 0)} months with us
Offer: {offer['type']} - {offer.get('value', '')}
Risk signals: {risk_factors_str}

Be specific, not generic. Don't mention risk/churn directly."""
            }]
        )
        return response.content[0].text

Model trained on 6 months of history predicts churn with AUC 0.82-0.88. Precision @30% threshold (high risk): 65-75%. Optimal timing for offer: 7-14 days before predicted churn, when user is still active. Personalized offer conversion vs. mass mailing: 12-18% vs. 2-4%.