change language

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-LongBenchmark 结果可视化
+LongBenchmark Results Visualization
 """
 
 import json
@@ -15,21 +15,21 @@ with open('./results/model_info.json', 'r', encoding='utf-8') as f:
     MODLE_INFO_DICT = json.load(f)
 
 def get_color(index):
-    """基于索引生成颜色，使用黄金角度确保颜色分布均匀且无限"""
-    # 黄金角度约 137.508 度，确保颜色在色环上分布均匀
+    """Generate color based on index, using golden angle to ensure uniform and infinite color distribution"""
+    # Golden angle approx 137.508 degrees
     hue = (index * 137.508) % 360
-    # 固定饱和度为70%，亮度为60%，确保颜色既鲜艳又不刺眼
+    # Fixed saturation 70%, lightness 60%
     return f"hsl({hue}, 70%, 60%)"
 
-# 自定义CSS
+# Custom CSS
 CUSTOM_CSS = """
-/* 强制标题居中 */
+/* Force title center */
 h1 {
     text-align: center;
     display: block;
 }
 
-/* 表头居中 */
+/* Header center */
 #leaderboard_table th, 
 #leaderboard_table th button, 
 #leaderboard_table th span {
@@ -37,10 +37,15 @@ h1 {
     justify-content: center !important;
 }
 
-/* 内容列居中：从第3列开始（跳过行号和模型名称） */
+/* Content column center: starting from 3rd column */
 #leaderboard_table td:nth-child(n+3) {
     text-align: center !important;
 }
+
+/* Make tab labels bold */
+button[role="tab"] {
+    font-weight: bold !important;
+}
 """
 
 class ResultParser:
@@ -49,30 +54,30 @@ class ResultParser:
         self.results = []
         
     def parse_filename(self, filename: str):
-        """解析文件名，提取context长度和是否包含thinking或nonthinking"""
-        # 提取context长度
+        """Parse filename to extract context length and thinking status"""
+        # Extract context length
         context_match = re.search(r'context-(\d+)', filename)
         context_length = int(context_match.group(1)) if context_match else 0
         
         filename_lower = filename.lower()
-        # 检查是否包含nonthinking（优先检查，因为nonthinking也包含thinking）
+        # Check nonthinking
         has_nonthinking = 'nonthinking' in filename_lower
-        # 检查是否包含thinking（但不包含nonthinking）
+        # Check thinking
         has_thinking = 'thinking' in filename_lower and not has_nonthinking
         
         return context_length, has_thinking, has_nonthinking
     
     def parse_result_file(self, model_name: str, file_path: Path):
-        """解析单个结果文件"""
+        """Parse single result file"""
         try:
             with open(file_path, 'r', encoding='utf-8') as f:
                 data = json.load(f)
             
             context_length, has_thinking, has_nonthinking = self.parse_filename(file_path.name)
-            # 使用JSON文件中的date字段作为评估日期
-            eval_date = data.get('date', "未知")
+            # Use date field as evaluation date
+            eval_date = data.get('date', "Unknown")
             
-            # 提取BoN数据
+            # Extract BoN data
             bon_data = {}
             for bon_key in ['BoN-1', 'BoN-2', 'BoN-3']:
                 if bon_key in data and 'overall_metric' in data[bon_key]:
@@ -90,7 +95,7 @@ class ResultParser:
                 'difficulty': data.get('average_difficulty_metric', {}),
                 'primary_task': data.get('average_primary_task_metric', {}),
                 'language': data.get('average_language_metric', {}),
-                'bon_data': bon_data,  # 存储BoN-1, BoN-2, BoN-3的overall_metric
+                'bon_data': bon_data,  # Store BoN-1, BoN-2, BoN-3 overall_metric
                 'pass_at_k': {
                     'pass@1': data.get('pass@1'),
                     'pass@2': data.get('pass@2'),
@@ -101,40 +106,40 @@ class ResultParser:
             return result
             
         except Exception as e:
-            print(f"解析文件 {file_path} 时出错: {e}")
+            print(f"Error parsing file {file_path}: {e}")
             return None
     
     def scan_all_results(self):
-        """扫描所有模型的结果文件"""
+        """Scan all model result files"""
         self.results = []
         
         if not self.output_dir.exists():
-            print(f"输出目录不存在: {self.output_dir}")
+            print(f"Output directory does not exist: {self.output_dir}")
             return
         
-        # 遍历所有模型目录
+        # Traverse all model directories
         for model_dir in self.output_dir.iterdir():
             if not model_dir.is_dir():
                 continue
                 
             model_name = model_dir.name
-            print(f"扫描模型: {model_name}")
+            print(f"Scanning model: {model_name}")
             
-            # 查找该模型下的所有_summary.json文件
+            # Find all _summary.json files
             for file_path in model_dir.glob("*_summary.json"):
-                print(f"  解析文件: {file_path.name}")
+                print(f"  Parsing file: {file_path.name}")
                 result = self.parse_result_file(model_name, file_path)
                 if result:
                     self.results.append(result)
         
-        print(f"总共解析了 {len(self.results)} 个结果文件")
+        print(f"Total parsed {len(self.results)} result files")
     
     def get_leaderboard_data(self):
-        """获取排行榜数据"""
+        """Get leaderboard data"""
         if not self.results:
             return pd.DataFrame()
         
-        # 按模型名称聚合数据
+        # Aggregate data by model name
         model_groups = {}
         for result in self.results:
             model_name = result['model_name']
@@ -158,14 +163,14 @@ class ResultParser:
         
         leaderboard_data = []
         for model_name, group in model_groups.items():
-            # 获取最新日期
-            valid_dates = [d for d in group['dates'] if d != "未知"]
-            latest_date = max(valid_dates) if valid_dates else "未知"
+            # Get latest date
+            valid_dates = [d for d in group['dates'] if d != "Unknown"]
+            latest_date = max(valid_dates) if valid_dates else "Unknown"
             
-            # 获取最大Context Window
+            # Get max Context Window
             max_context = max(group['contexts']) if group['contexts'] else 0
             
-            # 格式化截断长度
+            # Format truncated length
             if max_context >= 1000000:
                 context_str = f"{max_context/1000000:.0f}M" if max_context % 1000000 == 0 else f"{max_context/1000000:.1f}M"
             elif max_context >= 1000:
@@ -173,7 +178,7 @@ class ResultParser:
             else:
                 context_str = str(max_context)
             
-            # 获取模型类型和上下文长度
+            # Get model type and context length
             model_context = "-"
             model_url = ""
             if model_name in MODLE_INFO_DICT:
@@ -187,13 +192,13 @@ class ResultParser:
             else:
                 model_type = "Unknown"
             
-            # 处理模型名称链接和图标
+            # Handle model name link and icon
             display_model_name = model_name
 
             if model_url:
                 display_model_name = f"[{display_model_name}]({model_url})"
 
-            # 计算平均分
+            # Calculate average score
             nt_score_val = 0
             nt_score_str = "-"
             if group['non_thinking_scores']:
@@ -207,24 +212,24 @@ class ResultParser:
                 t_score_str = f"{t_score_val * 100:.2f}"
             
             leaderboard_data.append({
-                '模型名称': display_model_name,
-                '模型类型': model_type,
-                '上下文长度': model_context,
-                '截断长度': context_str,
-                '非思考得分': nt_score_str,
-                '思考得分': t_score_str,
+                'Model Name': display_model_name,
+                'Model Type': model_type,
+                'Context Length': model_context,
+                'Truncated Length': context_str,
+                'Non-Thinking Score': nt_score_str,
+                'Thinking Score': t_score_str,
                 '_sort_score': max(nt_score_val, t_score_val)
             })
         
         df = pd.DataFrame(leaderboard_data)
-        # 按最高分降序排列
+        # Sort by highest score descending
         if not df.empty:
             df = df.sort_values('_sort_score', ascending=False).drop(columns=['_sort_score']).reset_index(drop=True)
             
         return df
 
 def get_display_name_for_result(result):
-    """获取模型的显示名称（根据是否包含thinking或nonthinking添加后缀）"""
+    """Get display name for model (append suffix based on thinking/nonthinking)"""
     if result.get('has_nonthinking'):
         return f"{result['model_name']}_nonthinking"
     elif result.get('has_thinking'):
@@ -233,18 +238,18 @@ def get_display_name_for_result(result):
         return result['model_name']
 
 def get_model_color_index(model_name, all_models):
-    """获取模型在颜色列表中的索引"""
+    """Get model index in color list"""
     try:
         return all_models.index(model_name)
     except ValueError:
         return 0
 
 def create_contextual_requirement_chart(results, selected_models):
-    """创建上下文需求对比柱状图"""
+    """Create contextual requirement comparison bar chart"""
     if not selected_models:
         return go.Figure()
     
-    # 收集数据 - 直接使用summary中的值，不需要计算平均值
+    # Collect data
     chart_data = {}
     
     for result in results:
@@ -253,17 +258,17 @@ def create_contextual_requirement_chart(results, selected_models):
             model_name = display_name
             contextual_requirement = result['contextual_requirement']
             
-            # 直接存储每个模型的结果，不需要计算平均值
+            # Store each model's result directly
             if model_name not in chart_data:
                 chart_data[model_name] = {}
             
             for req_type, score in contextual_requirement.items():
-                chart_data[model_name][req_type] = score * 100  # 乘以100
+                chart_data[model_name][req_type] = score * 100  # multiply by 100
     
-    # 创建图表
+    # Create chart
     fig = go.Figure()
     
-    # 获取所有需求类型 - 保持原始顺序，不排序
+    # Get all requirement types
     all_req_types = []
     for result in results:
         display_name = get_display_name_for_result(result)
@@ -283,36 +288,36 @@ def create_contextual_requirement_chart(results, selected_models):
                 x=all_req_types,
                 y=scores,
                 marker_color=get_color(color_index),
-                text=[f"{score:.2f}" for score in scores],  # 保留2位小数
+                text=[f"{score:.2f}" for score in scores],  # keep 2 decimal places
                 textposition='auto'
             ))
     
     fig.update_layout(
-        title='模型在不同上下文需求上的性能对比',
-        xaxis_title='上下文需求类型',
-        yaxis_title='平均得分',
+        title='Performance Comparison on Different Context Requirements',
+        xaxis_title='Context Requirement Type',
+        yaxis_title='Average Score',
         barmode='group',
-        autosize=True,  # 自动调整大小
+        autosize=True,  # auto size
         legend=dict(
             orientation="h",
             yanchor="top",
-            y=-0.25,  # 调整到更下方
+            y=-0.25,  # adjust lower
             xanchor="center",
             x=0.5
         ),
-        margin=dict(b=100)  # 增加底部边距
+        margin=dict(b=100)  # increase bottom margin
     )
     
     return fig
 
 def create_primary_task_radar_chart(results, selected_models):
-    """创建主要任务雷达图（按任务前缀聚合，使用'.'前缀，绘制最多11个任务）"""
+    """Create primary task radar chart (aggregate by prefix)"""
     if not selected_models:
         return go.Figure()
     
-    # 收集所有模型下的任务前缀，保持出现顺序
+    # Collect all model task prefixes
     prefix_order = []
-    # 为每个模型构建 前缀 -> [scores] 的映射
+    # Map prefix -> [scores] for each model
     model_prefix_scores = {}
     
     for result in results:
@@ -330,16 +335,16 @@ def create_primary_task_radar_chart(results, selected_models):
                 model_prefix_scores[display_name][prefix] = []
             model_prefix_scores[display_name][prefix].append(score * 100)
     
-    # 只取前11个前缀用于绘制
+    # Take first 11 prefixes
     categories = prefix_order[:11]
     
-    # 创建雷达图
+    # Create radar chart
     fig = go.Figure()
     
     for model_name in selected_models:
         if model_name not in model_prefix_scores:
             continue
-        # 对每个前缀做均值聚合；缺失则为0
+        # Mean aggregation for each prefix
         values = []
         for prefix in categories:
             scores = model_prefix_scores[model_name].get(prefix, [])
@@ -347,7 +352,7 @@ def create_primary_task_radar_chart(results, selected_models):
                 values.append(sum(scores) / len(scores))
             else:
                 values.append(0)
-        # 闭合多边形
+        # Close polygon
         r_values = values + ([values[0]] if values else [])
         theta_values = categories + ([categories[0]] if categories else [])
         color_index = get_model_color_index(model_name, selected_models)
@@ -362,7 +367,7 @@ def create_primary_task_radar_chart(results, selected_models):
         ))
     
     fig.update_layout(
-        title='模型在不同主要任务上的性能对比',
+        title='Performance Comparison on Different Primary Tasks',
         polar=dict(
             radialaxis=dict(visible=True, range=[0, 100])
         ),
@@ -379,11 +384,11 @@ def create_primary_task_radar_chart(results, selected_models):
     return fig
 
 def create_language_chart(results, selected_models):
-    """创建语言对比柱状图"""
+    """Create language comparison bar chart"""
     if not selected_models:
         return go.Figure()
     
-    # 收集数据 - 直接使用summary中的值，不需要计算平均值
+    # Collect data
     chart_data = {}
     
     for result in results:
@@ -392,17 +397,17 @@ def create_language_chart(results, selected_models):
             model_name = display_name
             language = result['language']
             
-            # 直接存储每个模型的结果，不需要计算平均值
+            # Store each model's result directly
             if model_name not in chart_data:
                 chart_data[model_name] = {}
             
             for lang_type, score in language.items():
-                chart_data[model_name][lang_type] = score * 100  # 乘以100
+                chart_data[model_name][lang_type] = score * 100  # multiply by 100
     
-    # ��建图表
+    # Create chart
     fig = go.Figure()
     
-    # 获取所有语言类型 - 保持原始顺序，不排序
+    # Get all language types
     all_lang_types = []
     for result in results:
         display_name = get_display_name_for_result(result)
@@ -422,34 +427,34 @@ def create_language_chart(results, selected_models):
                 x=all_lang_types,
                 y=scores,
                 marker_color=get_color(color_index),
-                text=[f"{score:.2f}" for score in scores],  # 保留2位小数
+                text=[f"{score:.2f}" for score in scores],  # keep 2 decimal places
                 textposition='auto'
             ))
     
     fig.update_layout(
-        title='模型在不同语言上的性能对比',
-        xaxis_title='语言类型',
-        yaxis_title='平均得分',
+        title='Performance Comparison on Different Languages',
+        xaxis_title='Language Type',
+        yaxis_title='Average Score',
         barmode='group',
-        autosize=True,  # 自动调整大小
+        autosize=True,  # auto size
         legend=dict(
             orientation="h",
             yanchor="top",
-            y=-0.25,  # 调整到更下方
+            y=-0.25,  # adjust lower
             xanchor="center",
             x=0.5
         ),
-        margin=dict(b=100)  # 增加底部边距
+        margin=dict(b=100)  # increase bottom margin
     )
     
     return fig
 
 def create_difficulty_chart(results, selected_models):
-    """创建难度对比柱状图"""
+    """Create difficulty comparison bar chart"""
     if not selected_models:
         return go.Figure()
     
-    # 收集数据 - 直接使用summary中的值，不需要计算平均值
+    # Collect data
     chart_data = {}
     
     for result in results:
@@ -458,17 +463,17 @@ def create_difficulty_chart(results, selected_models):
             model_name = display_name
             difficulty = result['difficulty']
             
-            # 直接存储每个模型的结果，不需要计算平均值
+            # Store each model's result directly
             if model_name not in chart_data:
                 chart_data[model_name] = {}
             
             for diff_type, score in difficulty.items():
-                chart_data[model_name][diff_type] = score * 100  # 乘以100
+                chart_data[model_name][diff_type] = score * 100  # multiply by 100
     
-    # 创建图表
+    # Create chart
     fig = go.Figure()
     
-    # 获取所有难度类型 - 保持原始顺序，不排序
+    # Get all difficulty types
     all_diff_types = []
     for result in results:
         display_name = get_display_name_for_result(result)
@@ -488,38 +493,38 @@ def create_difficulty_chart(results, selected_models):
                 x=all_diff_types,
                 y=scores,
                 marker_color=get_color(color_index),
-                text=[f"{score:.2f}" for score in scores],  # 保留2位小数
+                text=[f"{score:.2f}" for score in scores],  # keep 2 decimal places
                 textposition='auto'
             ))
     
     fig.update_layout(
-        title='模型在不同难度上的性能对比',
-        xaxis_title='难度类型',
-        yaxis_title='平均得分',
+        title='Performance Comparison on Different Difficulties',
+        xaxis_title='Difficulty Type',
+        yaxis_title='Average Score',
         barmode='group',
-        autosize=True,  # 自动调整大小
+        autosize=True,  # auto size
         legend=dict(
             orientation="h",
             yanchor="top",
-            y=-0.25,  # 调整到更下方
+            y=-0.25,  # adjust lower
             xanchor="center",
             x=0.5
         ),
-        margin=dict(b=100)  # 增加底部边距
+        margin=dict(b=100)  # increase bottom margin
     )
     
     return fig
 
 def create_length_heatmap(results, selected_models):
-    """创建长度热力图：横坐标为长度，纵坐标为模型"""
+    """Create length heatmap"""
     if not selected_models:
         return go.Figure()
     
-    # 定义标准的context长度范围：8k, 16k, 32k, 64k, 128k, 256k
+    # Standard context lengths
     standard_lengths = [8000, 16000, 32000, 64000, 128000, 256000]
     standard_length_keys = ['8k', '16k', '32k', '64k', '128k', '256k']
     
-    # 准备热力图数据
+    # Prepare heatmap data
     heatmap_data = []
     model_names = []
     
@@ -528,52 +533,52 @@ def create_length_heatmap(results, selected_models):
         if display_name in selected_models:
             model_names.append(display_name)
             
-            # 从token_length_metrics中获取数据
+            # Get data from token_length_metrics
             token_length_metrics = result.get('token_length_metrics', {})
             row_data = []
             
             for key in standard_length_keys:
                 if key in token_length_metrics:
-                    row_data.append(token_length_metrics[key] * 100)  # 乘以100转换为百分比
+                    row_data.append(token_length_metrics[key] * 100)  # multiply by 100
                 else:
-                    row_data.append(None)  # 没有数据点
+                    row_data.append(None)  # No data point
             
             heatmap_data.append(row_data)
     
-    # 创建热力图
+    # Create heatmap
     fig = go.Figure(data=go.Heatmap(
         z=heatmap_data,
-        x=[f"{length//1000}k" for length in standard_lengths],  # x轴标签
-        y=model_names,  # y轴标签
-        colorscale='RdYlBu_r',  # 颜色映射：红色表示低分，蓝色表示高分
+        x=[f"{length//1000}k" for length in standard_lengths],  # x axis labels
+        y=model_names,  # y axis labels
+        colorscale='RdYlBu_r',  # Red is low, Blue is high
         showscale=True,
-        text=[[f"{val:.2f}" if val is not None else "N/A" for val in row] for row in heatmap_data],  # 显示数值
+        text=[[f"{val:.2f}" if val is not None else "N/A" for val in row] for row in heatmap_data],  # show values
         texttemplate="%{text}",
         textfont={"size": 10},
         hoverongaps=False
     ))
     
     fig.update_layout(
-        title='模型在不同Context长度上的性能热力图',
-        xaxis_title='Context长度 (tokens)',
-        yaxis_title='模型名称',
+        title='Performance Heatmap on Different Sample Lengths',
+        xaxis_title='Sample Length (tokens)',
+        yaxis_title='Model Name',
         autosize=True,
-        height=max(400, len(model_names) * 50),  # 根据模型数量调整高度
-        margin=dict(l=150, r=50, t=80, b=80)  # 调整边距，左侧留更多空间给模型名称
+        height=max(400, len(model_names) * 50),  # adjust height based on model count
+        margin=dict(l=150, r=50, t=80, b=80)  # adjust margins
     )
     
     return fig
 
 def create_bon_chart(results, selected_models):
-    """创建BoN 1-3折线图，显示overall_metric"""
+    """Create BoN 1-3 line chart"""
     if not selected_models:
         return go.Figure()
     
-    # BoN 标签
+    # BoN labels
     bon_labels = ['BoN-1', 'BoN-2', 'BoN-3']
     bon_indices = [1, 2, 3]
     
-    # 为每个模型准备数据
+    # Prepare data for each model
     model_data = {}
     for result in results:
         display_name = get_display_name_for_result(result)
@@ -581,21 +586,21 @@ def create_bon_chart(results, selected_models):
             if display_name not in model_data:
                 model_data[display_name] = {}
             
-            # 从bon_data中获取数据
+            # Get data from bon_data
             bon_data = result.get('bon_data', {})
             for bon_key in bon_labels:
                 if bon_key in bon_data:
                     bon_index = bon_labels.index(bon_key) + 1
-                    model_data[display_name][bon_index] = bon_data[bon_key] * 100  # 乘以100转换为百分比
+                    model_data[display_name][bon_index] = bon_data[bon_key] * 100  # multiply by 100
     
-    # 创建图表
+    # Create chart
     fig = go.Figure()
     
     for model_name, data in model_data.items():
         if not data:
             continue
         
-        # 为每个BoN准备数据
+        # Prepare data for each BoN
         x_values = []
         y_values = []
         text_values = []
@@ -609,7 +614,7 @@ def create_bon_chart(results, selected_models):
                 y_values.append(None)
                 text_values.append("")
         
-        # 获取模型颜色索引
+        # Get model color index
         color_index = get_model_color_index(model_name, selected_models)
         
         fig.add_trace(go.Scatter(
@@ -624,11 +629,11 @@ def create_bon_chart(results, selected_models):
             connectgaps=False
         ))
     
-    # 设置x轴
+    # Set x axis
     fig.update_layout(
-        title='模型在不同Best-of-N下的对比',
+        title='Performance Comparison on Different Best-of-N',
         xaxis_title='N',
-        yaxis_title='平均得分',
+        yaxis_title='Average Score',
         autosize=True,
         xaxis=dict(
             tickmode='array',
@@ -649,15 +654,15 @@ def create_bon_chart(results, selected_models):
     return fig
 
 def create_pass_k_chart(results, selected_models):
-    """创建Pass@N 折线图"""
+    """Create Pass@N line chart"""
     if not selected_models:
         return go.Figure()
     
-    # Pass@K 标签
-    k_labels = ['pass@1', 'pass@2', 'pass@3']
+    # Pass@K labels
+    k_labels = ['Pass@1', 'Pass@2', 'Pass@3']
     k_indices = [1, 2, 3]
     
-    # 为每个模型准备数据
+    # Prepare data for each model
     model_data = {}
     for result in results:
         display_name = get_display_name_for_result(result)
@@ -665,22 +670,22 @@ def create_pass_k_chart(results, selected_models):
             if display_name not in model_data:
                 model_data[display_name] = {}
             
-            # 从pass_at_k中获取数据
+            # Get data from pass_at_k
             pass_data = result.get('pass_at_k', {})
             for i, k_key in enumerate(k_labels):
                 val = pass_data.get(k_key)
                 if val is not None:
                     k_index = k_indices[i]
-                    model_data[display_name][k_index] = val * 100  # 乘以100转换为百分比
+                    model_data[display_name][k_index] = val * 100  # multiply by 100
     
-    # 创建图表
+    # Create chart
     fig = go.Figure()
     
     for model_name, data in model_data.items():
         if not data:
             continue
         
-        # 为每个Pass@K准备数据
+        # Prepare data for each Pass@K
         x_values = []
         y_values = []
         text_values = []
@@ -694,7 +699,7 @@ def create_pass_k_chart(results, selected_models):
                 y_values.append(None)
                 text_values.append("")
         
-        # 获取模型颜色索引
+        # Get model color index
         color_index = get_model_color_index(model_name, selected_models)
         
         fig.add_trace(go.Scatter(
@@ -709,9 +714,9 @@ def create_pass_k_chart(results, selected_models):
             connectgaps=False
         ))
     
-    # 设置x轴
+    # Set x axis
     fig.update_layout(
-        title='模型在不同Pass@N下的对比',
+        title='Performance Comparison on Different Pass@N',
         xaxis_title='N',
         yaxis_title='Pass@N (%)',
         autosize=True,
@@ -734,15 +739,15 @@ def create_pass_k_chart(results, selected_models):
     return fig
 
 def create_gradio_interface(parser: ResultParser):
-    """创建Gradio界面"""
+    """Create Gradio interface"""
     
     def refresh_data():
-        """刷新数据"""
+        """Refresh data"""
         parser.scan_all_results()
         return parser.get_leaderboard_data()
     
     def get_model_choices():
-        """获取模型选择列表（按是否包含Thinking或NonThinking区分，以相应后缀标识）"""
+        """Get model choices (distinguish by suffix for thinking/nonthinking)"""
         if not parser.results:
             return []
         display_names = set()
@@ -753,7 +758,7 @@ def create_gradio_interface(parser: ResultParser):
         return models
     
     def update_charts(selected_models):
-        """更新所有图表"""
+        """Update all charts"""
         if not selected_models:
             return None, None, None, None, None, None, None
         
@@ -767,9 +772,9 @@ def create_gradio_interface(parser: ResultParser):
         
         return length_heatmap, contextual_chart, primary_task_radar_chart, language_chart, difficulty_chart, bon_chart, pass_k_chart
     
-    # 创建界面
-    with gr.Blocks(title="LongBench Pro 结果可视化", theme=gr.themes.Soft(), css=CUSTOM_CSS) as demo:
-        gr.Markdown("# LongBench Pro 结果可视化")
+    # Create interface
+    with gr.Blocks(title="LongBench Pro Results Visualization", theme=gr.themes.Soft(), css=CUSTOM_CSS) as demo:
+        gr.Markdown("# LongBench Pro Results Visualization")
 
         gr.HTML("""
         <div style="text-align: center; display: flex; justify-content: center; gap: 10px; margin-bottom: 20px;">
@@ -780,14 +785,14 @@ def create_gradio_interface(parser: ResultParser):
         </div>
         """)
         
-        # 排行榜区域
-        gr.Markdown("## 🏆 总体性能排行榜")
+        # Leaderboard area
+        gr.Markdown("## 🏆 Overall Performance Leaderboard")
         gr.Markdown("""
-        - *思考模型和混合思考模型的思考得分，使用本身的思考能力（Non-Thinking Prompt）*
-        - *指令模型的思考得分，使用思考提示获得（Thinking Prompt）*
+        - *Thinking scores for Thinking and Mixed-Thinking models use their own thinking capabilities (Non-Thinking Prompt)*
+        - *Thinking scores for Instruct models are obtained using thinking prompts (Thinking Prompt)*
         """)
         leaderboard_df = gr.Dataframe(
-            headers=["模型名称", "模型类型", "上下文长度", "截断长度", "非思考得分", "思考得分"],
+            headers=["Model Name", "Model Type", "Context Length", "Truncation Length", "Non-Thinking Score", "Thinking Score"],
             datatype=["markdown", "str", "str", "str", "str", "str"],
             interactive=False,
             wrap=True,
@@ -798,47 +803,47 @@ def create_gradio_interface(parser: ResultParser):
             elem_id="leaderboard_table"
         )
         
-        # 模型筛选和图表区域
+        # Model selection and chart area
         gr.HTML("<br>")
-        gr.Markdown("## 📊 特定维度对比")
+        gr.Markdown("## 📊 Specific Dimension Comparison")
         with gr.Row():
             with gr.Column(scale=4):
                 model_selector = gr.Dropdown(
                     choices=[],
-                    label="选择模型",
+                    label="Select Models",
                     value=[],
                     multiselect=True,
                     interactive=True
                 )
             with gr.Column(scale=1):
-                update_charts_btn = gr.Button("更新图表", variant="primary", size="lg")
+                update_charts_btn = gr.Button("Update Charts", variant="primary", size="lg")
         
         with gr.Tabs():
-            with gr.TabItem("语言维度"):
-                language_plot = gr.Plot()
+            with gr.TabItem("Language"):
+                language_plot = gr.Plot(show_label=False)
             
-            with gr.TabItem("难度维度"):
-                difficulty_plot = gr.Plot()
+            with gr.TabItem("Difficulty"):
+                difficulty_plot = gr.Plot(show_label=False)
             
-            with gr.TabItem("长度维度"):
-                length_heatmap = gr.Plot()
+            with gr.TabItem("Sample Length"):
+                length_heatmap = gr.Plot(show_label=False)
             
-            with gr.TabItem("主要任务维度"):
-                primary_task_radar_plot = gr.Plot()
+            with gr.TabItem("Primary Task"):
+                primary_task_radar_plot = gr.Plot(show_label=False)
             
-            with gr.TabItem("上下文需求维度"):
-                contextual_plot = gr.Plot()
+            with gr.TabItem("Context Requirement"):
+                contextual_plot = gr.Plot(show_label=False)
             
-            with gr.TabItem("BoN维度"):
-                bon_plot = gr.Plot()
+            with gr.TabItem("Best-of-N"):
+                bon_plot = gr.Plot(show_label=False)
             
-            with gr.TabItem("Pass@N维度"):
-                pass_k_plot = gr.Plot()
+            with gr.TabItem("Pass@N"):
+                pass_k_plot = gr.Plot(show_label=False)
             
-        # 增加底部空白区域，确保下拉框有足够空间向下展开，而不是因为底部空间不足而向上展开
+        # Add bottom spacer
         gr.HTML("<div style='height: 100px;'></div>")
         
-        # 事件处理
+        # Event handling
         def update_model_choices():
             models = get_model_choices()
             return gr.Dropdown(choices=models, value=[])
@@ -849,7 +854,7 @@ def create_gradio_interface(parser: ResultParser):
             outputs=[length_heatmap, contextual_plot, primary_task_radar_plot, language_plot, difficulty_plot, bon_plot, pass_k_plot]
         )
         
-        # 初始化 - 页面加载时自动刷新数据
+        # Initialize
         demo.load(
             fn=refresh_data,
             outputs=[leaderboard_df]
@@ -861,19 +866,19 @@ def create_gradio_interface(parser: ResultParser):
     return demo
 
 def main():
-    """主函数"""
+    """Main function"""
     output_dir = "./results"
     
-    print("初始化结果解析器...")
+    print("Initializing result parser...")
     parser = ResultParser(output_dir)
     
-    print("扫描结果文件...")
+    print("Scanning result files...")
     parser.scan_all_results()
     
-    print("创建Gradio界面...")
+    print("Creating Gradio interface...")
     demo = create_gradio_interface(parser)
     
-    print("启动服务器...")
+    print("Starting server...")
     demo.launch()
 
 if __name__ == "__main__":