Upload 131 files

app.py

@@ -1,332 +1,394 @@
-import os
-import gradio as gr
-import pandas as pd
-from src.populate import get_leaderboard_df, get_filtered_leaderboard
-from src.display.filters import get_model_type_choices, get_strategy_choices, get_metric_categories
-
-# 配置路径
-RESULTS_PATH = os.path.join(os.path.dirname(__file__), "results")
-
-# 确保结果目录存在
-os.makedirs(RESULTS_PATH, exist_ok=True)
-
-
-def get_category_columns(df, category):
-    """获取特定类别的指标列，根据类别应用不同的命名规则"""
-    if df.empty:
-        return [], {}
-
-    category_name = category["name"]
-    prefixes = category["prefix"]
-    if not isinstance(prefixes, list):
-        prefixes = [prefixes]
-
-    # 确保model_name和model_type在前面
-    columns = []
-    if 'model_name' in df.columns:
-        columns.append('model_name')
-    if 'model_type' in df.columns and 'model_type' not in columns:
-        columns.append('model_type')
-
-    # 收集并处理指标列
-    metric_columns = []
-    for col in df.columns:
-        for p in prefixes:
-            if col.startswith(f"MAE_{p}") or col.startswith(f"MSE_{p}"):
-                # 不同类别使用不同的重命名规则
-                if category_name == "平稳性/非平稳性":
-                    # 平稳性保留原始名称
-                    simplified_col = col
-                elif category_name == "方差特性":
-                    # 方差特性：保留homo/hetero区分（小写简化）
-                    if "Homo-Scedasticity" in p:
-                        simplified_col = col.replace(p, "Homo_", 1)
-                    elif "Hetero-Scedasticity" in p:
-                        simplified_col = col.replace(p, "Hetero_", 1)
-                    else:
-                        simplified_col = col  # 兜底
-                elif category_name == "季节数":
-
-                    # 方差特性：保留homo/hetero区分（小写简化）
-                    if "Seasonality_Count" in p:
-
-                        simplified_col = col.replace(p, "Count", 1)
-                    else:
-                        simplified_col = col  # 兜底
-                else:
-                    # 其他类别（除平稳性和方差特性外）移除大类前缀
-                    simplified_col = col.replace(p, "", 1)
-                metric_columns.append((col, simplified_col))
-                break  # 避免重复处理
-
-    # 去重并保持顺序
-    seen = set()
-    unique_metrics = []
-    for col, simplified in metric_columns:
-        if col not in seen:
-            seen.add(col)
-            unique_metrics.append((col, simplified))
-
-    # 过滤存在的列
-    existing_columns = [col for col in columns + [col for col, _ in unique_metrics] if col in df.columns]
-
-    # 创建重命名字典
-    rename_dict = {col: simplified for col, simplified in unique_metrics if col in existing_columns}
-
-    return existing_columns, rename_dict
-
-
-def refresh_leaderboard():
-    """刷新排行榜数据，适配新的列处理逻辑"""
-    if not os.path.exists(RESULTS_PATH):
-        error_msg = f"❌ 结果目录不存在: {RESULTS_PATH}"
-        outputs = []
-        categories = get_metric_categories()
-        for _ in categories:
-            outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
-        outputs.append(gr.Markdown(value=error_msg, visible=True))
-        return outputs
-
-    if not os.path.isdir(RESULTS_PATH):
-        error_msg = f"❌ {RESULTS_PATH} 不是一个目录"
-        outputs = []
-        categories = get_metric_categories()
-        for _ in categories:
-            outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
-        outputs.append(gr.Markdown(value=error_msg, visible=True))
-        return outputs
-
-    df = get_leaderboard_df(RESULTS_PATH)
-    categories = get_metric_categories()
-    outputs = []
-
-    for category in categories:
-        if df.empty:
-            outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
-        else:
-            # 调用修改后的get_category_columns，获取列列表和重命名字典
-            category_cols, rename_dict = get_category_columns(df, category)
-            display_df = df[category_cols].copy()
-
-            # 应用列重命名
-            display_df = display_df.rename(columns=rename_dict)
-
-            # 截断过长的模型名称
-            if 'model_name' in display_df.columns:
-                display_df['model_name'] = display_df['model_name'].str.slice(0, 25) + \
-                                           (display_df['model_name'].str.len() > 25).map({True: '...', False: ''})
-
-            outputs.append(gr.Dataframe(value=display_df, visible=True))
-
-    if df.empty:
-        model_folders = [f for f in os.listdir(RESULTS_PATH) if os.path.isdir(os.path.join(RESULTS_PATH, f))]
-        error_msg = "⚠️ 找到模型文件夹，但无法加载数据" if model_folders else f"⚠️ 未在 {RESULTS_PATH} 中找到模型"
-        outputs.append(gr.Markdown(value=error_msg, visible=True))
-    else:
-        outputs.append(gr.Markdown(value="", visible=False))
-
-    return outputs
-
-
-def apply_filters(model_type, strategies, filter_mode):
-    """应用筛选条件，适配新的列处理逻辑"""
-    filtered_df = get_filtered_leaderboard(
-        RESULTS_PATH,
-        model_type=model_type,
-        strategies=strategies,
-        filter_mode=filter_mode
-    )
-    categories = get_metric_categories()
-    outputs = []
-
-    for category in categories:
-        if filtered_df.empty:
-            outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
-        else:
-            # 调用修改后的get_category_columns，获取列列表和重命名字典
-            category_cols, rename_dict = get_category_columns(filtered_df, category)
-            display_df = filtered_df[category_cols].copy()
-
-            # 应用列重命名
-            display_df = display_df.rename(columns=rename_dict)
-
-            # 截断模型名称
-            if 'model_name' in display_df.columns:
-                display_df['model_name'] = display_df['model_name'].str.slice(0, 25) + \
-                                           (display_df['model_name'].str.len() > 25).map({True: '...', False: ''})
-
-            outputs.append(gr.Dataframe(value=display_df, visible=True))
-
-    outputs.append(gr.Markdown(value="⚠️ 没有找到符合筛选条件的模型。", visible=filtered_df.empty))
-    return outputs
-
-
-def create_interface():
-    """创建Gradio界面，单表格固定model_name列（兼容旧版本Gradio）"""
-    try:
-        model_type_choices = get_model_type_choices()
-    except Exception as e:
-        model_type_choices = ["All"]
-        print(f"获取模型类型选项时出错: {str(e)}")
-
-    try:
-        strategy_choices = get_strategy_choices(RESULTS_PATH)
-    except Exception as e:
-        strategy_choices = []
-        print(f"获取策略选项时出错: {str(e)}")
-
-    categories = get_metric_categories()
-
-    with gr.Blocks(title="Aries 模型评估排行榜") as demo:
-        # 添加CSS确保model_name列固定
-        gr.HTML("""
-<style>
-    /* 表格容器基础设置 */
-    .fixed-column-table {
-    overflow: visible !important;  /* 原先是auto，改为visible禁用滚动条 */
-    position: relative !important;
-    max-height: 90vh !important;
-    height: auto !important;
-    }
-
-    /* 单元格内边距优化 */
-    .fixed-column-table td, 
-    .fixed-column-table th {
-        padding: 0.2rem 0.3rem !important;
-    }
-
-    /* 基础模式（浅色）样式 */
-    .fixed-column-table table th:first-child,
-    .fixed-column-table table td:first-child {
-        position: sticky !important;
-        left: 0 !important;
-        z-index: 2 !important;
-        background-color: white !important;
-        color: #333 !important; /* 文本色 */
-        min-width: 150px !important;
-        max-width: 150px !important;
-        font-weight: bold !important;
-        box-shadow: 1px 0 2px rgba(0,0,0,0.1) !important;
-    }
-
-    .fixed-column-table table thead th {
-        position: sticky !important;
-        top: 0 !important;
-        z-index: 1 !important;
-        background-color: white !important;
-        color: #333 !important; /* 文本色 */
-    }
-
-    .fixed-column-table table thead th:first-child {
-        z-index: 3 !important;
-    }
-
-    /* 第二列宽度设置 */
-    .fixed-column-table table th:nth-child(2),
-    .fixed-column-table table td:nth-child(2) {
-        min-width: 215px !important;
-        max-width: 215px !important;
-        white-space: nowrap !important;
-        overflow: hidden !important;
-        text-overflow: ellipsis !important;
-    }
-
-    /* 禁用内部滚动 */
-    .fixed-column-table .dataframe-container {
-        overflow: visible !important;
-    }
-
-    /* 深色模式适配 */
-    @media (prefers-color-scheme: dark) {
-        .fixed-column-table table th:first-child,
-        .fixed-column-table table td:first-child {
-            background-color: #333 !important;
-            color: #fff !important;
-            box-shadow: 1px 0 2px rgba(0,0,0,0.3) !important;
-        }
-
-        .fixed-column-table table thead th {
-            background-color: #333 !important;
-            color: #fff !important;
-        }
-    }
-</style>
-""")
-
-        gr.Markdown("# 🚀 Aries 模型评估排行榜")
-
-        with gr.Tabs():
-            with gr.Tab("模型排行榜"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 筛选条件")
-
-                        model_type = gr.Dropdown(
-                            choices=model_type_choices,
-                            label="模型类型",
-                            value="All"
-                        )
-
-                        strategies = gr.CheckboxGroup(
-                            choices=strategy_choices,
-                            label="选择策略（多选）",
-                            value=[]
-                        )
-
-                        filter_mode = gr.Radio(
-                            choices=["交集 (满足所有选中策略)", "并集 (满足任一选中策略)"],
-                            label="筛选模式",
-                            value="交集 (满足所有选中策略)"
-                        )
-
-                        filter_btn = gr.Button("应用筛选", variant="primary")
-                        refresh_btn = gr.Button("刷新数据")
-
-                    with gr.Column(scale=3):
-                        empty_state = gr.Markdown(visible=False)
-
-                        with gr.Tabs() as category_tabs:
-                            category_dataframes = []
-                            for category in categories:
-                                with gr.Tab(category["name"]):
-                                    # 单表格组件，移除不支持的sortable参数
-                                    df_component = gr.Dataframe(
-                                        interactive=False,
-                                        wrap=True,
-                                        label=category["description"],
-                                        elem_classes="fixed-column-table"
-                                    )
-                                    category_dataframes.append(df_component)
-
-            with gr.Tab("关于"):
-                gr.Markdown("""
-                ## 关于 Aries 模型评估排行榜
-                该排行榜展示了各种模型在标准基准测试中的表现，包含所有评估指标。
-                """)
-
-        # 设置事件处理
-        filter_btn.click(
-            fn=apply_filters,
-            inputs=[model_type, strategies, filter_mode],
-            outputs=category_dataframes + [empty_state]
-        )
-
-        refresh_btn.click(
-            fn=refresh_leaderboard,
-            outputs=category_dataframes + [empty_state]
-        )
-
-        demo.load(
-            fn=refresh_leaderboard,
-            outputs=category_dataframes + [empty_state]
-        )
-
-    return demo
-
-
-if __name__ == "__main__":
-    print(f"正在启动Aries模型评估排行榜，结果目录: {RESULTS_PATH}")
-    demo = create_interface()
-    demo.launch()
-
-
+import os
+import gradio as gr
+import pandas as pd
+from src.populate import get_leaderboard_df, get_filtered_leaderboard
+from src.display.filters import get_model_type_choices, get_strategy_choices, get_metric_categories
+from src.language import lang
+import logging
+import traceback
+
+# 配置路径
+RESULTS_PATH = os.path.join(os.path.dirname(__file__), "results")
+
+# 确保结果目录存在
+os.makedirs(RESULTS_PATH, exist_ok=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# 配置路径
+RESULTS_PATH = os.path.join(os.path.dirname(__file__), "results")
+
+# 确保结果目录存在
+os.makedirs(RESULTS_PATH, exist_ok=True)
+
+
+
+def get_category_columns(df, category):
+    """获取特定类别的指标列，根据类别应用不同的命名规则"""
+    if df.empty:
+        return [], {}
+
+    category_name = category["name"]
+    prefixes = category["prefix"]
+    if not isinstance(prefixes, list):
+        prefixes = [prefixes]
+
+    # 确保model_name和model_type在前面
+    columns = []
+    if 'model_name' in df.columns:
+        columns.append('model_name')
+    if 'model_type' in df.columns and 'model_type' not in columns:
+        columns.append('model_type')
+
+    # 收集并处理指标列
+    metric_columns = []
+    for col in df.columns:
+        for p in prefixes:
+            if col.startswith(f"MAE_{p}") or col.startswith(f"MSE_{p}"):
+                # 不同类别使用不同的重命名规则
+                if category_name == "平稳性/非平稳性":
+                    # 平稳性保留原始名称
+                    simplified_col = col
+                elif category_name == "方差特性":
+                    # 方差特性：保留homo/hetero区分（小写简化）
+                    if "Homo-Scedasticity" in p:
+                        simplified_col = col.replace(p, "Homo_", 1)
+                    elif "Hetero-Scedasticity" in p:
+                        simplified_col = col.replace(p, "Hetero_", 1)
+                    else:
+                        simplified_col = col  # 兜底
+                elif category_name == "季节数":
+
+                    # 方差特性：保留homo/hetero区分（小写简化）
+                    if "Seasonality_Count" in p:
+
+                        simplified_col = col.replace(p, "Count", 1)
+                    else:
+                        simplified_col = col  # 兜底
+                else:
+                    # 其他类别（除平稳性和方差特性外）移除大类前缀
+                    simplified_col = col.replace(p, "", 1)
+                metric_columns.append((col, simplified_col))
+                break  # 避免重复处理
+
+    # 去重并保持顺序
+    seen = set()
+    unique_metrics = []
+    for col, simplified in metric_columns:
+        if col not in seen:
+            seen.add(col)
+            unique_metrics.append((col, simplified))
+
+    # 过滤存在的列
+    existing_columns = [col for col in columns + [col for col, _ in unique_metrics] if col in df.columns]
+
+    # 创建重命名字典
+    rename_dict = {col: simplified for col, simplified in unique_metrics if col in existing_columns}
+
+    return existing_columns, rename_dict
+
+
+def refresh_leaderboard():
+    """刷新排行榜数据，添加详细日志和错误捕获"""
+    logger.info("开始刷新排行榜数据")
+    try:
+        if not os.path.exists(RESULTS_PATH):
+            error_msg = f"❌ 结果目录不存在: {RESULTS_PATH}"
+            logger.error(error_msg)
+            outputs = []
+            categories = get_metric_categories()
+            for _ in categories:
+                outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
+            outputs.append(gr.Markdown(value=error_msg, visible=True))
+            return outputs
+
+        if not os.path.isdir(RESULTS_PATH):
+            error_msg = f"❌ {RESULTS_PATH} 不是一个目录"
+            logger.error(error_msg)
+            outputs = []
+            categories = get_metric_categories()
+            for _ in categories:
+                outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
+            outputs.append(gr.Markdown(value=error_msg, visible=True))
+            return outputs
+
+        # 加载数据并打印日志
+        df = get_leaderboard_df(RESULTS_PATH)
+        logger.info(f"成功加载数据，共 {len(df)} 条记录")
+
+        categories = get_metric_categories()
+        outputs = []
+
+        for category in categories:
+            if df.empty:
+                outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
+            else:
+                category_cols, rename_dict = get_category_columns(df, category)
+                logger.info(f"类别 {category['name']} 的列: {category_cols}")
+
+                display_df = df[category_cols].copy()
+                display_df = display_df.rename(columns=rename_dict)
+
+                if 'model_name' in display_df.columns:
+                    display_df['model_name'] = display_df['model_name'].str.slice(0, 25) + \
+                                               (display_df['model_name'].str.len() > 25).map({True: '...', False: ''})
+
+                outputs.append(gr.Dataframe(value=display_df, visible=True))
+
+        if df.empty:
+            model_folders = [f for f in os.listdir(RESULTS_PATH) if os.path.isdir(os.path.join(RESULTS_PATH, f))]
+            error_msg = "⚠️ 找到模型文件夹，但无法加载数据" if model_folders else f"⚠️ 未在 {RESULTS_PATH} 中找到模型"
+            logger.warning(error_msg)
+            outputs.append(gr.Markdown(value=error_msg, visible=True))
+        else:
+            outputs.append(gr.Markdown(value="", visible=False))
+
+        logger.info("刷新排行榜完成")
+        return outputs
+
+    except Exception as e:
+        error_msg = f"刷新数据失败: {str(e)}\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        # 返回错误状态
+        categories = get_metric_categories()
+        outputs = [gr.Dataframe(value=pd.DataFrame(), visible=True) for _ in categories]
+        outputs.append(gr.Markdown(value=f"❌ 刷新失败: {str(e)}", visible=True))
+        return outputs
+
+
+def apply_filters(model_type, strategies, filter_mode):
+    """应用筛选条件，添加详细日志和错误捕获"""
+    logger.info(f"开始应用筛选: 模型类型={model_type}, 策略={strategies}, 模式={filter_mode}")
+    try:
+        filtered_df = get_filtered_leaderboard(
+            RESULTS_PATH,
+            model_type=model_type,
+            strategies=strategies,
+            filter_mode=filter_mode
+        )
+        logger.info(f"筛选完成，得到 {len(filtered_df)} 条记录")
+
+        categories = get_metric_categories()
+        outputs = []
+
+        for category in categories:
+            if filtered_df.empty:
+                outputs.append(gr.Dataframe(value=pd.DataFrame(), visible=True))
+            else:
+                category_cols, rename_dict = get_category_columns(filtered_df, category)
+                logger.info(f"筛选后类别 {category['name']} 的列: {category_cols}")
+
+                display_df = filtered_df[category_cols].copy()
+                display_df = display_df.rename(columns=rename_dict)
+
+                if 'model_name' in display_df.columns:
+                    display_df['model_name'] = display_df['model_name'].str.slice(0, 25) + \
+                                               (display_df['model_name'].str.len() > 25).map({True: '...', False: ''})
+
+                outputs.append(gr.Dataframe(value=display_df, visible=True))
+
+        empty_msg = "⚠️ 没有找到符合筛选条件的模型。" if filtered_df.empty else ""
+        outputs.append(gr.Markdown(value=empty_msg, visible=filtered_df.empty))
+        logger.info("筛选应用完成")
+        return outputs
+
+    except Exception as e:
+        error_msg = f"筛选失败: {str(e)}\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        # 返回错误状态
+        categories = get_metric_categories()
+        outputs = [gr.Dataframe(value=pd.DataFrame(), visible=True) for _ in categories]
+        outputs.append(gr.Markdown(value=f"❌ 筛选失败: {str(e)}", visible=True))
+        return outputs
+
+
+
+def create_interface():
+    """创建Gradio界面，单表格固定model_name列（兼容旧版本Gradio）"""
+    try:
+        model_type_choices = get_model_type_choices()
+    except Exception as e:
+        model_type_choices = ["All"]
+        print(f"获取模型类型选项时出错: {str(e)}")
+
+    try:
+        strategy_choices = get_strategy_choices(RESULTS_PATH)
+    except Exception as e:
+        strategy_choices = []
+        print(f"获取策略选项时出错: {str(e)}")
+
+    categories = get_metric_categories()
+
+    with gr.Blocks(title="Aries 模型评估排行榜") as demo:
+        # 添加CSS确保model_name列固定
+        gr.HTML("""
+<style>
+    /* 表格容器基础设置 */
+    .fixed-column-table {
+    overflow: visible !important;  /* 原先是auto，改为visible禁用滚动条 */
+    position: relative !important;
+    max-height: 90vh !important;
+    height: auto !important;
+    }
+
+    /* 单元格内边距优化 */
+    .fixed-column-table td, 
+    .fixed-column-table th {
+        padding: 0.2rem 0.3rem !important;
+    }
+
+    /* 基础模式（浅色）样式 */
+    .fixed-column-table table th:first-child,
+    .fixed-column-table table td:first-child {
+        position: sticky !important;
+        left: 0 !important;
+        z-index: 2 !important;
+        background-color: white !important;
+        color: #333 !important; /* 文本色 */
+        min-width: 150px !important;
+        max-width: 150px !important;
+        font-weight: bold !important;
+        box-shadow: 1px 0 2px rgba(0,0,0,0.1) !important;
+    }
+
+    .fixed-column-table table thead th {
+        position: sticky !important;
+        top: 0 !important;
+        z-index: 1 !important;
+        background-color: white !important;
+        color: #333 !important; /* 文本色 */
+    }
+
+    .fixed-column-table table thead th:first-child {
+        z-index: 3 !important;
+    }
+
+    /* 第二列宽度设置 */
+    .fixed-column-table table th:nth-child(2),
+    .fixed-column-table table td:nth-child(2) {
+        min-width: 215px !important;
+        max-width: 215px !important;
+        white-space: nowrap !important;
+        overflow: hidden !important;
+        text-overflow: ellipsis !important;
+    }
+
+    /* 禁用内部滚动 */
+    .fixed-column-table .dataframe-container {
+        overflow: visible !important;
+    }
+
+    /* 深色模式适配 */
+    @media (prefers-color-scheme: dark) {
+        .fixed-column-table table th:first-child,
+        .fixed-column-table table td:first-child {
+            background-color: #333 !important;
+            color: #fff !important;
+            box-shadow: 1px 0 2px rgba(0,0,0,0.3) !important;
+        }
+
+        .fixed-column-table table thead th {
+            background-color: #333 !important;
+            color: #fff !important;
+        }
+    }
+</style>
+""")
+
+        gr.Markdown(f"# {lang.get('title')}")
+        # 添加语言切换按钮
+        with gr.Row():
+            lang_btn = gr.Button(f"切换至英文" if lang.current_lang == "zh" else f"Switch to Chinese")
+
+        with gr.Tabs():
+            with gr.Tab(lang.get("model_leaderboard")):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown(f"### {lang.get('filter_conditions')}")
+
+                        model_type = gr.Dropdown(
+                            choices=model_type_choices,
+                            label=lang.get("model_type"),
+                            value="All"
+                        )
+
+                        strategies = gr.CheckboxGroup(
+                            choices=strategy_choices,
+                            label=lang.get("strategies"),
+                            value=[]
+                        )
+
+                        filter_mode = gr.Radio(
+                            choices=[lang.get("intersection"), lang.get("union")],
+                            label=lang.get("filter_mode"),
+                            value=lang.get("intersection")
+                        )
+
+                        with gr.Row():
+                            refresh_btn = gr.Button(lang.get("refresh"))
+                            apply_btn = gr.Button(lang.get("apply_filters"))  # 这个是正确的按钮变量名
+
+                    with gr.Column(scale=3):
+                        empty_state = gr.Markdown(visible=False)  # 对应错误信息显示组件
+
+                        with gr.Tabs() as category_tabs:
+                            category_dataframes = []  # 保存所有数据表格组件
+                            for category in categories:
+                                with gr.Tab(category["name"]):
+                                    df_component = gr.Dataframe(
+                                        interactive=False,
+                                        wrap=True,
+                                        label=category["description"],
+                                        elem_classes="fixed-column-table"
+                                    )
+                                    category_dataframes.append(df_component)
+
+            with gr.Tab("关于"):
+                gr.Markdown("""
+                ## 关于 Aries 模型评估排行榜
+                该排行榜展示了各种模型在标准基准测试中的表现，包含所有评估指标。
+                """)
+
+        # 设置事件处理 - 修正为正确的apply_btn
+        apply_btn.click(  # 这里之前错写为filter_btn
+            fn=apply_filters,
+            inputs=[model_type, strategies, filter_mode],
+            outputs=category_dataframes + [empty_state]
+        )
+
+        refresh_btn.click(
+            fn=refresh_leaderboard,
+            outputs=category_dataframes + [empty_state]
+        )
+
+        demo.load(
+            fn=refresh_leaderboard,
+            outputs=category_dataframes + [empty_state]
+        )
+
+        def toggle_language():
+            new_lang = lang.switch_language()
+            btn_text = "切换至英文" if new_lang == "en" else "Switch to Chinese"
+            # 刷新界面 - 使用正确的组件列表
+            return [btn_text] + refresh_leaderboard()
+
+        lang_btn.click(
+            fn=toggle_language,
+            inputs=[],
+            outputs=[lang_btn] + category_dataframes + [empty_state]  # 确保变量名一致
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    print(f"正在启动Aries模型评估排行榜，结果目录: {RESULTS_PATH}")
+    demo = create_interface()
+    demo.launch()
+
+

src/display/filters.py

@@ -1,70 +1,70 @@
-from src.display.utils import ModelType
-from src.leaderboard.read_evals import get_all_strategies
-
-def get_model_type_choices():
-    """获取模型类型筛选选项，与ModelType枚举兼容"""
-    # 生成带符号的模型类型选项
-    type_choices = [mt.to_str() for mt in ModelType if mt != ModelType.Unknown]
-    # 在开头添加"All"选项
-    return ["All"] + type_choices
-
-def get_strategy_choices(results_path):
-    """获取策略筛选选项"""
-    return get_all_strategies(results_path)
-
-def get_metric_categories():
-    """
-    获取指标类别分组，按照要求调整：
-    - 平稳性和非平稳性合并为一类
-    - 同方差和异方差合并为一类
-    - 季节特性拆分为季节强度和季节数
-    """
-    return [
-        {
-            "name": "常规指标",
-            "prefix": "Regular_",
-            "description": "基础评估指标，适用于所有类型的数据"
-        },
-        {
-            "name": "平稳性/非平稳性",
-            "prefix": ["Stationary_", "Non_Stationary_"],
-            "description": "模型在平稳和非平稳序列上的表现"
-        },
-        {
-            "name": "趋势强度",
-            "prefix": "Trend_Strength_",
-            "description": "模型在不同趋势强度数据上的表现"
-        },
-        # 拆分原"季节特性"为两个独立分组
-        {
-            "name": "季节强度",
-            "prefix": "Seasonality_Strength_",
-            "description": "模型在不同季节强度数据上的表现"
-        },
-        {
-            "name": "季节数",
-            "prefix": "Seasonality_Count_",
-            "description": "模型在不同季节计数（周期数量）数据上的表现"
-        },
-        {
-            "name": "波动性",
-            "prefix": "Volatility_",
-            "description": "模型在不同波动性特征数据上的表现"
-        },
-        {
-            "name": "记忆性",
-            "prefix": "Memory_",
-            "description": "模型在不同记忆性特征数据上的表现"
-        },
-        {
-            "name": "方差特性",
-            "prefix": ["Homo-Scedasticity_", "Hetero-Scedasticity_"],
-            "description": "模型在同方差和异方差数据上的表现"
-        },
-        {
-            "name": "异常值",
-            "prefix": "Anomaly_",
-            "description": "模型在包含不同比例异常值数据上的表现"
-        }
-    ]
-
+from src.display.utils import ModelType
+from src.leaderboard.read_evals import get_all_strategies
+from src.language import lang
+
+def get_model_type_choices():
+    """获取模型类型筛选选项，与ModelType枚举兼容"""
+    # 生成带符号的模型类型选项
+    type_choices = [mt.to_str() for mt in ModelType if mt != ModelType.Unknown]
+    # 在开头添加"All"选项
+    return ["All"] + type_choices
+
+def get_strategy_choices(results_path):
+    """获取策略筛选选项"""
+    return get_all_strategies(results_path)
+
+def get_metric_categories():
+    """
+    获取指标类别分组，按照要求调整：
+    - 平稳性和非平稳性合并为一类
+    - 同方差和异方差合并为一类
+    - 季节特性拆分为季节强度和季节数
+    """
+    return [
+        {
+            "name": lang.get("regular_metrics"),
+            "prefix": "Regular_",
+            "description": lang.get("regular_desc")
+        },
+        {
+            "name": lang.get("stationarity"),
+            "prefix": ["Stationary_", "Non_Stationary_"],
+            "description": lang.get("stationarity_desc")
+        },
+        {
+            "name": lang.get("trend_strength"),
+            "prefix": "Trend_Strength_",
+            "description": lang.get("trend_strength_desc")
+        },
+        {
+            "name": lang.get("seasonality_strength"),
+            "prefix": "Seasonality_Strength_",
+            "description": lang.get("seasonality_strength_desc")
+        },
+        {
+            "name": lang.get("seasonality_count"),
+            "prefix": "Seasonality_Count_",
+            "description": lang.get("seasonality_count_desc")
+        },
+        {
+            "name": lang.get("volatility"),
+            "prefix": "Volatility_",
+            "description": lang.get("volatility_desc")
+        },
+        {
+            "name": lang.get("memory"),
+            "prefix": "Memory_",
+            "description": lang.get("memory_desc")
+        },
+        {
+            "name": lang.get("variance_characteristics"),
+            "prefix": ["Homo-Scedasticity_", "Hetero-Scedasticity_"],
+            "description": lang.get("variance_characteristics_desc")
+        },
+        {
+            "name": lang.get("outliers"),
+            "prefix": "Anomaly_",
+            "description": lang.get("outliers_desc")
+        }
+    ]
+

src/language.py

@@ -0,0 +1,104 @@
+# src/language.py
+class LanguageManager:
+    def __init__(self):
+        self.current_lang = "en"  # 默认中文
+        self.translations = {
+            "zh": {
+                # app.py 中的文本
+                "title": "🚀 Aries 模型评估排行榜",
+                "model_leaderboard": "模型排行榜",
+                "filter_conditions": "筛选条件",
+                "model_type": "模型类型",
+                "strategies": "策略",
+                "filter_mode": "筛选模式",
+                "refresh": "刷新",
+                "apply_filters": "应用筛选",
+                "all": "All",  # 保持英文
+                "intersection": "交集 (满足所有选中策略)",
+                "union": "并集 (满足任一选中策略)",
+                "no_results": "⚠️ 没有找到符合筛选条件的模型。",
+                "results_dir_not_exist": "❌ 结果目录不存在: {path}",
+                "not_a_directory": "❌ {path} 不是一个目录",
+                "no_model_data": "⚠️ 找到模型文件夹，但无法加载数据",
+                "no_model_folders": "⚠️ 未在 {path} 中找到模型",
+
+                # 指标类别 - src/display/filters.py
+                "regular_metrics": "常规指标",
+                "stationarity": "平稳性/非平稳性",
+                "trend_strength": "趋势强度",
+                "seasonality_strength": "季节强度",
+                "seasonality_count": "季节数",
+                "volatility": "波动性",
+                "memory": "记忆性",
+                "variance_characteristics": "方差特性",
+                "outliers": "异常值",
+
+                # 指标描述
+                "regular_desc": "基础评估指标，适用于所有类型的数据",
+                "stationarity_desc": "模型在平稳和非平稳序列上的表现",
+                "trend_strength_desc": "模型在不同趋势强度数据上的表现",
+                "seasonality_strength_desc": "模型在不同季节强度数据上的表现",
+                "seasonality_count_desc": "模型在不同季节计数（周期数量）数据上的表现",
+                "volatility_desc": "模型在不同波动性特征数据上的表现",
+                "memory_desc": "模型在不同记忆性特征数据上的表现",
+                "variance_characteristics_desc": "模型在同方差和异方差数据上的表现",
+                "outliers_desc": "模型在包含不同比例异常值数据上的表现"
+            },
+            "en": {
+                # app.py 中的文本
+                "title": "🚀 Aries Model Evaluation Leaderboard",
+                "model_leaderboard": "Model Leaderboard",
+                "filter_conditions": "Filter Conditions",
+                "model_type": "Model Type",
+                "strategies": "Strategies",
+                "filter_mode": "Filter Mode",
+                "refresh": "Refresh",
+                "apply_filters": "Apply Filters",
+                "all": "All",
+                "intersection": "Intersection (meet all selected strategies)",
+                "union": "Union (meet any selected strategy)",
+                "no_results": "⚠️ No models found matching the filter criteria.",
+                "results_dir_not_exist": "❌ Results directory does not exist: {path}",
+                "not_a_directory": "❌ {path} is not a directory",
+                "no_model_data": "⚠️ Model folders found, but unable to load data",
+                "no_model_folders": "⚠️ No models found in {path}",
+
+                # 指标类别
+                "regular_metrics": "Regular Metrics",
+                "stationarity": "Stationarity/Non-stationarity",
+                "trend_strength": "Trend Strength",
+                "seasonality_strength": "Seasonality Strength",
+                "seasonality_count": "Seasonality Count",
+                "volatility": "Volatility",
+                "memory": "Memory",
+                "variance_characteristics": "Variance Characteristics",
+                "outliers": "Anomalies",
+
+                # 指标描述
+                "regular_desc": "Basic evaluation metrics applicable to all data types",
+                "stationarity_desc": "Model performance on stationary and non-stationary sequences",
+                "trend_strength_desc": "Model performance on data with different trend strengths",
+                "seasonality_strength_desc": "Model performance on data with different seasonality strengths",
+                "seasonality_count_desc": "Model performance on data with different seasonality counts (number of cycles)",
+                "volatility_desc": "Model performance on data with different volatility characteristics",
+                "memory_desc": "Model performance on data with different memory characteristics",
+                "variance_characteristics_desc": "Model performance on homoscedastic and heteroscedastic data",
+                "outliers_desc": "Model performance on data containing different proportions of outliers"
+            }
+        }
+
+    def switch_language(self):
+        """切换语言"""
+        self.current_lang = "en" if self.current_lang == "zh" else "zh"
+        return self.current_lang
+
+    def get(self, key, **kwargs):
+        """获取翻译文本，支持格式化参数"""
+        text = self.translations[self.current_lang].get(key, key)
+        if kwargs:
+            return text.format(**kwargs)
+        return text
+
+
+# 创建全局实例
+lang = LanguageManager()