Update app.py

app.py

@@ -431,11 +431,97 @@ def run_pipeline(
         log(f"\n{'━'*50}")
         log(f"  ✅ {nm} 个模型训练完成")
 
-        # ============================================================
-        # ── 辅助函数：Macro ROC / PR 曲线数据 ──
-        # ============================================================
-        def _macro_roc_curve(yt, yp, nc, cls_idx):
-            """Return (all_fpr, mean_tpr, macro_auc) for overlay plotting."""
+        # ── ROC Curves ──  【原有代码，原封不动】
+        progress(0.42, desc="📈 ROC曲线...")
+        log(f"\n  📈 绘制图表...")
+        for mn in mnames:
+            r = amr[mn]
+            plot_multiclass_roc(r['all_yt'], r['all_yproba'], class_indices,
+                f'ROC — {mn} ({task_type}, Macro AUC={r["mean_auc"]:.3f})', f'roc_{mn}', rf)
+
+        # Combined ROC (macro per model)  【原有代码，原封不动】
+        plt.figure(figsize=(10, 8))
+        for i, mn in enumerate(mnames):
+            r = amr[mn]
+            y_bin = label_binarize(r['all_yt'], classes=class_indices)
+            if n_classes == 2: y_bin = np.hstack([1 - y_bin, y_bin])
+            all_fpr = np.linspace(0, 1, 200); mean_tpr = np.zeros_like(all_fpr)
+            for c in range(n_classes):
+                f, t, _ = roc_curve(y_bin[:, c], r['all_yproba'][:, c])
+                mean_tpr += np.interp(all_fpr, f, t)
+            mean_tpr /= n_classes; mean_tpr[-1] = 1.0
+            ma = auc_score(all_fpr, mean_tpr)
+            plt.plot(all_fpr, mean_tpr, color=COLORS[i%8], lw=2.5, label=f'{mn} (Macro AUC={ma:.3f})')
+        plt.plot([0,1],[0,1],'--',color='#ccc',lw=1)
+        plt.xlim([-0.02,1.02]); plt.ylim([-0.02,1.02])
+        plt.xlabel('FPR',fontsize=13); plt.ylabel('TPR',fontsize=13)
+        plt.title(f'ROC — All Models ({task_type})',fontsize=14,fontweight='bold')
+        plt.legend(loc='lower right',fontsize=10); plt.grid(True,alpha=0.15); plt.tight_layout()
+        plt.savefig(os.path.join(rf,'roc_all.pdf'),format='pdf',bbox_inches='tight',dpi=300)
+        plt.savefig(os.path.join(rf,'roc_all.png'),format='png',bbox_inches='tight',dpi=150)
+        plt.close()
+
+        # ── PR Curves ──  【原有代码，原封不动】
+        progress(0.48, desc="📈 PR曲线...")
+        for mn in mnames:
+            r = amr[mn]
+            plot_multiclass_pr(r['all_yt'], r['all_yproba'], class_indices,
+                f'PR — {mn} ({task_type})', f'pr_{mn}', rf)
+
+        # ── Confusion Matrices ──  【原有代码，原封不动】
+        progress(0.52, desc="📊 混淆矩阵...")
+        for mn in mnames:
+            r = amr[mn]
+            plot_confusion_matrix(r['all_yt'], r['all_yp'], class_indices,
+                f'CM — {mn} (Acc={r["mean_acc"]:.3f})', f'cm_{mn}', rf)
+
+        # ── Bootstrap AUC Test ──  【原有代码，原封不动】
+        progress(0.55, desc="🔬 Bootstrap AUC 检验...")
+        best_mn = max(amr, key=lambda x: amr[x]['mean_auc'])
+        best_auc = amr[best_mn]['mean_auc']
+        log(f"\n  🏆 最佳模型: {best_mn} (Macro AUC={best_auc:.4f})")
+        log(f"  🔬 Bootstrap 检验 (n=2000, α=0.05)...")
+
+        ALPHA = 0.05
+        bootstrap_results = []
+        retained = [best_mn]
+
+        for om in mnames:
+            if om == best_mn:
+                continue
+            p_val, auc_a, auc_b, ci_lo, ci_hi = bootstrap_auc_test(
+                amr[best_mn]['all_yt'],
+                amr[best_mn]['all_yproba'],
+                amr[om]['all_yproba'],
+                class_indices, n_bootstrap=2000
+            )
+            if p_val >= ALPHA:
+                retained.append(om)
+                dec = "Retained"
+            else:
+                dec = "Excluded"
+
+            bootstrap_results.append({
+                'Model_A': best_mn, 'AUC_A': auc_a,
+                'Model_B': om, 'AUC_B': auc_b,
+                'AUC_Diff': auc_a - auc_b,
+                'CI_95_Low': ci_lo, 'CI_95_High': ci_hi,
+                'P_value': p_val, 'Decision': dec
+            })
+            log(f"     {best_mn} vs {om}: ΔAUC={auc_a-auc_b:+.4f}  95%CI=[{ci_lo:+.4f},{ci_hi:+.4f}]  P={p_val:.4f} → {dec}")
+
+        bootstrap_df = pd.DataFrame(bootstrap_results).sort_values('P_value', ascending=False) if bootstrap_results else pd.DataFrame()
+        log(f"  ✅ 保留 {len(retained)}/{nm} 个模型: {', '.join(retained)}")
+
+        # ====================================================================
+        # ★★★ 新增 Part-1：训练集全模型 ROC / PR 曲线
+        #     新文件名前缀 train_roc_* / train_pr_*，与原有文件名零冲突
+        # ====================================================================
+        progress(0.57, desc="📈 [新增] 训练集ROC/PR曲线...")
+        log(f"\n  📈 [新增] 各模型训练集（in-sample）ROC / PR 曲线...")
+
+        # 两个内部辅助函数，仅用于叠加绘图数据准备
+        def _macro_roc_arrays(yt, yp, nc, cls_idx):
             y_b = label_binarize(yt, classes=cls_idx)
             if nc == 2:
                 y_b = np.hstack([1 - y_b, y_b])
@@ -447,7 +533,7 @@ def run_pipeline(
             mean_tpr /= nc; mean_tpr[-1] = 1.0
             return all_fpr, mean_tpr, auc_score(all_fpr, mean_tpr)
 
-        def _macro_pr_curve(yt, yp, nc, cls_idx):
+        def _macro_pr_arrays(yt, yp, nc, cls_idx):
             y_b = label_binarize(yt, classes=cls_idx)
             if nc == 2:
                 y_b = np.hstack([1 - y_b, y_b])
@@ -459,44 +545,35 @@ def run_pipeline(
             mean_prec /= nc
             return all_rec, mean_prec
 
-        # ============================================================
-        # ── 训练集 ROC / PR（所有模型，in-sample）──
-        # ============================================================
-        progress(0.40, desc="📈 训练集ROC/PR曲线...")
-        log(f"\n  📈 绘制各模型训练集 ROC / PR 曲线...")
-
-        train_roc_summary = {}   # mn -> train macro_auc
-        train_roc_data = {}      # mn -> (fpr, tpr, auc)
-        train_pr_data = {}       # mn -> (rec, prec)
+        _tr_roc = {}   # mn -> (fpr, tpr, auc) 供汇总图使用
+        _tr_pr  = {}   # mn -> (rec, prec)      供汇总图使用
 
         for mn in mnames:
-            yproba_tr = tms[mn].predict_proba(X.values)
+            yp_tr = tms[mn].predict_proba(X.values)
 
-            # 每个模型：各类 + macro 的独立 ROC / PR 图
+            # 每个模型独立图：各类别曲线 + macro（复用已有绘图函数，仅前缀不同）
             plot_multiclass_roc(
-                y_mapped.values, yproba_tr, class_indices,
-                f'Train ROC — {mn} ({task_type})', f'train_roc_{mn}', rf
+                y_mapped.values, yp_tr, class_indices,
+                f'Train ROC — {mn} ({task_type})',
+                f'train_roc_{mn}', rf
             )
             plot_multiclass_pr(
-                y_mapped.values, yproba_tr, class_indices,
-                f'Train PR — {mn} ({task_type})', f'train_pr_{mn}', rf
+                y_mapped.values, yp_tr, class_indices,
+                f'Train PR — {mn} ({task_type})',
+                f'train_pr_{mn}', rf
             )
 
-            fpr_tr, tpr_tr, auc_tr = _macro_roc_curve(
-                y_mapped.values, yproba_tr, n_classes, class_indices)
-            rec_tr, prec_tr = _macro_pr_curve(
-                y_mapped.values, yproba_tr, n_classes, class_indices)
-
-            train_roc_data[mn] = (fpr_tr, tpr_tr, auc_tr)
-            train_pr_data[mn]  = (rec_tr, prec_tr)
-            train_roc_summary[mn] = auc_tr
+            fpr_t, tpr_t, auc_t = _macro_roc_arrays(y_mapped.values, yp_tr, n_classes, class_indices)
+            rec_t, prec_t = _macro_pr_arrays(y_mapped.values, yp_tr, n_classes, class_indices)
+            _tr_roc[mn] = (fpr_t, tpr_t, auc_t)
+            _tr_pr[mn]  = (rec_t, prec_t)
 
-        # 汇总训练集 ROC（所有模型叠加）
+        # 汇总：训练集全模型 ROC（train_roc_all）
         plt.figure(figsize=(10, 8))
         for i, mn in enumerate(mnames):
-            fpr_tr, tpr_tr, auc_tr = train_roc_data[mn]
-            plt.plot(fpr_tr, tpr_tr, color=COLORS[i % 8], lw=2.5,
-                     label=f'{mn} (Train Macro AUC={auc_tr:.3f})')
+            fpr_t, tpr_t, auc_t = _tr_roc[mn]
+            plt.plot(fpr_t, tpr_t, color=COLORS[i % 8], lw=2.5,
+                     label=f'{mn} (Train Macro AUC={auc_t:.3f})')
         plt.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
         plt.xlim([-0.02, 1.02]); plt.ylim([-0.02, 1.02])
         plt.xlabel('False Positive Rate', fontsize=13)
@@ -508,92 +585,61 @@ def run_pipeline(
         plt.savefig(os.path.join(rf, 'train_roc_all.png'), format='png', bbox_inches='tight', dpi=150)
         plt.close()
 
-        # 汇总训练集 PR（所有模型叠加）
+        # 汇总：训练集全模型 PR（train_pr_all）
         plt.figure(figsize=(10, 8))
         for i, mn in enumerate(mnames):
-            rec_tr, prec_tr = train_pr_data[mn]
-            plt.plot(rec_tr, prec_tr, color=COLORS[i % 8], lw=2.5,
-                     label=f'{mn} (Mean AP={prec_tr.mean():.3f})')
+            rec_t, prec_t = _tr_pr[mn]
+            plt.plot(rec_t, prec_t, color=COLORS[i % 8], lw=2.5,
+                     label=f'{mn} (Mean AP={prec_t.mean():.3f})')
         plt.xlim([-0.02, 1.02]); plt.ylim([-0.02, 1.02])
-        plt.xlabel('Recall', fontsize=13); plt.ylabel('Precision', fontsize=13)
+        plt.xlabel('Recall', fontsize=13)
+        plt.ylabel('Precision', fontsize=13)
         plt.title(f'Train PR — All Models ({task_type})', fontsize=14, fontweight='bold')
         plt.legend(loc='lower left', fontsize=10)
         plt.grid(True, alpha=0.15); plt.tight_layout()
         plt.savefig(os.path.join(rf, 'train_pr_all.pdf'), format='pdf', bbox_inches='tight', dpi=300)
         plt.savefig(os.path.join(rf, 'train_pr_all.png'), format='png', bbox_inches='tight', dpi=150)
         plt.close()
-        log(f"     ✅ 训练集 ROC/PR 曲线已生成（��模型独立 + 汇总共 {nm*2+2*2} 张图）")
-
-        # ============================================================
-        # ── 交叉验证 ROC（原有逻辑，保留）──
-        # ============================================================
-        progress(0.42, desc="📈 交叉验证ROC曲线...")
-        log(f"\n  📈 绘制交叉验证 ROC 曲线...")
-        for mn in mnames:
-            r = amr[mn]
-            plot_multiclass_roc(r['all_yt'], r['all_yproba'], class_indices,
-                f'CV ROC — {mn} ({task_type}, Macro AUC={r["mean_auc"]:.3f})', f'roc_{mn}', rf)
-
-        # 汇总 CV ROC（所有模型）
-        plt.figure(figsize=(10, 8))
-        for i, mn in enumerate(mnames):
-            r = amr[mn]
-            fpr_cv, tpr_cv, auc_cv = _macro_roc_curve(
-                r['all_yt'], r['all_yproba'], n_classes, class_indices)
-            plt.plot(fpr_cv, tpr_cv, color=COLORS[i % 8], lw=2.5,
-                     label=f'{mn} (CV Macro AUC={auc_cv:.3f})')
-        plt.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
-        plt.xlim([-0.02, 1.02]); plt.ylim([-0.02, 1.02])
-        plt.xlabel('FPR', fontsize=13); plt.ylabel('TPR', fontsize=13)
-        plt.title(f'CV ROC — All Models ({task_type})', fontsize=14, fontweight='bold')
-        plt.legend(loc='lower right', fontsize=10)
-        plt.grid(True, alpha=0.15); plt.tight_layout()
-        plt.savefig(os.path.join(rf, 'roc_all.pdf'), format='pdf', bbox_inches='tight', dpi=300)
-        plt.savefig(os.path.join(rf, 'roc_all.png'), format='png', bbox_inches='tight', dpi=150)
-        plt.close()
-
-        # ============================================================
-        # ── 最佳模型：训练集 vs 内部验证集（CV holdout）对比 ──
-        # ============================================================
-        progress(0.44, desc="📊 最终模型训练集vs内部验证集对比...")
-
-        # 先确定最佳模型（后续 Bootstrap 也会用到，此处提前计算）
-        best_mn = max(amr, key=lambda x: amr[x]['mean_auc'])
-        best_auc = amr[best_mn]['mean_auc']
-
-        log(f"\n  📊 最终模型 [{best_mn}] 训练集 vs 内部验证集（CV holdout）对比...")
-
-        # 训练集预测
-        yproba_best_train = tms[best_mn].predict_proba(X.values)
-        ypred_best_train  = tms[best_mn].predict(X.values)
-        metrics_train = compute_multiclass_metrics(
-            y_mapped.values, ypred_best_train, yproba_best_train, class_indices
-        )
-
-        # CV holdout（已在 amr 中累积）
-        yproba_best_cv = amr[best_mn]['all_yproba']
-        ypred_best_cv  = amr[best_mn]['all_yp']
-        ytrue_best_cv  = amr[best_mn]['all_yt']
-        metrics_cv = compute_multiclass_metrics(
-            ytrue_best_cv, ypred_best_cv, yproba_best_cv, class_indices
-        )
-
-        log(f"     Train  → AUC={metrics_train['Macro_AUC']:.4f}  Acc={metrics_train['Accuracy']:.4f}"
-            f"  F1={metrics_train['Macro_F1']:.4f}  Kappa={metrics_train['Kappa']:.4f}")
-        log(f"     CV-Val → AUC={metrics_cv['Macro_AUC']:.4f}  Acc={metrics_cv['Accuracy']:.4f}"
-            f"  F1={metrics_cv['Macro_F1']:.4f}  Kappa={metrics_cv['Kappa']:.4f}")
-
-        # 对比 ROC
-        fpr_tr_b, tpr_tr_b, auc_tr_b = _macro_roc_curve(
-            y_mapped.values, yproba_best_train, n_classes, class_indices)
-        fpr_cv_b, tpr_cv_b, auc_cv_b = _macro_roc_curve(
-            ytrue_best_cv, yproba_best_cv, n_classes, class_indices)
+        log(f"     ✅ 训练集 ROC/PR 已生成：各模型独立图 + 汇总图（train_roc_all / train_pr_all）")
+
+        # ====================================================================
+        # ★★★ 新增 Part-2：最终模型（best_mn）训练集 vs 内部 CV 对比
+        #     新文件：roc_train_vs_cv_* / pr_train_vs_cv_* / cm_train_*
+        #             train_vs_cv_*.xlsx
+        #     原有文件：roc_* / pr_* / cm_* / model_evaluation.xlsx 均不变
+        # ====================================================================
+        progress(0.59, desc="📊 [新增] 最终模型Train vs CV对比...")
+        log(f"\n  📊 [新增] 最终模型 [{best_mn}] 训练集 vs 内部验证集（CV holdout）...")
+
+        # 训练集预测（用全量 fit 后的模型 tms[best_mn]）
+        yp_best_tr = tms[best_mn].predict_proba(X.values)
+        yd_best_tr = tms[best_mn].predict(X.values)
+        met_tr = compute_multiclass_metrics(
+            y_mapped.values, yd_best_tr, yp_best_tr, class_indices)
+
+        # 内部 CV holdout（直接取 amr 中已累积的结果，不重新运算）
+        yp_best_cv = amr[best_mn]['all_yproba']
+        yd_best_cv = amr[best_mn]['all_yp']
+        yt_best_cv = amr[best_mn]['all_yt']
+        met_cv = compute_multiclass_metrics(
+            yt_best_cv, yd_best_cv, yp_best_cv, class_indices)
+
+        log(f"     Train  → AUC={met_tr['Macro_AUC']:.4f}  Acc={met_tr['Accuracy']:.4f}"
+            f"  F1={met_tr['Macro_F1']:.4f}  Kappa={met_tr['Kappa']:.4f}")
+        log(f"     CV-Val → AUC={met_cv['Macro_AUC']:.4f}  Acc={met_cv['Accuracy']:.4f}"
+            f"  F1={met_cv['Macro_F1']:.4f}  Kappa={met_cv['Kappa']:.4f}")
+
+        # 对比 ROC（roc_train_vs_cv_{best_mn}）
+        fpr_tb, tpr_tb, auc_tb = _macro_roc_arrays(
+            y_mapped.values, yp_best_tr, n_classes, class_indices)
+        fpr_cb, tpr_cb, auc_cb = _macro_roc_arrays(
+            yt_best_cv, yp_best_cv, n_classes, class_indices)
 
         fig, ax = plt.subplots(figsize=(10, 8))
-        ax.plot(fpr_tr_b, tpr_tr_b, color='#e41a1c', lw=2.5,
-                label=f'Train set (Macro AUC={auc_tr_b:.3f})')
-        ax.plot(fpr_cv_b, tpr_cv_b, color='#377eb8', lw=2.5, linestyle='--',
-                label=f'Internal CV (Macro AUC={auc_cv_b:.3f})')
+        ax.plot(fpr_tb, tpr_tb, color='#e41a1c', lw=2.5,
+                label=f'Train set (Macro AUC={auc_tb:.3f})')
+        ax.plot(fpr_cb, tpr_cb, color='#377eb8', lw=2.5, linestyle='--',
+                label=f'Internal CV (Macro AUC={auc_cb:.3f})')
         ax.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
         ax.set_xlim([-0.02, 1.02]); ax.set_ylim([-0.02, 1.02])
         ax.set_xlabel('False Positive Rate', fontsize=13)
@@ -608,17 +654,17 @@ def run_pipeline(
                     format='png', bbox_inches='tight', dpi=150)
         plt.close()
 
-        # 对比 PR
-        rec_tr_b, prec_tr_b = _macro_pr_curve(
-            y_mapped.values, yproba_best_train, n_classes, class_indices)
-        rec_cv_b, prec_cv_b = _macro_pr_curve(
-            ytrue_best_cv, yproba_best_cv, n_classes, class_indices)
+        # 对比 PR（pr_train_vs_cv_{best_mn}）
+        rec_tb, prec_tb = _macro_pr_arrays(
+            y_mapped.values, yp_best_tr, n_classes, class_indices)
+        rec_cb, prec_cb = _macro_pr_arrays(
+            yt_best_cv, yp_best_cv, n_classes, class_indices)
 
         fig, ax = plt.subplots(figsize=(10, 8))
-        ax.plot(rec_tr_b, prec_tr_b, color='#e41a1c', lw=2.5,
-                label=f'Train set (Mean AP={prec_tr_b.mean():.3f})')
-        ax.plot(rec_cv_b, prec_cv_b, color='#377eb8', lw=2.5, linestyle='--',
-                label=f'Internal CV (Mean AP={prec_cv_b.mean():.3f})')
+        ax.plot(rec_tb, prec_tb, color='#e41a1c', lw=2.5,
+                label=f'Train set (Mean AP={prec_tb.mean():.3f})')
+        ax.plot(rec_cb, prec_cb, color='#377eb8', lw=2.5, linestyle='--',
+                label=f'Internal CV (Mean AP={prec_cb.mean():.3f})')
         ax.set_xlim([-0.02, 1.02]); ax.set_ylim([-0.02, 1.02])
         ax.set_xlabel('Recall', fontsize=13)
         ax.set_ylabel('Precision', fontsize=13)
@@ -632,91 +678,41 @@ def run_pipeline(
                     format='png', bbox_inches='tight', dpi=150)
         plt.close()
 
-        # 训练集混淆矩阵（最佳模型）
+        # 训练集混淆矩阵（cm_train_{best_mn}）
         plot_confusion_matrix(
-            y_mapped.values, ypred_best_train, class_indices,
-            f'Train CM — {best_mn} (Acc={metrics_train["Accuracy"]:.3f})',
+            y_mapped.values, yd_best_tr, class_indices,
+            f'Train CM — {best_mn} (Acc={met_tr["Accuracy"]:.3f})',
             f'cm_train_{best_mn}', rf
         )
 
-        # 保存 Train vs CV 汇总 Excel
-        with pd.ExcelWriter(os.path.join(rf, f'train_vs_cv_{best_mn}.xlsx'),
-                            engine='openpyxl') as w:
-            summary_rows = [
-                {'Split': 'Train', 'Model': best_mn,
-                 'Macro_AUC': metrics_train['Macro_AUC'],
-                 'Accuracy':  metrics_train['Accuracy'],
-                 'Macro_F1':  metrics_train['Macro_F1'],
-                 'Weighted_F1': metrics_train['Weighted_F1'],
-                 'Kappa':     metrics_train['Kappa']},
+        # 指标汇总 Excel（train_vs_cv_{best_mn}.xlsx，独立新文件）
+        with pd.ExcelWriter(
+                os.path.join(rf, f'train_vs_cv_{best_mn}.xlsx'),
+                engine='openpyxl') as w:
+            pd.DataFrame([
+                {'Split': 'Train',       'Model': best_mn,
+                 'Macro_AUC':  met_tr['Macro_AUC'],  'Accuracy':    met_tr['Accuracy'],
+                 'Macro_F1':   met_tr['Macro_F1'],   'Weighted_F1': met_tr['Weighted_F1'],
+                 'Kappa':      met_tr['Kappa']},
                 {'Split': 'Internal_CV', 'Model': best_mn,
-                 'Macro_AUC': metrics_cv['Macro_AUC'],
-                 'Accuracy':  metrics_cv['Accuracy'],
-                 'Macro_F1':  metrics_cv['Macro_F1'],
-                 'Weighted_F1': metrics_cv['Weighted_F1'],
-                 'Kappa':     metrics_cv['Kappa']},
-            ]
-            pd.DataFrame(summary_rows).to_excel(w, sheet_name='Summary', index=False)
-            pd.DataFrame(metrics_train['report']).T.to_excel(w, sheet_name='Train_PerClass', index=True)
-            pd.DataFrame(metrics_cv['report']).T.to_excel(w,    sheet_name='CV_PerClass',    index=True)
+                 'Macro_AUC':  met_cv['Macro_AUC'],  'Accuracy':    met_cv['Accuracy'],
+                 'Macro_F1':   met_cv['Macro_F1'],   'Weighted_F1': met_cv['Weighted_F1'],
+                 'Kappa':      met_cv['Kappa']},
+            ]).to_excel(w, sheet_name='Summary', index=False)
+            pd.DataFrame(met_tr['report']).T.to_excel(w, sheet_name='Train_PerClass', index=True)
+            pd.DataFrame(met_cv['report']).T.to_excel(w, sheet_name='CV_PerClass',    index=True)
             amr[best_mn]['fold_df'].to_excel(w, sheet_name='CV_FoldDetail', index=False)
 
-        log(f"     ✅ Train vs CV 对比图及数据已保存 → train_vs_cv_{best_mn}.xlsx")
-
-        # ── PR Curves (CV，原有逻辑) ──
-        progress(0.48, desc="📈 交叉验证PR曲线...")
-        for mn in mnames:
-            r = amr[mn]
-            plot_multiclass_pr(r['all_yt'], r['all_yproba'], class_indices,
-                f'CV PR — {mn} ({task_type})', f'pr_{mn}', rf)
-
-        # ── Confusion Matrices (CV) ──
-        progress(0.52, desc="📊 混淆矩阵...")
-        for mn in mnames:
-            r = amr[mn]
-            plot_confusion_matrix(r['all_yt'], r['all_yp'], class_indices,
-                f'CV CM — {mn} (Acc={r["mean_acc"]:.3f})', f'cm_{mn}', rf)
-
-        # ── Bootstrap AUC Test ──
-        progress(0.55, desc="🔬 Bootstrap AUC 检验...")
-        log(f"\n  🏆 最佳模型: {best_mn} (Macro AUC={best_auc:.4f})")
-        log(f"  🔬 Bootstrap 检验 (n=2000, α=0.05)...")
+        log(f"     ✅ Train vs CV 对比图及汇总数据已保存 → train_vs_cv_{best_mn}.xlsx")
+        # ====================================================================
+        # ★★★ 新增结束
+        # ====================================================================
 
-        ALPHA = 0.05
-        bootstrap_results = []
-        retained = [best_mn]
-
-        for om in mnames:
-            if om == best_mn:
-                continue
-            p_val, auc_a, auc_b, ci_lo, ci_hi = bootstrap_auc_test(
-                amr[best_mn]['all_yt'],
-                amr[best_mn]['all_yproba'],
-                amr[om]['all_yproba'],
-                class_indices, n_bootstrap=2000
-            )
-            if p_val >= ALPHA:
-                retained.append(om)
-                dec = "Retained"
-            else:
-                dec = "Excluded"
-
-            bootstrap_results.append({
-                'Model_A': best_mn, 'AUC_A': auc_a,
-                'Model_B': om, 'AUC_B': auc_b,
-                'AUC_Diff': auc_a - auc_b,
-                'CI_95_Low': ci_lo, 'CI_95_High': ci_hi,
-                'P_value': p_val, 'Decision': dec
-            })
-            log(f"     {best_mn} vs {om}: ΔAUC={auc_a-auc_b:+.4f}  95%CI=[{ci_lo:+.4f},{ci_hi:+.4f}]  P={p_val:.4f} → {dec}")
-
-        bootstrap_df = pd.DataFrame(bootstrap_results).sort_values('P_value', ascending=False) if bootstrap_results else pd.DataFrame()
-        log(f"  ✅ 保留 {len(retained)}/{nm} 个模型: {', '.join(retained)}")
-
-        # ── SHAP ──
+        # ── SHAP ──  【原有代码，原封不动】
         progress(0.62, desc="🔥 SHAP分析...")
         log(f"\n  🔥 SHAP特征分析 (保留模型中 Top 3)...")
         shap_imp = {}
+        # SHAP for top 3 retained models
         models_for_shap = sorted(retained, key=lambda x: amr[x]['mean_auc'], reverse=True)[:3]
 
         for si, mn in enumerate(models_for_shap):
@@ -733,10 +729,12 @@ def run_pipeline(
                     exp = shap.KernelExplainer(lambda x, m=mo: m.predict_proba(x), bg)
                     sv = exp.shap_values(Xs)
 
+                # Handle SHAP output: could be list of arrays (one per class) or 3D array
                 if isinstance(sv, list):
+                    # Average absolute SHAP across all classes
                     sv_abs = np.mean([np.abs(s) for s in sv], axis=0)
                 elif sv.ndim == 3:
-                    sv_abs = np.mean(np.abs(sv), axis=2)
+                    sv_abs = np.mean(np.abs(sv), axis=2)  # (samples, features)
                 else:
                     sv_abs = np.abs(sv)
 
@@ -747,6 +745,7 @@ def run_pipeline(
                 idf = pd.DataFrame({'Feature': fnames, 'Importance': fi}).sort_values('Importance', ascending=False)
                 shap_imp[mn] = idf
 
+                # Bar plot (works for any number of classes)
                 plt.figure(figsize=(10, max(6, TOPN * 0.3)))
                 top_df = idf.head(TOPN).iloc[::-1]
                 plt.barh(top_df['Feature'], top_df['Importance'], color='#2563eb', alpha=0.8)
@@ -760,7 +759,7 @@ def run_pipeline(
             except Exception as e:
                 log(f"     ⚠ {mn} SHAP失败: {e}")
 
-        # ── Feature Ablation ──
+        # ── Feature Ablation (for best model only) ──  【原有代码，原封不动】
         progress(0.72, desc="🧪 特征消融...")
         log(f"\n  🧪 特征消融 (仅最佳模型 {best_mn})...")
         ablation_data = None
@@ -768,6 +767,7 @@ def run_pipeline(
             imp_df = shap_imp[best_mn]
             top_feats = imp_df.head(TOPN)['Feature'].tolist()
             fcs = []; aucs_a = []
+            scoring = 'roc_auc_ovr' if n_classes > 2 else 'roc_auc'
 
             for nf in range(1, len(top_feats) + 1):
                 Xsub = X[top_feats[:nf]]
@@ -788,31 +788,29 @@ def run_pipeline(
                     fold_aucs.append(a)
                 fcs.append(nf); aucs_a.append(np.mean(fold_aucs))
 
+            # Find optimal: first N where AUC >= 95% of full AUC
             full_auc = amr[best_mn]['mean_auc']
             opt_n = len(top_feats)
             for i, a in enumerate(aucs_a):
                 if a >= full_auc * 0.95:
                     opt_n = i + 1; break
 
-            ablation_data = {'fcs': fcs, 'aucs': aucs_a, 'feats': top_feats,
-                             'opt_n': opt_n, 'opt_feats': top_feats[:opt_n]}
+            ablation_data = {'fcs': fcs, 'aucs': aucs_a, 'feats': top_feats, 'opt_n': opt_n, 'opt_feats': top_feats[:opt_n]}
             log(f"     ✅ 最优特征数: {opt_n} (AUC={aucs_a[opt_n-1]:.4f} vs Full={full_auc:.4f})")
 
+            # Plot
             plt.figure(figsize=(10, 7))
             plt.plot(fcs, aucs_a, 'o-', color='#2563eb', lw=2, ms=5)
-            plt.scatter([opt_n], [aucs_a[opt_n-1]], s=200, marker='*',
-                        color='#ef4444', edgecolors='black', lw=2, zorder=5)
-            plt.axhline(y=full_auc, color='gray', ls='--', lw=1, alpha=0.5,
-                        label=f'Full AUC={full_auc:.3f}')
+            plt.scatter([opt_n], [aucs_a[opt_n-1]], s=200, marker='*', color='#ef4444', edgecolors='black', lw=2, zorder=5)
+            plt.axhline(y=full_auc, color='gray', ls='--', lw=1, alpha=0.5, label=f'Full AUC={full_auc:.3f}')
             plt.xlabel('Number of Features', fontsize=13); plt.ylabel('Macro AUC', fontsize=13)
-            plt.title(f'Feature Ablation — {best_mn} (★ Optimal={opt_n})',
-                      fontsize=14, fontweight='bold')
+            plt.title(f'Feature Ablation — {best_mn} (★ Optimal={opt_n})', fontsize=14, fontweight='bold')
             plt.legend(fontsize=11); plt.grid(True, alpha=0.15); plt.tight_layout()
             plt.savefig(os.path.join(rf, 'ablation.pdf'), format='pdf', bbox_inches='tight')
             plt.savefig(os.path.join(rf, 'ablation.png'), format='png', bbox_inches='tight', dpi=150)
             plt.close()
 
-        # ── External Validation ──
+        # ── External Validation ──  【原有代码，原封不动】
         val_files_list = [vf for vf in [val_file1, val_file2, val_file3] if vf is not None]
         final_feats = ablation_data['opt_feats'] if ablation_data else fnames
 
@@ -828,6 +826,7 @@ def run_pipeline(
                 vcol2_is_id = (vcol2.dtype == 'object') or (vcol2.nunique() / len(vcol2) > 0.5)
                 Xe = ed.iloc[:, 2:] if vcol2_is_id else ed.iloc[:, 1:]
 
+                # Map validation labels using same mapping
                 ye = ye_raw.map(label_map)
                 if ye.isna().any():
                     log(f"     ⚠ 验证集 {vi} 含有训练集中不存在的标签，已跳过")
@@ -844,60 +843,52 @@ def run_pipeline(
                 ye_np = ye.values
 
                 metrics = compute_multiclass_metrics(ye_np, yed, yep, class_indices)
-                log(f"     ✅ AUC={metrics['Macro_AUC']:.4f}  Acc={metrics['Accuracy']:.4f}"
-                    f"  F1={metrics['Macro_F1']:.4f}  Kappa={metrics['Kappa']:.4f}")
+                log(f"     ✅ AUC={metrics['Macro_AUC']:.4f}  Acc={metrics['Accuracy']:.4f}  F1={metrics['Macro_F1']:.4f}  Kappa={metrics['Kappa']:.4f}")
 
                 sfx = f'_ext{vi}' if len(val_files_list) > 1 else '_ext'
                 tag = f'Validation {vi}' if len(val_files_list) > 1 else 'External'
 
-                plot_multiclass_roc(ye_np, yep, class_indices,
-                    f'ROC — {tag} ({best_mn})', f'roc{sfx}', rf)
-                plot_multiclass_pr(ye_np, yep, class_indices,
-                    f'PR — {tag} ({best_mn})', f'pr{sfx}', rf)
-                plot_confusion_matrix(ye_np, yed, class_indices,
-                    f'CM — {tag} ({best_mn})', f'cm{sfx}', rf)
+                plot_multiclass_roc(ye_np, yep, class_indices, f'ROC — {tag} ({best_mn})', f'roc{sfx}', rf)
+                plot_multiclass_pr(ye_np, yep, class_indices, f'PR — {tag} ({best_mn})', f'pr{sfx}', rf)
+                plot_confusion_matrix(ye_np, yed, class_indices, f'CM — {tag} ({best_mn})', f'cm{sfx}', rf)
 
                 with pd.ExcelWriter(os.path.join(rf, f'validation{sfx}.xlsx'), engine='openpyxl') as w:
                     pd.DataFrame([{'Model': best_mn, 'N_Features': len(final_feats),
                         'Macro_AUC': metrics['Macro_AUC'], 'Accuracy': metrics['Accuracy'],
                         'Macro_F1': metrics['Macro_F1'], 'Weighted_F1': metrics['Weighted_F1'],
                         'Kappa': metrics['Kappa']}]).to_excel(w, sheet_name='Metrics', index=False)
-                    pd.DataFrame(metrics['report']).T.to_excel(w, sheet_name='Per_Class', index=True)
+                    rpt = pd.DataFrame(metrics['report']).T
+                    rpt.to_excel(w, sheet_name='Per_Class', index=True)
                     pd.DataFrame({'Feature': final_feats}).to_excel(w, sheet_name='Features', index=False)
 
-        # ── Save Results ──
+        # ── Save Results ──  【原有代码，原封不动】
         progress(0.92, desc="💾 保存结果...")
         log(f"\n  💾 保存结果...")
 
         with pd.ExcelWriter(os.path.join(rf, 'model_evaluation.xlsx'), engine='openpyxl') as w:
             for mn, r in amr.items():
                 r['fold_df'].to_excel(w, sheet_name=mn, index=False)
-            # Summary（新增 Train_AUC 列）
-            sd = [{'Model': mn,
-                   'CV_Macro_AUC': r['mean_auc'],
-                   'Train_Macro_AUC': train_roc_summary.get(mn, ''),
-                   'CV_Accuracy': r['mean_acc'],
-                   'CV_Macro_F1': r['mean_f1'],
-                   'Retained': 'Yes' if mn in retained else 'No',
+            # Summary with retained status
+            sd = [{'Model': mn, 'Macro_AUC': r['mean_auc'], 'Accuracy': r['mean_acc'],
+                   'Macro_F1': r['mean_f1'], 'Retained': 'Yes' if mn in retained else 'No',
                    'Best': 'Best' if mn == best_mn else ''}
                   for mn, r in amr.items()]
-            pd.DataFrame(sd).sort_values('CV_Macro_AUC', ascending=False).to_excel(
-                w, sheet_name='Summary', index=False)
+            pd.DataFrame(sd).sort_values('Macro_AUC', ascending=False).to_excel(w, sheet_name='Summary', index=False)
+            # Bootstrap test results
             if len(bootstrap_df) > 0:
                 bootstrap_df.to_excel(w, sheet_name='Bootstrap_Test', index=False)
-            best_report = classification_report(
-                amr[best_mn]['all_yt'], amr[best_mn]['all_yp'],
-                labels=class_indices, output_dict=True, zero_division=0)
+            # Per-class report for best model
+            best_report = classification_report(amr[best_mn]['all_yt'], amr[best_mn]['all_yp'],
+                                                labels=class_indices, output_dict=True, zero_division=0)
             pd.DataFrame(best_report).T.to_excel(w, sheet_name=f'{best_mn}_PerClass', index=True)
 
         if ablation_data:
             with pd.ExcelWriter(os.path.join(rf, 'feature_ablation.xlsx'), engine='openpyxl') as w:
-                pd.DataFrame({'N': ablation_data['fcs'], 'AUC': ablation_data['aucs']}).to_excel(
-                    w, sheet_name='Ablation', index=False)
+                pd.DataFrame({'N': ablation_data['fcs'], 'AUC': ablation_data['aucs']}).to_excel(w, sheet_name='Ablation', index=False)
                 for mn, idf in shap_imp.items():
                     idf.to_excel(w, sheet_name=f'{mn}_Imp', index=False)
 
-        # Save params
+        # Save params (English for SCI)  【原有代码，原封不动】
         with open(os.path.join(rf, 'best_params.txt'), 'w', encoding='utf-8') as f:
             f.write(f"Task: {task_type} Classification ({n_classes} classes)\n")
             f.write(f"Classes: {classes}\n")
@@ -906,8 +897,7 @@ def run_pipeline(
             f.write(f"Retained Models: {', '.join(retained)} ({len(retained)}/{nm})\n\n")
             for mn in mcfg:
                 status = "* Best" if mn == best_mn else ("Retained" if mn in retained else "Excluded")
-                f.write(f"Model: {mn}  |  CV_AUC={amr[mn]['mean_auc']:.4f}"
-                        f"  |  Train_AUC={train_roc_summary.get(mn, 'N/A')}  |  {status}\n")
+                f.write(f"Model: {mn}  |  AUC={amr[mn]['mean_auc']:.4f}  |  {status}\n")
                 bp = bpd[mn]
                 if isinstance(bp, dict):
                     for k, v in bp.items(): f.write(f"  {k}: {v}\n")
@@ -919,40 +909,24 @@ def run_pipeline(
                 f.write("=" * 50 + "\n")
                 for _, row in bootstrap_df.iterrows():
                     f.write(f"  {row['Model_A']} vs {row['Model_B']}: ")
-                    f.write(f"dAUC={row['AUC_Diff']:+.4f}  "
-                            f"95%CI=[{row['CI_95_Low']:+.4f},{row['CI_95_High']:+.4f}]  ")
+                    f.write(f"dAUC={row['AUC_Diff']:+.4f}  95%CI=[{row['CI_95_Low']:+.4f},{row['CI_95_High']:+.4f}]  ")
                     f.write(f"P={row['P_value']:.4f} -> {row['Decision']}\n")
             if ablation_data:
-                f.write(f"\nOptimal Features ({ablation_data['opt_n']}): "
-                        f"{', '.join(ablation_data['opt_feats'])}\n")
-            f.write(f"\n{'='*50}\n")
-            f.write(f"Best Model [{best_mn}] Train vs Internal CV\n")
-            f.write(f"{'='*50}\n")
-            f.write(f"  Train  → AUC={metrics_train['Macro_AUC']:.4f}"
-                    f"  Acc={metrics_train['Accuracy']:.4f}"
-                    f"  F1={metrics_train['Macro_F1']:.4f}"
-                    f"  Kappa={metrics_train['Kappa']:.4f}\n")
-            f.write(f"  CV-Val → AUC={metrics_cv['Macro_AUC']:.4f}"
-                    f"  Acc={metrics_cv['Accuracy']:.4f}"
-                    f"  F1={metrics_cv['Macro_F1']:.4f}"
-                    f"  Kappa={metrics_cv['Kappa']:.4f}\n")
-
-        # Save model
+                f.write(f"\nOptimal Features ({ablation_data['opt_n']}): {', '.join(ablation_data['opt_feats'])}\n")
+
+        # Save model  【原有代码，原封不动】
         pickle.dump({
             'model_name': best_mn, 'model': tms[best_mn], 'best_params': bpd[best_mn],
             'classes': classes, 'n_classes': n_classes, 'label_map': label_map,
             'features': final_feats, 'task_type': task_type
         }, open(os.path.join(rf, f'model_{best_mn}.pkl'), 'wb'))
 
-        # ── ZIP ──
+        # ── ZIP ──  【原有代码，原封不动】
         progress(0.97, desc="📦 打包ZIP...")
-        zp = os.path.join(tempfile.gettempdir(),
-                          f"ml_results_{int(time.time())}_{os.getpid()}.zip")
+        zp = os.path.join(tempfile.gettempdir(), f"ml_results_{int(time.time())}_{os.getpid()}.zip")
         with zipfile.ZipFile(zp, 'w', zipfile.ZIP_DEFLATED) as zf:
             for root, _, files in os.walk(rf):
-                for fn in files:
-                    zf.write(os.path.join(root, fn),
-                             os.path.relpath(os.path.join(root, fn), rf))
+                for fn in files: zf.write(os.path.join(root, fn), os.path.relpath(os.path.join(root, fn), rf))
 
         nf = sum(len(f) for _, _, f in os.walk(rf))
         shutil.rmtree(rf, ignore_errors=True); gc.collect()
@@ -973,7 +947,7 @@ def run_pipeline(
 
 
 # ============================================================================
-# Gradio UI
+# Gradio UI  【原有代码，原封不动】
 # ============================================================================
 CUSTOM_CSS = """
 .header-banner {
@@ -1029,7 +1003,6 @@ with gr.Blocks(
     <div class="pipeline-box">
         <strong>📋 流程：</strong>
         <code>选择分类数</code> → <code>模型训练</code> → <code>交叉验证</code> →
-        <code>训练集ROC/PR</code> → <code>Train vs CV对比</code> →
         <code>SHAP分析</code> → <code>特征消融</code> → <code>外部验证</code>
         &nbsp;&nbsp;|&nbsp;&nbsp;
         <strong>CSV格式：</strong> 第1列=标签(整数), 第2列=ID, 第3列起=特征
@@ -1063,22 +1036,20 @@ with gr.Blocks(
                 info="RF=随机森林  DT=决策树  KNN=K近邻  XGB=XGBoost  AdaBoost  LR=逻辑回归  NB=朴素贝叶斯  SVM=支持向量机",
             )
             with gr.Row():
-                btn_all    = gr.Button("🔘 全选",     size="sm", variant="secondary")
-                btn_tree   = gr.Button("🌲 树模型",   size="sm", variant="secondary")
+                btn_all = gr.Button("🔘 全选", size="sm", variant="secondary")
+                btn_tree = gr.Button("🌲 树模型", size="sm", variant="secondary")
                 btn_linear = gr.Button("📐 线性模型", size="sm", variant="secondary")
-                btn_top4   = gr.Button("⚡ 经典四模型", size="sm", variant="secondary")
+                btn_top4 = gr.Button("⚡ 经典四模型", size="sm", variant="secondary")
             btn_all.click(lambda: ALL_MODEL_NAMES, outputs=model_selector)
             btn_tree.click(lambda: ['RF','DT','XGB','AdaBoost'], outputs=model_selector)
             btn_linear.click(lambda: ['LR','SVM','NB'], outputs=model_selector)
             btn_top4.click(lambda: ['RF','XGB','LR','SVM'], outputs=model_selector)
 
             gr.HTML('<div class="section-title">⚙️ 参数配置</div>')
-            enable_tuning = gr.Checkbox(
-                value=False,
-                label="启用超参数调优 (GridSearchCV)  ⚠️ 开启后运行时间显著增加")
+            enable_tuning = gr.Checkbox(value=False, label="启用超参数调优 (GridSearchCV)  ⚠️ 开启后运行时间显著增加")
             with gr.Row():
                 cv_folds = gr.Slider(3, 10, value=5, step=1, label="交叉验证折数")
-                top_n    = gr.Slider(5, 50, value=20, step=1, label="SHAP 前 N 个特征")
+                top_n = gr.Slider(5, 50, value=20, step=1, label="SHAP 前 N 个特征")
             shap_sz = gr.Slider(30, 200, value=80, step=10, label="SHAP 采样数量")
 
             run_btn = gr.Button("🚀 开始分析", variant="primary", size="lg")
@@ -1102,7 +1073,7 @@ with gr.Blocks(
     )
 
 # ============================================================================
-# Authentication
+# Authentication  【原有代码，原封不动】
 # ============================================================================
 from datetime import datetime