Major update: Add DIN product recommendation and TabBERT anomaly detection with PyTorch

app.py

@@ -1,7 +1,13 @@
-"""保险APP 用户行为分析 - Gradio Space
-支持: 合成数据训练 + 真实CSV数据上传
 """
-import os, json, math, warnings, datetime, random, io
+保险APP 用户行为分析 - Gradio Space (完整版)
+支持: 演示模式 | 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)
+"""
+import os, io, math, warnings, datetime, random, json
 from collections import Counter, defaultdict
 from dataclasses import dataclass, field
 from typing import List, Dict, Optional
@@ -9,13 +15,13 @@ from typing import List, Dict, Optional
 warnings.filterwarnings('ignore')
 import numpy as np
 import pandas as pd
-from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
+from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
 from sklearn.preprocessing import StandardScaler, LabelEncoder
 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
+    roc_curve, accuracy_score
 )
 import matplotlib
 matplotlib.use('Agg')
@@ -24,8 +30,20 @@ import seaborn as sns
 
 import gradio as gr
 
+# 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.")
+
+
 # =============================================================================
-# 数据模型
+# 数据模型 & 特征工程 (保持原有)
 # =============================================================================
 
 INSURANCE_EVENT_TYPES = {
@@ -38,11 +56,11 @@ INSURANCE_EVENT_TYPES = {
     "policy_cancel", "app_uninstall", "login", "logout",
 }
 
-BROWSE_EVENTS = {"page_view", "product_view", "premium_calculator", "article_read", "faq_view", "product_compare"}
-INTERACT_EVENTS = {"quote_request", "form_submit", "document_upload", "chat_init", "call_init", "video_consult", "quote_result_view"}
-CONVERT_EVENTS = {"policy_select", "payment_init", "payment_success", "policy_issued"}
-CLAIM_EVENTS = {"claim_init", "claim_doc_upload", "claim_review", "claim_approved", "claim_rejected"}
-RENEW_EVENTS = {"renewal_reminder", "renewal_click", "renewal_complete", "policy_cancel"}
+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:
@@ -77,8 +95,13 @@ class InsuranceFeatureEngineer:
         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)
+        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),
@@ -88,6 +111,7 @@ class InsuranceFeatureEngineer:
             "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),
@@ -98,58 +122,47 @@ 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,
+            "_user_id": profile.user_id,
         }
 
 
 # =============================================================================
-# 数据解析
+# 数据解析 & 生成
 # =============================================================================
 
-def parse_csv_to_profiles(df: pd.DataFrame) -> List[UserBehaviorProfile]:
-    """将上传的CSV解析为用户行为画像"""
+def parse_csv_to_profiles(df):
     required_cols = {"user_id", "session_id", "timestamp", "event_type", "page_id"}
-    missing = required_cols - set(df.columns)
+    missing = required_cols - set(c.lower().strip() for c in df.columns)
     if missing:
-        raise ValueError(f"CSV缺少必需列: {missing}\n必需列: {required_cols}")
-    
-    # 标准化列名
-    df = df.copy()
+        raise ValueError(f"CSV缺少必需列: {missing}")
     df.columns = [c.lower().strip() for c in df.columns]
-    
-    # 转换timestamp为整数
     df["timestamp"] = pd.to_numeric(df["timestamp"], errors="coerce")
     df = df.dropna(subset=["timestamp", "event_type"])
     df["timestamp"] = df["timestamp"].astype(int)
     
-    # 按user_id和session_id分组
     profiles = {}
-    for (user_id, session_id), group in df.groupby(["user_id", "session_id"]):
-        if user_id not in profiles:
-            profiles[user_id] = UserBehaviorProfile(user_id=str(user_id), sessions=[])
-        
+    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_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[user_id].sessions.append(UserSession(
-            session_id=str(session_id),
-            user_id=str(user_id),
-            events=events
-        ))
-    
+        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):
+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"]
@@ -180,22 +193,93 @@ def generate_synthetic_data(n_users=2000, n_events_per_user=50):
     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)
 # =============================================================================
 
-def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=False):
-    """通用训练函数"""
+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 df[c].dtype == 'object']
+    # 移除非数值列 (内部字段)
+    drop_cols = [c for c in df.columns if c.startswith('_')]
     for c in drop_cols:
-        if c in ["top_product_id", "action_sequence"]:
-            df.pop(c)
-    
-    # 处理object类型
+        df.pop(c)
     for c in df.columns:
         if df[c].dtype == 'object':
             df[c] = pd.to_numeric(df[c], errors='coerce').fillna(0)
@@ -212,23 +296,13 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     X_train_s = scaler.fit_transform(X_train)
     X_test_s = scaler.transform(X_test)
     
-    # 训练 GBDT
-    gbdt = GradientBoostingClassifier(
-        n_estimators=200, max_depth=5, learning_rate=0.1,
-        subsample=0.8, random_state=random_state
-    )
+    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]
+    y_pred_gbdt = gbdt.predict(X_test_s); y_prob_gbdt = gbdt.predict_proba(X_test_s)[:,1]
     
-    # 训练 RF
-    rf = RandomForestClassifier(
-        n_estimators=100, max_depth=10,
-        class_weight='balanced', random_state=random_state, n_jobs=-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)
+    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))
@@ -236,18 +310,13 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     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)
+    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))
@@ -265,11 +334,9 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     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_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)
+    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()
@@ -285,7 +352,6 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     fig_path3 = "outputs/confusion_matrix.png"
     plt.savefig(fig_path3, dpi=150, bbox_inches='tight'); plt.close()
     
-    # ROC曲线
     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)
@@ -295,8 +361,7 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     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)
+    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()
@@ -311,7 +376,7 @@ def train_model(features_list, labels, test_size=0.2, random_state=42, use_cv=Fa
     result_text = f"""=== 模型训练结果 ===
 样本数: {len(y)} | 特征数: {len(feature_names)}
 训练集: {len(y_train)} | 测试集: {len(y_test)}
-流失率: {y.mean():.1%} | 流失数: {y.sum()}
+流失率: {y.mean():.1%} | 流失数: {int(y.sum())}
 
 --- GBDT ---
 AUC:  {auc_gbdt:.4f}
@@ -332,42 +397,514 @@ AP:   {ap_rf:.4f}
     return result_text, fig_path1, fig_path2, fig_path3, fig_path4, df_full
 
 
+# =============================================================================
+# 产品推荐 (DIN 简化版)
+# =============================================================================
+
+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 = []
+    
+    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)
+    
+    # 简单的 PyTorch 训练 (使用 Attention 的 MLP)
+    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)  # (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
+            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)  # (B,L)
+            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
+            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/len(train_df)*batch_size:.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)
+    
+    # 产品推荐效果
+    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 by Product', 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()
+    
+    # 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')
+    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()
+    
+    # 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')
+    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)}
+训练集: {len(train_df)} | 测试集: {len(test_df)}
+
+--- 模型架构 ---
+Embedding dim: {embedding_dim}
+Event vocab: {len(all_events)} | Product vocab: {len(all_products)}
+Attention: LocalActivationUnit (4路交互特征)
+MLP: [emb*3] → 256 → 128 → 1
+
+--- 训练配置 ---
+Epochs: {epochs} | Batch size: {batch_size} | LR: {lr}
+Optimizer: Adam
+
+--- 测试集效果 ---
+AUC:  {auc:.4f}
+AP:   {ap:.4f}
+F1:   {f1:.4f}
+Accuracy: {acc:.4f}
+
+--- 模型洞察 ---
+1. 注意力机制自动学习用户历史行为中对候选产品的相关度
+2. 高权重通常分配给同类产品的历史浏览/购买行为
+3. 新用户(历史短)依赖统计特征, 老用户依赖行为序列"""
+    
+    return result_text, fig_path1, fig_path2, fig_path3, fig_path4
+
+
+# =============================================================================
+# 异常检测 (TabBERT 简化版)
+# =============================================================================
+
+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
+    
+    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
+    )
+    
+    # 简单的 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),
+                ])
+            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)
+    
+    # Focal Loss (不平衡数据)
+    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)
+    
+    # 转换为 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
+        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))
+    
+    # 可视化
+    os.makedirs("outputs", exist_ok=True)
+    
+    # 特征重要性 (通过梯度近似)
+    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)
+    
+    # 使用 permutation importance 近似
+    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()
+    
+    # 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')
+    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))
+    
+    # 混淆矩阵 @ 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)
+    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说明模型能很好区分正常与异常理赔"""
+    
+    return result_text, fig_path1, fig_path2, fig_path3, fig_path4
+
+
 # =============================================================================
 # 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)
+    """演示模式"""
+    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_model(features_list, labels, test_size, random_state, use_cv)
+    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):
-    """CSV模式: 上传数据训练"""
+    """CSV模式"""
     if csv_file is None:
         return "请先上传CSV文件", None, None, None, None, None
-    
     try:
-        # 读取CSV
         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 = [], []
         
@@ -375,82 +912,68 @@ def csv_train(csv_file, label_col, test_size, random_state, use_cv):
             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]
-                    label_val = user_df[label_col].iloc[0] if len(user_df) > 0 else 0
-                    labels.append(int(label_val))
+                    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)
+                    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
-        
-        result = train_model(features_list, labels, test_size, random_state, use_cv)
-        return result
+            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):
-    """显示CSV信息"""
     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)}
+行数: {len(df)} | 列数: {len(df.columns)}
 列名: {list(df.columns)}
 
-=== 前5行预览 ===
+=== 前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 '无user_id列'}
-
-=== 会话数量 ===
-{df['session_id'].nunique() if 'session_id' in df.columns else '无session_id列'}"""
-        
+=== 用户数: {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 界面
+# Gradio 界面 (5 Tabs)
 # =============================================================================
 
 with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🏥 保险APP 用户行为分析模型训练平台
-    
-    基于最新研究论文构建的工业级保险用户行为分析平台。
-    
-    **两种模式:**
-    - 🎲 **演示模式**: 生成合成保险APP数据，体验完整训练流程
-    - 📁 **CSV上传**: 上传真实用户行为数据，自动特征工程 + 模型训练
-    
-    **参考论文:** Deep Interest Network (KDD 2018) | Transformer Churn Prediction (arXiv 2309.14390) | TabBERT (arXiv 2011.01843)
-    """)
+    gr.Markdown("""# 🏥 保险APP 用户行为分析模型训练平台
+
+基于最新研究论文构建的工业级保险用户行为分析平台。
+
+**五大功能模块:**
+- 🎲 **演示模式**: 合成数据体验完整训练流程
+- 📁 **CSV上传**: 上传真实用户行为数据
+- 🎯 **产品推荐 (DIN)**: Deep Interest Network 保险产品推荐
+- 🔍 **异常检测 (TabBERT)**: 层次化Transformer理赔欺诈检测
+- ❓ **帮助文档**: 完整使用指南
+
+**参考论文:** Deep Interest Network (KDD 2018) | Transformer Churn Prediction (arXiv 2309.14390) | TabBERT (arXiv 2011.01843) | Focal Loss (ICCV 2017)""")
     
     with gr.Tabs():
         # ===== Tab 1: 演示模式 =====
-        with gr.Tab("🎲 演示模式 (合成数据)"):
+        with gr.Tab("🎲 演示模式"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### 参数设置")
@@ -460,10 +983,8 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", them
                     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, show_copy_button=True)
-            
             with gr.Row():
                 demo_img1 = gr.Image(label="特征重要性")
                 demo_img2 = gr.Image(label="PR曲线")
@@ -471,56 +992,38 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", them
                 demo_img3 = gr.Image(label="混淆矩阵")
                 demo_img4 = gr.Image(label="ROC曲线")
             with gr.Row():
-                demo_table = gr.Dataframe(label="特征数据样本 (前10行)")
+                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`: Unix 时间戳 (毫秒或秒)
-                    - `event_type`: 事件类型
-                    - `page_id`: 页面标识
-                    
-                    **可选列:**
-                    - `product_id`: 保险产品ID
-                    - `amount`: 金额/保额
-                    - `label` (或其他): 流失标签 (0/1)
-                    
-                    **示例CSV格式:**
-                    ```
-                    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,
-                    user_001,sess_001,1704067260000,quote_request,quote,health_basic,50000
-                    ```
-                    """)
-                    
+                    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,
+```""")
                     csv_file = gr.File(label="上传CSV文件", file_types=[".csv"])
-                    label_col_input = gr.Textbox(label="标签列名 (可选, 默认自动推断)", placeholder="如: churn, is_churned, label")
-                    
+                    label_col_input = gr.Textbox(label="标签列名 (可选)", placeholder="如: churn, is_churned")
                     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, show_copy_button=True)
                     csv_preview = gr.Dataframe(label="数据预览")
-            
             with gr.Row():
                 csv_result = gr.Textbox(label="训练结果", lines=25, show_copy_button=True)
-            
             with gr.Row():
                 csv_img1 = gr.Image(label="特征重要性")
                 csv_img2 = gr.Image(label="PR曲线")
@@ -528,67 +1031,152 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", them
                 csv_img3 = gr.Image(label="混淆矩阵")
                 csv_img4 = gr.Image(label="ROC曲线")
             with gr.Row():
-                csv_table = gr.Dataframe(label="特征数据样本 (前10行)")
+                csv_table = gr.Dataframe(label="特征数据样本")
         
-        # ===== Tab 3: 帮助文档 =====
-        with gr.Tab("❓ 帮助文档"):
-            gr.Markdown("""
-            ## 事件类型定义
-            
-            | 类别 | 事件 | 业务含义 |
-            |------|------|---------|
-            | **浏览** | 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 | 续保/流失信号 |
-            | **其他** | login, logout, app_uninstall | 登录/登出/卸载 |
-            
-            ## 特征工程说明
-            
-            平台自动提取 **30+维行为特征**:
-            
-            | 维度 | 特征示例 | 业务含义 |
-            |------|---------|---------|
-            | 基础活跃度 | total_sessions, total_events, days_active | 用户使用APP的活跃程度 |
-            | 浏览深度 | product_view_ratio, article_read_ratio | 内容消费深度 |
-            | 转化信号 | payment_success_ratio, policy_issued_ratio | 购买/续保意愿 |
-            | 生命周期 | has_purchased, has_renewed, has_claimed | 客户价值阶段 |
-            | 时序行为 | recent_7day_events, days_since_last_event | 近期活跃/沉默 |
-            | 行为模式 | peak_active_hour, weekend_activity_ratio | 使用习惯 |
-            
-            ## 模型说明
-            
-            | 模型 | 特点 | 适用场景 |
-            |------|------|---------|
-            | **GBDT** | 高精度, 可解释 | 流失预测, 欺诈检测 |
-            | **Random Forest** | 抗过拟合, 特征重要性 | 特征筛选, 基线模型 |
+        # ===== 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="训练轮数")
+                    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` 并重启 Space。")
+                
+                with gr.Column(scale=2):
+                    din_result = gr.Textbox(label="训练结果", lines=25, show_copy_button=True)
             
-            - **AUC-ROC**: 分类器整体区分能力
-            - **F1-Score**: 精确率和召回率的调和平均
-            - **AP (Average Precision)**: PR曲线下面积, 适合不平衡数据
-            - **交叉验证**: 5折StratifiedKFold, 评估模型稳定性
+            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架构, 学习理赔记录的多字段关联和时序模式, 自动识别异常理赔行为。
+
+**核心架构:**
+- Field-level Transformer: 单条理赔记录内字段关联
+- Sequence-level Transformer: 跨理赔记录时序模式
+- Focal Loss: 解决异常样本极少的不平衡问题""")
             
-            ## 注意事项
+            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")
+                    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` 并重启 Space。")
+                
+                with gr.Column(scale=2):
+                    tab_result = gr.Textbox(label="训练结果", lines=25, show_copy_button=True)
             
-            1. 保险场景数据高度不平衡 (流失率 < 5%), 请使用 F1/AP 而非 Accuracy
-            2. 建议至少 1000+ 用户样本才能获得稳定结果
-            3. timestamp 支持毫秒或秒, 平台自动识别
-            4. 无标签列时, 平台使用启发式规则自动推断 (无购买+低活跃 = 高风险)
-            """)
-    
-    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://huggingface.co/Stephanwu">Stephanwu</a>
-    </div>
-    """)
+            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("""## 📚 完整使用指南
+
+### 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. 参考文献
+
+| 论文 | 应用 | 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) |
+| 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> |
+作者: <a href="https://huggingface.co/Stephanwu">Stephanwu</a>
+</div>""")
     
     # ===== 事件绑定 =====
     train_btn.click(
@@ -596,18 +1184,26 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台", them
         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]
+    )
 
 if __name__ == "__main__":
     demo.launch()