Add model management (HF Hub save/load) and survival analysis (lifelines + DeepSurv)

app.py

@@ -1,22 +1,25 @@
 """
-保险APP 用户行为分析 - Gradio Space (完整版)
-支持: 演示模式 | CSV上传 | 产品推荐(DIN) | 异常检测(TabBERT)
+保险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
+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
+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, LabelEncoder
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
 from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
 from sklearn.metrics import (
     roc_auc_score, f1_score, confusion_matrix,
@@ -30,20 +33,39 @@ import seaborn as sns
 
 import gradio as gr
 
-# PyTorch (可选, 用于深度学习模型)
+# PyTorch
 try:
     import torch
     import torch.nn as nn
     import torch.nn.functional as F
-    from torch.utils.data import Dataset, DataLoader
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
-    print("PyTorch not available. Deep learning models disabled.")
+    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 = {
@@ -56,12 +78,6 @@ INSURANCE_EVENT_TYPES = {
     "policy_cancel", "app_uninstall", "login", "logout",
 }
 
-BROWSE = {"page_view","product_view","premium_calculator","article_read","faq_view","product_compare"}
-INTERACT = {"quote_request","form_submit","document_upload","chat_init","call_init","video_consult","quote_result_view"}
-CONVERT = {"policy_select","payment_init","payment_success","policy_issued"}
-CLAIM = {"claim_init","claim_doc_upload","claim_review","claim_approved","claim_rejected"}
-RENEW = {"renewal_reminder","renewal_click","renewal_complete","policy_cancel"}
-
 @dataclass
 class InsuranceAppEvent:
     event_id: str; user_id: str; session_id: str; timestamp: int
@@ -79,6 +95,10 @@ class UserBehaviorProfile:
     user_id: str; sessions: List[UserSession] = field(default_factory=list)
 
 
+# =============================================================================
+# 特征工程
+# =============================================================================
+
 class InsuranceFeatureEngineer:
     def extract_user_features(self, profile):
         sessions = profile.sessions
@@ -97,11 +117,8 @@ class InsuranceFeatureEngineer:
         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)
-        
-        # 计算行为序列 (用于DIN)
         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),
@@ -122,9 +139,7 @@ class InsuranceFeatureEngineer:
             "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,
+            "_event_sequence": event_seq, "_product_sequence": product_seq,
             "_user_id": profile.user_id,
         }
 
@@ -142,7 +157,6 @@ def parse_csv_to_profiles(df):
     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:
@@ -193,108 +207,24 @@ def generate_synthetic_data(n_users=2000, n_events_per_user=50, seed=42):
     return data
 
 
-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"]
-    event_types = list(INSURANCE_EVENT_TYPES)
-    
-    records = []
-    for u in range(n_users):
-        user_id = u
-        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': user_id,
-            '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 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):
-        record = {
-            '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,  # 正常
-        }
-        normal_records.append(record)
-    
-    anomaly_records = []
-    for i in range(n_anomaly):
-        # 异常特征: 高金额、刚投保、多理赔、少材料、快处理
-        record = {
-            '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,  # 异常
-        }
-        anomaly_records.append(record)
-    
-    df = pd.DataFrame(normal_records + anomaly_records)
-    df = df.sample(frac=1, random_state=seed).reset_index(drop=True)  # 打乱
-    return df
-
-
 # =============================================================================
-# 通用训练函数 (sklearn)
+# 通用 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 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
-    )
-    
+    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)
+    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)
@@ -376,7 +306,6 @@ def train_sklearn(features_list, labels, test_size=0.2, random_state=42, use_cv=
     result_text = f"""=== 模型训练结果 ===
 样本数: {len(y)} | 特征数: {len(feature_names)}
 训练集: {len(y_train)} | 测试集: {len(y_test)}
-流失率: {y.mean():.1%} | 流失数: {int(y.sum())}
 
 --- GBDT ---
 AUC:  {auc_gbdt:.4f}
@@ -394,58 +323,77 @@ AP:   {ap_rf:.4f}
 --- 分类报告 (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 简化版)
+# 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):
-    """训练 DIN 风格的产品推荐模型 (简化版, 使用 PyTorch 模拟)"""
     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)
     
-    # 构建 vocab
     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 = []
-    
+    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
+            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)
     
-    # 简单的 PyTorch 训练 (使用 Attention 的 MLP)
     device = torch.device('cpu')
     
     class SimpleDIN(nn.Module):
@@ -454,33 +402,22 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
             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)
-            )
-        
+            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)  # (B,L,D/2)
-            p_emb = self.prod_emb(bp)   # (B,L,D/2)
-            beh_emb = torch.cat([e_emb, p_emb], dim=-1)  # (B,L,D)
-            cand_emb = self.cand_emb(cp)  # (B,D)
-            
-            # Attention
+            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
+            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)  # (B,L)
+            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)  # (B,D)
-            
-            # MLP
+            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)
     
@@ -488,10 +425,8 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     criterion = nn.BCEWithLogitsLoss()
     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     
-    # 训练
     for epoch in range(epochs):
-        model.train()
-        epoch_loss = 0
+        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)
@@ -499,18 +434,14 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
             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()
+            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/len(train_df)*batch_size:.4f}")
+            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)
@@ -518,7 +449,6 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
         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))
@@ -526,26 +456,33 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     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': []}
+        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)
@@ -554,46 +491,36 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
         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 by Product', fontweight='bold')
+        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]
-        
+        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)
+        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
+        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')
+    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()
     
-    # ROC曲线
     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')
@@ -605,7 +532,6 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     fig_path3 = "outputs/din_roc.png"
     plt.savefig(fig_path3, dpi=150); plt.close()
     
-    # PR曲线
     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')
@@ -618,17 +544,17 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     
     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}
-Event vocab: {len(all_events)} | Product vocab: {len(all_products)}
-Attention: LocalActivationUnit (4路交互特征)
+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
+Optimizer: Adam | Loss: BCEWithLogitsLoss
 
 --- 测试集效果 ---
 AUC:  {auc:.4f}
@@ -639,26 +565,55 @@ Accuracy: {acc:.4f}
 --- 模型洞察 ---
 1. 注意力机制自动学习用户历史行为中对候选产品的相关度
 2. 高权重通常分配给同类产品的历史浏览/购买行为
-3. 新用户(历史短)依赖统计特征, 老用户依赖行为序列"""
+3. 新用户(历史短)依赖统计特征, 老用户依赖行为序列
+
+--- 模型文件 ---
+模型已保存至: outputs/din_model.pt
+可使用"模型管理"Tab上传至Hugging Face Hub"""
     
     return result_text, fig_path1, fig_path2, fig_path3, fig_path4
 
 
 # =============================================================================
-# 异��检测 (TabBERT 简化版)
+# 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):
-    """训练 TabularBERT 风格的异常检测模型"""
     if not TORCH_AVAILABLE:
-        return "❌ PyTorch 未安装。请在 requirements.txt 中添加 torch 并重启 Space。", None, None, None, None, None
+        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)
     
@@ -668,7 +623,6 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     X = df[feature_cols].values.astype(np.float32)
     y = df['label'].values.astype(np.float32)
     
-    # 标准化
     scaler = StandardScaler()
     X_s = scaler.fit_transform(X)
     
@@ -676,34 +630,21 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
         X_s, y, test_size=0.2, random_state=seed, stratify=y
     )
     
-    # 简单的 Tabular MLP (模拟 TabBERT)
     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)
-            
-            # 模拟 Transformer layers
             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),
+                    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)
-            )
-        
+            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)
@@ -711,12 +652,9 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     
     model = SimpleTabBERT(input_dim=len(feature_cols), d_model=d_model).to(device)
     
-    # Focal Loss (不平衡数据)
     class FocalLoss(nn.Module):
         def __init__(self, alpha=0.25, gamma=2.0):
-            super().__init__()
-            self.alpha = alpha; self.gamma = gamma
-        
+            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)
@@ -725,35 +663,24 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     criterion = FocalLoss(alpha=0.25, gamma=2.0)
     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     
-    # 转换为 tensor
     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
+        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]
-            
+            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()
+            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()
@@ -762,16 +689,18 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     ap = float(average_precision_score(y_test, preds))
     f1 = float(f1_score(y_test, preds > 0.5))
     
-    # 可视化
-    os.makedirs("outputs", exist_ok=True)
+    # 保存模型
+    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')
     
-    # 特征重要性 (通过梯度近似)
-    model.eval()
-    X_test_grad = torch.tensor(X_test, dtype=torch.float32, requires_grad=True).to(device)
-    with torch.no_grad():
-        outputs = model(X_test_grad)
+    os.makedirs("outputs", exist_ok=True)
     
-    # 使用 permutation importance 近似
     baseline_auc = auc
     importances = []
     for i in range(len(feature_cols)):
@@ -792,10 +721,8 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     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]
+    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')
@@ -806,7 +733,6 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     fig_path2 = "outputs/tabbert_distribution.png"
     plt.savefig(fig_path2, dpi=150); plt.close()
     
-    # ROC曲线
     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')
@@ -818,21 +744,16 @@ def train_tabbert_anomaly(n_normal, n_anomaly, d_model, epochs, batch_size, lr,
     fig_path3 = "outputs/tabbert_roc.png"
     plt.savefig(fig_path3, dpi=150); plt.close()
     
-    # 混淆矩阵 + 阈值分析
     fig, axs = plt.subplots(1, 2, figsize=(14,6))
-    
-    # 混淆矩阵 @ 0.5
     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)
@@ -870,17 +791,518 @@ 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说明模型能很好区分正常与异常理赔"""
+4. 高AUC说明模型能很好区分正常与异常理赔
+
+--- 模型文件 ---
+模型已保存至: outputs/tabbert_model.pt
+可使用"模型管理"Tab上传至Hugging Face Hub"""
     
     return result_text, fig_path1, fig_path2, fig_path3, fig_path4
 
 
 # =============================================================================
-# Gradio 回调函数
+# 模型管理 — 保存/加载到 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 = [], []
@@ -891,7 +1313,6 @@ def demo_train(n_users, n_events, test_size, random_state, use_cv):
 
 
 def csv_train(csv_file, label_col, test_size, random_state, use_cv):
-    """CSV模式"""
     if csv_file is None:
         return "请先上传CSV文件", None, None, None, None, None
     try:
@@ -899,15 +1320,12 @@ def csv_train(csv_file, label_col, test_size, random_state, use_cv):
             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:
@@ -918,10 +1336,8 @@ def csv_train(csv_file, label_col, test_size, random_state, use_cv):
                 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
@@ -954,26 +1370,21 @@ def show_csv_info(csv_file):
 
 
 # =============================================================================
-# Gradio 界面 (5 Tabs)
+# Gradio 界面 (7 Tabs)
 # =============================================================================
 
-with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""# 🏥 保险APP 用户行为分析模型训练平台
+with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台 v3.0", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""# 🏥 保险APP 用户行为分析模型训练平台 v3.0
 
-基于最新研究论文构建的工��级保险用户行为分析平台。
+基于最新研究论文构建的**工业级保险用户行为分析平台**。
 
-**五大功能模块:**
-- 🎲 **演示模式**: 合成数据体验完整训练流程
-- 📁 **CSV上传**: 上传真实用户行为数据
-- 🎯 **产品推荐 (DIN)**: Deep Interest Network 保险产品推荐
-- 🔍 **异常检测 (TabBERT)**: 层次化Transformer理赔欺诈检测
-- ❓ **帮助文档**: 完整使用指南
+**七大功能模块:** 🎲演示 | 📁CSV上传 | 🎯产品推荐(DIN) | 🔍异常检测(TabBERT) | 💾模型管理 | ⏱️生存分析 | ❓帮助
 
-**参考论文:** Deep Interest Network (KDD 2018) | Transformer Churn Prediction (arXiv 2309.14390) | TabBERT (arXiv 2011.01843) | Focal Loss (ICCV 2017)""")
+**参考论文:** [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.Tab("🎲 演示"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### 参数设置")
@@ -995,23 +1406,14 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", them
                 demo_table = gr.Dataframe(label="特征数据样本")
         
         # ===== Tab 2: CSV上传 =====
-        with gr.Tab("📁 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`(流失标签)
-
-**示例:**
-```
-user_id,session_id,timestamp,event_type,page_id,product_id,amount
-user_001,sess_001,1704067200000,page_view,home,,
-user_001,sess_001,1704067230000,product_view,product,health_basic,
-```""")
+**可选:** `product_id`, `amount`, `label`""")
                     csv_file = gr.File(label="上传CSV文件", file_types=[".csv"])
-                    label_col_input = gr.Textbox(label="标签列名 (可选)", placeholder="如: churn, is_churned")
+                    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)
@@ -1033,19 +1435,12 @@ user_001,sess_001,1704067230000,product_view,product,health_basic,
             with gr.Row():
                 csv_table = gr.Dataframe(label="特征数据样本")
         
-        # ===== Tab 3: 产品推荐 (DIN) =====
+        # ===== Tab 3: DIN 产品推荐 =====
         with gr.Tab("🎯 产品推荐 (DIN)"):
             gr.Markdown("""### Deep Interest Network - 保险产品推荐
-
-基于用户历史行为序列, 通过注意力机制动态计算对候选保险产品的兴趣度, 预测购买概率。
-
-**核心架构:**
-- 用户历史行为 → Embedding → LocalActivationUnit → 动态兴趣向量
-- 候选产品Embedding → 拼接交互特征 → MLP → 购买概率""")
-            
+基于用户历史行为序列, 通过注意力机制动态计算对候选保险产品的兴趣度。""")
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### DIN 参数")
                     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="训练轮数")
@@ -1053,13 +1448,10 @@ user_001,sess_001,1704067230000,product_view,product,health_basic,
                     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` 并重启 Space。")
-                
+                        gr.Markdown("⚠️ **PyTorch 未安装**。请在 requirements.txt 中添加 `torch>=2.0.0` 并重启。")
                 with gr.Column(scale=2):
                     din_result = gr.Textbox(label="训练结果", lines=25, show_copy_button=True)
-            
             with gr.Row():
                 din_img1 = gr.Image(label="产品推荐效果")
                 din_img2 = gr.Image(label="注意力权重示例")
@@ -1067,20 +1459,12 @@ user_001,sess_001,1704067230000,product_view,product,health_basic,
                 din_img3 = gr.Image(label="ROC曲线")
                 din_img4 = gr.Image(label="PR曲线")
         
-        # ===== Tab 4: 异常检测 (TabBERT) =====
+        # ===== Tab 4: TabBERT 异常检测 =====
         with gr.Tab("🔍 异常检测 (TabBERT)"):
             gr.Markdown("""### TabularBERT - 理赔欺诈/异常检测
-
-层次化Transformer架构, 学习理赔记录的多字段关联和时序模式, 自动识别异常理赔行为。
-
-**核心架构:**
-- Field-level Transformer: 单条理赔记录内字段关联
-- Sequence-level Transformer: 跨理赔记录时序模式
-- Focal Loss: 解决异常样本极少的不平衡问题""")
-            
+层次化Transformer架构, 学习理赔记录的多字段关联和时序模式。""")
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### TabBERT 参数")
                     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")
@@ -1089,13 +1473,10 @@ user_001,sess_001,1704067230000,product_view,product,health_basic,
                     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` 并重启 Space。")
-                
+                        gr.Markdown("⚠️ **PyTorch 未安装**。请在 requirements.txt 中添加 `torch>=2.0.0` 并重启。")
                 with gr.Column(scale=2):
                     tab_result = gr.Textbox(label="训练结果", lines=25, show_copy_button=True)
-            
             with gr.Row():
                 tab_img1 = gr.Image(label="特征重要性")
                 tab_img2 = gr.Image(label="异常分数分布")
@@ -1103,107 +1484,142 @@ user_001,sess_001,1704067230000,product_view,product,health_basic,
                 tab_img3 = gr.Image(label="ROC曲线")
                 tab_img4 = gr.Image(label="混淆矩阵与阈值分析")
         
-        # ===== Tab 5: 帮助文档 =====
-        with gr.Tab("❓ 帮助文档"):
+        # ===== 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, show_copy_button=True)
+            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, show_copy_button=True)
+            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行为数据
-- 高流失风险用户模拟: 低频浏览、无转化、短会话
-- 低流失风险用户模拟: 完整行为漏斗、有保单、有续保
-
-### 2. CSV数据上传
-**必需列:**
-| 列名 | 类型 | 说明 |
-|------|------|------|
-| user_id | string/int | 用户唯一标识 |
-| session_id | string/int | 会话标识 |
-| timestamp | int | Unix时间戳(毫秒或秒) |
-| event_type | string | 见下方事件类型表 |
-| page_id | string | 页面标识 |
-
-**可选列:**
-| 列名 | 类型 | 说明 |
-|------|------|------|
-| product_id | string | 保险产品ID |
-| amount | float | 金额/保额 |
-| label | int(0/1) | 流失标签 |
-
-### 3. 事件类型定义
-
-| 类别 | 事件 | 业务含义 |
-|------|------|---------|
-| **浏览** | page_view, product_view, premium_calculator, article_read, faq_view, product_compare | 用户浏览保险产品页面 |
-| **交互** | quote_request, form_submit, document_upload, chat_init, call_init, video_consult, quote_result_view | 用户深度参与行为 |
-| **转化** | policy_select, payment_init, payment_success, policy_issued | 核心KPI转化行为 |
-| **理赔** | claim_init, claim_doc_upload, claim_review, claim_approved, claim_rejected | 理赔全流程 |
-| **续保** | renewal_reminder, renewal_click, renewal_complete, policy_cancel | 续保/流失信号 |
-
-### 4. 模型对比
-
-| 模型 | 适用场景 | 核心特点 |
-|------|---------|---------|
-| **GBDT** | 流失预测基线 | 高精度, 可解释, 训练快 |
-| **Random Forest** | 特征筛选 | 抗过拟合, 特征重要性直观 |
-| **DIN** | 产品推荐 | 注意力动态兴趣, 候选产品自适应 |
-| **TabBERT** | 异常检测 | 层次化Transformer, Focal Loss |
-
-### 5. 评估指标
-
-| 指标 | 说明 | 适用场景 |
-|------|------|---------|
-| **AUC-ROC** | 分类器整体区分能力 | 所有二分类任务 |
-| **F1-Score** | 精确率与召回率调和平均 | 不平衡数据 |
-| **AP** | PR曲线下面积 | 正样本极少时 |
-| **交叉验证** | 5折StratifiedKFold | 评估模型稳定性 |
-
-### 6. 参考文献
+合成保险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 用户行为分析模型训练平台</b> | 
-<a href="https://arxiv.org/abs/1706.06978">DIN</a> | 
-<a href="https://arxiv.org/abs/2309.14390">Churn Transformer</a> | 
-<a href="https://arxiv.org/abs/2011.01843">TabBERT</a> | 
-<a href="https://arxiv.org/abs/1708.02002">Focal Loss</a> |
+<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]
-    )
+    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()