Add main app.py with insurance behavior analysis

app.py

@@ -0,0 +1,243 @@
+"""保险APP 用户行为分析 - Gradio Space"""
+import os, json, math, warnings, datetime, random
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+warnings.filterwarnings('ignore')
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+from sklearn.metrics import (
+    roc_auc_score, f1_score, confusion_matrix,
+    average_precision_score, precision_recall_curve, classification_report
+)
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+import gradio as gr
+
+INSURANCE_EVENT_TYPES = {
+    "page_view", "product_view", "product_compare", "premium_calculator",
+    "faq_view", "article_read", "quote_request", "quote_result_view",
+    "document_upload", "form_submit", "chat_init", "call_init", "video_consult",
+    "policy_select", "payment_init", "payment_success", "policy_issued",
+    "claim_init", "claim_doc_upload", "claim_review", "claim_approved",
+    "claim_rejected", "renewal_reminder", "renewal_click", "renewal_complete",
+    "policy_cancel", "app_uninstall", "login", "logout",
+}
+
+@dataclass
+class InsuranceAppEvent:
+    event_id: str; user_id: str; session_id: str; timestamp: int
+    event_type: str; page_id: str
+    product_id: Optional[str] = None; amount: Optional[float] = None
+    channel: str = "app"; device_type: str = "mobile"
+
+@dataclass
+class UserSession:
+    session_id: str; user_id: str
+    events: List[InsuranceAppEvent] = field(default_factory=list)
+
+@dataclass
+class UserBehaviorProfile:
+    user_id: str; sessions: List[UserSession] = field(default_factory=list)
+
+
+class InsuranceFeatureEngineer:
+    def extract_user_features(self, profile):
+        sessions = profile.sessions
+        if not sessions: return None
+        all_events = []
+        for s in sessions: all_events.extend(s.events)
+        all_events.sort(key=lambda e: e.timestamp)
+        all_type_counts = Counter(e.event_type for e in all_events)
+        total = len(all_events)
+        if total == 0: return None
+        product_counter = Counter(e.product_id for e in all_events if e.product_id)
+        top_product = product_counter.most_common(1)[0][0] if product_counter else None
+        first_ts = all_events[0].timestamp; last_ts = all_events[-1].timestamp
+        days_active = (last_ts - first_ts) / (24 * 3600 * 1000)
+        has_purchased = any(e.event_type == "policy_issued" for e in all_events)
+        has_renewed = any(e.event_type == "renewal_complete" for e in all_events)
+        has_claimed = any(e.event_type in ("claim_init", "claim_approved") for e in all_events)
+        support = all_type_counts.get("chat_init", 0) + all_type_counts.get("call_init", 0)
+        return {
+            "total_sessions": len(sessions), "total_events": total,
+            "days_active": days_active, "avg_events_per_session": total / len(sessions),
+            "product_view_ratio": all_type_counts.get("product_view", 0) / total,
+            "quote_request_ratio": all_type_counts.get("quote_request", 0) / total,
+            "article_read_ratio": all_type_counts.get("article_read", 0) / total,
+            "payment_success_ratio": all_type_counts.get("payment_success", 0) / total,
+            "policy_issued_ratio": all_type_counts.get("policy_issued", 0) / total,
+            "unique_products_viewed": len(product_counter),
+            "has_purchased": int(has_purchased), "has_renewed": int(has_renewed),
+            "has_claimed": int(has_claimed), "support_dependency": support / total,
+            "renewal_click_count": all_type_counts.get("renewal_click", 0),
+            "policy_cancel_count": all_type_counts.get("policy_cancel", 0),
+            "claim_init_count": all_type_counts.get("claim_init", 0),
+            "days_since_last_event": (datetime.datetime.now().timestamp()*1000 - last_ts)/(24*3600*1000),
+            "weekend_activity_ratio": sum(1 for e in all_events if datetime.datetime.fromtimestamp(e.timestamp/1000).weekday()>=5)/total,
+            "peak_active_hour": Counter(datetime.datetime.fromtimestamp(e.timestamp/1000).hour for e in all_events).most_common(1)[0][0],
+            "recent_7day_events": sum(1 for e in all_events if (last_ts-e.timestamp)<7*24*3600*1000),
+            "recent_30day_events": sum(1 for e in all_events if (last_ts-e.timestamp)<30*24*3600*1000),
+        }
+
+
+def generate_synthetic_data(n_users=2000, n_events_per_user=50):
+    event_types = list(INSURANCE_EVENT_TYPES)
+    products = ["health_basic","health_premium","critical_illness","term_life",
+                "auto_compulsory","auto_commercial","home","travel_domestic"]
+    data = []
+    for u in range(n_users):
+        user_id = f"user_{u:04d}"; churn_risk = random.random()
+        sessions = []; base_ts = int(datetime.datetime(2024,1,1).timestamp()*1000)
+        for s in range(random.randint(1,5)):
+            session_id = f"sess_{u}_{s}"
+            n_events = random.randint(5, n_events_per_user // max(1, random.randint(1,5)))
+            events = []
+            for e in range(n_events):
+                if churn_risk > 0.7:
+                    event_type = random.choices(["page_view","product_view","article_read","app_uninstall"],weights=[0.4,0.3,0.2,0.1])[0]
+                else:
+                    stages = n_events
+                    if e < stages*0.3: event_type = random.choice(["page_view","product_view","article_read"])
+                    elif e < stages*0.6: event_type = random.choice(["product_view","quote_request","premium_calculator","faq_view"])
+                    elif e < stages*0.8: event_type = random.choice(["quote_result_view","form_submit","document_upload","payment_init"])
+                    else: event_type = random.choice(["payment_success","policy_issued","renewal_click","renewal_complete"])
+                timestamp = base_ts + e * random.randint(5000,30000)
+                events.append(InsuranceAppEvent(f"evt_{u}_{s}_{e}", user_id, session_id, timestamp, event_type, f"page_{event_type}",
+                    random.choice(products) if event_type in ["product_view","quote_request"] else None,
+                    random.uniform(1000,100000) if event_type in ["quote_request","payment_success"] else None))
+            sessions.append(UserSession(session_id, user_id, events))
+            base_ts += 24 * 3600 * 1000
+        data.append((UserBehaviorProfile(user_id, sessions), int(churn_risk > 0.7)))
+    return data
+
+
+def train_model(n_users, n_events, test_size, random_state):
+    data = generate_synthetic_data(n_users=n_users, n_events_per_user=n_events)
+    engineer = InsuranceFeatureEngineer()
+    features_list, labels = [], []
+    for profile, label in data:
+        f = engineer.extract_user_features(profile)
+        if f: features_list.append(f); labels.append(label)
+    df = pd.DataFrame(features_list)
+    df_full = df.copy()
+    for c in df.columns:
+        if df[c].dtype == 'object':
+            df[c] = pd.to_numeric(df[c], errors='coerce').fillna(0)
+    df = df.fillna(0).replace([np.inf, -np.inf], 0)
+    X = df.values; y = np.array(labels)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state, stratify=y)
+    scaler = StandardScaler()
+    X_train_s = scaler.fit_transform(X_train); X_test_s = scaler.transform(X_test)
+    
+    gbdt = GradientBoostingClassifier(n_estimators=200, max_depth=5, learning_rate=0.1, subsample=0.8, random_state=random_state)
+    gbdt.fit(X_train_s, y_train)
+    y_pred_gbdt = gbdt.predict(X_test_s); y_prob_gbdt = gbdt.predict_proba(X_test_s)[:,1]
+    
+    rf = RandomForestClassifier(n_estimators=100, max_depth=10, class_weight='balanced', random_state=random_state, n_jobs=-1)
+    rf.fit(X_train_s, y_train)
+    y_prob_rf = rf.predict_proba(X_test_s)[:,1]; y_pred_rf = rf.predict(X_test_s)
+    
+    auc_gbdt = float(roc_auc_score(y_test, y_prob_gbdt))
+    f1_gbdt = float(f1_score(y_test, y_pred_gbdt))
+    ap_gbdt = float(average_precision_score(y_test, y_prob_gbdt))
+    auc_rf = float(roc_auc_score(y_test, y_prob_rf))
+    ap_rf = float(average_precision_score(y_test, y_prob_rf))
+    
+    fi = pd.DataFrame({'feature': list(df.columns), 'importance': rf.feature_importances_}).sort_values('importance', ascending=False)
+    
+    os.makedirs("outputs", exist_ok=True)
+    
+    fig, ax = plt.subplots(figsize=(12,8))
+    top = fi.head(15)
+    ax.barh(top['feature'][::-1], top['importance'][::-1], color='steelblue')
+    ax.set_title('Insurance APP - Top 15 Feature Importance')
+    ax.set_xlabel('Importance')
+    plt.tight_layout()
+    fig_path1 = "outputs/feature_importance.png"
+    plt.savefig(fig_path1, dpi=150, bbox_inches='tight'); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(8,6))
+    pg, rg, _ = precision_recall_curve(y_test, y_prob_gbdt)
+    pr, rr, _ = precision_recall_curve(y_test, y_prob_rf)
+    ax.plot(rg, pg, label=f'GBDT AP={ap_gbdt:.3f}')
+    ax.plot(rr, pr, label=f'RF AP={ap_rf:.3f}')
+    ax.set_xlabel('Recall'); ax.set_ylabel('Precision')
+    ax.set_title('Precision-Recall Curve'); ax.legend()
+    plt.tight_layout()
+    fig_path2 = "outputs/pr_curve.png"
+    plt.savefig(fig_path2, dpi=150, bbox_inches='tight'); plt.close()
+    
+    fig, axs = plt.subplots(1,2,figsize=(12,5))
+    sns.heatmap(confusion_matrix(y_test, y_pred_gbdt), annot=True, fmt='d', cmap='Blues', ax=axs[0])
+    axs[0].set_title(f'GBDT (AUC={auc_gbdt:.3f})')
+    sns.heatmap(confusion_matrix(y_test, y_pred_rf), annot=True, fmt='d', cmap='Greens', ax=axs[1])
+    axs[1].set_title(f'RF (AUC={auc_rf:.3f})')
+    plt.tight_layout()
+    fig_path3 = "outputs/confusion_matrix.png"
+    plt.savefig(fig_path3, dpi=150, bbox_inches='tight'); plt.close()
+    
+    fi_str = fi.head(15).to_string(index=False)
+    report = classification_report(y_test, y_pred_gbdt, digits=4)
+    
+    result_text = f"""=== 模型训练结果 ===
+样本数: {n_users} | 特征��: {len(df.columns)}
+训练集: {len(y_train)} | 测试集: {len(y_test)}
+
+--- GBDT ---
+AUC:  {auc_gbdt:.4f}
+F1:   {f1_gbdt:.4f}
+AP:   {ap_gbdt:.4f}
+
+--- Random Forest ---
+AUC:  {auc_rf:.4f}
+AP:   {ap_rf:.4f}
+
+--- Top 15 特征重要性 ---
+{fi_str}
+
+--- 分类报告 (GBDT) ---
+{report}"""
+    
+    return result_text, fig_path1, fig_path2, fig_path3, df_full
+
+
+with gr.Blocks(title="保险APP 用户行为分析模型") as demo:
+    gr.Markdown("""# 🏥 保险APP 用户行为分析模型训练平台
+基于合成数据演示保险APP用户流失预测模型的完整训练流程。
+**核心功能:** 生成合成数据 → 自动特征工程 → 训练 GBDT + RF → 可视化结果
+
+**参考论文:** Deep Interest Network (KDD 2018) | Transformer Churn Prediction (arXiv 2309.14390) | TabBERT (arXiv 2011.01843)""")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            n_users_slider = gr.Slider(500, 5000, value=2000, step=100, label="用户数量")
+            n_events_slider = gr.Slider(10, 100, value=50, step=5, label="每用户最大事件数")
+            test_size_slider = gr.Slider(0.1, 0.4, value=0.2, step=0.05, label="测试集比例")
+            random_seed = gr.Number(value=42, label="随机种子", precision=0)
+            train_btn = gr.Button("🚀 开始训练", variant="primary")
+        with gr.Column(scale=2):
+            result_text = gr.Textbox(label="训练结果", lines=20)
+    
+    with gr.Row():
+        img1 = gr.Image(label="特征重要性")
+        img2 = gr.Image(label="PR曲线")
+    with gr.Row():
+        img3 = gr.Image(label="混淆矩阵")
+        data_table = gr.Dataframe(label="数据样本 (前10行)")
+    
+    train_btn.click(fn=train_model, inputs=[n_users_slider, n_events_slider, test_size_slider, random_seed],
+                    outputs=[result_text, img1, img2, img3, data_table])
+    
+    gr.Markdown("""---
+**事件类型:** 浏览(page_view, product_view) | 交互(quote_request, chat_init) | 转化(payment_success, policy_issued) | 理赔(claim_init) | 续保(renewal_click, policy_cancel)""")
+
+if __name__ == "__main__":
+    demo.launch()