Upload app.py with huggingface_hub

app.py

@@ -338,8 +338,11 @@ AP:   {ap_rf:.4f}
 
 
 # =============================================================================
-# DIN 产品推荐
+# DIEN 产品推荐 (Deep Interest Evolution Network)
 # =============================================================================
+# DIEN = DIN + Interest Extractor (GRU) + Interest Evolving (AUGRU)
+# 论文: Deep Interest Evolution Network for Click-Through Rate Prediction (AAAI 2019)
+# arXiv: https://arxiv.org/abs/1809.03672
 
 def generate_product_recommendation_data(n_users=1000, seed=42):
     random.seed(seed); np.random.seed(seed)
@@ -363,11 +366,33 @@ def generate_product_recommendation_data(n_users=1000, seed=42):
             'user_features': np.random.randn(20).astype(np.float32),
         })
     return pd.DataFrame(records)
+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):
+def train_dien_recommendation(n_users, embedding_dim, epochs, batch_size, lr, seed):
     if not TORCH_AVAILABLE:
-        return "❌ PyTorch 未安装。请在 requirements.txt 中添加 torch 并重启 Space。", None, None, None, None, None
+        return "PyTorch not installed. Please add torch to requirements.txt and restart 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)
@@ -396,34 +421,67 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     
     device = torch.device('cpu')
     
-    class SimpleDIN(nn.Module):
+    # ===== DIEN Model Implementation =====
+    class AUGRUCell(nn.Module):
+        """Attentional Update Gate Recurrent Unit - core DIEN component"""
+        def __init__(self, input_dim, hidden_dim):
+            super().__init__()
+            self.input_dim = input_dim
+            self.hidden_dim = hidden_dim
+            self.W_ug = nn.Linear(input_dim + hidden_dim, hidden_dim)
+            self.W_rg = nn.Linear(input_dim + hidden_dim, hidden_dim)
+            self.W_cand = nn.Linear(input_dim + hidden_dim, hidden_dim)
+            
+        def forward(self, x_t, h_prev, attn_t):
+            concat = torch.cat([x_t, h_prev], dim=-1)
+            r_t = torch.sigmoid(self.W_rg(concat))
+            u_t = torch.sigmoid(self.W_ug(concat))
+            u_t_att = attn_t * u_t
+            r_concat = torch.cat([x_t, r_t * h_prev], dim=-1)
+            h_tilde = torch.tanh(self.W_cand(r_concat))
+            h_t = (1 - u_t_att) * h_prev + u_t_att * h_tilde
+            return h_t
+    
+    class SimpleDIEN(nn.Module):
         def __init__(self, num_events, num_products, d_model=64, max_len=20):
             super().__init__()
+            self.d_model = d_model
+            self.max_len = max_len
             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),
+            self.gru = nn.GRU(input_size=d_model, hidden_size=d_model, batch_first=True)
+            self.augru = AUGRUCell(d_model, 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)
+            B, L = be.size()
             e_emb = self.event_emb(be)
             p_emb = self.prod_emb(bp)
             beh_emb = torch.cat([e_emb, p_emb], dim=-1)
             cand_emb = self.cand_emb(cp)
-            cand_exp = cand_emb.unsqueeze(1).expand(B, L, -1)
-            diff = cand_exp - beh_emb; prod = cand_exp * beh_emb
-            attn_in = torch.cat([cand_exp, beh_emb, diff, prod], dim=-1)
-            attn_w = self.attn(attn_in).squeeze(-1)
-            attn_w = attn_w.masked_fill(~bm.bool(), -1e9)
-            attn_w = torch.softmax(attn_w, dim=1)
-            interest = (beh_emb * attn_w.unsqueeze(-1)).sum(dim=1)
-            x = torch.cat([interest, cand_emb, interest*cand_emb], dim=-1)
+            gru_out, _ = self.gru(beh_emb)
+            h_t = torch.zeros(B, self.d_model, device=beh_emb.device)
+            for t in range(L):
+                gru_t = gru_out[:, t, :]
+                cand_exp = cand_emb
+                diff = cand_exp - gru_t
+                prod_feat = cand_exp * gru_t
+                attn_in = torch.cat([cand_exp, gru_t, diff, prod_feat], dim=-1)
+                attn_t = torch.sigmoid(self.attn(attn_in))
+                mask_t = bm[:, t:t+1].float()
+                h_new = self.augru(gru_t, h_t, attn_t)
+                h_t = mask_t * h_new + (1 - mask_t) * h_t
+            final_interest = h_t
+            interest_prod = final_interest * cand_emb
+            x = torch.cat([final_interest, cand_emb, interest_prod], dim=-1)
             return self.mlp(x).squeeze(-1)
     
-    model = SimpleDIN(len(all_events), len(all_products), d_model=embedding_dim).to(device)
+    model = SimpleDIEN(len(all_events), len(all_products), d_model=embedding_dim).to(device)
     criterion = nn.BCEWithLogitsLoss()
-    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)
     
     for epoch in range(epochs):
         model.train(); epoch_loss = 0
@@ -437,10 +495,13 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
             optimizer.zero_grad()
             outputs = model(be, bp, bm, cp)
             loss = criterion(outputs, labels)
-            loss.backward(); optimizer.step()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
+            optimizer.step()
             epoch_loss += loss.item()
+        avg_loss = epoch_loss * batch_size / len(train_df)
         if (epoch+1) % max(1, epochs//5) == 0 or epoch == 0:
-            print(f"Epoch {epoch+1}/{epochs}, Loss: {epoch_loss*batch_size/len(train_df):.4f}")
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}")
     
     model.eval()
     with torch.no_grad():
@@ -458,7 +519,6 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
     
     os.makedirs("outputs", exist_ok=True)
     
-    # 保存 PyTorch 模型
     torch.save({
         'model_state_dict': model.state_dict(),
         'event_vocab': event_vocab,
@@ -468,14 +528,14 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
         'num_events': len(all_events),
         'num_products': len(all_products),
         'metrics': {'auc': auc, 'ap': ap, 'f1': f1, 'acc': acc}
-    }, 'outputs/din_model.pt')
+    }, 'outputs/dien_model.pt')
     
+    # Visualizations
     fig, ax = plt.subplots(figsize=(10,6))
     product_perf = {}
-    for _, row in test_df.iterrows():
+    for idx, 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 = []
@@ -492,88 +552,114 @@ def train_din_recommendation(n_users, embedding_dim, epochs, batch_size, lr, see
         ax2.plot(x, rates, 'ro-', label='Conversion Rate')
         ax.set_xticks(x); ax.set_xticklabels(prods, rotation=45, ha='right')
         ax.set_ylabel('AUC', color='steelblue'); ax2.set_ylabel('Conversion Rate', color='red')
-        ax.set_title('Product Recommendation Performance', fontweight='bold')
+        ax.set_title('DIEN - 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"
+    fig_path1 = "outputs/dien_product_performance.png"
     plt.savefig(fig_path1, dpi=150); plt.close()
     
-    fig, ax = plt.subplots(figsize=(10,6))
+    fig, ax = plt.subplots(figsize=(12,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
-        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()
+        gru_out, _ = model.gru(beh_emb)
+        h_t = torch.zeros(B, model.d_model, device=beh_emb.device)
+        attn_weights = []
+        interest_norms = []
+        for t in range(L):
+            gru_t = gru_out[:, t, :]
+            cand_exp = cand_emb
+            diff = cand_exp - gru_t
+            prod_feat = cand_exp * gru_t
+            attn_in = torch.cat([cand_exp, gru_t, diff, prod_feat], dim=-1)
+            attn_t = torch.sigmoid(model.attn(attn_in))
+            h_new = model.augru(gru_t, h_t, attn_t)
+            mask_t = bm_s[:, t:t+1].float()
+            h_t = mask_t * h_new + (1 - mask_t) * h_t
+            attn_weights.append(attn_t.item())
+            interest_norms.append(torch.norm(h_t).item())
     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')
+    valid_attn = attn_weights[-valid_len:] if valid_len > 0 else attn_weights
+    valid_norms = interest_norms[-valid_len:] if valid_len > 0 else interest_norms
+    ax.plot(range(len(valid_attn)), valid_attn, 'o-', color='coral', linewidth=2, label='Attention Weight', markersize=6)
+    ax_twin = ax.twinx()
+    ax_twin.plot(range(len(valid_norms)), valid_norms, 's--', color='steelblue', linewidth=2, label='Interest Norm (L2)', markersize=6)
+    ax.set_xlabel('Behavior Position')
+    ax.set_ylabel('Attention Weight', color='coral')
+    ax_twin.set_ylabel('Interest Norm', color='steelblue')
+    ax.set_title('DIEN - Interest Evolution (Sample User)', fontweight='bold')
+    ax.legend(loc='upper left')
+    ax_twin.legend(loc='upper right')
+    ax.grid(True, alpha=0.3)
     plt.tight_layout()
-    fig_path2 = "outputs/din_attention.png"
+    fig_path2 = "outputs/dien_interest_evolution.png"
     plt.savefig(fig_path2, dpi=150); plt.close()
     
     fig, ax = plt.subplots(figsize=(8,6))
     fpr, tpr, _ = roc_curve(labels, preds)
-    ax.plot(fpr, tpr, label=f'DIN AUC={auc:.3f}', linewidth=2, color='#2E86AB')
+    ax.plot(fpr, tpr, label=f'DIEN 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.set_title('ROC Curve - DIEN Product Recommendation', fontweight='bold')
     ax.legend(); ax.grid(True, alpha=0.3)
     plt.tight_layout()
-    fig_path3 = "outputs/din_roc.png"
+    fig_path3 = "outputs/dien_roc.png"
     plt.savefig(fig_path3, dpi=150); plt.close()
     
     fig, ax = plt.subplots(figsize=(8,6))
     prec, rec, _ = precision_recall_curve(labels, preds)
-    ax.plot(rec, prec, label=f'DIN AP={ap:.3f}', linewidth=2, color='#A23B72')
+    ax.plot(rec, prec, label=f'DIEN 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.set_title('Precision-Recall Curve - DIEN', fontweight='bold')
     ax.legend(); ax.grid(True, alpha=0.3)
     plt.tight_layout()
-    fig_path4 = "outputs/din_pr.png"
+    fig_path4 = "outputs/dien_pr.png"
     plt.savefig(fig_path4, dpi=150); plt.close()
     
-    result_text = f"""=== DIN 保险产品推荐模型 ===
-样本数: {n_users} | 产品数: {len(all_products)}
+    result_text = f"""=== DIEN (Deep Interest Evolution Network) Product Recommendation Model ===
+Samples: {n_users} | Products: {len(all_products)}
 Event vocab: {len(all_events)} | Product vocab: {len(all_products)}
-训练集: {len(train_df)} | 测试集: {len(test_df)}
-
---- 模型架构 ---
-Embedding dim: {embedding_dim}
-Attention: LocalActivationUnit (4路交互: [c, b, c-b, c*b])
-MLP: [emb*3] → 256 → 128 → 1
-
---- 训练配置 ---
+Train: {len(train_df)} | Test: {len(test_df)}
+
+--- DIEN Architecture (3 layers) ---
+Layer 1: Embedding
+  - event_emb({len(all_events)+1} -> {embedding_dim//2}) + prod_emb({len(all_products)+1} -> {embedding_dim//2})
+Layer 2: Interest Extractor (GRU)
+  - Input: concat(event_emb, prod_emb) -> GRU({embedding_dim} -> {embedding_dim})
+Layer 3: Interest Evolving (AUGRU)
+  - AUGRUCell: Attention-gated recurrent unit
+  - u_t' = a_t * u_t (attention modulated update gate)
+Layer 4: MLP
+  - [emb*3] -> 256 -> 128 -> 1
+
+--- Training Config ---
 Epochs: {epochs} | Batch size: {batch_size} | LR: {lr}
-Optimizer: Adam | Loss: BCEWithLogitsLoss
+Optimizer: Adam (weight_decay=1e-5) | Gradient clip: max_norm=5.0
 
---- 测试集效果 ---
+--- Test Results ---
 AUC:  {auc:.4f}
 AP:   {ap:.4f}
 F1:   {f1:.4f}
 Accuracy: {acc:.4f}
 
---- 模型洞察 ---
-1. 注意力机制自动学习用户历史行为中对候选产品的相关度
-2. 高权重通常分配给同类产品的历史浏览/购买行为
-3. 新用户(历史短)依赖统计特征, 老用户依赖行为序列
+--- DIEN vs DIN ---
+1. [GRU Interest Extractor] Models temporal dependencies in behavior sequences
+2. [AUGRU Interest Evolving] Attention-modulated update gate, preserves only target-relevant interest evolution
+3. [Better cold-start] Short sequences benefit from GRU temporal modeling
 
---- 模型文件 ---
-模型已保存至: outputs/din_model.pt
-可使用"模型管理"Tab上传至Hugging Face Hub"""
+--- Model File ---
+Saved to: outputs/dien_model.pt
+Upload to HF Hub via Model Management tab"""
     
     return result_text, fig_path1, fig_path2, fig_path3, fig_path4
-
-
 # =============================================================================
 # TabBERT 异常检测
 # =============================================================================
@@ -830,12 +916,12 @@ def save_model_to_hub(repo_id, token, model_type, notes):
                 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")
+            # 检查 DIEN 模型
+            dien_path = Path("outputs/dien_model.pt")
+            if dien_path.exists():
+                artifacts['dien'] = torch.load(dien_path, map_location='cpu')
+                torch.save(artifacts['dien'], tmpdir / "dien_model.pt")
+                model_files.append("dien_model.pt")
             
             # 检查 TabBERT 模型
             tab_path = Path("outputs/tabbert_model.pt")
@@ -871,7 +957,7 @@ def save_model_to_hub(repo_id, token, model_type, notes):
 | File | Description |
 |------|-------------|
 | `sklearn_model.joblib` | GBDT + Random Forest + Scaler (sklearn) |
-| `din_model.pt` | Deep Interest Network (PyTorch) |
+| `dien_model.pt` | Deep Interest Evolution Network (PyTorch) |
 | `tabbert_model.pt` | TabularBERT Anomaly Detection (PyTorch) |
 | `model_metadata.json` | Model metadata |
 
@@ -887,10 +973,10 @@ 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']
+# Load DIEN
+dien_path = hf_hub_download(repo_id="{repo_id}", filename="dien_model.pt")
+dien_ckpt = torch.load(dien_path)
+# dien_ckpt['model_state_dict'], dien_ckpt['event_vocab'], dien_ckpt['product_vocab']
 ```
 
 ## Reference
@@ -959,16 +1045,16 @@ def load_model_from_hub(repo_id, token, model_type):
                 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 模型已加载")
+        # 加载 DIEN
+        if "dien_model.pt" in metadata.get('files', []):
+            dien_path = hf_hub_download(repo_id=repo_id, filename="dien_model.pt", token=token, repo_type="model")
+            dien_ckpt = torch.load(dien_path, map_location='cpu')
+            metrics = dien_ckpt.get('metrics', {})
+            results.append(f"📦 DIEN 模型已加载")
             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', {}))}")
+            results.append(f"   Embedding dim: {dien_ckpt.get('embedding_dim', 'N/A')}")
+            results.append(f"   Event vocab: {len(dien_ckpt.get('event_vocab', {}))}")
+            results.append(f"   Product vocab: {len(dien_ckpt.get('product_vocab', {}))}")
         
         # 加载 TabBERT
         if "tabbert_model.pt" in metadata.get('files', []):
@@ -1435,10 +1521,10 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台 v3.0",
             with gr.Row():
                 csv_table = gr.Dataframe(label="特征数据样本")
         
-        # ===== Tab 3: DIN 产品推荐 =====
-        with gr.Tab("🎯 产品推荐 (DIN)"):
-            gr.Markdown("""### Deep Interest Network - 保险产品推荐
-基于用户历史行为序列, 通过注意力机制动态计算对候选保险产品的兴趣度。""")
+        # ===== Tab 3: DIEN 产品推荐 =====
+        with gr.Tab("🎯 产品推荐 (DIEN)"):
+            gr.Markdown("""### Deep Interest Evolution Network - 保险产品推荐
+基于DIEN (AAAI 2019), 通过 GRU兴趣提取 + AUGRU兴趣演化 建模用户对候选保险产品的动态兴趣演化过程。""")
             with gr.Row():
                 with gr.Column(scale=1):
                     din_users = gr.Slider(500, 5000, value=2000, step=100, label="用户数量")
@@ -1447,7 +1533,7 @@ with gr.Blocks(title="🏥 保险APP 用户行为分析模型训练平台 v3.0",
                     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")
+                    din_btn = gr.Button("🚀 训练DIEN模型", variant="primary", size="lg")
                     if not TORCH_AVAILABLE:
                         gr.Markdown("⚠️ **PyTorch 未安装**。请在 requirements.txt 中添加 `torch>=2.0.0` 并重启。")
                 with gr.Column(scale=2):
@@ -1610,7 +1696,7 @@ product_compare | video_consult | | | |
     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],
+    din_btn.click(fn=train_dien_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])