Update app.py

app.py

@@ -1,18 +1,18 @@
-# app.py
-
 import gradio as gr
 from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
 import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from huggingface_hub import snapshot_download
 import os
-import json # 导入 json 和 os 库，用于处理文件
+import json
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch # 导入 torch
 
 # 从现有的 src 导入，这些我们无法修改，但需要继续使用其提供的功能
 from src.about import (
     CITATION_BUTTON_LABEL,
     CITATION_BUTTON_TEXT,
-    EVALUATION_QUEUE_TEXT,
+    EVALUATION_QUEUE_TEXT, # 这个可能不再需要，但保留以防万一
     INTRODUCTION_TEXT,
     LLM_BENCHMARKS_TEXT,
     TITLE,
@@ -21,14 +21,11 @@ from src.display.css_html_js import custom_css
 
 # =====================================================================
 # **重要修改开始：直接在 app.py 中定义 GRACE 相关的类和函数**
-#   我们无法修改 src/display/utils.py 和 src/populate.py
-#   所以在这里重新定义或覆盖部分功能，以添加 GRACE 维度。
 # =====================================================================
 
 from enum import Enum
 from typing import NamedTuple, List
 
-# 重新定义 Column 类（如果 src/display/utils 中有，这里的定义将优先被 app.py 使用）
 class Column(NamedTuple):
     name: str
     type: str
@@ -37,22 +34,13 @@ class Column(NamedTuple):
     hidden: bool = False
     filterable: bool = True
 
-# 重新定义 AutoEvalColumn，加入 GRACE 维度
 class AutoEvalColumn(Enum):
-    # 尽可能复制 src/display/utils.py 中已有的 AutoEvalColumn 定义
-    # 但请注意，如果您不知道原始的精确定义，这可能会导致不一致。
-    # 这里我将使用一个合理的通用版本，并加入 GRACE 维度。
-    # 您需要确保这些列名与您评估结果数据中的列名匹配。
     model = Column("Model", "str", displayed_by_default=True, never_hidden=True)
     model_type = Column("Model type", "str", displayed_by_default=True)
     precision = Column("Precision", "str", displayed_by_default=False)
     params = Column("Params (B)", "number", displayed_by_default=True)
     license = Column("License", "str", displayed_by_default=False)
     still_on_hub = Column("On Hub", "boolean", displayed_by_default=True, hidden=True)
-    # ... 您可以尝试从已运行的 Leaderboard 检查元素，推断出其他默认列 ...
-    # 例如：
-    # dataset = Column("Dataset", "str", displayed_by_default=False)
-    # average_score = Column("Average Score", "number", displayed_by_default=True) # 假设有一个总分
 
     # GRACE 框架新增列
     generalization_score = Column("G: 泛化性", "number", displayed_by_default=True, filterable=True)
@@ -61,39 +49,27 @@ class AutoEvalColumn(Enum):
     consistency_score = Column("C: 一致性", "number", displayed_by_default=True, filterable=True)
     efficiency_score = Column("E: 效率性", "number", displayed_by_default=True, filterable=True)
 
-# 重新定义 fields() 函数
 def fields(cls: type) -> List[Column]:
     return [c.value for c in cls if isinstance(c.value, Column)]
 
-# 重新定义 ModelType 枚举（选择一个作为焦点，例如 LanguageModeling）
 class ModelType(Enum):
     LanguageModeling = "语言生成模型"
     ImageGeneration = "图像生成模型"
-    AudioSynthesis = "音频模型"
-    # ... 根据您实际的 src/display/utils.py 或项目需求添加其他类型
-    Unknown = "未知" # 保持 Unknown，防止意外
+    Unknown = "未知"
 
     def to_str(self, sep: str = " : ") -> str:
         return f"{self.name}{sep}{self.value}"
 
-# 重新定义 WeightType 和 Precision 枚举
 class WeightType(Enum):
     Original = NamedTuple("Original", [("name", str)])("Original")
     Lora = NamedTuple("Lora", [("name", str)])("Lora")
-    # Add other types if necessary from your original src/display/utils.py
-    # Example:
-    # Adapter = NamedTuple("Adapter", [("name", str)])("Adapter")
 
 class Precision(Enum):
     float16 = NamedTuple("float16", [("name", str)])("float16")
     bfloat16 = NamedTuple("bfloat16", [("name", str)])("bfloat16")
-    # Add other types if necessary
     Unknown = NamedTuple("Unknown", [("name", str)])("Unknown")
 
-
-# 重新定义 COLS, BENCHMARK_COLS, EVAL_COLS, EVAL_TYPES
-# 这些列表现在将使用我们在 app.py 中定义的 AutoEvalColumn
-COLS = fields(AutoEvalColumn) # 所有列，包括 GRACE
+COLS = fields(AutoEvalColumn)
 BENCHMARK_COLS = [
     AutoEvalColumn.model.value,
     AutoEvalColumn.params.value,
@@ -102,193 +78,191 @@ BENCHMARK_COLS = [
     AutoEvalColumn.artistry_score.value,
     AutoEvalColumn.consistency_score.value,
     AutoEvalColumn.efficiency_score.value,
-    # ... 其他你想在基准测试中默认显示的列
 ]
-EVAL_COLS = [c.name for c in fields(AutoEvalColumn)] # 评估队列的列名
-EVAL_TYPES = [c.type for c in fields(AutoEvalColumn)] # 评估队列的列类型
-
-
-# 重新定义 get_leaderboard_df 和 get_evaluation_queue_df 函数
-# 这两个函数现在将直接在 app.py 中处理数据加载和 GRACE 维度的添加。
-# 由于您无法修改 src/populate.py，我们需要在这里实现其功能。
+EVAL_COLS = [c.name for c in fields(AutoEvalColumn)]
+EVAL_TYPES = [c.type for c in fields(AutoEvalColumn)]
 
+# 简化 get_leaderboard_df 和 get_evaluation_queue_df
+# 由于我们是手动比较，而不是自动评估，这些函数更多是用于显示模拟数据
 def get_leaderboard_df(eval_results_path: str, eval_requests_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
-    """
-    加载评估结果并构建排行榜 DataFrame。
-    此函数现在在 app.py 中定义，以包含 GRACE 分数。
-    """
-    all_results = []
-
-    # ============== **重点修改区域：GRACE 分数的数据来源** ==============
-    # 您需要根据您实际的评估结果文件格式来读取数据并包含 GRACE 分数。
-    # 假设您的评估结果是在 EVAL_RESULTS_PATH 目录下，每个模型的 JSON 文件。
-    # 示例路径：EVAL_RESULTS_PATH/model_name/results.json
-    if os.path.exists(eval_results_path) and os.path.isdir(eval_results_path):
-        for model_dir in os.listdir(eval_results_path):
-            model_path = os.path.join(eval_results_path, model_dir)
-            if os.path.isdir(model_path):
-                # 尝试读取 results.json 或其他命名约定
-                results_file = os.path.join(model_path, "results.json")
-                if os.path.exists(results_file):
-                    try:
-                        with open(results_file, "r", encoding="utf-8") as f:
-                            data = json.load(f)
-                            # 确保 data 字典中包含 'generalization_score', 'relevance_score' 等键
-                            # 如果您的原始结果没有这些键，您需要在外部评估过程生成它们，或在这里进行计算。
-                            # 这里假设结果文件中直接有这些字段。
-                            all_results.append(data)
-                    except json.JSONDecodeError as e:
-                        print(f"解析 {results_file} 失败: {e}")
-                    except Exception as e:
-                        print(f"读取 {results_file} 发生未知错误: {e}")
-                else:
-                    print(f"在 {model_path} 中未找到 results.json。")
-    else:
-        print(f"评估结果路径不存在或不是目录: {eval_results_path}")
-
-    # 如果没有实际结果，提供一些模拟数据以便测试和展示 GRACE 维度
-    if not all_results:
-        print("未找到评估结果，使用模拟数据填充排行榜。")
-        all_results = [
-            {
-                "model": "模拟模型_A",
-                "model_type": ModelType.LanguageModeling.to_str(),
-                "precision": Precision.float16.value.name,
-                "params": 7.0,
-                "license": "apache-2.0",
-                "still_on_hub": True,
-                "generalization_score": 0.85,
-                "relevance_score": 0.92,
-                "artistry_score": 0.78,
-                "consistency_score": 0.88,
-                "efficiency_score": 0.95,
-                # ... 其他您希望展示的列，确保与 AutoEvalColumn 定义匹配
-            },
-            {
-                "model": "模拟模型_B",
-                "model_type": ModelType.LanguageModeling.to_str(),
-                "precision": Precision.float16.value.name,
-                "params": 13.0,
-                "license": "mit",
-                "still_on_hub": True,
-                "generalization_score": 0.90,
-                "relevance_score": 0.88,
-                "artistry_score": 0.85,
-                "consistency_score": 0.91,
-                "efficiency_score": 0.90,
-                # ...
-            },
-            {
-                "model": "模拟模型_C_图像",
-                "model_type": ModelType.ImageGeneration.to_str(),
-                "precision": Precision.bfloat16.value.name,
-                "params": 3.0,
-                "license": "gpl-3.0",
-                "still_on_hub": True,
-                "generalization_score": 0.70,
-                "relevance_score": 0.75,
-                "artistry_score": 0.90,
-                "consistency_score": None, # 图像模型可能没有一致性得分
-                "efficiency_score": 0.80,
-                # ...
-            }
-        ]
-    # =====================================================================
-
-    if all_results:
-        df = pd.DataFrame(all_results)
-    else:
-        df = pd.DataFrame(columns=[c.name for c in fields(AutoEvalColumn)])
-
-    # 确保所有期望的列都存在，如果缺失则填充 None
-    expected_cols_names = [c.name for c in cols]
-    for col_name in expected_cols_names:
-        if col_name not in df.columns:
-            df[col_name] = None
-    
-    # 对 DataFrame 进行必要的处理，例如排序
-    if AutoEvalColumn.generalization_score.value.name in df.columns and not df[AutoEvalColumn.generalization_score.value.name].isnull().all():
-        df = df.sort_values(by=AutoEvalColumn.generalization_score.value.name, ascending=False).reset_index(drop=True)
-
+    print("使用模拟数据填充排行榜。")
+    # 这里我们不再尝试从文件读取，直接生成模拟数据
+    all_results = [
+        {
+            "model": "google/gemma-2b-it", # 示例模型1
+            "model_type": ModelType.LanguageModeling.to_str(),
+            "precision": Precision.float16.value.name,
+            "params": 2.0,
+            "license": "apache-2.0",
+            "still_on_hub": True,
+            "generalization_score": 0.0, # 初始为0，等待用户输入
+            "relevance_score": 0.0,
+            "artistry_score": 0.0,
+            "consistency_score": 0.0,
+            "efficiency_score": 0.0,
+        },
+        {
+            "model": "microsoft/phi-2", # 示例模型2
+            "model_type": ModelType.LanguageModeling.to_str(),
+            "precision": Precision.float16.value.name,
+            "params": 2.7,
+            "license": "mit",
+            "still_on_hub": True,
+            "generalization_score": 0.0,
+            "relevance_score": 0.0,
+            "artistry_score": 0.0,
+            "consistency_score": 0.0,
+            "efficiency_score": 0.0,
+        },
+        {
+            "model": "EleutherAI/gpt-neo-125m", # 示例模型3，非常小以确保能加载
+            "model_type": ModelType.LanguageModeling.to_str(),
+            "precision": Precision.float16.value.name,
+            "params": 0.125,
+            "license": "apache-2.0",
+            "still_on_hub": True,
+            "generalization_score": 0.0,
+            "relevance_score": 0.0,
+            "artistry_score": 0.0,
+            "consistency_score": 0.0,
+            "efficiency_score": 0.0,
+        }
+    ]
+    df = pd.DataFrame(all_results)
+    # 对 DataFrame 进行必要的处理，例如排序 (这里不需要排序因为分数是0)
     return df
 
 def get_evaluation_queue_df(eval_requests_path: str, eval_cols: list):
-    """
-    加载评估请求队列数据。此函数现在在 app.py 中定义。
-    """
-    pending_requests = []
-    running_requests = []
-    finished_requests = []
-
-    # 示例：假设请求文件是位于 eval_requests_path 的 jsonl 文件
-    if os.path.exists(eval_requests_path) and os.path.isdir(eval_requests_path):
-        for filename in os.listdir(eval_requests_path):
-            if filename.endswith(".jsonl"): # 或者其他你存储请求的文件格式
-                filepath = os.path.join(eval_requests_path, filename)
-                try:
-                    with open(filepath, "r", encoding="utf-8") as f:
-                        for line in f:
-                            try:
-                                request_data = json.loads(line)
-                                status = request_data.get('status', 'pending') # 假设请求数据中有 'status' 字段
-                                if status == 'finished':
-                                    finished_requests.append(request_data)
-                                elif status == 'running':
-                                    running_requests.append(request_data)
-                                else: # 默认或其他状态归为 pending
-                                    pending_requests.append(request_data)
-                            except json.JSONDecodeError as e:
-                                print(f"解析 JSONL 行失败: {line.strip()}, 错误: {e}")
-                except Exception as e:
-                    print(f"读取 {filepath} 失败: {e}")
-    else:
-        print(f"评估请求路径不存在或不是目录: {eval_requests_path}")
-
-    # 将列表转换为 DataFrame，并确保列与 eval_cols 匹配
-    finished_df = pd.DataFrame(finished_requests, columns=eval_cols) if finished_requests else pd.DataFrame(columns=eval_cols)
-    running_df = pd.DataFrame(running_requests, columns=eval_cols) if running_requests else pd.DataFrame(columns=eval_cols)
-    pending_df = pd.DataFrame(pending_requests, columns=eval_cols) if pending_requests else pd.DataFrame(columns=eval_cols)
-
-    return finished_df, running_df, pending_df
+    # 评估队列不再是主要功能，返回空 DataFrame
+    empty_df = pd.DataFrame(columns=eval_cols)
+    return empty_df, empty_df, empty_df
 
 # =====================================================================
-# **重要修改结束：直接在 app.py 中定义 GRACE 相关的类和函数**
+# **重要修改结束**
 # =====================================================================
 
+# 假设 src.envs 中的 API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN 可用
+# 如果 TOKEN 未在 src.envs 中定义，您需要在 Hugging Face Space Secrets 中设置 HF_TOKEN。
+# 这里为了能运行，我们直接使用 os.getenv 获取 TOKEN。
+# from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
+# 这里需要调整为从环境变量读取，以适应 Hugging Face Space 的最佳实践
+TOKEN = os.getenv("HF_TOKEN") # 确保您的 Space Secrets 中设置了 HF_TOKEN
+# 假设这些路径是可写的，但在此场景下，我们不再依赖它们来存储评估结果
+EVAL_REQUESTS_PATH = "./eval_requests"
+EVAL_RESULTS_PATH = "./eval_results"
+# 对于演示，我们不需要实际的 API 调用来重启 Space 或提交任务
+# 所以我们可以创建一个模拟的 API 类
+class MockAPI:
+    def restart_space(self, repo_id: str):
+        print(f"MockAPI: Restarting space {repo_id}. (No actual restart for demo)")
+class MockSubmit:
+    def add_new_eval(self, *args):
+        # 这个函数不再用于实际提交，可以返回一个消息
+        return "在此演示中，模型已预先加载，无需提交新评估。"
+
+API = MockAPI()
+add_new_eval = MockSubmit().add_new_eval
+
+# 预加载模型和分词器
+# 考虑到免费 Space 的资源限制，这里选择较小的模型
+MODELS_TO_COMPARE = [
+    {"id": "google/gemma-2b-it", "name": "Gemma 2B Instruct"},
+    {"id": "microsoft/phi-2", "name": "Phi-2"},
+    {"id": "EleutherAI/gpt-neo-125m", "name": "GPT-Neo 125M"}, # 更小的模型，确保加载
+]
 
-# 继续使用 src.envs 中的 API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
-# 这里我们假设这些环境变量或常量是可以通过某种方式加载的，或者在 Space 设置中配置的。
-# 如果 src.envs 也是无法修改的，且您无法通过环境变量设置这些值，那可能会有问题。
-# 通常在 Hugging Face Space 中，这些值是从环境变量或 Space Secrets 中加载的。
-# 这里我不会重定义它们，假设它们是可用的。
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
-from src.submission.submit import add_new_eval # 假设 add_new_eval 也是从 src 导入的
-
-def restart_space():
-    API.restart_space(repo_id=REPO_ID)
-
-### Space initialisation
-try:
-    print(f"下载评估请求到: {EVAL_REQUESTS_PATH}")
-    snapshot_download(
-        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception as e:
-    print(f"下载评估请求失败: {e}")
-    restart_space()
-try:
-    print(f"下载评估结果到: {EVAL_RESULTS_PATH}")
-    snapshot_download(
-        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-except Exception as e:
-    print(f"下载评估结果失败: {e}")
-    restart_space()
-
+# 用于存储加载的模型和分词器
+loaded_models = {}
+
+def load_models():
+    global loaded_models
+    for model_info in MODELS_TO_COMPARE:
+        model_id = model_info["id"]
+        model_name = model_info["name"]
+        print(f"正在加载模型: {model_name} ({model_id})...")
+        try:
+            # 尝试加载模型到 GPU (cuda) 或 CPU (cpu)
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            print(f"模型 {model_id} 将加载到 {device}")
+
+            tokenizer = AutoTokenizer.from_pretrained(model_id, token=TOKEN)
+            # 使用 torch.float16 或 torch.bfloat16 减少内存使用
+            if device == "cuda":
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_id,
+                    torch_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
+                    token=TOKEN
+                ).to(device)
+            else: # CPU
+                model = AutoModelForCausalLM.from_pretrained(model_id, token=TOKEN)
+
+            loaded_models[model_id] = {"model": model, "tokenizer": tokenizer, "name": model_name}
+            print(f"成功加载模型: {model_name}")
+        except Exception as e:
+            print(f"加载模型 {model_name} ({model_id}) 失败: {e}")
+            # 如果加载失败，将该模型从比较列表中移除
+            # 或者将其模型对象设置为 None，以便在推理时跳过
+            loaded_models[model_id] = None # 表示加载失败
+
+# 在应用程序启动时加载模型
+# 注意：在 Gradio Blocks 的 launch() 之前调用，确保模型在界面初始化前加载
+load_models()
+
+
+# 模型生成函数
+def generate_text(prompt, max_new_tokens=100):
+    outputs = {}
+    for model_id, model_data in loaded_models.items():
+        if model_data: # 确保模型已成功加载
+            model = model_data["model"]
+            tokenizer = model_data["tokenizer"]
+            model_name = model_data["name"]
+
+            try:
+                inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+                # print(f"Generating with {model_name} on device: {model.device}")
+                # 调整 generation_config 参数以获得更好的可控性
+                generated_ids = model.generate(
+                    **inputs,
+                    max_new_tokens=max_new_tokens,
+                    do_sample=True, # 启用采样
+                    temperature=0.7, # 控制生成文本的随机性
+                    top_k=50, # 从概率最高的k个词中选择
+                    top_p=0.95, # 累积概率达到p的词中选择
+                    pad_token_id=tokenizer.eos_token_id, # 处理 pad token
+                    eos_token_id=tokenizer.eos_token_id # 结束标志
+                )
+                generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
+                outputs[model_name] = generated_text
+            except Exception as e:
+                outputs[model_name] = f"生成失败: {e}"
+        else:
+            outputs[model_data["name"]] = "模型未加载或加载失败。"
+    return list(outputs.values()) # 返回一个列表，对应多个输出框
+
+# 更新排行榜数据函数
+def update_leaderboard(g_score, r_score, a_score, c_score, e_score, model_idx):
+    global LEADERBOARD_DF
+    # 假设模型的索引与 MODELS_TO_COMPARE 列表中的顺序一致
+    # 在实际应用中，您可能需要更健壮的方式来匹配模型
+    if model_idx is not None and 0 <= model_idx < len(MODELS_TO_COMPARE):
+        model_id_to_update = MODELS_TO_COMPARE[model_idx]["id"]
+        # 找到 DataFrame 中对应的行
+        row_index = LEADERBOARD_DF[LEADERBOARD_DF['Model'] == MODELS_TO_COMPARE[model_idx]["name"]].index
+        if not row_index.empty:
+            # 更新 GRACE 分数 (这里假设是从 0.0-1.0 的分数，Gradio 滑块可能输出 0-100)
+            # 如果 Gradio 滑块输出 0-100，需要除以 100 转换为 0-1.0
+            LEADERBOARD_DF.loc[row_index, 'G: 泛化性'] = g_score / 100.0
+            LEADERBOARD_DF.loc[row_index, 'R: 相关性'] = r_score / 100.0
+            LEADERBOARD_DF.loc[row_index, 'A: 创新表现力'] = a_score / 100.0
+            LEADERBOARD_DF.loc[row_index, 'C: 一致性'] = c_score / 100.0
+            LEADERBOARD_DF.loc[row_index, 'E: 效率性'] = e_score / 100.0
+            # 重新排序排行榜 (如果需要根据某个分数排序)
+            LEADERBOARD_DF = LEADERBOARD_DF.sort_values(by=AutoEvalColumn.generalization_score.value.name, ascending=False).reset_index(drop=True)
+            return LEADERBOARD_DF
+    return LEADERBOARD_DF # 返回更新后的 DataFrame
 
-# 现在，这些函数调用将使用我们刚刚在 app.py 中定义的版本
 LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
-
 (
     finished_eval_queue_df,
     running_eval_queue_df,
@@ -299,7 +273,7 @@ def init_leaderboard(dataframe):
     if dataframe is None or dataframe.empty:
         print("Leaderboard DataFrame 为空或 None，初始化空排行榜。")
         return Leaderboard(
-            value=pd.DataFrame(columns=[c.name for c in fields(AutoEvalColumn)]), # 提供空但带列名的DataFrame
+            value=pd.DataFrame(columns=[c.name for c in fields(AutoEvalColumn)]),
             datatype=[c.type for c in fields(AutoEvalColumn)],
             select_columns=SelectColumns(
                 default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
@@ -308,7 +282,7 @@ def init_leaderboard(dataframe):
             ),
             search_columns=[AutoEvalColumn.model.name, AutoEvalColumn.license.name],
             hide_columns=[c.name for c in fields(AutoEvalColumn) if c.hidden],
-            filter_columns=[], # 如果是空 DataFrame，这里不添加具体的过滤器，避免错误
+            filter_columns=[],
             bool_checkboxgroup_label="隐藏模型",
             interactive=False,
         )
@@ -337,13 +311,13 @@ def init_leaderboard(dataframe):
                 AutoEvalColumn.still_on_hub.name, type="boolean", label="已删除/不完整", default=True
             ),
             # 为 GRACE 分数添加筛选器 (滑块)
-            # 假设分数在 0.0 到 1.0 之间
             ColumnFilter(
                 AutoEvalColumn.generalization_score.value.name,
                 type="slider",
                 min=0.0,
                 max=1.0,
                 label="G: 泛化性得分",
+                step=0.01 # 允许小数
             ),
             ColumnFilter(
                 AutoEvalColumn.relevance_score.value.name,
@@ -351,6 +325,7 @@ def init_leaderboard(dataframe):
                 min=0.0,
                 max=1.0,
                 label="R: 相关性得分",
+                step=0.01
             ),
             ColumnFilter(
                 AutoEvalColumn.artistry_score.value.name,
@@ -358,6 +333,7 @@ def init_leaderboard(dataframe):
                 min=0.0,
                 max=1.0,
                 label="A: 创新表现力得分",
+                step=0.01
             ),
             ColumnFilter(
                 AutoEvalColumn.consistency_score.value.name,
@@ -365,6 +341,7 @@ def init_leaderboard(dataframe):
                 min=0.0,
                 max=1.0,
                 label="C: 一致性得���",
+                step=0.01
             ),
             ColumnFilter(
                 AutoEvalColumn.efficiency_score.value.name,
@@ -372,6 +349,7 @@ def init_leaderboard(dataframe):
                 min=0.0,
                 max=1.0,
                 label="E: 效率性得分",
+                step=0.01
             ),
         ],
         bool_checkboxgroup_label="隐藏模型",
@@ -385,102 +363,74 @@ with demo:
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
+        with gr.TabItem("💬 模型比较与生成", elem_id="model-comparison-tab", id=0): # 新的标签页
+            gr.Markdown("## 输入您的提示，查看不同模型的生成效果！", elem_classes="markdown-text")
+            with gr.Row():
+                input_prompt = gr.Textbox(label="输入提示词", placeholder="请写一首关于春天的诗歌。", lines=3)
+                generate_button = gr.Button("生成文本")
+            
+            # 创建多个输出框，每个模型一个
+            output_boxes = []
+            for model_info in MODELS_TO_COMPARE:
+                output_boxes.append(gr.Textbox(label=f"{model_info['name']} 的生成结果", lines=5, interactive=False))
+            
+            # 将生成按钮与 generate_text 函数连接
+            generate_button.click(
+                fn=generate_text,
+                inputs=[input_prompt],
+                outputs=output_boxes
+            )
+
+            gr.Markdown("## 手动评估 GRACE 维度", elem_classes="markdown-text")
+            gr.Markdown("请手动评估上述生成结果，并更新排行榜中的 GRACE 分数。", elem_classes="markdown-text")
+
+            # 用于选择要评估的模型
+            model_selector = gr.Dropdown(
+                choices=[(m["name"], idx) for idx, m in enumerate(MODELS_TO_COMPARE)],
+                label="选择要评估的模型",
+                interactive=True
+            )
+
+            # GRACE 维度滑块
+            with gr.Column():
+                generalization_slider = gr.Slider(minimum=0, maximum=100, step=1, value=75, label="G: 泛化性得分 (0-100)")
+                relevance_slider = gr.Slider(minimum=0, maximum=100, step=1, value=75, label="R: 相关性得分 (0-100)")
+                artistry_slider = gr.Slider(minimum=0, maximum=100, step=1, value=75, label="A: 创新表现力得分 (0-100)")
+                consistency_slider = gr.Slider(minimum=0, maximum=100, step=1, value=75, label="C: 一致性得分 (0-100)")
+                efficiency_slider = gr.Slider(minimum=0, maximum=100, step=1, value=75, label="E: 效率性得分 (0-100)")
+                
+                update_grace_button = gr.Button("更新 GRACE 评分到排行榜")
+            
+            # 更新排行榜的逻辑
+            update_grace_button.click(
+                fn=update_leaderboard,
+                inputs=[
+                    generalization_slider,
+                    relevance_slider,
+                    artistry_slider,
+                    consistency_slider,
+                    efficiency_slider,
+                    model_selector # 传递选中的模型索引
+                ],
+                outputs=leaderboard # 更新 Leaderboard 组件
+            )
+
+
+        with gr.TabItem("🏅 LLM Benchmark", elem_id="llm-benchmark-tab-table", id=1): # 调整 ID
             leaderboard = init_leaderboard(LEADERBOARD_DF)
 
         with gr.TabItem("📝 关于", elem_id="llm-benchmark-tab-table", id=2):
             gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
 
-        with gr.TabItem("🚀 在此提交!", elem_id="llm-benchmark-tab-table", id=3):
-            with gr.Column():
-                with gr.Row():
-                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                with gr.Column():
-                    with gr.Accordion(
-                        f"✅ 已完成评估 ({len(finished_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            finished_eval_table = gr.components.Dataframe(
-                                value=finished_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                                label="已完成评估队列",
-                            )
-                    with gr.Accordion(
-                        f"🔄 正在运行的评估队列 ({len(running_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            running_eval_table = gr.components.Dataframe(
-                                value=running_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                                label="正在运行的评估队列",
-                            )
-
-                    with gr.Accordion(
-                        f"⏳ 待处理的评估队列 ({len(pending_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            pending_eval_table = gr.components.Dataframe(
-                                value=pending_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                                label="待处理的评估队列",
-                            )
-            with gr.Row():
-                gr.Markdown("# ✉️✨ 在此提交您的模型!", elem_classes="markdown-text")
+        with gr.TabItem("🚀 在此提交!", elem_id="llm-benchmark-tab-table", id=3): # 这个标签页保留，但内容将被简化
+            gr.Markdown("## 在此演示中，模型已预先加载进行比较，无需提交新模型。", elem_classes="markdown-text")
+            gr.Markdown("您可以在 **💬 模型比较与生成** 标签页中输入提示词并评估模型。", elem_classes="markdown-text")
+            # 移除所有提交相关的 UI 元素和逻辑
+            # 但是由于需要保持 add_new_eval 的引用，我们让它返回一个字符串
+            # gr.Textbox(label="模型名称") # 示例：保留一个文本框，但它不会做任何事情
+            # gr.Button("提交评估").click(fn=add_new_eval, inputs=[], outputs=[gr.Markdown()])
+            gr.Markdown("（本页面仅用于保留原始结构，实际提交功能已禁用）")
 
-            with gr.Row():
-                with gr.Column():
-                    model_name_textbox = gr.Textbox(label="模型名称")
-                    revision_name_textbox = gr.Textbox(label="修订提交", placeholder="main")
-                    # 设置模型类型的默认值，以体现项目焦点（例如：语言生成模型）
-                    model_type = gr.Dropdown(
-                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                        label="模型类型",
-                        multiselect=False,
-                        value=ModelType.LanguageModeling.to_str(" : "), # 示例：聚焦于语言生成模型
-                        interactive=True,
-                    )
-
-                with gr.Column():
-                    precision = gr.Dropdown(
-                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
-                        label="精度",
-                        multiselect=False,
-                        value="float16",
-                        interactive=True,
-                    )
-                    weight_type = gr.Dropdown(
-                        choices=[i.value.name for i in WeightType],
-                        label="权重类型",
-                        multiselect=False,
-                        value="Original",
-                        interactive=True,
-                    )
-                    base_model_name_textbox = gr.Textbox(label="基础模型 (适用于 delta 或 adapter 权重)")
-
-            submit_button = gr.Button("提交评估")
-            submission_result = gr.Markdown()
-            submit_button.click(
-                add_new_eval,
-                [
-                    model_name_textbox,
-                    base_model_name_textbox,
-                    revision_name_textbox,
-                    precision,
-                    weight_type,
-                    model_type,
-                ],
-                submission_result,
-            )
 
     with gr.Row():
         with gr.Accordion("📙 引用", open=False):
@@ -492,8 +442,10 @@ with demo:
                 show_copy_button=True,
             )
 
+# 调度器，每 30 分钟重启一次 Space
+# 在此演示中，由于模型是预加载的，并且没有持续的评估队列，重启的意义不大，但保留。
 scheduler = BackgroundScheduler()
-# 每 30 分钟重启一次 Space，确保数据刷新
-scheduler.add_job(restart_space, "interval", seconds=1800) 
+scheduler.add_job(API.restart_space, "interval", seconds=1800, args=[REPO_ID])
 scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+
+demo.queue(default_concurrency_limit=1).launch() # 降低并发限制，避免内存溢出