Churn Prediction Model Expert агент

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def create_churn_features(df, observation_end_date, window_days=90):
    """
    Create comprehensive churn prediction features
    """
    observation_start = observation_end_date - timedelta(days=window_days)

    # Behavioral features
    features = {
        # Recency features
        'days_since_last_login': (observation_end_date - df.groupby('customer_id')['last_login_date'].max()).dt.days,
        'days_since_last_purchase': (observation_end_date - df.groupby('customer_id')['last_purchase_date'].max()).dt.days,

        # Frequency features
        'login_frequency': df.groupby('customer_id')['login_count'].sum() / window_days,
        'purchase_frequency': df.groupby('customer_id')['purchase_count'].sum() / window_days,
        'support_ticket_frequency': df.groupby('customer_id')['support_tickets'].sum() / window_days,

        # Monetary features
        'total_spend': df.groupby('customer_id')['revenue'].sum(),
        'avg_order_value': df.groupby('customer_id')['revenue'].mean(),
        'spend_trend': df.groupby('customer_id').apply(lambda x: np.polyfit(range(len(x)), x['revenue'], 1)[0]),

        # Engagement features
        'feature_usage_breadth': df.groupby('customer_id')['unique_features_used'].nunique(),
        'session_duration_avg': df.groupby('customer_id')['session_duration'].mean(),
        'bounce_rate': df.groupby('customer_id')['single_page_sessions'].sum() / df.groupby('customer_id')['total_sessions'].sum(),

        # Lifecycle features
        'customer_age_days': (observation_end_date - df.groupby('customer_id')['signup_date'].first()).dt.days,
        'tenure_bucket': pd.cut((observation_end_date - df.groupby('customer_id')['signup_date'].first()).dt.days, 
                              bins=[0, 30, 90, 365, float('inf')], labels=['new', 'growing', 'mature', 'veteran'])
    }

    return pd.DataFrame(features)

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import TimeSeriesSplit, GridSearchCV
from sklearn.preprocessing import StandardScaler
from imblearn.over_sampling import SMOTE

def train_churn_models(X, y, test_size=0.2):
    """
    Train and compare multiple churn prediction models
    """
    # Time-aware split to prevent data leakage
    split_point = int(len(X) * (1 - test_size))
    X_train, X_test = X[:split_point], X[split_point:]
    y_train, y_test = y[:split_point], y[split_point:]

    # Handle class imbalance
    smote = SMOTE(random_state=42)
    X_train_balanced, y_train_balanced = smote.fit_resample(X_train, y_train)

    models = {
        'logistic': LogisticRegression(class_weight='balanced', random_state=42),
        'random_forest': RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42),
        'xgboost': XGBClassifier(scale_pos_weight=len(y_train[y_train==0])/len(y_train[y_train==1]), random_state=42),
        'gradient_boosting': GradientBoostingClassifier(random_state=42)
    }

    trained_models = {}
    for name, model in models.items():
        if name == 'logistic':
            scaler = StandardScaler()
            X_train_scaled = scaler.fit_transform(X_train_balanced)
            model.fit(X_train_scaled, y_train_balanced)
            trained_models[name] = (model, scaler)
        else:
            model.fit(X_train_balanced, y_train_balanced)
            trained_models[name] = model

    return trained_models, X_test, y_test

from sklearn.metrics import precision_recall_curve, roc_auc_score, classification_report
import matplotlib.pyplot as plt

def evaluate_churn_model(model, X_test, y_test, model_name):
    """
    Comprehensive evaluation focusing on business metrics
    """
    if isinstance(model, tuple):  # Handle scaled models
        clf, scaler = model
        y_pred_proba = clf.predict_proba(scaler.transform(X_test))[:, 1]
        y_pred = clf.predict(scaler.transform(X_test))
    else:
        y_pred_proba = model.predict_proba(X_test)[:, 1]
        y_pred = model.predict(X_test)

    # Core metrics
    precision, recall, thresholds = precision_recall_curve(y_test, y_pred_proba)
    auc_score = roc_auc_score(y_test, y_pred_proba)

    # Business metrics
    def calculate_business_value(precision, recall, threshold):
        # Assume: $100 cost to contact customer, $500 value if churn prevented
        true_positives = recall * sum(y_test)
        false_positives = (sum(y_pred_proba > threshold) - true_positives)

        revenue_saved = true_positives * 500
        contact_cost = (true_positives + false_positives) * 100
        return revenue_saved - contact_cost

    # Find optimal threshold for business value
    business_values = [calculate_business_value(p, r, t) for p, r, t in zip(precision, recall, thresholds)]
    optimal_idx = np.argmax(business_values)
    optimal_threshold = thresholds[optimal_idx]

    print(f"Model: {model_name}")
    print(f"AUC-ROC: {auc_score:.3f}")
    print(f"Optimal Threshold: {optimal_threshold:.3f}")
    print(f"Precision at Optimal: {precision[optimal_idx]:.3f}")
    print(f"Recall at Optimal: {recall[optimal_idx]:.3f}")
    print(f"Maximum Business Value: ${business_values[optimal_idx]:,.2f}")

    return optimal_threshold, business_values[optimal_idx]

import shap

def explain_churn_predictions(model, X, feature_names):
    """
    Generate interpretable explanations for churn predictions
    """
    # SHAP explanations
    explainer = shap.TreeExplainer(model)
    shap_values = explainer.shap_values(X)

    # Feature importance summary
    feature_importance = pd.DataFrame({
        'feature': feature_names,
        'importance': np.abs(shap_values).mean(0)
    }).sort_values('importance', ascending=False)

    print("Top 10 Churn Drivers:")
    print(feature_importance.head(10))

    return shap_values, feature_importance

def create_customer_risk_segments(predictions, probabilities):
    """
    Segment customers by churn risk for targeted interventions
    """
    risk_segments = pd.cut(probabilities, 
                          bins=[0, 0.3, 0.6, 0.8, 1.0],
                          labels=['Low Risk', 'Medium Risk', 'High Risk', 'Critical Risk'])

    interventions = {
        'Low Risk': 'Monitor engagement metrics',
        'Medium Risk': 'Proactive customer success outreach',
        'High Risk': 'Personalized retention offers',
        'Critical Risk': 'Executive intervention required'
    }

    return risk_segments, interventions

def monitor_model_drift(reference_data, new_data, threshold=0.1):
    """
    Monitor for feature drift and model degradation
    """
    from scipy.stats import ks_2samp

    drift_scores = {}
    for column in reference_data.columns:
        if reference_data[column].dtype in ['int64', 'float64']:
            statistic, p_value = ks_2samp(reference_data[column], new_data[column])
            drift_scores[column] = {'ks_statistic': statistic, 'p_value': p_value}

            if p_value < 0.05:  # Significant drift detected
                print(f"⚠️  Drift detected in {column}: KS={statistic:.3f}, p={p_value:.3f}")

    return drift_scores

def update_model_performance(model, new_X, new_y, performance_threshold=0.75):
    """
    Check if model retraining is needed based on performance degradation
    """
    current_auc = roc_auc_score(new_y, model.predict_proba(new_X)[:, 1])

    if current_auc < performance_threshold:
        print(f"🔄 Model retraining recommended. Current AUC: {current_auc:.3f}")
        return True
    else:
        print(f"✅ Model performance stable. Current AUC: {current_auc:.3f}")
        return False