Upload app.py with huggingface_hub

app.py

@@ -1,3 +1,1625 @@
-# read content from file and upload
-with open('/app/app.py', 'r') as f:
-    content = f.read()
+"""
+保险APP 用户行为分析 - Gradio Space (终极版 v3.0)
+支持: 演示模式 | CSV上传 | 产品推荐(DIN) | 异常检测(TabBERT) | 模型管理 | 生存分析
+
+参考文献:
+- DIN: Deep Interest Network (KDD 2018, arxiv:1706.06978)
+- TabBERT: Tabular Transformers (arxiv:2011.01843)
+- Focal Loss: RetinaNet (ICCV 2017, arxiv:1708.02002)
+- DeepSurv: Cox-PH Neural Network (JAMIA 2018, arxiv:1606.00931)
+- RNN Survival: arxiv:2304.00575
+"""
+import os, io, math, warnings, datetime, random, json, tempfile, pickle
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from pathlib import Path
+
+warnings.filterwarnings('ignore')
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+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,
+    roc_curve, accuracy_score
+)
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+import gradio as gr
+
+# PyTorch
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    print("⚠️ PyTorch not available. Deep learning models disabled.")
+
+# Hugging Face Hub (模型保存/加载)
+try:
+    from huggingface_hub import HfApi, create_repo, hf_hub_download, login
+    HFHUB_AVAILABLE = True
+except ImportError:
+    HFHUB_AVAILABLE = False
+    print("⚠️ huggingface_hub not available. Model save/load disabled.")
+
+# lifelines (生存分析)
+try:
+    from lifelines import CoxPHFitter, KaplanMeierFitter, NelsonAalenFitter
+    from lifelines.statistics import logrank_test
+    LIFELINES_AVAILABLE = True
+except ImportError:
+    LIFELINES_AVAILABLE = False
+    print("⚠️ lifelines not available. Statistical survival analysis disabled.")
+
+# joblib
+import joblib
+
+
+# =============================================================================
+# 全局配置 & 数据模型
+# =============================================================================
+
+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)
+        event_seq = [e.event_type for e in all_events]
+        product_seq = [e.product_id or "none" for e in all_events]
+        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),
+            "top_product_id": top_product or "none",
+            "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),
+            "_event_sequence": event_seq, "_product_sequence": product_seq,
+            "_user_id": profile.user_id,
+        }
+
+
+# =============================================================================
+# 数据解析 & 生成
+# =============================================================================
+
+def parse_csv_to_profiles(df):
+    required_cols = {"user_id", "session_id", "timestamp", "event_type", "page_id"}
+    missing = required_cols - set(c.lower().strip() for c in df.columns)
+    if missing:
+        raise ValueError(f"CSV缺少必需列: {missing}")
+    df.columns = [c.lower().strip() for c in df.columns]
+    df["timestamp"] = pd.to_numeric(df["timestamp"], errors="coerce")
+    df = df.dropna(subset=["timestamp", "event_type"])
+    df["timestamp"] = df["timestamp"].astype(int)
+    profiles = {}
+    for (uid, sid), group in df.groupby(["user_id", "session_id"]):
+        if uid not in profiles:
+            profiles[uid] = UserBehaviorProfile(user_id=str(uid), sessions=[])
+        events = []
+        for _, row in group.sort_values("timestamp").iterrows():
+            events.append(InsuranceAppEvent(
+                event_id=f"evt_{row.name}", user_id=str(row["user_id"]),
+                session_id=str(row["session_id"]), timestamp=int(row["timestamp"]),
+                event_type=str(row["event_type"]).strip(),
+                page_id=str(row.get("page_id", "unknown")),
+                product_id=str(row.get("product_id")) if pd.notna(row.get("product_id")) else None,
+                amount=float(row["amount"]) if pd.notna(row.get("amount")) else None,
+            ))
+        profiles[uid].sessions.append(UserSession(session_id=str(sid), user_id=str(uid), events=events))
+    return list(profiles.values())
+
+
+def generate_synthetic_data(n_users=2000, n_events_per_user=50, seed=42):
+    random.seed(seed); np.random.seed(seed)
+    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
+
+
+# =============================================================================
+# 通用 sklearn 训练函数
+# =============================================================================
+
+def train_sklearn(features_list, labels, test_size=0.2, random_state=42, use_cv=False):
+    df = pd.DataFrame(features_list)
+    df_full = df.copy()
+    drop_cols = [c for c in df.columns if c.startswith('_')]
+    for c in drop_cols: df.pop(c)
+    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)
+    feature_names = list(df.columns)
+    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': feature_names, 'importance': rf.feature_importances_}).sort_values('importance', ascending=False)
+    
+    cv_scores = None
+    if use_cv and len(y) >= 100:
+        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
+        cv_scores = cross_val_score(rf, X, y, cv=skf, scoring='roc_auc')
+    
+    os.makedirs("outputs", exist_ok=True)
+    
+    fig, ax = plt.subplots(figsize=(12,8))
+    top = fi.head(15)
+    colors = plt.cm.RdYlGn(np.linspace(0.2, 0.8, len(top)))[::-1]
+    ax.barh(top['feature'][::-1], top['importance'][::-1], color=colors)
+    ax.set_title('Insurance APP - Top 15 Feature Importance', fontsize=14, fontweight='bold')
+    ax.set_xlabel('Importance Score')
+    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}', linewidth=2, color='#2E86AB')
+    ax.plot(rr, pr, label=f'RF AP={ap_rf:.3f}', linewidth=2, color='#A23B72')
+    ax.set_xlabel('Recall', fontsize=12); ax.set_ylabel('Precision', fontsize=12)
+    ax.set_title('Precision-Recall Curve', fontsize=14, fontweight='bold')
+    ax.legend(fontsize=11); ax.grid(True, alpha=0.3)
+    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], cbar=False)
+    axs[0].set_title(f'GBDT (AUC={auc_gbdt:.3f})', fontsize=12, fontweight='bold')
+    axs[0].set_xlabel('Predicted'); axs[0].set_ylabel('Actual')
+    sns.heatmap(confusion_matrix(y_test, y_pred_rf), annot=True, fmt='d', cmap='Greens', ax=axs[1], cbar=False)
+    axs[1].set_title(f'RF (AUC={auc_rf:.3f})', fontsize=12, fontweight='bold')
+    axs[1].set_xlabel('Predicted'); axs[1].set_ylabel('Actual')
+    plt.tight_layout()
+    fig_path3 = "outputs/confusion_matrix.png"
+    plt.savefig(fig_path3, dpi=150, bbox_inches='tight'); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(8,6))
+    fpr_g, tpr_g, _ = roc_curve(y_test, y_prob_gbdt)
+    fpr_r, tpr_r, _ = roc_curve(y_test, y_prob_rf)
+    ax.plot(fpr_g, tpr_g, label=f'GBDT AUC={auc_gbdt:.3f}', linewidth=2, color='#2E86AB')
+    ax.plot(fpr_r, tpr_r, label=f'RF AUC={auc_rf:.3f}', linewidth=2, color='#A23B72')
+    ax.plot([0,1], [0,1], 'k--', alpha=0.5)
+    ax.set_xlabel('False Positive Rate', fontsize=12)
+    ax.set_ylabel('True Positive Rate', fontsize=12)
+    ax.set_title('ROC Curve', fontsize=14, fontweight='bold')
+    ax.legend(fontsize=11); ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path4 = "outputs/roc_curve.png"
+    plt.savefig(fig_path4, 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)
+    
+    cv_str = ""
+    if cv_scores is not None:
+        cv_str = f"\n--- 5折交叉验证 (RF AUC) ---\nMean: {cv_scores.mean():.4f} (+/- {cv_scores.std()*2:.4f})\nScores: {cv_scores.round(4).tolist()}"
+    
+    result_text = f"""=== 模型训练结果 ===
+样本数: {len(y)} | 特征数: {len(feature_names)}
+训练集: {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}
+{cv_str}
+
+--- Top 15 特征重要性 ---
+{fi_str}
+
+--- 分类报告 (GBDT) ---
+{report}"""
+    
+    # 保存模型到内存供后续保存到Hub
+    model_artifacts = {
+        'gbdt': gbdt,
+        'rf': rf,
+        'scaler': scaler,
+        'feature_names': feature_names,
+        'metrics': {'auc_gbdt': auc_gbdt, 'f1_gbdt': f1_gbdt, 'auc_rf': auc_rf, 'ap_gbdt': ap_gbdt, 'ap_rf': ap_rf}
+    }
+    # 保存到本地临时文件
+    joblib.dump(model_artifacts, 'outputs/sklearn_model_artifacts.joblib')
+    
+    return result_text, fig_path1, fig_path2, fig_path3, fig_path4, df_full
+
+
+# =============================================================================
+# DIN 产品推荐
+# =============================================================================
+
+def generate_product_recommendation_data(n_users=1000, seed=42):
+    random.seed(seed); np.random.seed(seed)
+    products = ["health_basic","health_premium","critical_illness","term_life",
+                "auto_compulsory","auto_commercial","home","travel_domestic"]
+    records = []
+    for u in range(n_users):
+        n_behaviors = random.randint(5, 30)
+        behavior_events = []
+        behavior_products = []
+        for i in range(n_behaviors):
+            et = random.choice(["page_view","product_view","quote_request","article_read"])
+            behavior_events.append(et)
+            behavior_products.append(random.choice(products))
+        candidate = random.choice(products)
+        label = 1 if candidate in behavior_products else random.choices([0,1], weights=[0.7,0.3])[0]
+        records.append({
+            'user_id': u, 'behavior_events': behavior_events,
+            'behavior_products': behavior_products,
+            'candidate_product': candidate, 'label': label,
+            'user_features': np.random.randn(20).astype(np.float32),
+        })
+    return pd.DataFrame(records)
+
+
+def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, seed):
+    if not TORCH_AVAILABLE:
+        return "❌ PyTorch 未安装。请在 requirements.txt 中添加 torch 并重启 Space。", None, None, None, None, None
+    
+    torch.manual_seed(seed); np.random.seed(seed); random.seed(seed)
+    df = generate_product_recommendation_data(n_users=n_users, seed=seed)
+    
+    all_events = sorted(set(e for seq in df['behavior_events'] for e in seq))
+    event_vocab = {e: i+1 for i, e in enumerate(all_events)}
+    all_products = sorted(set(p for seq in df['behavior_products'] for p in seq) | set(df['candidate_product']))
+    product_vocab = {p: i+1 for i, p in enumerate(all_products)}
+    
+    max_seq_len = 20
+    behavior_events_padded = []; behavior_products_padded = []; behavior_masks = []
+    for _, row in df.iterrows():
+        e_seq = [event_vocab[e] for e in row['behavior_events'][-max_seq_len:]]
+        p_seq = [product_vocab[p] for p in row['behavior_products'][-max_seq_len:]]
+        mask = [1] * len(e_seq)
+        if len(e_seq) < max_seq_len:
+            pad = max_seq_len - len(e_seq)
+            e_seq = [0]*pad + e_seq; p_seq = [0]*pad + p_seq; mask = [0]*pad + mask
+        behavior_events_padded.append(e_seq); behavior_products_padded.append(p_seq); behavior_masks.append(mask)
+    
+    df['be'] = behavior_events_padded; df['bp'] = behavior_products_padded; df['bm'] = behavior_masks
+    df['cp'] = df['candidate_product'].map(product_vocab)
+    
+    train_df = df.sample(frac=0.8, random_state=seed)
+    test_df = df.drop(train_df.index)
+    
+    device = torch.device('cpu')
+    
+    class SimpleDIN(nn.Module):
+        def __init__(self, num_events, num_products, d_model=64, max_len=20):
+            super().__init__()
+            self.event_emb = nn.Embedding(num_events+1, d_model//2, padding_idx=0)
+            self.prod_emb = nn.Embedding(num_products+1, d_model//2, padding_idx=0)
+            self.cand_emb = nn.Embedding(num_products+1, d_model)
+            self.attn = nn.Sequential(nn.Linear(d_model*4, 128), nn.ReLU(), nn.Linear(128, 1))
+            self.mlp = nn.Sequential(nn.Linear(d_model*3, 256), nn.ReLU(), nn.Dropout(0.3),
+                                     nn.Linear(256, 128), nn.ReLU(), nn.Dropout(0.3), nn.Linear(128, 1))
+        def forward(self, be, bp, bm, cp):
+            B = be.size(0); L = be.size(1)
+            e_emb = self.event_emb(be)
+            p_emb = self.prod_emb(bp)
+            beh_emb = torch.cat([e_emb, p_emb], dim=-1)
+            cand_emb = self.cand_emb(cp)
+            cand_exp = cand_emb.unsqueeze(1).expand(B, L, -1)
+            diff = cand_exp - beh_emb; prod = cand_exp * beh_emb
+            attn_in = torch.cat([cand_exp, beh_emb, diff, prod], dim=-1)
+            attn_w = self.attn(attn_in).squeeze(-1)
+            attn_w = attn_w.masked_fill(~bm.bool(), -1e9)
+            attn_w = torch.softmax(attn_w, dim=1)
+            interest = (beh_emb * attn_w.unsqueeze(-1)).sum(dim=1)
+            x = torch.cat([interest, cand_emb, interest*cand_emb], dim=-1)
+            return self.mlp(x).squeeze(-1)
+    
+    model = SimpleDIN(len(all_events), len(all_products), d_model=embedding_dim).to(device)
+    criterion = nn.BCEWithLogitsLoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    
+    for epoch in range(epochs):
+        model.train(); epoch_loss = 0
+        for i in range(0, len(train_df), batch_size):
+            batch = train_df.iloc[i:i+batch_size]
+            be = torch.tensor(np.stack(batch['be'].values), dtype=torch.long).to(device)
+            bp = torch.tensor(np.stack(batch['bp'].values), dtype=torch.long).to(device)
+            bm = torch.tensor(np.stack(batch['bm'].values), dtype=torch.bool).to(device)
+            cp = torch.tensor(batch['cp'].values, dtype=torch.long).to(device)
+            labels = torch.tensor(batch['label'].values, dtype=torch.float32).to(device)
+            optimizer.zero_grad()
+            outputs = model(be, bp, bm, cp)
+            loss = criterion(outputs, labels)
+            loss.backward(); optimizer.step()
+            epoch_loss += loss.item()
+        if (epoch+1) % max(1, epochs//5) == 0 or epoch == 0:
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {epoch_loss*batch_size/len(train_df):.4f}")
+    
+    model.eval()
+    with torch.no_grad():
+        be = torch.tensor(np.stack(test_df['be'].values), dtype=torch.long).to(device)
+        bp = torch.tensor(np.stack(test_df['bp'].values), dtype=torch.long).to(device)
+        bm = torch.tensor(np.stack(test_df['bm'].values), dtype=torch.bool).to(device)
+        cp = torch.tensor(test_df['cp'].values, dtype=torch.long).to(device)
+        labels = test_df['label'].values
+        preds = torch.sigmoid(model(be, bp, bm, cp)).cpu().numpy()
+    
+    auc = float(roc_auc_score(labels, preds))
+    ap = float(average_precision_score(labels, preds))
+    f1 = float(f1_score(labels, preds > 0.5))
+    acc = float(accuracy_score(labels, preds > 0.5))
+    
+    os.makedirs("outputs", exist_ok=True)
+    
+    # 保存 PyTorch 模型
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'event_vocab': event_vocab,
+        'product_vocab': product_vocab,
+        'embedding_dim': embedding_dim,
+        'max_seq_len': max_seq_len,
+        'num_events': len(all_events),
+        'num_products': len(all_products),
+        'metrics': {'auc': auc, 'ap': ap, 'f1': f1, 'acc': acc}
+    }, 'outputs/din_model.pt')
+    
+    fig, ax = plt.subplots(figsize=(10,6))
+    product_perf = {}
+    for _, row in test_df.iterrows():
+        prod = row['candidate_product']
+        if prod not in product_perf: product_perf[prod] = {'preds': [], 'labels': []}
+        idx = test_df.index.get_loc(_)
+        product_perf[prod]['preds'].append(preds[idx])
+        product_perf[prod]['labels'].append(row['label'])
+    prod_aucs = []
+    for prod, data in product_perf.items():
+        if len(set(data['labels'])) > 1 and len(data['labels']) >= 5:
+            prod_auc = roc_auc_score(data['labels'], data['preds'])
+            prod_aucs.append((prod, prod_auc, np.mean(data['labels'])))
+    if prod_aucs:
+        prod_aucs.sort(key=lambda x: x[1], reverse=True)
+        prods, aucs, rates = zip(*prod_aucs)
+        x = np.arange(len(prods))
+        ax.bar(x, aucs, color='steelblue', alpha=0.7, label='AUC')
+        ax2 = ax.twinx()
+        ax2.plot(x, rates, 'ro-', label='Conversion Rate')
+        ax.set_xticks(x); ax.set_xticklabels(prods, rotation=45, ha='right')
+        ax.set_ylabel('AUC', color='steelblue'); ax2.set_ylabel('Conversion Rate', color='red')
+        ax.set_title('Product Recommendation Performance', fontweight='bold')
+        ax.legend(loc='upper left'); ax2.legend(loc='upper right')
+    plt.tight_layout()
+    fig_path1 = "outputs/din_product_performance.png"
+    plt.savefig(fig_path1, dpi=150); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(10,6))
+    sample_idx = 0
+    with torch.no_grad():
+        be_s = be[sample_idx:sample_idx+1]; bp_s = bp[sample_idx:sample_idx+1]
+        bm_s = bm[sample_idx:sample_idx+1]; cp_s = cp[sample_idx:sample_idx+1]
+        B, L = be_s.size()
+        e_emb = model.event_emb(be_s); p_emb = model.prod_emb(bp_s)
+        beh_emb = torch.cat([e_emb, p_emb], dim=-1)
+        cand_emb = model.cand_emb(cp_s)
+        cand_exp = cand_emb.unsqueeze(1).expand(B, L, -1)
+        diff = cand_exp - beh_emb; prod_feat = cand_exp * beh_emb
+        attn_in = torch.cat([cand_exp, beh_emb, diff, prod_feat], dim=-1)
+        attn_w = torch.softmax(model.attn(attn_in).squeeze(-1).masked_fill(~bm_s, -1e9), dim=1)
+        weights = attn_w[0].cpu().numpy()
+    valid_len = bm_s[0].sum().item()
+    valid_weights = weights[-valid_len:] if valid_len > 0 else weights
+    ax.bar(range(len(valid_weights)), valid_weights, color='coral')
+    ax.set_title('Attention Weights (Sample User)', fontweight='bold')
+    ax.set_xlabel('Behavior Position'); ax.set_ylabel('Attention Weight')
+    plt.tight_layout()
+    fig_path2 = "outputs/din_attention.png"
+    plt.savefig(fig_path2, dpi=150); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(8,6))
+    fpr, tpr, _ = roc_curve(labels, preds)
+    ax.plot(fpr, tpr, label=f'DIN AUC={auc:.3f}', linewidth=2, color='#2E86AB')
+    ax.plot([0,1], [0,1], 'k--', alpha=0.5)
+    ax.set_xlabel('False Positive Rate'); ax.set_ylabel('True Positive Rate')
+    ax.set_title('ROC Curve - Product Recommendation', fontweight='bold')
+    ax.legend(); ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path3 = "outputs/din_roc.png"
+    plt.savefig(fig_path3, dpi=150); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(8,6))
+    prec, rec, _ = precision_recall_curve(labels, preds)
+    ax.plot(rec, prec, label=f'DIN AP={ap:.3f}', linewidth=2, color='#A23B72')
+    ax.set_xlabel('Recall'); ax.set_ylabel('Precision')
+    ax.set_title('Precision-Recall Curve - Product Recommendation', fontweight='bold')
+    ax.legend(); ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path4 = "outputs/din_pr.png"
+    plt.savefig(fig_path4, dpi=150); plt.close()
+    
+    result_text = f"""=== DIN 保险产品推荐模型 ===
+样本数: {n_users} | 产品数: {len(all_products)}
+Event vocab: {len(all_events)} | Product vocab: {len(all_products)}
+训练集: {len(train_df)} | 测试集: {len(test_df)}
+
+--- 模型架构 ---
+Embedding dim: {embedding_dim}
+Attention: LocalActivationUnit (4路交互: [c, b, c-b, c*b])
+MLP: [emb*3] → 256 → 128 → 1
+
+--- 训练配置 ---
+Epochs: {epochs} | Batch size: {batch_size} | LR: {lr}
+Optimizer: Adam | Loss: BCEWithLogitsLoss
+
+--- 测试集效果 ---
+AUC:  {auc:.4f}
+AP:   {ap:.4f}
+F1:   {f1:.4f}
+Accuracy: {acc:.4f}
+
+--- 模型洞察 ---
+1. 注意力机制自动学习用户历史行为中对候选产品的相关度
+2. 高权重通常分配给同类产品的历史浏览/购买行为
+3. 新用户(历史短)依赖统计特征, 老用户依赖行为序列
+
+--- 模型文件 ---
+模型已保存至: outputs/din_model.pt
+可使用"模型管理"Tab上传至Hugging Face Hub"""
+    
+    return result_text, fig_path1, fig_path2, fig_path3, fig_path4
+
+
+# =============================================================================
+# TabBERT 异常检测
+# =============================================================================
+
+def generate_anomaly_data(n_normal=800, n_anomaly=200, seed=42):
+    random.seed(seed); np.random.seed(seed)
+    normal_records = []
+    for i in range(n_normal):
+        normal_records.append({
+            'user_id': i, 'claim_amount': random.uniform(1000, 50000),
+            'claim_type': random.choice(["health","auto","property"]),
+            'days_since_policy': random.randint(30, 365),
+            'num_previous_claims': random.randint(0, 3),
+            'document_count': random.randint(3, 10),
+            'processing_time_days': random.uniform(1, 15),
+            'label': 0,
+        })
+    anomaly_records = []
+    for i in range(n_anomaly):
+        anomaly_records.append({
+            'user_id': n_normal + i, 'claim_amount': random.uniform(50000, 200000),
+            'claim_type': random.choice(["health","auto","property"]),
+            'days_since_policy': random.randint(1, 15),
+            'num_previous_claims': random.randint(5, 20),
+            'document_count': random.randint(0, 2),
+            'processing_time_days': random.uniform(0.1, 2),
+            'label': 1,
+        })
+    df = pd.DataFrame(normal_records + anomaly_records)
+    df = df.sample(frac=1, random_state=seed).reset_index(drop=True)
+    return df
+
+
+def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr, seed):
+    if not TORCH_AVAILABLE:
+        return "❌ PyTorch 未安装。请在 requirements.txt 中添加 torch 并重启 Space。", None, None, None, None
+    
+    torch.manual_seed(seed); np.random.seed(seed); random.seed(seed)
+    df = generate_anomaly_data(n_normal=n_normal, n_anomaly=n_anomaly, seed=seed)
+    
+    claim_type_map = {"health": 0, "auto": 1, "property": 2}
+    df['claim_type_enc'] = df['claim_type'].map(claim_type_map)
+    
+    feature_cols = ['claim_amount', 'claim_type_enc', 'days_since_policy',
+                    'num_previous_claims', 'document_count', 'processing_time_days']
+    
+    X = df[feature_cols].values.astype(np.float32)
+    y = df['label'].values.astype(np.float32)
+    
+    scaler = StandardScaler()
+    X_s = scaler.fit_transform(X)
+    
+    X_train, X_test, y_train, y_test = train_test_split(
+        X_s, y, test_size=0.2, random_state=seed, stratify=y
+    )
+    
+    device = torch.device('cpu')
+    
+    class SimpleTabBERT(nn.Module):
+        def __init__(self, input_dim=6, d_model=128, n_layers=4):
+            super().__init__()
+            self.input_proj = nn.Linear(input_dim, d_model)
+            layers = []
+            for _ in range(n_layers):
+                layers.extend([
+                    nn.Linear(d_model, d_model*4), nn.ReLU(), nn.Dropout(0.2),
+                    nn.Linear(d_model*4, d_model), nn.LayerNorm(d_model), nn.ReLU(), nn.Dropout(0.2),
+                ])
+            self.transformer = nn.Sequential(*layers)
+            self.head = nn.Sequential(nn.Linear(d_model, 256), nn.ReLU(), nn.Dropout(0.3),
+                                       nn.Linear(256, 64), nn.ReLU(), nn.Linear(64, 1))
+        def forward(self, x):
+            x = self.input_proj(x)
+            x = self.transformer(x)
+            return self.head(x).squeeze(-1)
+    
+    model = SimpleTabBERT(input_dim=len(feature_cols), d_model=d_model).to(device)
+    
+    class FocalLoss(nn.Module):
+        def __init__(self, alpha=0.25, gamma=2.0):
+            super().__init__(); self.alpha = alpha; self.gamma = gamma
+        def forward(self, inputs, targets):
+            bce = F.binary_cross_entropy_with_logits(inputs, targets, reduction='none')
+            pt = torch.exp(-bce)
+            return (self.alpha * (1-pt)**self.gamma * bce).mean()
+    
+    criterion = FocalLoss(alpha=0.25, gamma=2.0)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    
+    X_train_t = torch.tensor(X_train, dtype=torch.float32).to(device)
+    y_train_t = torch.tensor(y_train, dtype=torch.float32).to(device)
+    X_test_t = torch.tensor(X_test, dtype=torch.float32).to(device)
+    y_test_t = torch.tensor(y_test, dtype=torch.float32).to(device)
+    
+    for epoch in range(epochs):
+        model.train(); epoch_loss = 0
+        n_batches = math.ceil(len(X_train_t) / batch_size)
+        for i in range(n_batches):
+            start = i * batch_size; end = min(start + batch_size, len(X_train_t))
+            xb = X_train_t[start:end]; yb = y_train_t[start:end]
+            optimizer.zero_grad()
+            outputs = model(xb); loss = criterion(outputs, yb)
+            loss.backward(); optimizer.step()
+            epoch_loss += loss.item()
+        if (epoch+1) % max(1, epochs//5) == 0 or epoch == 0:
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {epoch_loss/n_batches:.4f}")
+    
+    model.eval()
+    with torch.no_grad():
+        preds = torch.sigmoid(model(X_test_t)).cpu().numpy()
+    
+    auc = float(roc_auc_score(y_test, preds))
+    ap = float(average_precision_score(y_test, preds))
+    f1 = float(f1_score(y_test, preds > 0.5))
+    
+    # 保存模型
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'feature_cols': feature_cols,
+        'd_model': d_model,
+        'scaler_mean': scaler.mean_,
+        'scaler_scale': scaler.scale_,
+        'metrics': {'auc': auc, 'ap': ap, 'f1': f1}
+    }, 'outputs/tabbert_model.pt')
+    
+    os.makedirs("outputs", exist_ok=True)
+    
+    baseline_auc = auc
+    importances = []
+    for i in range(len(feature_cols)):
+        X_perm = X_test.copy()
+        np.random.shuffle(X_perm[:, i])
+        X_perm_t = torch.tensor(X_perm, dtype=torch.float32).to(device)
+        with torch.no_grad():
+            perm_preds = torch.sigmoid(model(X_perm_t)).cpu().numpy()
+        perm_auc = roc_auc_score(y_test, perm_preds)
+        importances.append(baseline_auc - perm_auc)
+    
+    fig, ax = plt.subplots(figsize=(10,6))
+    colors = ['red' if imp > 0 else 'gray' for imp in importances]
+    ax.barh(feature_cols, importances, color=colors)
+    ax.set_title('TabularBERT - Feature Importance (Permutation)', fontweight='bold')
+    ax.set_xlabel('AUC Drop (Importance)')
+    plt.tight_layout()
+    fig_path1 = "outputs/tabbert_feature_importance.png"
+    plt.savefig(fig_path1, dpi=150); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(10,6))
+    normal_scores = preds[y_test == 0]; anomaly_scores = preds[y_test == 1]
+    ax.hist(normal_scores, bins=30, alpha=0.6, label=f'Normal (n={len(normal_scores)})', color='steelblue', edgecolor='white')
+    ax.hist(anomaly_scores, bins=30, alpha=0.6, label=f'Anomaly (n={len(anomaly_scores)})', color='red', edgecolor='white')
+    ax.axvline(x=0.5, color='black', linestyle='--', label='Threshold=0.5')
+    ax.set_xlabel('Anomaly Score'); ax.set_ylabel('Count')
+    ax.set_title('Anomaly Score Distribution', fontweight='bold')
+    ax.legend(); ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path2 = "outputs/tabbert_distribution.png"
+    plt.savefig(fig_path2, dpi=150); plt.close()
+    
+    fig, ax = plt.subplots(figsize=(8,6))
+    fpr, tpr, _ = roc_curve(y_test, preds)
+    ax.plot(fpr, tpr, label=f'TabBERT AUC={auc:.3f}', linewidth=2, color='#2E86AB')
+    ax.plot([0,1], [0,1], 'k--', alpha=0.5)
+    ax.set_xlabel('False Positive Rate'); ax.set_ylabel('True Positive Rate')
+    ax.set_title('ROC Curve - Anomaly Detection', fontweight='bold')
+    ax.legend(); ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path3 = "outputs/tabbert_roc.png"
+    plt.savefig(fig_path3, dpi=150); plt.close()
+    
+    fig, axs = plt.subplots(1, 2, figsize=(14,6))
+    cm = confusion_matrix(y_test, preds > 0.5)
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axs[0], cbar=False)
+    axs[0].set_title(f'Confusion Matrix @ threshold=0.5\n(F1={f1:.3f})', fontweight='bold')
+    axs[0].set_xlabel('Predicted'); axs[0].set_ylabel('Actual')
+    
+    thresholds = np.linspace(0.1, 0.9, 50)
+    f1s = [f1_score(y_test, preds > t) for t in thresholds]
+    precs = [precision_score(y_test, preds > t, zero_division=0) for t in thresholds]
+    recs = [recall_score(y_test, preds > t, zero_division=0) for t in thresholds]
+    axs[1].plot(thresholds, f1s, label='F1', linewidth=2)
+    axs[1].plot(thresholds, precs, label='Precision', linewidth=2)
+    axs[1].plot(thresholds, recs, label='Recall', linewidth=2)
+    best_t = thresholds[np.argmax(f1s)]
+    axs[1].axvline(x=best_t, color='red', linestyle='--', label=f'Best F1 @ {best_t:.2f}')
+    axs[1].set_xlabel('Threshold'); axs[1].set_ylabel('Score')
+    axs[1].set_title('Threshold Analysis', fontweight='bold')
+    axs[1].legend(); axs[1].grid(True, alpha=0.3)
+    plt.tight_layout()
+    fig_path4 = "outputs/tabbert_threshold.png"
+    plt.savefig(fig_path4, dpi=150); plt.close()
+    
+    result_text = f"""=== TabularBERT 异常行为检测模型 ===
+样本数: {len(df)} (正常: {n_normal}, 异常: {n_anomaly})
+特征数: {len(feature_cols)}
+训练集: {len(y_train)} | 测试集: {len(y_test)}
+
+--- 模型架构 ---
+Input dim: {len(feature_cols)} → d_model: {d_model}
+Transformer layers: {4} (模拟层次化BERT)
+Head: {d_model} → 256 → 64 → 1
+Loss: Focal Loss (α=0.25, γ=2.0)
+
+--- 训练配置 ---
+Epochs: {epochs} | Batch size: {batch_size} | LR: {lr}
+Optimizer: Adam
+
+--- 测试集效果 ---
+AUC:  {auc:.4f}
+AP:   {ap:.4f}
+F1:   {f1:.4f} @ threshold=0.5
+Best F1: {max(f1s):.4f} @ threshold={best_t:.2f}
+
+--- 模型洞察 ---
+1. Focal Loss 自动聚焦难分异常样本, 解决类别不平衡
+2. 关键异常特征: claim_amount(高), days_since_policy(短), document_count(少)
+3. 建议阈值: {best_t:.2f} (平衡精确率与召回率)
+4. 高AUC说明模型能很好区分正常与异常理赔
+
+--- 模型文件 ---
+模型已保存至: outputs/tabbert_model.pt
+可使用"模型管理"Tab上传至Hugging Face Hub"""
+    
+    return result_text, fig_path1, fig_path2, fig_path3, fig_path4
+
+
+# =============================================================================
+# 模型管理 — 保存/加载到 Hugging Face Hub
+# =============================================================================
+
+def save_model_to_hub(repo_id, token, model_type, notes):
+    """将训练好的模型保存到 Hugging Face Hub"""
+    if not HFHUB_AVAILABLE:
+        return "❌ huggingface_hub 未安装。无法保存到 Hub。", None
+    
+    if not token or not token.strip():
+        return "❌ 需要提供 Hugging Face Token。在 https://huggingface.co/settings/tokens 获取。", None
+    
+    try:
+        api = HfApi(token=token.strip())
+        create_repo(repo_id, repo_type="model", exist_ok=True, token=token.strip())
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            
+            # 收集所有模型文件
+            model_files = []
+            artifacts = {}
+            
+            # 检查 sklearn 模型
+            sklearn_path = Path("outputs/sklearn_model_artifacts.joblib")
+            if sklearn_path.exists():
+                artifacts['sklearn'] = joblib.load(sklearn_path)
+                joblib.dump(artifacts['sklearn'], tmpdir / "sklearn_model.joblib")
+                model_files.append("sklearn_model.joblib")
+            
+            # 检查 DIN 模型
+            din_path = Path("outputs/din_model.pt")
+            if din_path.exists():
+                artifacts['din'] = torch.load(din_path, map_location='cpu')
+                torch.save(artifacts['din'], tmpdir / "din_model.pt")
+                model_files.append("din_model.pt")
+            
+            # 检查 TabBERT 模型
+            tab_path = Path("outputs/tabbert_model.pt")
+            if tab_path.exists():
+                artifacts['tabbert'] = torch.load(tab_path, map_location='cpu')
+                torch.save(artifacts['tabbert'], tmpdir / "tabbert_model.pt")
+                model_files.append("tabbert_model.pt")
+            
+            if not model_files:
+                return "❌ 未找到训练好的模型。请先在其他Tab训练模型。", None
+            
+            # 保存元数据
+            metadata = {
+                "model_type": model_type,
+                "notes": notes,
+                "files": model_files,
+                "timestamp": datetime.datetime.now().isoformat(),
+                "insurance_app_behavior": True,
+                "version": "3.0"
+            }
+            with open(tmpdir / "model_metadata.json", "w") as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+            
+            # 保存 README
+            readme = f"""# Insurance App Behavior Model
+
+**Model Type:** {model_type}
+**Notes:** {notes}
+**Date:** {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `sklearn_model.joblib` | GBDT + Random Forest + Scaler (sklearn) |
+| `din_model.pt` | Deep Interest Network (PyTorch) |
+| `tabbert_model.pt` | TabularBERT Anomaly Detection (PyTorch) |
+| `model_metadata.json` | Model metadata |
+
+## Usage
+
+```python
+from huggingface_hub import hf_hub_download
+import joblib
+import torch
+
+# Load sklearn models
+model_path = hf_hub_download(repo_id="{repo_id}", filename="sklearn_model.joblib")
+artifacts = joblib.load(model_path)
+# artifacts['gbdt'], artifacts['rf'], artifacts['scaler']
+
+# Load DIN
+din_path = hf_hub_download(repo_id="{repo_id}", filename="din_model.pt")
+din_ckpt = torch.load(din_path)
+# din_ckpt['model_state_dict'], din_ckpt['event_vocab'], din_ckpt['product_vocab']
+```
+
+## Reference
+
+- Deep Interest Network (KDD 2018): https://arxiv.org/abs/1706.06978
+- TabBERT (arXiv 2011.01843): https://arxiv.org/abs/2011.01843
+"""
+            with open(tmpdir / "README.md", "w") as f:
+                f.write(readme)
+            
+            api.upload_folder(
+                folder_path=str(tmpdir),
+                repo_id=repo_id,
+                repo_type="model",
+                token=token.strip()
+            )
+        
+        return f"✅ 模型已成功保存到 https://huggingface.co/{repo_id}", None
+        
+    except Exception as e:
+        import traceback
+        return f"❌ 保存失败: {str(e)}\n\n{traceback.format_exc()}", None
+
+
+def load_model_from_hub(repo_id, token, model_type):
+    """从 Hugging Face Hub 加载模型"""
+    if not HFHUB_AVAILABLE:
+        return "❌ huggingface_hub 未安装。无法从 Hub 加载。", None, None, None
+    
+    if not token or not token.strip():
+        return "❌ 需要提供 Hugging Face Token。", None, None, None
+    
+    try:
+        token = token.strip()
+        
+        # 尝试下载元数据
+        metadata_path = hf_hub_download(repo_id=repo_id, filename="model_metadata.json", token=token, repo_type="model")
+        with open(metadata_path) as f:
+            metadata = json.load(f)
+        
+        results = [f"✅ 成功加载模型: {repo_id}", f"模型类型: {metadata.get('model_type', 'Unknown')}",
+                   f"备注: {metadata.get('notes', 'N/A')}", f"时间: {metadata.get('timestamp', 'N/A')}",
+                   f"文件列表: {', '.join(metadata.get('files', []))}", "---"]
+        
+        images = []
+        
+        # 加载 sklearn 模型
+        if "sklearn_model.joblib" in metadata.get('files', []):
+            sklearn_path = hf_hub_download(repo_id=repo_id, filename="sklearn_model.joblib", token=token, repo_type="model")
+            artifacts = joblib.load(sklearn_path)
+            metrics = artifacts.get('metrics', {})
+            results.append(f"📦 sklearn 模型已加载")
+            results.append(f"   GBDT AUC: {metrics.get('auc_gbdt', 'N/A')}")
+            results.append(f"   RF AUC: {metrics.get('auc_rf', 'N/A')}")
+            results.append(f"   特征数: {len(artifacts.get('feature_names', []))}")
+            
+            # 特征重要性图
+            if 'rf' in artifacts:
+                fig, ax = plt.subplots(figsize=(10,6))
+                fi = pd.DataFrame({'feature': artifacts['feature_names'], 'importance': artifacts['rf'].feature_importances_})
+                fi = fi.sort_values('importance', ascending=False).head(10)
+                ax.barh(fi['feature'][::-1], fi['importance'][::-1], color='steelblue')
+                ax.set_title('Loaded Model - Feature Importance', fontweight='bold')
+                plt.tight_layout()
+                img_path = "outputs/loaded_feature_importance.png"
+                plt.savefig(img_path, dpi=150); plt.close()
+                images.append(img_path)
+        
+        # 加载 DIN
+        if "din_model.pt" in metadata.get('files', []):
+            din_path = hf_hub_download(repo_id=repo_id, filename="din_model.pt", token=token, repo_type="model")
+            din_ckpt = torch.load(din_path, map_location='cpu')
+            metrics = din_ckpt.get('metrics', {})
+            results.append(f"📦 DIN 模型已加载")
+            results.append(f"   AUC: {metrics.get('auc', 'N/A')}")
+            results.append(f"   Embedding dim: {din_ckpt.get('embedding_dim', 'N/A')}")
+            results.append(f"   Event vocab: {len(din_ckpt.get('event_vocab', {}))}")
+            results.append(f"   Product vocab: {len(din_ckpt.get('product_vocab', {}))}")
+        
+        # 加载 TabBERT
+        if "tabbert_model.pt" in metadata.get('files', []):
+            tab_path = hf_hub_download(repo_id=repo_id, filename="tabbert_model.pt", token=token, repo_type="model")
+            tab_ckpt = torch.load(tab_path, map_location='cpu')
+            metrics = tab_ckpt.get('metrics', {})
+            results.append(f"📦 TabBERT 模型已加载")
+            results.append(f"   AUC: {metrics.get('auc', 'N/A')}")
+            results.append(f"   d_model: {tab_ckpt.get('d_model', 'N/A')}")
+            results.append(f"   特征: {', '.join(tab_ckpt.get('feature_cols', []))}")
+        
+        return "\n".join(results), images[0] if images else None, images[1] if len(images) > 1 else None, images[2] if len(images) > 2 else None
+        
+    except Exception as e:
+        import traceback
+        return f"❌ 加载失败: {str(e)}\n\n{traceback.format_exc()}", None, None, None
+
+
+# =============================================================================
+# 生存分析 — lifelines + DeepSurv
+# =============================================================================
+
+def generate_survival_data(n_samples=2000, seed=42):
+    """生成保险生存分析合成数据"""
+    random.seed(seed); np.random.seed(seed)
+    
+    records = []
+    for i in range(n_samples):
+        age = random.randint(18, 75)
+        gender = random.choice([0, 1])  # 0=female, 1=male
+        income = random.uniform(30000, 200000)
+        policy_type = random.choice(["term_life", "whole_life", "health", "auto", "property"])
+        premium_amount = random.uniform(1000, 50000)
+        coverage_amount = premium_amount * random.uniform(10, 100)
+        risk_score = random.uniform(0, 1)
+        
+        # 根据特征计算基础风险
+        base_hazard = (
+            0.001 * (age - 18) +           # 年龄越大风险越高
+            0.05 * gender +                 # 性别差异
+            0.00001 * (200000 - income) +   # 收入越低风险越高
+            0.1 * risk_score +               # 风险评分
+            random.gauss(0, 0.05)           # 噪声
+        )
+        
+        # 保单类型调整
+        policy_hazard = {"term_life": 0.02, "whole_life": 0.01, "health": 0.05,
+                         "auto": 0.03, "property": 0.01}[policy_type]
+        
+        total_hazard = base_hazard + policy_hazard
+        total_hazard = max(total_hazard, 0.001)  # 最小风险
+        
+        # 指数分布: time ~ Exp(lambda)
+        time_to_event = random.expovariate(total_hazard)
+        
+        # 右删失: 最大观察时间 3650天 (10年)
+        max_observation = 3650
+        event_observed = 1 if time_to_event < max_observation else 0
+        duration = min(time_to_event, max_observation)
+        
+        records.append({
+            'user_id': f"user_{i:04d}",
+            'age': age,
+            'gender': gender,
+            'income': income,
+            'policy_type': policy_type,
+            'premium_amount': premium_amount,
+            'coverage_amount': coverage_amount,
+            'risk_score': risk_score,
+            'duration': duration,
+            'event_observed': event_observed,
+        })
+    
+    return pd.DataFrame(records)
+
+
+def train_survival_analysis(n_samples, test_size, seed, use_deep_surv, epochs, lr):
+    """训练生存分析模型"""
+    df = generate_survival_data(n_samples=n_samples, seed=seed)
+    
+    # 编码分类变量
+    df['policy_type_enc'] = pd.Categorical(df['policy_type']).codes
+    
+    # 特征列
+    feature_cols = ['age', 'gender', 'income', 'policy_type_enc',
+                    'premium_amount', 'coverage_amount', 'risk_score']
+    
+    # 划分训练/测试
+    train_df = df.sample(frac=1-test_size, random_state=seed)
+    test_df = df.drop(train_df.index)
+    
+    os.makedirs("outputs", exist_ok=True)
+    
+    # ===== 1. lifelines Cox-PH =====
+    results = ["=== 保险理赔/购买时序生存分析 ===", f"总样本: {len(df)} | 训练: {len(train_df)} | 测试: {len(test_df)}",
+               f"事件发生率: {df['event_observed'].mean():.1%} ({df['event_observed'].sum()}/{len(df)})",
+               f"平均观察时长: {df['duration'].mean():.0f} 天", "---"]
+    
+    cph_figures = []
+    
+    if LIFELINES_AVAILABLE:
+        # Kaplan-Meier 曲线
+        fig, ax = plt.subplots(figsize=(10,6))
+        kmf = KaplanMeierFitter()
+        
+        # 整体
+        kmf.fit(df['duration'], df['event_observed'], label='Overall')
+        kmf.plot_survival_function(ax=ax, ci_show=True, color='steelblue', linewidth=2)
+        
+        # 按性别分组
+        for gender, color in [(0, '#E74C3C'), (1, '#2ECC71')]:
+            sub = df[df['gender'] == gender]
+            kmf.fit(sub['duration'], sub['event_observed'], label=f'{"Female" if gender==0 else "Male"}')
+            kmf.plot_survival_function(ax=ax, ci_show=False, color=color, linestyle='--', linewidth=2)
+        
+        ax.set_title('Kaplan-Meier Survival Curve', fontsize=14, fontweight='bold')
+        ax.set_xlabel('Duration (days)', fontsize=12)
+        ax.set_ylabel('Survival Probability S(t)', fontsize=12)
+        ax.legend(fontsize=11); ax.grid(True, alpha=0.3)
+        plt.tight_layout()
+        km_path = "outputs/survival_kaplan_meier.png"
+        plt.savefig(km_path, dpi=150); plt.close()
+        cph_figures.append(km_path)
+        
+        # Cox-PH 模型
+        cph = CoxPHFitter(penalizer=0.1)
+        cph_train = train_df[feature_cols + ['duration', 'event_observed']].copy()
+        
+        try:
+            cph.fit(cph_train, duration_col='duration', event_col='event_observed')
+            
+            # 系数可视化
+            fig, ax = plt.subplots(figsize=(10,6))
+            summary = cph.summary.copy()
+            summary['coef'] = summary['coef'].astype(float)
+            summary['exp(coef)'] = summary['exp(coef)'].astype(float)
+            summary = summary.sort_values('coef')
+            
+            colors = ['green' if c < 0 else 'red' for c in summary['coef']]
+            ax.barh(summary.index, summary['coef'], color=colors, alpha=0.7, edgecolor='white')
+            ax.axvline(x=0, color='black', linestyle='-', linewidth=0.5)
+            ax.set_title('Cox-PH Coefficients (log Hazard Ratio)', fontsize=14, fontweight='bold')
+            ax.set_xlabel('Coefficient')
+            plt.tight_layout()
+            coef_path = "outputs/survival_cox_coefficients.png"
+            plt.savefig(coef_path, dpi=150); plt.close()
+            cph_figures.append(coef_path)
+            
+            # 预测生存函数 (测试集前5个样本)
+            fig, ax = plt.subplots(figsize=(10,6))
+            test_subset = test_df.head(5)
+            predictions = cph.predict_survival_function(test_subset[feature_cols])
+            for i, col in enumerate(predictions.columns):
+                ax.plot(predictions.index, predictions[col], label=f'Sample {i+1}', linewidth=2, alpha=0.8)
+            ax.set_title('Predicted Survival Functions (Test Samples)', fontsize=14, fontweight='bold')
+            ax.set_xlabel('Duration (days)', fontsize=12)
+            ax.set_ylabel('Survival Probability', fontsize=12)
+            ax.legend(fontsize=10); ax.grid(True, alpha=0.3)
+            plt.tight_layout()
+            pred_path = "outputs/survival_predictions.png"
+            plt.savefig(pred_path, dpi=150); plt.close()
+            cph_figures.append(pred_path)
+            
+            # Concordance Index
+            from lifelines.utils import concordance_index
+            pred_risk = cph.predict_partial_hazard(test_df[feature_cols])
+            c_index = concordance_index(test_df['duration'], -pred_risk, test_df['event_observed'])
+            
+            results.append("--- lifelines Cox-PH ---")
+            results.append(f"Concordance Index: {c_index:.4f}")
+            results.append(f"Log-likelihood: {cph.log_likelihood_:.2f}")
+            results.append(f"AIC: {cph.AIC_partial_:.2f}")
+            results.append("")
+            results.append("--- Cox-PH 系数 (Top 影响因子) ---")
+            for idx, row in cph.summary.head(7).iterrows():
+                hr = float(row['exp(coef)'])
+                results.append(f"  {idx}: HR={hr:.3f} (p={row['p']:.4f})")
+            
+            results.append("")
+            results.append("HR > 1: 风险增加 | HR < 1: 风险降低")
+            
+        except Exception as e:
+            results.append(f"⚠️ Cox-PH 拟合失败: {str(e)}")
+    else:
+        results.append("⚠️ lifelines 未安装。统计生存分析功能禁用。")
+    
+    # ===== 2. DeepSurv (PyTorch) =====
+    deep_surv_result = ""
+    if use_deep_surv and TORCH_AVAILABLE:
+        results.append("--- DeepSurv (Neural Cox-PH) ---")
+        
+        X_train = train_df[feature_cols].values.astype(np.float32)
+        X_test = test_df[feature_cols].values.astype(np.float32)
+        
+        scaler = StandardScaler()
+        X_train_s = scaler.fit_transform(X_train)
+        X_test_s = scaler.transform(X_test)
+        
+        T_train = train_df['duration'].values.astype(np.float32)
+        E_train = train_df['event_observed'].values.astype(np.float32)
+        T_test = test_df['duration'].values.astype(np.float32)
+        E_test = test_df['event_observed'].values.astype(np.float32)
+        
+        device = torch.device('cpu')
+        
+        class DeepSurv(nn.Module):
+            def __init__(self, input_dim, hidden_dims=[128, 64, 32], dropout=0.3):
+                super().__init__()
+                layers = []
+                prev = input_dim
+                for h in hidden_dims:
+                    layers.extend([nn.Linear(prev, h), nn.ReLU(), nn.Dropout(dropout)])
+                    prev = h
+                layers.append(nn.Linear(prev, 1))
+                self.net = nn.Sequential(*layers)
+            
+            def forward(self, x):
+                return self.net(x).squeeze(-1)
+        
+        model = DeepSurv(input_dim=len(feature_cols), hidden_dims=[128, 64, 32]).to(device)
+        optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+        
+        # Cox partial likelihood loss
+        def cox_ph_loss(pred, time, event):
+            """Negative Cox partial likelihood"""
+            # Sort by time descending
+            idx = torch.argsort(time, descending=True)
+            pred_sorted = pred[idx]
+            event_sorted = event[idx]
+            
+            # logcumsumexp for numerical stability
+            log_cumsum_h = torch.logcumsumexp(pred_sorted, dim=0)
+            
+            # Only event samples contribute
+            loss = -torch.sum(event_sorted * (pred_sorted - log_cumsum_h)) / event_sorted.sum().clamp(min=1)
+            return loss
+        
+        X_train_t = torch.tensor(X_train_s, dtype=torch.float32).to(device)
+        T_train_t = torch.tensor(T_train, dtype=torch.float32).to(device)
+        E_train_t = torch.tensor(E_train, dtype=torch.float32).to(device)
+        
+        # Training
+        model.train()
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            pred = model(X_train_t)
+            loss = cox_ph_loss(pred, T_train_t, E_train_t)
+            loss.backward()
+            optimizer.step()
+            
+            if (epoch+1) % max(1, epochs//5) == 0 or epoch == 0:
+                print(f"DeepSurv Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}")
+        
+        # Evaluation
+        model.eval()
+        with torch.no_grad():
+            X_test_t = torch.tensor(X_test_s, dtype=torch.float32).to(device)
+            pred_test = model(X_test_t).cpu().numpy()
+        
+        # Concordance Index
+        from lifelines.utils import concordance_index
+        deep_c_index = concordance_index(T_test, -pred_test, E_test)
+        
+        results.append(f"Concordance Index: {deep_c_index:.4f}")
+        results.append(f"Training epochs: {epochs} | LR: {lr}")
+        results.append("")
+        results.append("--- DeepSurv 洞察 ---")
+        results.append("1. 神经网络学习非线性特征交互, 捕捉复杂风险模式")
+        results.append("2. 相比线性Cox-PH, 能建模年龄×收入×风险评分的组合效应")
+        results.append("3. 输出log hazard ratio: 正值=高风险, 负值=低风险")
+        
+        # 保存模型
+        torch.save({
+            'model_state_dict': model.state_dict(),
+            'feature_cols': feature_cols,
+            'hidden_dims': [128, 64, 32],
+            'scaler_mean': scaler.mean_,
+            'scaler_scale': scaler.scale_,
+            'metrics': {'concordance_index': deep_c_index}
+        }, 'outputs/deepsurv_model.pt')
+        
+        # 风险分层可视化
+        fig, ax = plt.subplots(figsize=(10,6))
+        risk_scores = pred_test
+        risk_percentiles = np.percentile(risk_scores, [33, 66])
+        
+        low_risk = test_df[risk_scores < risk_percentiles[0]]
+        mid_risk = test_df[(risk_scores >= risk_percentiles[0]) & (risk_scores < risk_percentiles[1])]
+        high_risk = test_df[risk_scores >= risk_percentiles[1]]
+        
+        colors = ['#2ECC71', '#F39C12', '#E74C3C']
+        labels = ['Low Risk (bottom 33%)', 'Medium Risk (33-66%)', 'High Risk (top 33%)']
+        
+        for subset, color, label in [(low_risk, colors[0], labels[0]),
+                                       (mid_risk, colors[1], labels[1]),
+                                       (high_risk, colors[2], labels[2])]:
+            if len(subset) > 0:
+                kmf = KaplanMeierFitter()
+                kmf.fit(subset['duration'], subset['event_observed'], label=label)
+                kmf.plot_survival_function(ax=ax, ci_show=False, color=color, linewidth=2.5)
+        
+        ax.set_title('Survival by DeepSurv Risk Strata', fontsize=14, fontweight='bold')
+        ax.set_xlabel('Duration (days)', fontsize=12)
+        ax.set_ylabel('Survival Probability', fontsize=12)
+        ax.legend(fontsize=11); ax.grid(True, alpha=0.3)
+        plt.tight_layout()
+        risk_path = "outputs/survival_risk_strata.png"
+        plt.savefig(risk_path, dpi=150); plt.close()
+        cph_figures.append(risk_path)
+        
+        deep_surv_result = f"DeepSurv C-index: {deep_c_index:.4f}"
+        
+    elif use_deep_surv and not TORCH_AVAILABLE:
+        results.append("⚠️ PyTorch 未安装。DeepSurv 禁用。")
+    
+    # 保存 lifelines 结果
+    results.append("---")
+    results.append(f"所有图表已保存到 outputs/ 目录")
+    results.append(f"模型已保存至: outputs/deepsurv_model.pt (如使用DeepSurv)")
+    
+    result_text = "\n".join(results)
+    
+    return result_text, cph_figures[0] if len(cph_figures) > 0 else None, \
+           cph_figures[1] if len(cph_figures) > 1 else None, \
+           cph_figures[2] if len(cph_figures) > 2 else None, \
+           cph_figures[3] if len(cph_figures) > 3 else None, \
+           df.head(20)
+
+
+# =============================================================================
+# Gradio 回调
+# =============================================================================
+
+def demo_train(n_users, n_events, test_size, random_state, use_cv):
+    data = generate_synthetic_data(n_users=n_users, n_events_per_user=n_events, seed=random_state)
+    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)
+    return train_sklearn(features_list, labels, test_size, random_state, use_cv)
+
+
+def csv_train(csv_file, label_col, test_size, random_state, use_cv):
+    if csv_file is None:
+        return "请先上传CSV文件", None, None, None, None, None
+    try:
+        if isinstance(csv_file, str):
+            df = pd.read_csv(csv_file)
+        else:
+            df = pd.read_csv(csv_file.name if hasattr(csv_file, 'name') else io.BytesIO(csv_file))
+        label_col = label_col.strip() if label_col else None
+        if label_col and label_col not in df.columns:
+            return f"标签列 '{label_col}' 不存在。可用列: {list(df.columns)}", None, None, None, None, None
+        profiles = parse_csv_to_profiles(df)
+        engineer = InsuranceFeatureEngineer()
+        features_list, labels = [], []
+        for profile in profiles:
+            f = engineer.extract_user_features(profile)
+            if f:
+                features_list.append(f)
+                if label_col and label_col in df.columns:
+                    user_df = df[df["user_id"] == profile.user_id]
+                    labels.append(int(user_df[label_col].iloc[0]))
+                else:
+                    is_high_risk = (f["has_purchased"] == 0 and f["has_renewed"] == 0 and f["total_events"] < 20)
+                    labels.append(int(is_high_risk))
+        if len(features_list) < 50:
+            return f"有效样本数 {len(features_list)} 太少，需要至少50个", None, None, None, None, None
+        return train_sklearn(features_list, labels, test_size, random_state, use_cv)
+    except Exception as e:
+        import traceback
+        return f"错误: {str(e)}\n\n{traceback.format_exc()}", None, None, None, None, None
+
+
+def show_csv_info(csv_file):
+    if csv_file is None:
+        return "请先上传CSV文件", None
+    try:
+        if isinstance(csv_file, str):
+            df = pd.read_csv(csv_file)
+        else:
+            df = pd.read_csv(csv_file.name if hasattr(csv_file, 'name') else io.BytesIO(csv_file))
+        info = f"""=== CSV文件信息 ===
+行数: {len(df)} | 列数: {len(df.columns)}
+列名: {list(df.columns)}
+
+=== 前5行 ===
+{df.head().to_string()}
+
+=== 事件类型分布 (前10) ===
+{df['event_type'].value_counts().head(10).to_string() if 'event_type' in df.columns else '无event_type列'}
+
+=== 用户数: {df['user_id'].nunique() if 'user_id' in df.columns else 'N/A'} ===
+=== 会话数: {df['session_id'].nunique() if 'session_id' in df.columns else 'N/A'} ==="""
+        return info, df.head(20)
+    except Exception as e:
+        return f"解析错误: {str(e)}", None
+
+
+# =============================================================================
+# Gradio 界面 (7 Tabs)
+# =============================================================================
+
+with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台 v3.0", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""# 🏥 保险APP 用户行为分析模型训练平台 v3.0
+
+基于最新研究论文构建的**工业级保险用户行为分析平台**。
+
+**七大功能模块:** 🎲演示 | 📁CSV上传 | 🎯产品推荐(DIN) | 🔍异常检测(TabBERT) | 💾模型管理 | ⏱️生存分析 | ❓帮助
+
+**参考论文:** [DIN](https://arxiv.org/abs/1706.06978) | [Churn Transformer](https://arxiv.org/abs/2309.14390) | [TabBERT](https://arxiv.org/abs/2011.01843) | [DeepSurv](https://arxiv.org/abs/1606.00931) | [RNN Survival](https://arxiv.org/abs/2304.00575)""")
+    
+    with gr.Tabs():
+        # ===== Tab 1: 演示模式 =====
+        with gr.Tab("🎲 演示"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 参数设置")
+                    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)
+                    use_cv_check = gr.Checkbox(value=False, label="启用5折交叉验证")
+                    train_btn = gr.Button("🚀 开始训练", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    demo_result = gr.Textbox(label="训练结果", lines=25)
+            with gr.Row():
+                demo_img1 = gr.Image(label="特征重要性")
+                demo_img2 = gr.Image(label="PR曲线")
+            with gr.Row():
+                demo_img3 = gr.Image(label="混淆矩阵")
+                demo_img4 = gr.Image(label="ROC曲线")
+            with gr.Row():
+                demo_table = gr.Dataframe(label="特征数据样本")
+        
+        # ===== Tab 2: CSV上传 =====
+        with gr.Tab("📁 CSV上传"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("""### 📤 上传数据
+**必需列:** `user_id`, `session_id`, `timestamp`, `event_type`, `page_id`
+**可选:** `product_id`, `amount`, `label`""")
+                    csv_file = gr.File(label="上传CSV文件", file_types=[".csv"])
+                    label_col_input = gr.Textbox(label="标签列名 (可选)", placeholder="如: churn")
+                    with gr.Row():
+                        csv_test_size = gr.Slider(0.1, 0.4, value=0.2, step=0.05, label="测试集比例")
+                        csv_random_seed = gr.Number(value=42, label="随机种子", precision=0)
+                    csv_use_cv = gr.Checkbox(value=False, label="启用5折交叉验证")
+                    with gr.Row():
+                        info_btn = gr.Button("📊 查看数据信息", variant="secondary")
+                        csv_train_btn = gr.Button("🚀 训练模型", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    csv_info = gr.Textbox(label="CSV信息", lines=15)
+                    csv_preview = gr.Dataframe(label="数据预览")
+            with gr.Row():
+                csv_result = gr.Textbox(label="训练结果", lines=25)
+            with gr.Row():
+                csv_img1 = gr.Image(label="特征重要性")
+                csv_img2 = gr.Image(label="PR曲线")
+            with gr.Row():
+                csv_img3 = gr.Image(label="混淆矩阵")
+                csv_img4 = gr.Image(label="ROC曲线")
+            with gr.Row():
+                csv_table = gr.Dataframe(label="特征数据样本")
+        
+        # ===== Tab 3: DIN 产品推荐 =====
+        with gr.Tab("🎯 产品推荐 (DIN)"):
+            gr.Markdown("""### Deep Interest Network - 保险产品推荐
+基于用户历史行为序列, 通过注意力机制动态计算对候选保险产品的兴趣度。""")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    din_users = gr.Slider(500, 5000, value=2000, step=100, label="用户数量")
+                    din_emb = gr.Slider(32, 256, value=64, step=32, label="Embedding维度")
+                    din_epochs = gr.Slider(5, 50, value=20, step=5, label="训练轮数")
+                    din_batch = gr.Slider(32, 512, value=128, step=32, label="Batch Size")
+                    din_lr = gr.Slider(0.0001, 0.01, value=0.001, step=0.0001, label="学习率")
+                    din_seed = gr.Number(value=42, label="随机种子", precision=0)
+                    din_btn = gr.Button("🚀 训练DIN模型", variant="primary", size="lg")
+                    if not TORCH_AVAILABLE:
+                        gr.Markdown("⚠️ **PyTorch 未安装**。请在 requirements.txt 中添加 `torch>=2.0.0` 并重启。")
+                with gr.Column(scale=2):
+                    din_result = gr.Textbox(label="训练结果", lines=25)
+            with gr.Row():
+                din_img1 = gr.Image(label="产品推荐效果")
+                din_img2 = gr.Image(label="注意力权重示例")
+            with gr.Row():
+                din_img3 = gr.Image(label="ROC曲线")
+                din_img4 = gr.Image(label="PR曲线")
+        
+        # ===== Tab 4: TabBERT 异常检测 =====
+        with gr.Tab("🔍 异常检测 (TabBERT)"):
+            gr.Markdown("""### TabularBERT - 理赔欺诈/异常检测
+层次化Transformer架构, 学习理赔记录的多字段关联和时序模式。""")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    tab_normal = gr.Slider(500, 2000, value=800, step=100, label="正常样本数")
+                    tab_anomaly = gr.Slider(100, 1000, value=200, step=50, label="异常样本数")
+                    tab_dmodel = gr.Slider(64, 256, value=128, step=64, label="模型维度 d_model")
+                    tab_epochs = gr.Slider(10, 100, value=30, step=10, label="训练轮数")
+                    tab_batch = gr.Slider(16, 256, value=64, step=16, label="Batch Size")
+                    tab_lr = gr.Slider(0.0001, 0.01, value=0.001, step=0.0001, label="学习率")
+                    tab_seed = gr.Number(value=42, label="随机种子", precision=0)
+                    tab_btn = gr.Button("🚀 训练TabBERT模型", variant="primary", size="lg")
+                    if not TORCH_AVAILABLE:
+                        gr.Markdown("⚠️ **PyTorch 未安装**。请在 requirements.txt 中添加 `torch>=2.0.0` 并重启。")
+                with gr.Column(scale=2):
+                    tab_result = gr.Textbox(label="训练结果", lines=25)
+            with gr.Row():
+                tab_img1 = gr.Image(label="特征重要性")
+                tab_img2 = gr.Image(label="异常分数分布")
+            with gr.Row():
+                tab_img3 = gr.Image(label="ROC曲线")
+                tab_img4 = gr.Image(label="混淆矩阵与阈值分析")
+        
+        # ===== Tab 5: 模型管理 =====
+        with gr.Tab("💾 模型管理"):
+            gr.Markdown("""### Hugging Face Hub 模型管理
+保存训练好的模型到 Hub, 或从 Hub 加载已有模型。
+
+**获取 Token:** https://huggingface.co/settings/tokens""")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("#### 保存模型到 Hub")
+                    save_repo_id = gr.Textbox(label="Hub Repo ID", placeholder="如: yourname/insurance-model-v1")
+                    save_token = gr.Textbox(label="HF Token", placeholder="hf_xxxxx", type="password")
+                    save_type = gr.Dropdown(["churn_prediction", "product_recommendation", "anomaly_detection", "all"],
+                                             value="all", label="模型类型")
+                    save_notes = gr.Textbox(label="备注", placeholder="模型描述...")
+                    save_btn = gr.Button("📤 保存到 Hub", variant="primary")
+                    save_result = gr.Textbox(label="保存结果", lines=10)
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("#### 从 Hub 加载模型")
+                    load_repo_id = gr.Textbox(label="Hub Repo ID", placeholder="如: yourname/insurance-model-v1")
+                    load_token = gr.Textbox(label="HF Token", placeholder="hf_xxxxx", type="password")
+                    load_type = gr.Dropdown(["churn_prediction", "product_recommendation", "anomaly_detection", "all"],
+                                            value="all", label="模型类型")
+                    load_btn = gr.Button("📥 从 Hub 加载", variant="primary")
+                    load_result = gr.Textbox(label="加载结果", lines=15)
+            with gr.Row():
+                load_img1 = gr.Image(label="加载模型可视化 1")
+                load_img2 = gr.Image(label="加载模型可视化 2")
+                load_img3 = gr.Image(label="加载模型可视化 3")
+        
+        # ===== Tab 6: 生存分析 =====
+        with gr.Tab("⏱️ 生存分析"):
+            gr.Markdown("""### 保险理赔/购买时序生存分析
+预测从投保到理赔/购买/流失的时间, 处理右删失数据 (部分用户尚未发生事件)。
+
+**统计方法:** lifelines Cox-PH + Kaplan-Meier | **深度方法:** DeepSurv (Neural Cox-PH)""")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    surv_samples = gr.Slider(500, 5000, value=2000, step=100, label="样本数量")
+                    surv_test_size = gr.Slider(0.1, 0.4, value=0.2, step=0.05, label="测试集比例")
+                    surv_seed = gr.Number(value=42, label="随机种子", precision=0)
+                    use_deep_surv = gr.Checkbox(value=True, label="启用 DeepSurv (PyTorch)")
+                    deep_epochs = gr.Slider(10, 200, value=50, step=10, label="DeepSurv Epochs")
+                    deep_lr = gr.Slider(0.0001, 0.01, value=0.001, step=0.0001, label="DeepSurv LR")
+                    surv_btn = gr.Button("🚀 训练生存分析模型", variant="primary", size="lg")
+                    
+                    if not LIFELINES_AVAILABLE:
+                        gr.Markdown("⚠️ **lifelines 未安装**。统计生存分析禁用。")
+                    if not TORCH_AVAILABLE:
+                        gr.Markdown("⚠️ **PyTorch 未安装**。DeepSurv 禁用。")
+                
+                with gr.Column(scale=2):
+                    surv_result = gr.Textbox(label="训练结果", lines=30)
+            with gr.Row():
+                surv_img1 = gr.Image(label="Kaplan-Meier 生存曲线")
+                surv_img2 = gr.Image(label="Cox-PH 系数")
+            with gr.Row():
+                surv_img3 = gr.Image(label="预测生存函数")
+                surv_img4 = gr.Image(label="DeepSurv 风险分层")
+            with gr.Row():
+                surv_table = gr.Dataframe(label="数据样本")
+        
+        # ===== Tab 7: 帮助文档 =====
+        with gr.Tab("❓ 帮助"):
+            gr.Markdown("""## 📚 完整使用指南
+
+### 1. 演示模式
+合成保险APP行为数据, 自动标注流失/留存标签, 训练 GBDT + RF。
+
+### 2. CSV上传
+**必需列:** `user_id`, `session_id`, `timestamp`, `event_type`, `page_id`
+**可选:** `product_id`, `amount`, `label`
+
+### 3. DIN 产品推荐
+- 输入: 用户历史行为序列 + 候选保险产品
+- 核心: LocalActivationUnit 注意力机制
+- 输出: 购买概率 + 注意力权重可视化
+
+### 4. TabBERT 异常检测
+- 输入: 理赔记录多维特征
+- 损失: Focal Loss (解决1:4不平衡)
+- 输出: 异常分数 + 阈值分析
+
+### 5. 模型管理
+- 保存: 训练后自动保存到 `outputs/`, 可一键上传至 Hugging Face Hub
+- 加载: 从 Hub 下载已有模型, 查看指标和特征重要性
+
+### 6. 生存分析
+- **lifelines Cox-PH**: 统计基线, 可解释系数, Kaplan-Meier 曲线
+- **DeepSurv**: 神经网络Cox-PH, 学习非线性交互, 风险分层
+- **右删失处理**: 自动处理尚未发生事件的用户
+
+### 事件类型 (30种)
+浏览 | 交互 | 转化 | 理赔 | 续保 | 其他
+---|---|---|---|---|---
+page_view | quote_request | payment_success | claim_init | renewal_click | login
+product_view | form_submit | policy_issued | claim_doc_upload | renewal_complete | logout
+premium_calculator | document_upload | policy_select | claim_review | policy_cancel | app_uninstall
+article_read | chat_init | payment_init | claim_approved | renewal_reminder |
+faq_view | call_init | | claim_rejected | |
+product_compare | video_consult | | | |
+
+### 参考文献
+| 论文 | 应用 | arXiv |
+|------|------|-------|
+| Deep Interest Network | 产品推荐 | [1706.06978](https://arxiv.org/abs/1706.06978) |
+| SDIM | 长期行为建模 | [2205.10249](https://arxiv.org/abs/2205.10249) |
+| TabBERT/TabFormer | 表格时序异常检测 | [2011.01843](https://arxiv.org/abs/2011.01843) |
+| Transformer Churn | 非合约流失预测 | [2309.14390](https://arxiv.org/abs/2309.14390) |
+| DeepSurv | 生存分析 | [1606.00931](https://arxiv.org/abs/1606.00931) |
+| RNN Survival | 购买时序预测 | [2304.00575](https://arxiv.org/abs/2304.00575) |
+| Focal Loss | 不平衡分类 | [1708.02002](https://arxiv.org/abs/1708.02002) |
+""")
+    
+    gr.Markdown("""---
+<div align="center">
+<b>保险APP 用户行为分析模型训练平台 v3.0</b> | 
+作者: <a href="https://huggingface.co/Stephanwu">Stephanwu</a>
+</div>""")
+    
+    # ===== 事件绑定 =====
+    train_btn.click(fn=demo_train, inputs=[n_users_slider, n_events_slider, test_size_slider, random_seed, use_cv_check],
+                    outputs=[demo_result, demo_img1, demo_img2, demo_img3, demo_img4, demo_table])
+    info_btn.click(fn=show_csv_info, inputs=[csv_file], outputs=[csv_info, csv_preview])
+    csv_train_btn.click(fn=csv_train, inputs=[csv_file, label_col_input, csv_test_size, csv_random_seed, csv_use_cv],
+                        outputs=[csv_result, csv_img1, csv_img2, csv_img3, csv_img4, csv_table])
+    din_btn.click(fn=train_din_recommendation, inputs=[din_users, din_emb, din_epochs, din_batch, din_lr, din_seed],
+                  outputs=[din_result, din_img1, din_img2, din_img3, din_img4])
+    tab_btn.click(fn=train_tabbert_anomaly, inputs=[tab_normal, tab_anomaly, tab_dmodel, tab_epochs, tab_batch, tab_lr, tab_seed],
+                  outputs=[tab_result, tab_img1, tab_img2, tab_img3, tab_img4])
+    save_btn.click(fn=save_model_to_hub, inputs=[save_repo_id, save_token, save_type, save_notes],
+                   outputs=[save_result])
+    load_btn.click(fn=load_model_from_hub, inputs=[load_repo_id, load_token, load_type],
+                   outputs=[load_result, load_img1, load_img2, load_img3])
+    surv_btn.click(fn=train_survival_analysis, inputs=[surv_samples, surv_test_size, surv_seed, use_deep_surv, deep_epochs, deep_lr],
+                   outputs=[surv_result, surv_img1, surv_img2, surv_img3, surv_img4, surv_table])
+
+if __name__ == "__main__":
+    demo.launch()