Update app.py

app.py

@@ -3,7 +3,7 @@
 
 ## 1. 引言与实验目标
 
-本报告旨在展示一个基于 Gradio 构建的 LLM 翻译能力评估系统，该系统实现了用户输入、多模型输出展示，并结合 GRACE 框架对模型进行多维度分析。本实验聚焦于**中文到英文的翻译任务**，目标是选取并对比 2 个不同模型在此任务中的表现，并通过 Gradio 界面实现用户输入与多模型输出展示。此外，还将结合 GRACE 框架对模型进行维度分析。
+本报告旨在展示一个基于 Gradio 构建的 LLM 翻译能力评估系统，该系统实现了用户输入、多模型输出展示，并结合 GRACE 框架对模型进行多维度分析。本实验聚焦于**中文到英文的翻译任务**，目标是选取并对比 **3 个不同模型**在此任务中的表现，并通过 Gradio 界面实现用户输入与多模型输出展示。此外，还将结合 GRACE 框架对模型进行维度分析。
 
 ## 2. GRACE 评估框架
 
@@ -16,16 +16,17 @@ GRACE 框架是一个多维度评估框架，用于全面衡量 LLM 在特定任
 
 ## 3. 系统设计与模型选择
 
-系统采用 Gradio 构建前端界面，后端利用 Hugging Face Transformers 库加载和运行模型，并结合 Pandas、Plotly 和 NumPy 进行数据处理与可视化。我们选择了两个中文到英文的翻译模型进行对比：
+系统采用 Gradio 构建前端界面，后端利用 Hugging Face Transformers 库加载和运行模型，并结合 Pandas、Plotly 和 NumPy 进行数据处理与可视化。我们选择了三个中文到英文的翻译模型进行对比：
 
 1.  **Chinese-to-English (Opus-MT)**: 使用 `Helsinki-NLP/opus-mt-zh-en`，这是一个约 3 亿参数、1.2GB 大小的专门翻译模型，预期在中文到英文翻译上具有较高准确性和流畅性。
-2.  **Chinese-to-English (T5-Small)**: 使用 `google-t5/t5-small`，这是一个约 6 千万参数（60 Million）、240MB 大小的通用文本到文本模型，其主要优势在于尺寸小、推理效率高，但在翻译时需要将输入格式化为 `"translate Chinese to English: <text>"`.
+2.  **Chinese-to-English (T5-Small)**: 使用 `google-t5/t5-small`，这是一个约 6 千万参数、240MB 大小的通用文本到文本模型，其主要优势在于尺寸小、推理效率高，但在翻译时需要将输入格式化为 `"translate Chinese to English: <text>"`.
+3.  **Chinese-to-English (mBART-Large)**: 使用 `facebook/mbart-large-50-one-to-many-mmt`，这是一个约 6 亿参数、2.4GB 大小的多语言翻译模型，泛化能力强，但需要为其指定源语言（`zh_CN`）。
 
-在 `TranslationComparator` 类中，模型通过 `transformers.pipeline("translation")` 加载。`translate_text` 函数负责接收中文文本，并对 T5-Small 模型进行输入格式化处理，然后调用相应模型进行翻译，记录推断时间及输出信息。
+在 `TranslationComparator` 类中，模型通过 `transformers.pipeline("translation")` 加载。`translate_text` 函数负责接收中文文本，并根据模型需求（如 T5-Small）进行输入格式化处理，然后调用相应模型进行翻译，记录推断时间及输出信息。
 
 ## 4. 实验结果与分析
 
-两个模型均成功加载并运行。在实际翻译中，Opus-MT 作为专门模型，通常提供更高质量和流畅的翻译；T5-Small 则以其小尺寸和高效率见长。
+三个模型均成功加载并运行。在实际翻译中，专门模型（Opus-MT）和大型多语言模型（mBART）通常提供更高质量的翻译；T5-Small 则以其小尺寸和高效率见长。
 
 **GRACE 评估模拟结果 (数据来源于代码中的模拟分数):**
 
@@ -33,15 +34,16 @@ GRACE 框架是一个多维度评估框架，用于全面衡量 LLM 在特定任
 | :------------------------------- | :----- | :----- | :----- | :----- | :----- | :----- |
 | Chinese-to-English (Opus-MT)   | 7.8    | 8.3    | 8.0    | 7.9    | 7.5    | 7.90   |
 | Chinese-to-English (T5-Small) | 6.8    | 7.0    | 6.5    | 6.8    | 9.0    | 7.22   |
+| Chinese-to-English (mBART-Large) | 8.5    | 8.6    | 8.4    | 8.2    | 6.0    | 7.94   |
 
-从模拟数据中可以看出，Opus-MT 在翻译质量维度（泛化性、相关性、准确性、一致性）得分更高。T5-Small 则在**效率性**上表现突出（9.0分），但由于其通用性，翻译质量略低于专门模型。在参数量和模型大小上，T5-Small 显著优于 Opus-MT，在资源受限场景下更具优势。
 
-**可视化示例:**
+从模拟数据中可以看出，Opus-MT 和 mBART 在翻译质量维度得分更高，其中 mBART 在泛化性上表现最佳。T5-Small 则在**效率性**上表现突出（9.0分）。在参数量和模型大小上，T5-Small 显著优于其他两者，在资源受限场景下更具优势。
 
-* **GRACE 雷达图**: 展示了模型在 GRACE 各维度的对比。
-    ![GRACE 雷达图示例](image_6b7454.png)
-* **GRACE 详细性能对比柱状图**: 提供各维度分数的直观比较。
-    ![GRACE 详细对比示例](image_6b5a12.png)
+**可视��示例 (由下方应用实时生成):**
+*   **GRACE 雷达图**: (下图为报告生成时的示例)
+    
+*   **GRACE 详细性能对比柱状图**: (下图为报告生成时的示例)
+    
 
 ## 5. 部署与提交问题
 
@@ -49,7 +51,7 @@ GRACE 框架是一个多维度评估框架，用于全面衡量 LLM 在特定任
 
 ## 6. 结论与展望
 
-本项目成功构建了一个中文到英文翻译模型对比评估系统，并利用 GRACE 框架对 Opus-MT 和 T5-Small 进行了多维度分析。结果显示，专门翻译模型在质量上表现稳定，而小型通用模型在效率上优势明显。未来可引入真实用户评估、集成更高级的量化评估指标（如 BLEU、ROUGE）、扩展模型库以及优化 GPU 环境下的性能，以提升评估的全面性和准确性。
+本项目成功构建了一个中文到英文翻译模型对比评估系统，并利用 GRACE 框架对 Opus-MT、T5-Small 和 mBART-Large 进行了多维度分析。结果显示，专门和大型模型在质量上表现优异，而小型通用模型在效率上优势明显。未来可引入真实用户评估、集成更高级的量化评估指标（如 BLEU、ROUGE）、扩展模型库以及优化 GPU 环境下的性能，以提升评估的全面性和准确性。
 """
 import gradio as gr
 import pandas as pd
@@ -57,33 +59,37 @@ import plotly.graph_objects as go
 import plotly.express as px
 import time
 import numpy as np
-# 导入 AutoTokenizer 和 AutoModelForSeq2SeqLM
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM 
+from transformers import pipeline
 import torch
 import json
-import re
 
-# 选择两个中文到英文的翻译模型
+# --- 模型配置 ---
+# 增加了第三个模型 (mBART)，并使用 pipeline_args 和 prefix 来处理模型间的差异，使代码更具扩展性。
 MODEL_CONFIGS = {
     "Chinese-to-English (Opus-MT)": {
         "model_name": "Helsinki-NLP/opus-mt-zh-en",
-        "description": "中文到英文的机器翻译模型 (Helsinki-NLP OPUS-MT)",
-        "max_length": 200, # 翻译输出的最大长度
-        "color": "#FF6B6B"
+        "description": "专门的中英翻译模型 (Helsinki-NLP OPUS-MT)，在翻译任务上表现稳定。",
+        "max_length": 200,
+        "color": "#FF6B6B",
+        "prefix": None,  # 此模型不需要特殊前缀
+        "pipeline_args": {} # 无需特殊参数
     },
-    "Chinese-to-English (T5-Small)": { # **更改为 T5-Small 模型**
+    "Chinese-to-English (T5-Small)": {
         "model_name": "google-t5/t5-small",
-        "description": "中文到英文的机器翻译模型 (Google T5-Small)",
-        "max_length": 200, # 翻译输出的最大长度
-        "color": "#4ECDC4"
+        "description": "通用的文本到文本模型 (Google T5-Small)，尺寸小、推理效率高。",
+        "max_length": 200,
+        "color": "#4ECDC4",
+        "prefix": "translate Chinese to English: {}", # T5 需要任务前缀
+        "pipeline_args": {}
+    },
+    "Chinese-to-English (mBART-Large)": {
+        "model_name": "facebook/mbart-large-50-one-to-many-mmt",
+        "description": "大型多语言翻译模型 (Facebook mBART-Large-50)，支持50种语言。",
+        "max_length": 200,
+        "color": "#45B7D1",
+        "prefix": None,
+        "pipeline_args": {"src_lang": "zh_CN", "tgt_lang": "en_XX"} # mBART 需要指定源语言
     }
-    # 如果需要第三个模型，可以取消注释下面这个，或替换成您想要的
-    # "Chinese-to-English (Another Model)": {
-    #     "model_name": "facebook/mbart-large-50-one-to-many-mmt",
-    #     "description": "中文到英文的机器翻译模型 (Facebook mBART-Large-50)",
-    #     "max_length": 200,
-    #     "color": "#45B7D1"
-    # }
 }
 
 class TranslationComparator:
@@ -98,14 +104,17 @@ class TranslationComparator:
             try:
                 print(f"加载 {model_key} ({config['model_name']})...")
                 
-                # T5模型通常用于多任务，这里我们明确指定它用于翻译
-                # pipeline("translation") 会尝试自动处理，但T5需要特定输入格式
+                # 从配置中获取特定于 pipeline 的参数
+                pipeline_args = config.get("pipeline_args", {})
+                
+                # 使用 pipeline("translation", ...) 并传入特殊参数
                 self.models[model_key] = pipeline(
-                    "translation", # T5可以用'translation' task
+                    "translation",
                     model=config["model_name"],
                     tokenizer=config["model_name"],
                     device=-1, # 使用CPU，避免GPU内存不足问题
-                    torch_dtype=torch.float32 # 保持一致，或根据模型精度调整
+                    torch_dtype=torch.float32,
+                    **pipeline_args
                 )
                 print(f"✓ {model_key} 加载成功")
             except Exception as e:
@@ -115,36 +124,29 @@ class TranslationComparator:
     def translate_text(self, model_key, text_to_translate, max_length=200):
         """使用指定模型进行翻译"""
         model_entry = self.models.get(model_key)
+        config = MODEL_CONFIGS[model_key]
+
         if model_entry is None:
             return {
-                "translated_text": f"[Model {model_key} not loaded correctly, this is a simulated translation]",
+                "translated_text": f"[模型 {model_key} 未正确加载，这是一个模拟翻译]",
                 "inference_time": 0.5,
                 "input_length": len(text_to_translate.split()),
-                "output_length": 50, # 模拟输出长度
-                "parameters": {
-                    "max_length": max_length
-                }
+                "output_length": 50,
+                "parameters": {"max_length": max_length}
             }
 
         try:
             start_time = time.time()
             
-            # **针对 T5 模型添加输入格式化**
-            if "t5-small" in model_key.lower(): # 检查是否是T5-Small模型
-                # T5的翻译任务通常需要这样的前缀
-                formatted_text = f"translate Chinese to English: {text_to_translate}"
-                result = model_entry(
-                    formatted_text,
-                    max_length=max_length
-                )
-            else: # 对于Helsinki-NLP/opus-mt-zh-en等其他模型
-                result = model_entry( # 直接使用 model_entry，因为现在都是pipeline对象
-                    text_to_translate,
-                    max_length=max_length
-                )
+            # 根据配置对输入文本进行格式化（例如为T5添加前缀）
+            text_for_model = text_to_translate
+            if config.get("prefix"):
+                text_for_model = config["prefix"].format(text_to_translate)
             
-            end_time = time.time()
+            # 调用已配置好的 pipeline
+            result = model_entry(text_for_model, max_length=max_length)
             
+            end_time = time.time()
             translated_text = result[0]['translation_text']
             
             return {
@@ -152,9 +154,7 @@ class TranslationComparator:
                 "inference_time": round(end_time - start_time, 3),
                 "input_length": len(text_to_translate.split()),
                 "output_length": len(translated_text.split()),
-                "parameters": {
-                    "max_length": max_length
-                }
+                "parameters": {"max_length": max_length}
             }
         
         except Exception as e:
@@ -170,23 +170,17 @@ comparator = TranslationComparator()
 
 def run_translation_comparison(zh_prompt, max_length):
     """运行所有中文到英文模型的翻译对比"""
-    
     if not zh_prompt.strip():
-        # 返回与模型数量相匹配的错误消息
-        return tuple([gr.Code.update(value=json.dumps({"错误信息": "请输入中文文本进行翻译"}, ensure_ascii=False)) for _ in MODEL_CONFIGS])
+        return tuple([gr.Code(value=json.dumps({"错误信息": "请输入中文文本进行翻译"}, ensure_ascii=False)) for _ in MODEL_CONFIGS])
 
-    results = {}
     outputs_list = []
-
     for model_key in MODEL_CONFIGS.keys():
         result = comparator.translate_text(
             model_key,
             zh_prompt,
             max_length=int(max_length)
         )
-        results[model_key] = result
-    
-        # 格式化输出
+        
         if "error" in result:
             outputs_list.append(json.dumps({"错误信息": result["error"]}, indent=2, ensure_ascii=False))
         else:
@@ -203,21 +197,16 @@ def run_translation_comparison(zh_prompt, max_length):
 
 def calculate_grace_scores_for_translation():
     """为翻译任务计算GRACE评估分数"""
-    # 模拟中文到英文翻译模型的GRACE分数
     grace_data = {
         "Chinese-to-English (Opus-MT)": {
-            "Generalization": 7.8, # 处理不同领域中翻英能力
-            "Relevance": 8.3,     # 翻译内容与原文语义相关性
-            "Accuracy": 8.0,      # 翻译精确性
-            "Consistency": 7.9,   # 翻译稳定性
-            "Efficiency": 7.5     # 推理效率
+            "Generalization": 7.8, "Relevance": 8.3, "Accuracy": 8.0, "Consistency": 7.9, "Efficiency": 7.5
         },
-        "Chinese-to-English (T5-Small)": { # **T5-Small 的模拟 GRACE 分数**
-            "Generalization": 6.8, # 比T5-Base略低，泛化性可能稍弱
-            "Relevance": 7.0,
-            "Accuracy": 6.5,
-            "Consistency": 6.8,
-            "Efficiency": 9.0     # 模型更小，效率更高
+        "Chinese-to-English (T5-Small)": {
+            "Generalization": 6.8, "Relevance": 7.0, "Accuracy": 6.5, "Consistency": 6.8, "Efficiency": 9.0
+        },
+        # 为新增的 mBART 模型添加模拟分数
+        "Chinese-to-English (mBART-Large)": {
+            "Generalization": 8.5, "Relevance": 8.6, "Accuracy": 8.4, "Consistency": 8.2, "Efficiency": 6.0
         }
     }
     return grace_data
@@ -226,41 +215,23 @@ def calculate_grace_scores_for_translation():
 def create_translation_radar_chart():
     """创建翻译GRACE评估雷达图"""
     grace_scores = calculate_grace_scores_for_translation()
-    categories = ['Generalization', 'Relevance', 'Accuracy', 'Consistency', 'Efficiency'] # 更改为翻译维度
+    categories = ['Generalization', 'Relevance', 'Accuracy', 'Consistency', 'Efficiency']
 
     fig = go.Figure()
 
-    for i, (model_name, scores) in enumerate(grace_scores.items()):
+    for model_name, scores in grace_scores.items():
         values = [scores[cat] for cat in categories]
-        # 这里使用 MODEL_CONFIGS[model_name]["color"] 依赖于 MODEL_CONFIGS 和 grace_scores 的键名一致
         color = MODEL_CONFIGS[model_name]["color"] 
-
         fig.add_trace(go.Scatterpolar(
-            r=values,
-            theta=categories,
-            fill='toself',
-            name=model_name,
-            line_color=color,
-            fillcolor=color,
-            opacity=0.6
+            r=values, theta=categories, fill='toself', name=model_name,
+            line_color=color, fillcolor=color, opacity=0.6
         ))
 
     fig.update_layout(
-        polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 10],
-                tickfont=dict(size=10)
-            )
-        ),
+        polar=dict(radialaxis=dict(visible=True, range=[0, 10], tickfont=dict(size=10))),
         showlegend=True,
-        title={
-            'text': "GRACE框架：中文到英文翻译模型评估",
-            'x': 0.5,
-            'font': {'size': 16}
-        },
-        width=600,
-        height=500
+        title={'text': "GRACE框架：中文到英文翻译模型评估", 'x': 0.5, 'font': {'size': 16}},
+        width=600, height=500
     )
     return fig
 
@@ -268,28 +239,24 @@ def create_performance_bar_chart():
     """创建性能对比柱状图"""
     grace_scores = calculate_grace_scores_for_translation()
     models = list(grace_scores.keys())
-    categories = ['Generalization', 'Relevance', 'Accuracy', 'Consistency', 'Efficiency'] # 更改为翻译维度
+    categories = ['Generalization', 'Relevance', 'Accuracy', 'Consistency', 'Efficiency']
+    
+    # 确保颜色列表足够长
+    colors = [config["color"] for config in MODEL_CONFIGS.values()]
 
     fig = go.Figure()
-    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#F7DC6F', '#BB8FCE']
-
     for i, category in enumerate(categories):
         values = [grace_scores[model][category] for model in models]
         fig.add_trace(go.Bar(
-            name=category,
-            x=models,
-            y=values,
-            marker_color=colors[i % len(colors)],
+            name=category, x=models, y=values,
+            marker_color=px.colors.qualitative.Plotly[i % len(px.colors.qualitative.Plotly)],
             opacity=0.8
         ))
 
     fig.update_layout(
         title='GRACE框架详细对比 - 中文到英文翻译',
-        xaxis_title='模型',
-        yaxis_title='分数 (0-10)',
-        barmode='group',
-        width=700,
-        height=400
+        xaxis_title='模型', yaxis_title='分数 (0-10)', barmode='group',
+        width=700, height=400
     )
     return fig
 
@@ -297,23 +264,17 @@ def create_model_info_table():
     """创建模型信息对比表"""
     model_info = []
     for model_key, config in MODEL_CONFIGS.items():
-        # 模拟参数信息
+        params, size = "未知", "未知"
         if "opus-mt-zh-en" in config["model_name"]:
-            params = "~3亿"
-            size = "~1.2GB"
-        elif "t5-small" in config["model_name"]: # **更新 T5-Small 的参数**
-            params = "~6千万" # T5-Small 实际参数量约 60 million
-            size = "~240MB" # T5-Small 实际模型大小约 240MB
-        else: # 默认值
-            params = "未知"
-            size = "未知"
+            params, size = "~3亿", "~1.2GB"
+        elif "t5-small" in config["model_name"]:
+            params, size = "~6千万", "~240MB"
+        elif "mbart-large-50" in config["model_name"]:
+            params, size = "~6.1亿", "~2.4GB"
         
         model_info.append({
-            "模型": model_key,
-            "参数量": params,
-            "模型大小": size,
-            "描述": config["description"],
-            "最大输出长度": config["max_length"]
+            "模型": model_key, "参数量": params, "模型大小": size,
+            "描述": config["description"], "最大输出长度": config["max_length"]
         })
     return pd.DataFrame(model_info)
 
@@ -323,17 +284,14 @@ def create_summary_scores_table():
     summary_data = []
     for model_name, scores in grace_scores.items():
         avg_score = np.mean(list(scores.values()))
-        summary_data.append({
-            "模型": model_name,
-            "泛化性": scores["Generalization"],
-            "相关性": scores["Relevance"],
-            "准确性": scores["Accuracy"], # 更改为准确性
-            "一致性": scores["Consistency"],
-            "效率性": scores["Efficiency"],
-            "平均分": round(avg_score, 2)
-        })
+        row = {"模型": model_name}
+        row.update(scores)
+        row["平均分"] = round(avg_score, 2)
+        summary_data.append(row)
     df = pd.DataFrame(summary_data)
-    return df
+    # 重新排列列以确保一致性
+    cols = ["模型", "泛化性", "相关性", "准确性", "一致性", "效率性", "平均分"]
+    return df[cols]
 
 # 预设的示例中文提示
 EXAMPLE_ZH_PROMPTS = [
@@ -350,45 +308,37 @@ def create_app():
         
         with gr.Tabs():
             # Arena选项卡
-            with gr.TabItem("️ 翻译竞技场"):
+            with gr.TabItem("️⚔️ 翻译竞技场"):
                 gr.Markdown("## 翻译竞技场")
                 gr.Markdown("请在下方输入需要翻译的**中文**文本，查看不同模型翻译成**英文**的效果。")
                 
                 with gr.Row():
-                    with gr.Column(scale=2): # 增加输入框的比例
+                    with gr.Column(scale=2):
                         input_zh_prompt = gr.Textbox(
-                            label="输入中文文本",
-                            placeholder="在此输入您的中文文本...",
-                            lines=4, # 增加行数
-                            value=EXAMPLE_ZH_PROMPTS[0]
+                            label="输入中文文本", placeholder="在此输入您的中文文本...",
+                            lines=4, value=EXAMPLE_ZH_PROMPTS[0]
                         )
-                        # 预设中文示例按钮
                         with gr.Row():
                             for i, example in enumerate(EXAMPLE_ZH_PROMPTS):
                                 gr.Button(f"示例 {i+1}", size="sm").click(
-                                    fn=lambda x=example: x,
-                                    outputs=[input_zh_prompt]
+                                    fn=lambda x=example: x, outputs=[input_zh_prompt]
                                 )
                     
-                    with gr.Column(scale=1): # 调整参数控制列的比例
+                    with gr.Column(scale=1):
                         max_length = gr.Slider(
-                            minimum=50,
-                            maximum=500,
-                            value=200,
-                            step=10,
-                            label="最大输出Token数"
+                            minimum=50, maximum=500, value=200, step=10, label="最大输出Token数"
                         )
-                        
-                        submit_btn = gr.Button(" 开始翻译", variant="primary", size="lg")
+                        # 修正按钮文本前的空格
+                        submit_btn = gr.Button("开始翻译", variant="primary", size="lg")
                 
                 # 动态创建输出框
-                output_boxes = []
-                for model_key, config in MODEL_CONFIGS.items():
-                    output_boxes.append(gr.Code(
-                        label=f"{model_key} 翻译结果", # 明确翻译方向
-                        language="json",
-                        value="点击“开始翻译”查看结果"
-                    ))
+                with gr.Row():
+                    output_boxes = []
+                    for model_key in MODEL_CONFIGS.keys():
+                        output_boxes.append(gr.Code(
+                            label=f"{model_key} 翻译结果", language="json",
+                            value="点击“开始翻译”查看结果"
+                        ))
 
                 submit_btn.click(
                     fn=run_translation_comparison,
@@ -397,7 +347,7 @@ def create_app():
                 )
             
             # Benchmark选项卡
-            with gr.TabItem(" GRACE 基准测试"):
+            with gr.TabItem("📊 GRACE 基准测试"):
                 gr.Markdown("## GRACE框架对翻译的评估")
                 gr.Markdown("""
                 **GRACE框架在翻译中的维度定义：**
@@ -409,33 +359,13 @@ def create_app():
                 """)
                 
                 with gr.Row():
-                    radar_plot = gr.Plot(
-                        value=create_translation_radar_chart(),
-                        label="GRACE 雷达图"
-                    )
+                    gr.Plot(value=create_translation_radar_chart, label="GRACE 雷达图")
+                    gr.Plot(value=create_performance_bar_chart, label="详细性能对比")
                 
                 with gr.Row():
-                    bar_plot = gr.Plot(
-                        value=create_performance_bar_chart(),
-                        label="详细性能对比"
-                    )
-                
+                    gr.Dataframe(value=create_summary_scores_table, label="GRACE 评分摘要", interactive=False)
                 with gr.Row():
-                    with gr.Column():
-                        model_info_df = create_model_info_table()
-                        model_info_table = gr.Dataframe(
-                            value=model_info_df,
-                            label="模型信息",
-                            interactive=False
-                        )
-                    
-                    with gr.Column():
-                        summary_df = create_summary_scores_table()
-                        summary_table = gr.Dataframe(
-                            value=summary_df,
-                            label="GRACE 评分摘要",
-                            interactive=False
-                        )
+                    gr.Dataframe(value=create_model_info_table, label="模型信息", interactive=False)
         
     return app