Update app.py

app.py

@@ -159,109 +159,16 @@ def init_space_storage() -> None:
 
 init_space_storage()
 
-# Movie-Level 指标定义
+# Movie-Level 指标定义（仅保留六个聚合指标）
 MOVIE_CRITERIA: List[Tuple[str, str, str]] = [
-    ("SF", "剧本忠实度", "生成的视觉内容与原始剧本描述的吻合程度。"),
-    ("NC", "叙事连贯性", "镜头间情节发展的逻辑性，确保故事表达清晰、不破碎。"),
-    ("VQ", "视觉质量", "画面的清晰度、噪点控制、光影效果等基础图像质量。"),
-    ("CC", "角色一致性", "同一角色在不同镜头、不同角度下的外貌、服装及特征的稳定性。"),
-    ("PLC", "物理规律符合度", "运动、重力、碰撞等是否符合现实物理逻辑，是否存在严重 AI 幻觉。"),
-    ("V_AQ", "语音/音频质量", "配音、背景音乐和音效的清晰度、自然度及技术品质。"),
-    ("CT", "电影技巧", "镜头运动、景深控制及构图的专业性。"),
-    ("AVR", "视听丰富度", "画面细节精细度以及音频层次（音效、氛围音）的丰富程度。"),
-    ("NP", "叙事节奏", "镜头剪辑长短切换是否契合故事情节张力需求。"),
-    ("VAC", "视听协调性", "画面动作与音效、音乐卡点的同步率。"),
-    ("CD", "引人入胜程度", "吸引注意力并引发情感共鸣或沉浸感的能力。"),
-    ("OQ", "整体质量", "对生成视频作为“电影作品”的综合观感评分。"),
+    ("NS", "叙事与剧本", "剧情忠实且连贯"),
+    ("AT", "视听与技术", "画音质量与一致性"),
+    ("AE", "美学与表现力", "镜头语言与风格层次"),
+    ("RF", "节奏与流动性", "叙事节奏与音画衔接"),
+    ("EE", "情感与参与度", "情绪感染与沉浸感"),
+    ("OE", "整体体验", "整体观感与完成度"),
 ]
 
-METRIC_SCORING_STANDARDS: Dict[str, str] = {
-    "SF": (
-        "- **1分：严重偏离原始剧本**：>= 50% 的关键场景缺失或被替换，两个及以上主要角色属性被改动，且有三个及以上情节与原作矛盾。\n"
-        "- **2分：部分遵循原始剧本**：保留的关键场景少于 50%，角色设定有 1-2 处重大不一致，且至少两处偏离核心剧情事件。\n"
-        "- **3分：总体遵循原始剧本**：>= 70% 的关键场景被保留，角色设定基本一致，仅有不影响主线的次要偏差。\n"
-        "- **4分：高度忠实原始剧本**：>= 90% 的关键场景被准确呈现，主要角色设定均被保留，仅有轻微删减且不构成剧情冲突。\n"
-        "- **5分：完全忠实原始剧本**：所有关键场景、角色设定与相关细节均正确复现，无可检测偏差。"
-    ),
-    "NC": (
-        "- **1分：叙事混乱无序**：存在 >= 3 个重大逻辑问题（如因果错误、时间矛盾、角色行为前后冲突、剧情断裂），导致无法连贯理解。\n"
-        "- **2分：基本可懂但缺陷明显**：有 >= 2 处清晰逻辑断点或过渡缺失，明显破坏叙事逻辑。\n"
-        "- **3分：总体连贯**：主线清晰，可能有 1 处轻微逻辑不足（如动机铺垫偏弱），但不影响整体理解。\n"
-        "- **4分：流畅连贯**：情节推进自然，因果关系清楚，仅有可忽略的逻辑瑕疵。\n"
-        "- **5分：完全连贯**：剧情发展自然且论证充分，无逻辑漏洞，所有因果关系清晰明确。"
-    ),
-    "VQ": (
-        "- **1分：画面严重损坏**：出现多个关键失败（>= 3），如目标缺失、严重畸变、破帧，关键元素难以识别。\n"
-        "- **2分：明显视觉缺陷**：至少两处场景存在元素缺失或畸变，伪影明显干扰观看。\n"
-        "- **3分：画面基本完整**：核心元素齐全，偶发轻微错误或短暂伪影，不影响理解。\n"
-        "- **4分：画面清晰完整**：仅有极少轻微瑕疵，无明显缺失或严重畸变。\n"
-        "- **5分：画面无可挑剔**：所有元素始终正确呈现，无可见畸变或伪影。"
-    ),
-    "CC": (
-        "- **1分：角色设计严重不一致**：跨场景有 >= 2 项主要外观属性（如脸型、发型、服饰）变化，同一角色可能像不同人。\n"
-        "- **2分：角色波动明显**：多个场景中角色特征变化明显，虽可辨认身份但一致性较差。\n"
-        "- **3分：角色总体一致**：外观基本稳定，仅在仔细观察时可见少量轻微不一致。\n"
-        "- **4分：角色高度一致**：几乎所有场景与角度下特征稳定，个别差异可忽略。\n"
-        "- **5分：角色完全一致**：所有场景与动作下角色特征精准保持，无可见波动。"
-    ),
-    "PLC": (
-        "- **1分：严重违反物理规律**：存在 >= 3 处极端违背（不可能运动、重力错误、碰撞失真），真实感崩坏。\n"
-        "- **2分：多处违反物理规律**：至少两处明显物理错误，动作或效果显著不真实。\n"
-        "- **3分：总体符合物理规��**：大多数运动符合预期，部分动作稍显生硬但可接受。\n"
-        "- **4分：物理符合度较好**：运动自然、交互可信，仅有极少偏差。\n"
-        "- **5分：物理完全符合**：运动、碰撞与效果均符合现实规律，无异常。"
-    ),
-    "V_AQ": (
-        "- **1分：音频极差**：人声不清或缺失，音效混乱或严重失真，影响内容理解。\n"
-        "- **2分：音频较差**：人声偶尔不清晰，音效较少或同步较差，明显低于可用标准。\n"
-        "- **3分：音频中等**：人声总体清楚，音效匹配基本合适，但精细度一般。\n"
-        "- **4分：音频良好**：人声清晰、混音良好，音效丰富且有效支撑场景。\n"
-        "- **5分：音频优秀**：人声清晰且富有表现力，声音设计细腻、同步精准，无明显缺陷。"
-    ),
-    "CT": (
-        "- **1分：镜头单一僵硬**：构图与景别重复、静止，几乎无目的性电影语言。\n"
-        "- **2分：镜头变化有限**：有少量镜头类型但运镜生硬，电影语言使用不稳定或效果弱。\n"
-        "- **3分：常见技巧使用尚可**：近景/中景/远景等基本镜头具备，运镜总体平稳但风格不突出。\n"
-        "- **4分：电影语言丰富**：镜头类型多样且有意图，运镜自然并能增强叙事或情绪。\n"
-        "- **5分：技巧高度创造且精准**：镜头设计丰富有创意，运镜控制精准，电影语言表达力强且目的明确。"
-    ),
-    "AVR": (
-        "- **1分：视听表达极其有限**：视觉与声音元素单调重复，变化和层次极少。\n"
-        "- **2分：表达基础且程式化**：虽有表达尝试，但形式简单可预测，风格多样性不足。\n"
-        "- **3分：多样性中等**：部分场景在风格或节奏上有变化，但整体丰富度不均衡、统一性不足。\n"
-        "- **4分：视听表达较强**：多种技法协同，形成层次、情绪转折或风格细节。\n"
-        "- **5分：视听语言极其丰富**：声音与画面运用多样且富创造力，形成鲜明艺术风格并带来强叙事/情感冲击。"
-    ),
-    "NP": (
-        "- **1分：节奏完全失控**：出现 >= 3 处极端问题（突兀跳切、过长停滞、关键事件过快），严重影响理解。\n"
-        "- **2分：节奏明显不稳**：至少两处明显节奏失衡（过赶或拖沓），破坏整体韵律。\n"
-        "- **3分：节奏总体合适**：推进基本合理，个别场景略快/略慢但不影响理解。\n"
-        "- **4分：节奏控制良好**：时长与转场自然，张弛平衡较佳。\n"
-        "- **5分：节奏控制精准**：时间分配有明确意图，显著增强情绪张力与叙事清晰度，快慢切换顺畅。"
-    ),
-    "VAC": (
-        "- **1分：视听严重不同步**：持续音画错位，多次口型偏差（多帧）与声画动作不匹配，显著影响观看。\n"
-        "- **2分：同步问题明显**：反复出现口型或时间点错位，语音与画面配合较差。\n"
-        "- **3分：基本同步**：大多数片段音画对齐，偶有轻微错位但不妨碍观看。\n"
-        "- **4分：协调性良好**：语音、音效与画面整体匹配，错误较少且影响很小。\n"
-        "- **5分：完美同步**：所有声音元素与画面动作、口型精准对应，整体体验和谐。"
-    ),
-    "CD": (
-        "- **1分：毫无吸引力**：难以让观众沉浸或产生情感连接，内容缺乏参与感。\n"
-        "- **2分：吸引力不足**：情绪表达较弱，难以持续抓住观众注意力。\n"
-        "- **3分：有基础吸引力**：能引发一定兴趣，但情感深度不足，难形成强共鸣。\n"
-        "- **4分：吸引力较强**：情绪表达有效，能产生明确情绪反应并维持观看兴趣。\n"
-        "- **5分：极具感染力**：情绪张力与参与度很强，观众高度沉浸并产生强烈共鸣。"
-    ),
-    "OQ": (
-        "- **1分：整体质量极差**：>= 3 个核心维度严重不足，明显影响理解与观看价值。\n"
-        "- **2分：整体质量较差**：至少两个主要维度低于可接受标准，观看价值有限。\n"
-        "- **3分：整体质量中等**：多数维度达到一般或可接受水平，优缺点相对平衡，具备基础观看价值。\n"
-        "- **4分：整体质量良好**：大部分维度表现到位且协同较好，仅有少量问题，观看价值较高。\n"
-        "- **5分：整体质量优秀**：主要维度均高水平发挥，表现稳定、协调且具艺术性，观看与审美价值很高。"
-    ),
-}
-
 BASE_METRIC_KEYS = [k for k, _, _ in MOVIE_CRITERIA]
 SAVE_LOCK = threading.Lock()
 
@@ -470,25 +377,48 @@ def sync_results_from_hub_to_local() -> None:
 
 
 def build_pending_samples() -> List[Dict[str, Any]]:
-    """构建样本池（直接读取 input），并分配匿名ID。"""
+    """构建对比样本池：同一 story 下不同方法两两配对。"""
     all_samples = load_dataset_index()
-    pending = all_samples
-
-    # 按“随机方法 -> 方法内随机 story”组织顺序
-    by_method: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
-    for sample in pending:
-        by_method[sample["method"]].append(sample)
-    methods = list(by_method.keys())
-    random.shuffle(methods)
-
-    randomized_pending: List[Dict[str, Any]] = []
-    for method in methods:
-        method_samples = by_method[method]
-        random.shuffle(method_samples)
-        randomized_pending.extend(method_samples)
-
-    pending = randomized_pending
+    by_story: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+    for sample in all_samples:
+        by_story[sample["story_name"]].append(sample)
+
+    pending: List[Dict[str, Any]] = []
+    for story_name, story_samples in by_story.items():
+        # 同一 story 至少两个方法才能做 A/B 对比
+        if len(story_samples) < 2:
+            continue
+        story_samples = sorted(story_samples, key=lambda x: x["method"])
+        for i in range(len(story_samples)):
+            for j in range(i + 1, len(story_samples)):
+                first = story_samples[i]
+                second = story_samples[j]
+                # 随机左右位，降低固定左右带来的偏置
+                if random.random() < 0.5:
+                    a_sample, b_sample = first, second
+                else:
+                    a_sample, b_sample = second, first
+                pending.append(
+                    {
+                        "pair_id": f"{story_name}__{first['method']}_vs_{second['method']}",
+                        "story_name": story_name,
+                        "story_text": first.get("story_text", "") or second.get("story_text", ""),
+                        "A": {
+                            "method": a_sample["method"],
+                            "video_name": a_sample["video_name"],
+                            "video_path": a_sample["video_path"],
+                            "sample_id": a_sample["sample_id"],
+                        },
+                        "B": {
+                            "method": b_sample["method"],
+                            "video_name": b_sample["video_name"],
+                            "video_path": b_sample["video_path"],
+                            "sample_id": b_sample["sample_id"],
+                        },
+                    }
+                )
 
+    random.shuffle(pending)
     for i, sample in enumerate(pending, start=1):
         sample["anon_id"] = f"id_{i:03d}"
     return pending
@@ -508,37 +438,41 @@ def build_data_diagnostics(samples: List[Dict[str, Any]]) -> str:
 
 
 def compute_derived(scores: Dict[str, float]) -> Dict[str, float]:
-    """计算 CL / CRh / AVG。"""
-    cl = (
-        (scores["SF"] + scores["NC"] + scores["VQ"] + scores["CC"] + scores["PLC"]) / 5.0
-        + 0.5 * ((scores["CT"] + scores["AVR"]) / 2.0)
-    )
-    crh = (
-        (scores["V_AQ"] + scores["NP"] + scores["VAC"] + scores["CD"] + scores["OQ"]) / 5.0
-        + 0.5 * ((scores["CT"] + scores["AVR"]) / 2.0)
-    )
-    avg = sum(scores[k] for k in BASE_METRIC_KEYS) / len(BASE_METRIC_KEYS)
-    return {"CL": cl, "CRh": crh, "AVG": avg}
-
-
-def save_single_result(sample: Dict[str, Any], evaluator_id: str, scores: Dict[str, int], reasons: Dict[str, str], summary: str) -> Path:
-    """保存单个问卷结果。"""
+    """计算 CL / CRH / AVG。"""
+    cl = ((2 * scores["NS"] + 3 * scores["AT"]) / 5.0) + 0.5 * scores["AE"]
+    crh = ((scores["AT"] + 2 * scores["RF"] + scores["EE"] + scores["OE"]) / 5.0) + 0.5 * scores["AE"]
+    avg = (
+        2 * scores["NS"]
+        + 4 * scores["AT"]
+        + 2 * scores["AE"]
+        + 2 * scores["RF"]
+        + scores["EE"]
+        + scores["OE"]
+    ) / 12.0
+    return {"CL": cl, "CRH": crh, "AVG": avg}
+
+
+def save_single_result(
+    sample: Dict[str, Any],
+    evaluator_id: str,
+    metric_choice: Dict[str, str],
+    method_scores: Dict[str, Dict[str, float]],
+    summary: str,
+) -> Path:
+    """保存单个 A/B 对比问卷结果。"""
     ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    result_dir = OUTPUT_DIR / "raw_results" / sample["method"] / sample["story_name"]
+    result_dir = OUTPUT_DIR / "raw_results" / sample["story_name"]
     result_dir.mkdir(parents=True, exist_ok=True)
-    out_path = result_dir / f"{sample['video_name'].replace('.mp4', '')}_{evaluator_id}_{ts}.json"
-
-    score_float = {k: float(v) for k, v in scores.items()}
-    derived = compute_derived(score_float)
+    out_path = result_dir / f"{sample['pair_id']}_{evaluator_id}_{ts}.json"
 
     payload = {
         "timestamp": datetime.now().isoformat(),
         "evaluator_id": evaluator_id,
-        "sample": sample,
-        "scores": scores,
-        "reasons": reasons,
+        "pair": sample,
+        "metric_choice": metric_choice,
+        "method_scores": method_scores,
+        "method_derived": {m: compute_derived(v) for m, v in method_scores.items()},
         "summary": summary,
-        "derived": derived,
     }
     with open(out_path, "w", encoding="utf-8") as f:
         json.dump(payload, f, ensure_ascii=False, indent=2)
@@ -548,7 +482,7 @@ def save_single_result(sample: Dict[str, Any], evaluator_id: str, scores: Dict[s
 def recompute_method_aggregates() -> Path:
     """
     统计每个方法各维度均分，并输出 method_aggregates.json。
-    同时给出 CL/CRh/AVG 的方法均值。
+    同时给出 CL/CRH/AVG 的方法均值。
     """
     raw_root = OUTPUT_DIR / "raw_results"
     method_scores: Dict[str, Dict[str, List[float]]] = defaultdict(lambda: defaultdict(list))
@@ -558,23 +492,21 @@ def recompute_method_aggregates() -> Path:
         for fp in raw_root.rglob("*.json"):
             with open(fp, "r", encoding="utf-8-sig") as f:
                 data = json.load(f)
-            method = data.get("sample", {}).get("method", "UNKNOWN")
-            scores = data.get("scores", {})
-            if not all(k in scores for k in BASE_METRIC_KEYS):
-                continue
-            method_count[method] += 1
-            for k in BASE_METRIC_KEYS:
-                method_scores[method][k].append(float(scores[k]))
-
-            # 衍生指标也参与方法均值统计
-            derived = compute_derived({k: float(scores[k]) for k in BASE_METRIC_KEYS})
-            for d_key, d_val in derived.items():
-                method_scores[method][d_key].append(float(d_val))
+            pair_method_scores = data.get("method_scores", {})
+            for method, scores in pair_method_scores.items():
+                if not all(k in scores for k in BASE_METRIC_KEYS):
+                    continue
+                method_count[method] += 1
+                for k in BASE_METRIC_KEYS:
+                    method_scores[method][k].append(float(scores[k]))
+                derived = compute_derived({k: float(scores[k]) for k in BASE_METRIC_KEYS})
+                for d_key, d_val in derived.items():
+                    method_scores[method][d_key].append(float(d_val))
 
     agg = {
         "updated_at": datetime.now().isoformat(),
         "metric_keys": BASE_METRIC_KEYS,
-        "derived_keys": ["CL", "CRh", "AVG"],
+            "derived_keys": ["CL", "CRH", "AVG"],
         "methods": {},
     }
     for method in sorted(method_scores.keys()):
@@ -629,8 +561,11 @@ def push_result_files_to_hub(single_path: Path, agg_path: Path) -> Optional[str]
 def build_sample_brief_html(sample: Dict[str, Any], index: int, total: int) -> str:
     story = sample.get("story_text") or "(未找到对应 story 文本，请检查 clip_movie_story 下是否有同名 txt)"
     safe_story = html.escape(story)
+    a_method = html.escape(sample.get("A", {}).get("method", ""))
+    b_method = html.escape(sample.get("B", {}).get("method", ""))
     return (
         "<div class='sample-card'>"
+        f"<div class='sid'>对比 {index + 1}/{total} · A: {a_method} · B: {b_method}</div>"
         "<div class='story-title'>剧情描述</div>"
         f"<p class='story-body'>{safe_story}</p>"
         "</div>"
@@ -649,7 +584,7 @@ def create_app():
             """
             <div id="hero">
                 <h1>VideoEval · Movie-Level Evaluation</h1>
-                <p>统一电影级评测问卷，支持方法级均分统计（含 CL / CRh / AVG）</p>
+                <p>统一电影级评测问卷，支持方法级均分统计（含 CL / CRH / AVG）</p>
             </div>
             """
         )
@@ -660,24 +595,26 @@ def create_app():
         with gr.Row():
             with gr.Column(elem_classes=["panel", "center-panel"]):
                 gr.HTML("<div class='section-head' style='text-align:center;'>1) 视频与剧情</div>")
-                movie_video = gr.Video(label="Movie Video", value=samples[0]["video_path"] if samples else None, height=460)
+                with gr.Row():
+                    video_a = gr.Video(label="A", value=samples[0]["A"]["video_path"] if samples else None, height=360)
+                    video_b = gr.Video(label="B", value=samples[0]["B"]["video_path"] if samples else None, height=360)
                 sample_info = gr.HTML(
                     "<div class='sample-card'><p class='story-body'>无可用样本</p></div>"
                     if not samples else build_sample_brief_html(samples[0], 0, len(samples))
                 )
 
         status = gr.Markdown("")
-        gr.Markdown("## 2) 评分（1-5）")
-        gr.Markdown("<span class='hint'>请先完成 1-5 分评分，未打分无法提交。</span>")
+        gr.Markdown("## 2) 对比评分（A好 / B好 / 平手）")
+        gr.Markdown("<span class='hint'>每项都必须选择，A好= A得1/B得0，B好反之，平手各0.5。</span>")
 
         score_widgets: Dict[str, gr.Radio] = {}
         metric_groups = {
-            "I. 叙事与剧本 (NS)": ["SF", "NC"],
-            "II. 视听与技术 (AT)": ["VQ", "CC", "PLC", "V_AQ"],
-            "III. 美学与表现力 (AE)": ["CT", "AVR"],
-            "IV. 节奏与流动性 (RF)": ["NP", "VAC"],
-            "V. 情感与参与度 (EE)": ["CD"],
-            "VI. 整体体验 (OE)": ["OQ"],
+            "I. 叙事与剧本 (NS)": ["NS"],
+            "II. 视听与技术 (AT)": ["AT"],
+            "III. 美学与表现力 (AE)": ["AE"],
+            "IV. 节奏与流动性 (RF)": ["RF"],
+            "V. 情感与参与度 (EE)": ["EE"],
+            "VI. 整体体验 (OE)": ["OE"],
         }
         criteria_map = {k: (name, desc) for k, name, desc in MOVIE_CRITERIA}
 
@@ -688,11 +625,9 @@ def create_app():
                     with gr.Group(elem_classes=["metric-card"]):
                         gr.Markdown(f"**{key} · {name}**")
                         gr.Markdown(f"<span class='hint'>{desc}</span>")
-                        with gr.Accordion("评分标准（点击展开）", open=False):
-                            gr.Markdown(METRIC_SCORING_STANDARDS[key])
-                        score_widgets[key] = gr.Radio(choices=[1, 2, 3, 4, 5], label=f"{key} Score")
+                        score_widgets[key] = gr.Radio(choices=["A好", "B好", "平手"], label=f"{key} Winner")
 
-        final_summary = gr.Textbox(label="Final Summary（可选）", lines=4, placeholder="总结该视频的主要优缺点")
+        final_summary = gr.Textbox(label="Final Summary（可选）", lines=4, placeholder="总结 A/B 的主要优缺点")
         submit_btn = gr.Button("提交", variant="primary", elem_id="submit-btn")
 
         def _submit(summary: str, curr_samples: List[Dict[str, Any]], *score_vals):
@@ -704,40 +639,46 @@ def create_app():
             sample = curr_samples[0]
             evaluator_id = "anonymous"
 
-            scores: Dict[str, int] = {}
-            reasons: Dict[str, str] = {}
+            a_method = sample["A"]["method"]
+            b_method = sample["B"]["method"]
+            method_scores: Dict[str, Dict[str, float]] = {
+                a_method: {k: 0.0 for k in BASE_METRIC_KEYS},
+                b_method: {k: 0.0 for k in BASE_METRIC_KEYS},
+            }
+            metric_choice: Dict[str, str] = {}
             for i, key in enumerate(BASE_METRIC_KEYS):
                 raw_score = score_vals[i] if i < len(score_vals) else None
 
-                # 兼容不同前端/版本返回：None / "" / "None" / [] / 0 等均视为“未打分”
-                if raw_score in (None, "", [], 0):
+                if raw_score in (None, "", []):
                     msg = f"❌ 请为 `{key}` 打分。"
                     gr.Warning(msg)
                     return "", False
-                if isinstance(raw_score, str) and raw_score.strip().lower() in {"none", "null", "[]", "0"}:
+                if isinstance(raw_score, str) and raw_score.strip().lower() in {"none", "null", "[]"}:
                     msg = f"❌ 请为 `{key}` 打分。"
                     gr.Warning(msg)
                     return "", False
 
-                try:
-                    score = int(raw_score)
-                except (TypeError, ValueError):
-                    msg = f"❌ `{key}` 的评分无效，请重新选择 1-5 分。"
+                choice = str(raw_score).strip()
+                if choice not in {"A好", "B好", "平手"}:
+                    msg = f"❌ `{key}` 的选择无效，请重新选择 A好/B好/平手。"
                     gr.Warning(msg)
                     return msg, False
 
-                if score < 1 or score > 5:
-                    msg = f"❌ `{key}` 的评分无效，请重新选择 1-5 分。"
-                    gr.Warning(msg)
-                    return msg, False
-
-                scores[key] = score
-                reasons[key] = ""
+                metric_choice[key] = choice
+                if choice == "A好":
+                    method_scores[a_method][key] = 1.0
+                    method_scores[b_method][key] = 0.0
+                elif choice == "B好":
+                    method_scores[a_method][key] = 0.0
+                    method_scores[b_method][key] = 1.0
+                else:
+                    method_scores[a_method][key] = 0.5
+                    method_scores[b_method][key] = 0.5
 
             with SAVE_LOCK:
                 # 同步远程最新结果，确保“允许重复提交”后平均分统计包含全量提交。
                 sync_results_from_hub_to_local()
-                single_path = save_single_result(sample, evaluator_id, scores, reasons, summary or "")
+                single_path = save_single_result(sample, evaluator_id, metric_choice, method_scores, summary or "")
                 agg_path = recompute_method_aggregates()
                 push_err = push_result_files_to_hub(single_path, agg_path)
 
@@ -749,34 +690,47 @@ def create_app():
             _ = (single_path, agg_path)
             return "", True
 
-        def _refresh_on_load() -> Tuple[Any, str, str, List[Dict[str, Any]]]:
+        def _refresh_on_load() -> Tuple[Any, Any, str, str, List[Dict[str, Any]]]:
             refreshed_samples = build_pending_samples()
             if not refreshed_samples:
-                return None, "<div class='sample-card'><p class='story-body'>无可用样本（可能都已评估）</p></div>", "", refreshed_samples
+                return None, None, "<div class='sample-card'><p class='story-body'>无可用样本（需要同剧情下至少两个方法）</p></div>", "", refreshed_samples
 
             first = refreshed_samples[0]
-            return first["video_path"], build_sample_brief_html(first, 0, len(refreshed_samples)), "", refreshed_samples
+            return (
+                first["A"]["video_path"],
+                first["B"]["video_path"],
+                build_sample_brief_html(first, 0, len(refreshed_samples)),
+                "",
+                refreshed_samples,
+            )
 
         def _refresh_after_submit(
             submit_ok: bool,
             submit_msg: str,
-            curr_video: Any,
+            curr_video_a: Any,
+            curr_video_b: Any,
             curr_info: str,
             curr_samples: List[Dict[str, Any]],
-        ) -> Tuple[Any, str, str, List[Dict[str, Any]]]:
+        ) -> Tuple[Any, Any, str, str, List[Dict[str, Any]]]:
             submit_msg = (submit_msg or "").strip()
             # 提交失败时，不刷新样本/故事，保持当前页面不变
             if not submit_ok:
-                return curr_video, curr_info, submit_msg, curr_samples
+                return curr_video_a, curr_video_b, curr_info, submit_msg, curr_samples
 
             refreshed_samples = build_pending_samples()
             if not refreshed_samples:
                 status_msg = submit_msg
-                return None, "<div class='sample-card'><p class='story-body'>无可用样本（可能都已评估）</p></div>", status_msg, refreshed_samples
+                return None, None, "<div class='sample-card'><p class='story-body'>无可用样本（需要同剧情下至少两个方法）</p></div>", status_msg, refreshed_samples
 
             first = refreshed_samples[0]
             status_msg = submit_msg
-            return first["video_path"], build_sample_brief_html(first, 0, len(refreshed_samples)), status_msg, refreshed_samples
+            return (
+                first["A"]["video_path"],
+                first["B"]["video_path"],
+                build_sample_brief_html(first, 0, len(refreshed_samples)),
+                status_msg,
+                refreshed_samples,
+            )
 
         def _clear_scores_after_submit(submit_ok: bool) -> Tuple[Any, ...]:
             # 提交失败时不清空输入，便于用户补充后重提
@@ -801,13 +755,13 @@ def create_app():
         )
         submit_evt.then(
             _refresh_after_submit,
-            inputs=[submit_ok_state, status, movie_video, sample_info, samples_state],
-            outputs=[movie_video, sample_info, status, samples_state],
+            inputs=[submit_ok_state, status, video_a, video_b, sample_info, samples_state],
+            outputs=[video_a, video_b, sample_info, status, samples_state],
         )
 
         app.load(
             _refresh_on_load,
-            outputs=[movie_video, sample_info, status, samples_state],
+            outputs=[video_a, video_b, sample_info, status, samples_state],
         )
 
     return app