Update UI

README.md

@@ -10,3 +10,36 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+## ASR LLM Agent Upgrade
+
+This version adds an LLM-based diagnosis layer on top of alignment/event statistics:
+
+- `analysis/llm_analyzer.py`: sends representative ASR error cases + aggregate stats to an LLM
+- `pipeline/run_analysis.py`: optionally runs LLM diagnosis when `OPENAI_API_KEY` is set
+- `scripts/run_diagnostic.py`: regenerate `llm_diagnosis.json` and `diagnostic_report.md`
+- `report.md`: now includes LLM semantic findings and priority actions
+
+### What the LLM adds
+
+Compared with rule-only classification, the LLM layer can:
+
+- separate surface-form differences from true semantic distortions
+- identify meaning-preserving paraphrases vs business-critical errors
+- infer likely causes from representative cases
+- propose prioritized, actionable improvement suggestions
+
+### Quick start
+
+```bash
+export OPENAI_API_KEY=your_key
+python pipeline/run_all.py   --manifest data/manifest.jsonl   --model_name openai/whisper-small   --llm_model gpt-4.1-mini
+```
+
+Or rerun diagnosis only for an existing run:
+
+```bash
+export OPENAI_API_KEY=your_key
+python scripts/run_diagnostic.py --run_id <run_id> --model gpt-4.1-mini
+```

analysis/llm_analyzer.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from openai import OpenAI
+
+
+SEMANTIC_SCHEMA_EXAMPLE = {
+    "utt_id": "string",
+    "semantic_judgement": "语义基本等价|轻微偏差|明显偏差|严重失真",
+    "severity": "high|medium|low",
+    "semantic_error_types": ["string"],
+    "business_impact": "high|medium|low",
+    "reason": "string",
+    "improvement_suggestions": ["string"],
+    "confidence": 0.0,
+}
+
+
+def _safe_float(v: Any) -> Optional[float]:
+    try:
+        if v is None:
+            return None
+        return float(v)
+    except Exception:
+        return None
+
+
+def build_case_pack(df_align: pd.DataFrame, df_events: pd.DataFrame, max_cases: int = 24) -> List[Dict[str, Any]]:
+    if df_align is None or len(df_align) == 0:
+        return []
+
+    align = df_align.copy()
+    if "cer" not in align.columns:
+        align["cer"] = None
+    if "wer" not in align.columns:
+        align["wer"] = None
+
+    sort_cols = [c for c in ["cer", "wer"] if c in align.columns]
+    if sort_cols:
+        align = align.sort_values(sort_cols, ascending=False, na_position="last")
+
+    cases: List[Dict[str, Any]] = []
+    seen = set()
+
+    def _event_summary(utt_id: str) -> Dict[str, Any]:
+        if df_events is None or len(df_events) == 0 or "utt_id" not in df_events.columns:
+            return {"error_classes": {}, "ops": {}, "examples": []}
+        x = df_events[df_events["utt_id"] == utt_id].copy()
+        if len(x) == 0:
+            return {"error_classes": {}, "ops": {}, "examples": []}
+        examples = []
+        for _, row in x.head(10).iterrows():
+            examples.append({
+                "level": row.get("level"),
+                "op_type": row.get("op_type"),
+                "ref": row.get("ref"),
+                "hyp": row.get("hyp"),
+                "error_class": row.get("error_class"),
+            })
+        return {
+            "error_classes": {str(k): int(v) for k, v in x["error_class"].value_counts().head(10).to_dict().items()} if "error_class" in x.columns else {},
+            "ops": {str(k): int(v) for k, v in x["op_type"].value_counts().to_dict().items()} if "op_type" in x.columns else {},
+            "examples": examples,
+        }
+
+    for _, row in align.head(max_cases).iterrows():
+        utt_id = str(row.get("utt_id"))
+        if utt_id in seen:
+            continue
+        seen.add(utt_id)
+        meta = {k: row.get(k) for k in ["device", "domain", "accent", "speaker"] if k in row.index and pd.notna(row.get(k))}
+        cases.append({
+            "utt_id": utt_id,
+            "ref_text": row.get("ref_text"),
+            "hyp_text": row.get("hyp_text"),
+            "norm_ref": row.get("norm_ref"),
+            "norm_hyp": row.get("norm_hyp"),
+            "wer": _safe_float(row.get("wer")),
+            "cer": _safe_float(row.get("cer")),
+            "meta": meta,
+            "event_summary": _event_summary(utt_id),
+        })
+        if len(cases) >= max_cases:
+            break
+
+    return cases
+
+
+def build_global_stats(df_align: pd.DataFrame, df_events: pd.DataFrame, summary: Dict[str, Any]) -> Dict[str, Any]:
+    stats: Dict[str, Any] = {
+        "summary": summary,
+        "num_utterances": int(len(df_align)) if df_align is not None else 0,
+        "num_events": int(len(df_events)) if df_events is not None else 0,
+    }
+    if df_events is not None and len(df_events) > 0:
+        if "op_type" in df_events.columns:
+            stats["op_counts"] = {str(k): int(v) for k, v in df_events["op_type"].value_counts().to_dict().items()}
+        if "error_class" in df_events.columns:
+            stats["error_class_counts"] = {str(k): int(v) for k, v in df_events["error_class"].value_counts().head(20).to_dict().items()}
+
+    slice_stats = {}
+    if df_align is not None and len(df_align) > 0 and "cer" in df_align.columns:
+        for key in ["device", "domain", "accent", "speaker"]:
+            if key in df_align.columns and df_align[key].notna().any():
+                g = df_align.groupby(key)["cer"].mean().dropna().sort_values(ascending=False).head(10)
+                if len(g) > 0:
+                    slice_stats[key] = [{"key": str(k), "cer": float(v)} for k, v in g.items()]
+    if slice_stats:
+        stats["slice_stats"] = slice_stats
+    return stats
+
+
+SYSTEM_PROMPT = """你是资深 ASR 诊断专家，同时具备语音识别、语言学和业务语义分析能力。
+你的任务不是只做 S/I/D 统计，而是识别：
+1. 结构性错误（替换、删除、插入、数字、英文、专名等）
+2. 语义层错误（是否改变原意、是否造成业务理解偏差、是否只是表面字词不同但语义基本等价）
+3. 可能成因（口音、同音混淆、领域词缺失、分段/VAD、噪声、数字口语化、语言模型偏置等）
+4. 可执行的改进建议
+
+必须严格基于输入证据，不要编造音频层信息。若证据不足，明确写“不确定”���
+请输出严格 JSON。"""
+
+
+def _extract_json(text: str) -> Dict[str, Any]:
+    text = text.strip()
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    start = text.find("{")
+    end = text.rfind("}")
+    if start >= 0 and end > start:
+        return json.loads(text[start:end + 1])
+    raise ValueError("LLM output is not valid JSON")
+
+
+def analyze_with_llm(
+    df_align: pd.DataFrame,
+    df_events: pd.DataFrame,
+    summary: Dict[str, Any],
+    model: str = "gpt-4.1-mini",
+    client: Optional[OpenAI] = None,
+    max_cases: int = 24,
+) -> Dict[str, Any]:
+    client = client or OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+    case_pack = build_case_pack(df_align, df_events, max_cases=max_cases)
+    global_stats = build_global_stats(df_align, df_events, summary)
+
+    user_prompt = {
+        "task": "请对 ASR 结果做结构+语义联合诊断，并给出改进建议。",
+        "instructions": {
+            "output_schema": {
+                "executive_summary": "string",
+                "major_patterns": [
+                    {
+                        "title": "string",
+                        "priority": 1,
+                        "phenomenon": "string",
+                        "evidence": ["string"],
+                        "semantic_impact": "high|medium|low",
+                        "likely_causes": ["string"],
+                        "recommendations": ["string"],
+                        "confidence": 0.0,
+                    }
+                ],
+                "case_findings": [
+                    {
+                        "utt_id": "string",
+                        "semantic_judgement": "语义基本等价|轻微偏差|明显偏差|严重失真",
+                        "severity": "high|medium|low",
+                        "reason": "string",
+                        "semantic_error_types": ["string"],
+                        "suggestions": ["string"],
+                    }
+                ],
+                "priority_actions": ["string"],
+                "uncertainties": ["string"],
+            },
+            "requirements": [
+                "不要复述所有 case，只保留最有代表性的 findings。",
+                "要区分字符差异和真正改变语义的错误。",
+                "如果 ref/hyp 只是同义改写或口语差异，应该指出语义影响较低。",
+                "建议必须可执行，优先包含数据、解码、后处理、术语表、prompt/context、评测集扩展等方向。",
+            ],
+        },
+        "global_stats": global_stats,
+        "cases": case_pack,
+    }
+
+    resp = client.chat.completions.create(
+        model=model,
+        temperature=0.2,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": json.dumps(user_prompt, ensure_ascii=False)},
+        ],
+        response_format={"type": "json_object"},
+    )
+    raw = resp.choices[0].message.content or "{}"
+    parsed = _extract_json(raw)
+    parsed["model"] = model
+    parsed["num_cases_sent"] = len(case_pack)
+    parsed["global_stats"] = global_stats
+    return parsed
+
+
+def _build_semantic_rows(df_align: pd.DataFrame, df_events: pd.DataFrame) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    event_map: Dict[str, List[Dict[str, Any]]] = {}
+    if df_events is not None and len(df_events) > 0 and "utt_id" in df_events.columns:
+        for utt_id, sub in df_events.groupby("utt_id"):
+            examples = []
+            for _, row in sub.head(8).iterrows():
+                examples.append({
+                    "op_type": row.get("op_type"),
+                    "ref": row.get("ref"),
+                    "hyp": row.get("hyp"),
+                    "error_class": row.get("error_class"),
+                    "level": row.get("level"),
+                })
+            event_map[str(utt_id)] = examples
+
+    for _, row in df_align.iterrows():
+        utt_id = str(row.get("utt_id"))
+        meta = {k: row.get(k) for k in ["device", "domain", "accent", "speaker"] if k in row.index and pd.notna(row.get(k))}
+        rows.append({
+            "utt_id": utt_id,
+            "ref_text": row.get("ref_text"),
+            "hyp_text": row.get("hyp_text"),
+            "norm_ref": row.get("norm_ref"),
+            "norm_hyp": row.get("norm_hyp"),
+            "wer": _safe_float(row.get("wer")),
+            "cer": _safe_float(row.get("cer")),
+            "meta": meta,
+            "events": event_map.get(utt_id, []),
+        })
+    return rows
+
+
+def _normalize_semantic_item(item: Dict[str, Any], fallback: Dict[str, Any]) -> Dict[str, Any]:
+    semantic_types = item.get("semantic_error_types") or []
+    suggestions = item.get("improvement_suggestions") or item.get("suggestions") or []
+    return {
+        "utt_id": str(item.get("utt_id") or fallback.get("utt_id")),
+        "semantic_judgement": str(item.get("semantic_judgement") or "不确定"),
+        "severity": str(item.get("severity") or "low"),
+        "semantic_error_types": semantic_types if isinstance(semantic_types, list) else [str(semantic_types)],
+        "business_impact": str(item.get("business_impact") or "low"),
+        "reason": str(item.get("reason") or ""),
+        "improvement_suggestions": suggestions if isinstance(suggestions, list) else [str(suggestions)],
+        "confidence": _safe_float(item.get("confidence")) if item.get("confidence") is not None else None,
+        "ref_text": fallback.get("ref_text"),
+        "hyp_text": fallback.get("hyp_text"),
+        "wer": fallback.get("wer"),
+        "cer": fallback.get("cer"),
+        "device": (fallback.get("meta") or {}).get("device"),
+        "domain": (fallback.get("meta") or {}).get("domain"),
+        "accent": (fallback.get("meta") or {}).get("accent"),
+        "speaker": (fallback.get("meta") or {}).get("speaker"),
+    }
+
+
+def analyze_semantic_per_utterance(
+    df_align: pd.DataFrame,
+    df_events: pd.DataFrame,
+    model: str = "gpt-4.1-mini",
+    client: Optional[OpenAI] = None,
+    batch_size: int = 12,
+) -> pd.DataFrame:
+    client = client or OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    rows = _build_semantic_rows(df_align, df_events)
+    if not rows:
+        return pd.DataFrame()
+
+    results: List[Dict[str, Any]] = []
+    for start in range(0, len(rows), batch_size):
+        batch = rows[start:start + batch_size]
+        payload = {
+            "task": "逐条 utterance 做语义级错误判断。",
+            "requirements": [
+                "逐条判断 ref_text 与 hyp_text 的语义偏差程度。",
+                "不要因为表面字不同就判严重错误；如果基本不改变含义，应标注为语义基本等价或轻微偏差。",
+                "结合 events 判断数字、时间、专名、否定、实体、动作关系等关键语义是否出错。",
+                "输出必须覆盖 batch 中每个 utt_id，且仅输出 JSON 对象。",
+            ],
+            "output_schema": {"items": [SEMANTIC_SCHEMA_EXAMPLE]},
+            "items": batch,
+        }
+        resp = client.chat.completions.create(
+            model=model,
+            temperature=0,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": json.dumps(payload, ensure_ascii=False)},
+            ],
+            response_format={"type": "json_object"},
+        )
+        raw = resp.choices[0].message.content or "{}"
+        parsed = _extract_json(raw)
+        items = parsed.get("items") or []
+        by_id = {str(x.get("utt_id")): x for x in items if isinstance(x, dict)}
+        for fallback in batch:
+            item = by_id.get(str(fallback.get("utt_id")), {"utt_id": fallback.get("utt_id"), "semantic_judgement": "不确定", "reason": "LLM 未返回该条结果。"})
+            results.append(_normalize_semantic_item(item, fallback))
+
+    df = pd.DataFrame(results)
+    if len(df) > 0 and "semantic_error_types" in df.columns:
+        df["semantic_error_types_str"] = df["semantic_error_types"].apply(lambda xs: " | ".join(xs) if isinstance(xs, list) else str(xs))
+    if len(df) > 0 and "improvement_suggestions" in df.columns:
+        df["improvement_suggestions_str"] = df["improvement_suggestions"].apply(lambda xs: " | ".join(xs) if isinstance(xs, list) else str(xs))
+    df["llm_model"] = model
+    return df

pipeline/run_all.py

@@ -10,6 +10,8 @@ def main():
     ap.add_argument("--model_name", default="small")
     ap.add_argument("--device", default="cpu")
     ap.add_argument("--compute_type", default="int8")
+    ap.add_argument("--llm_model", default="gpt-4.1-mini")
+    ap.add_argument("--disable_llm", action="store_true")
     args = ap.parse_args()
 
     run_id = run_asr(
@@ -18,7 +20,7 @@ def main():
         device=args.device,
         compute_type=args.compute_type,
     )
-    run_analysis(run_id)
+    run_analysis(run_id, llm_enabled=not args.disable_llm, llm_model=args.llm_model)
     print(f"Done. Run: runs/{run_id}")
 
 

pipeline/run_analysis.py

@@ -1,29 +1,42 @@
 from __future__ import annotations
 import json
+import os
 from pathlib import Path
-from typing import List, Dict
+from typing import List, Dict, Optional
 
 import pandas as pd
+from openai import OpenAI
 
 from core.io import read_jsonl, write_jsonl
 from analysis.align import align_one
 from analysis.events import extract_events
 from analysis.aggregate import aggregate_summary
+from analysis.llm_analyzer import analyze_with_llm, analyze_semantic_per_utterance
 from report.generate import write_report
+from report.diagnostic_report import generate_report_with_openai
 
 
-def run_analysis(run_id: str, out_root: str = "runs") -> None:
+def run_analysis(
+    run_id: str,
+    out_root: str = "runs",
+    llm_enabled: bool = True,
+    llm_model: str = "gpt-4.1-mini",
+    write_diagnostic_report: bool = True,
+) -> None:
     run_dir = Path(out_root) / run_id
     run_meta = json.loads((run_dir / "run_meta.json").read_text(encoding="utf-8"))
 
     asr_path = run_dir / "asr_outputs.jsonl"
     aligned_path = run_dir / "aligned.jsonl"
     events_path = run_dir / "events.parquet"
+    semantic_path = run_dir / "semantic_findings.parquet"
+    semantic_jsonl_path = run_dir / "semantic_findings.jsonl"
 
     aligned_records: List[Dict] = []
     events_records: List[Dict] = []
 
-    for r in read_jsonl(asr_path):
+    asr_rows = list(read_jsonl(asr_path))
+    for r in asr_rows:
         utt_id = r["utt_id"]
         ref = r.get("ref_text")
         hyp = r.get("hyp_text", "")
@@ -44,17 +57,46 @@ def run_analysis(run_id: str, out_root: str = "runs") -> None:
         df_events = pd.DataFrame(events_records)
         df_events.to_parquet(events_path, index=False)
     else:
-        df_events = pd.DataFrame(columns=["op_type", "error_class"])
-
-    # merge meta slice fields into align if they exist
-    # df_align currently doesn't have meta; add a few common keys if present
-    # We'll reconstruct from asr_outputs for slicing.
-    # (Simple approach) reload and join on utt_id:
-    meta_map = {}
-    for r in read_jsonl(asr_path):
-        meta_map[r["utt_id"]] = r.get("meta", {}) or {}
+        df_events = pd.DataFrame(columns=["utt_id", "op_type", "error_class", "ref", "hyp", "level"])
+
+    meta_map = {r["utt_id"]: r.get("meta", {}) or {} for r in asr_rows}
     for key in ["device", "domain", "accent", "speaker"]:
         df_align[key] = df_align["utt_id"].map(lambda u: meta_map.get(u, {}).get(key))
 
     summary = aggregate_summary(df_events, df_align)
-    write_report(run_dir, run_meta, summary)
+
+    llm_diagnosis: Optional[Dict] = None
+    semantic_df = pd.DataFrame()
+    if llm_enabled and os.getenv("OPENAI_API_KEY") and len(df_align) > 0:
+        client = OpenAI()
+        llm_diagnosis = analyze_with_llm(
+            df_align=df_align,
+            df_events=df_events,
+            summary=summary,
+            model=llm_model,
+            client=client,
+        )
+        semantic_df = analyze_semantic_per_utterance(
+            df_align=df_align,
+            df_events=df_events,
+            model=llm_model,
+            client=client,
+        )
+        if len(semantic_df) > 0:
+            semantic_df.to_parquet(semantic_path, index=False)
+            write_jsonl(semantic_jsonl_path, semantic_df.to_dict(orient="records"))
+        if write_diagnostic_report:
+            report = generate_report_with_openai(llm_diagnosis, summary, client, model=llm_model)
+            (run_dir / "diagnostic_report.md").write_text(report, encoding="utf-8")
+    elif write_diagnostic_report and not (run_dir / "diagnostic_report.md").exists():
+        (run_dir / "diagnostic_report.md").write_text(
+            "LLM diagnostic report was skipped because OPENAI_API_KEY is not set.\n"
+            "You can still inspect summary.json and report.md, or rerun with an API key.",
+            encoding="utf-8",
+        )
+
+    write_report(run_dir, run_meta, summary, llm_diagnosis=llm_diagnosis)
+
+
+if __name__ == "__main__":
+    raise SystemExit("Use pipeline/run_all.py or import run_analysis()")

report/diagnostic_report.py

@@ -6,39 +6,40 @@ from typing import Dict, Any
 
 SYSTEM_PROMPT = """You are an ASR diagnostics expert.
 Write a concise but evidence-based ASR error analysis report in Chinese.
-Do not invent evidence. Only use the provided structured statistics.
+Do not invent evidence. Use both structured metrics and LLM semantic diagnosis.
 Focus on:
 1. major error patterns
-2. likely root causes
-3. confidence and uncertainty
-4. actionable next steps
+2. semantic impact of errors
+3. likely root causes
+4. confidence and uncertainty
+5. actionable next steps
 """
 
 
-def build_prompt(root_cause: Dict[str, Any], summary: Dict[str, Any]) -> str:
+def build_prompt(llm_diagnosis: Dict[str, Any], summary: Dict[str, Any]) -> str:
     return f"""
 请基于下面的结构化分析结果，生成一份中文 ASR 错误诊断报告。
 
 要求：
 - 先写总体结论
 - 再写主要错误原因（按优先级排序）
-- 每个原因要包含：现象、证据、可能原因、改进建议
+- 每个原因要包含：现象、证据、语义影响、可能原因、改进建议
 - 最后给出一个优先级排序的行动清单
 - 如果证据不足，要明确说“不确定”
 
 【summary.json】
 {json.dumps(summary, ensure_ascii=False, indent=2)}
 
-【root_cause.json】
-{json.dumps(root_cause, ensure_ascii=False, indent=2)}
+【llm_diagnosis.json】
+{json.dumps(llm_diagnosis, ensure_ascii=False, indent=2)}
 """
 
 
-def generate_report_with_openai(root_cause: Dict[str, Any], summary: Dict[str, Any], client) -> str:
-    prompt = build_prompt(root_cause, summary)
+def generate_report_with_openai(llm_diagnosis: Dict[str, Any], summary: Dict[str, Any], client, model: str = "gpt-4.1-mini") -> str:
+    prompt = build_prompt(llm_diagnosis, summary)
 
     resp = client.chat.completions.create(
-        model="gpt-4.1-mini",
+        model=model,
         messages=[
             {"role": "system", "content": SYSTEM_PROMPT},
             {"role": "user", "content": prompt},

report/generate.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 import json
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Optional
 from .templates import render_markdown
 
 
-def write_report(run_dir: Path, run_meta: Dict, summary: Dict) -> None:
+def write_report(run_dir: Path, run_meta: Dict, summary: Dict, llm_diagnosis: Optional[Dict] = None) -> None:
     run_dir.mkdir(parents=True, exist_ok=True)
 
     (run_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
-    md = render_markdown(run_meta, summary)
+    if llm_diagnosis is not None:
+        (run_dir / "llm_diagnosis.json").write_text(json.dumps(llm_diagnosis, ensure_ascii=False, indent=2), encoding="utf-8")
+    md = render_markdown(run_meta, summary, llm_diagnosis=llm_diagnosis)
     (run_dir / "report.md").write_text(md, encoding="utf-8")

report/templates.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
-from typing import Dict
+from typing import Dict, Optional
 
 
-def render_markdown(run_meta: Dict, summary: Dict) -> str:
+def render_markdown(run_meta: Dict, summary: Dict, llm_diagnosis: Optional[Dict] = None) -> str:
     lines = []
-    lines.append(f"# ASR Error Analysis Report\n")
+    lines.append("# ASR Error Analysis Report\n")
     lines.append(f"**Run ID:** {run_meta.get('run_id')}")
     lines.append(f"**Model:** {run_meta.get('model_info')}\n")
 
@@ -25,7 +25,6 @@ def render_markdown(run_meta: Dict, summary: Dict) -> str:
     for k, v in (summary.get("top_confusions", {}) or {}).items():
         lines.append(f"- {k}: {v}")
 
-    # Slice
     for key in ["device", "domain", "accent", "speaker"]:
         k2 = f"worst_{key}_by_cer"
         if k2 in summary:
@@ -33,9 +32,48 @@ def render_markdown(run_meta: Dict, summary: Dict) -> str:
             for item in summary[k2]:
                 lines.append(f"- {item['key']}: {item['cer']:.4f}")
 
-    lines.append("\n## Recommendations (auto-generated starter)")
-    lines.append("- 优先检查 CER/WER 在特定子集（device/domain/accent）是否显著升高，针对性补数据或做增强。")
-    lines.append("- 如果 top_confusions 集中在数字/时间类，可加入数字规范化与专门的后处理规则。")
-    lines.append("- 如果 mixed_language 占比高，考虑加入英文热词/专名词表或做 LM/解码侧增强。")
+    if llm_diagnosis:
+        lines.append("\n## LLM Executive Summary")
+        if llm_diagnosis.get("executive_summary"):
+            lines.append(llm_diagnosis["executive_summary"])
+
+        patterns = llm_diagnosis.get("major_patterns") or []
+        if patterns:
+            lines.append("\n## LLM Major Patterns")
+            for idx, item in enumerate(patterns, 1):
+                lines.append(f"### {idx}. {item.get('title', 'Untitled Pattern')}")
+                if item.get("phenomenon"):
+                    lines.append(f"- 现象: {item['phenomenon']}")
+                if item.get("semantic_impact"):
+                    lines.append(f"- 语义影响: {item['semantic_impact']}")
+                if item.get("confidence") is not None:
+                    lines.append(f"- 置信度: {item['confidence']}")
+                for e in item.get("evidence", []) or []:
+                    lines.append(f"- 证据: {e}")
+                for c in item.get("likely_causes", []) or []:
+                    lines.append(f"- 可能原因: {c}")
+                for r in item.get("recommendations", []) or []:
+                    lines.append(f"- 建议: {r}")
+
+        findings = llm_diagnosis.get("case_findings") or []
+        if findings:
+            lines.append("\n## Representative Semantic Findings")
+            for item in findings[:10]:
+                lines.append(f"- {item.get('utt_id')}: {item.get('semantic_judgement')}；原因：{item.get('reason')}")
+
+        if llm_diagnosis.get("priority_actions"):
+            lines.append("\n## Priority Actions")
+            for x in llm_diagnosis["priority_actions"]:
+                lines.append(f"- {x}")
+
+        if llm_diagnosis.get("uncertainties"):
+            lines.append("\n## Uncertainties")
+            for x in llm_diagnosis["uncertainties"]:
+                lines.append(f"- {x}")
+    else:
+        lines.append("\n## Recommendations (auto-generated starter)")
+        lines.append("- 优先检查 CER/WER 在特定子集（device/domain/accent）是否显著升高，针对性补数据或做增强。")
+        lines.append("- 如果 top_confusions 集中在数字/时间类，可加入数字规范化与专门的后处理规则。")
+        lines.append("- 如果 mixed_language 占比高，考虑加入英文热词/专名词表或做 LM/解码侧增强。")
 
     return "\n".join(lines)

scripts/run_diagnostic.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import pandas as pd
 from openai import OpenAI
 
-from analysis.root_cause import infer_root_causes
+from analysis.llm_analyzer import analyze_with_llm
 from report.diagnostic_report import generate_report_with_openai
 
 
@@ -20,21 +20,21 @@ def load_jsonl(path: Path):
     return rows
 
 
-def main(run_id: str, runs_dir: str = "runs"):
+def main(run_id: str, runs_dir: str = "runs", model: str = "gpt-4.1-mini"):
     run_dir = Path(runs_dir) / run_id
 
     df_align = pd.DataFrame(load_jsonl(run_dir / "aligned.jsonl"))
     df_events = pd.read_parquet(run_dir / "events.parquet") if (run_dir / "events.parquet").exists() else pd.DataFrame()
     summary = json.loads((run_dir / "summary.json").read_text(encoding="utf-8")) if (run_dir / "summary.json").exists() else {}
 
-    root_cause = infer_root_causes(df_events, df_align)
-    (run_dir / "root_cause.json").write_text(
-        json.dumps(root_cause, ensure_ascii=False, indent=2),
+    client = OpenAI()
+    llm_diagnosis = analyze_with_llm(df_align, df_events, summary, model=model, client=client)
+    (run_dir / "llm_diagnosis.json").write_text(
+        json.dumps(llm_diagnosis, ensure_ascii=False, indent=2),
         encoding="utf-8"
     )
 
-    client = OpenAI()
-    report = generate_report_with_openai(root_cause, summary, client)
+    report = generate_report_with_openai(llm_diagnosis, summary, client, model=model)
     (run_dir / "diagnostic_report.md").write_text(report, encoding="utf-8")
 
     print(f"Diagnostic report written to: {run_dir / 'diagnostic_report.md'}")
@@ -45,5 +45,6 @@ if __name__ == "__main__":
     ap = argparse.ArgumentParser()
     ap.add_argument("--run_id", required=True)
     ap.add_argument("--runs_dir", default="runs")
+    ap.add_argument("--model", default="gpt-4.1-mini")
     args = ap.parse_args()
-    main(args.run_id, args.runs_dir)
+    main(args.run_id, args.runs_dir, args.model)

ui/app.py

@@ -5,11 +5,15 @@ import subprocess
 import sys
 from pathlib import Path
 
-import pandas as pd
 import gradio as gr
+import pandas as pd
 
 RUNS_DIR = Path("runs")
 
+SEMANTIC_JUDGEMENTS = ["ALL", "语义基本等价", "轻微偏差", "明显偏差", "严重失真", "不确定"]
+SEVERITIES = ["ALL", "high", "medium", "low"]
+BUSINESS_IMPACTS = ["ALL", "high", "medium", "low"]
+
 
 def list_runs():
     if not RUNS_DIR.exists():
@@ -20,107 +24,213 @@ def list_runs():
     )
 
 
-def load_run(run_id: str):
-    run_dir = RUNS_DIR / run_id
+def _read_json(path: Path, default):
+    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else default
 
-    meta = json.loads((run_dir / "run_meta.json").read_text(encoding="utf-8"))
 
-    summary = (
-        json.loads((run_dir / "summary.json").read_text(encoding="utf-8"))
-        if (run_dir / "summary.json").exists()
-        else {}
-    )
+def _read_jsonl(path: Path):
+    rows = []
+    if not path.exists():
+        return rows
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
 
-    aligned_path = run_dir / "aligned.jsonl"
-    if aligned_path.exists():
-        rows = []
-        with aligned_path.open("r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if line:
-                    rows.append(json.loads(line))
-        df_align = pd.DataFrame(rows)
-    else:
-        df_align = pd.DataFrame()
 
-    events_path = run_dir / "events.parquet"
-    df_events = pd.read_parquet(events_path) if events_path.exists() else pd.DataFrame()
+def _normalize_semantic_df(df: pd.DataFrame) -> pd.DataFrame:
+    if df is None or len(df) == 0:
+        return pd.DataFrame()
+    out = df.copy()
+    for col in ["semantic_error_types", "improvement_suggestions"]:
+        if col in out.columns:
+            out[col] = out[col].apply(lambda xs: xs if isinstance(xs, list) else ([] if pd.isna(xs) else [str(xs)]))
+    if "semantic_error_types" in out.columns and "semantic_error_types_str" not in out.columns:
+        out["semantic_error_types_str"] = out["semantic_error_types"].apply(lambda xs: " | ".join(xs))
+    if "improvement_suggestions" in out.columns and "improvement_suggestions_str" not in out.columns:
+        out["improvement_suggestions_str"] = out["improvement_suggestions"].apply(lambda xs: " | ".join(xs))
+    return out
 
-    diagnostic_path = run_dir / "diagnostic_report.md"
-    diagnostic_text = (
-        diagnostic_path.read_text(encoding="utf-8")
-        if diagnostic_path.exists()
-        else "No diagnostic report yet."
-    )
 
-    return meta, summary, df_align, df_events, diagnostic_text
+def load_run(run_id: str):
+    run_dir = RUNS_DIR / run_id
+    meta = _read_json(run_dir / "run_meta.json", {})
+    summary = _read_json(run_dir / "summary.json", {})
+    df_align = pd.DataFrame(_read_jsonl(run_dir / "aligned.jsonl"))
+    df_events = pd.read_parquet(run_dir / "events.parquet") if (run_dir / "events.parquet").exists() else pd.DataFrame()
+    if (run_dir / "semantic_findings.parquet").exists():
+        df_semantic = _normalize_semantic_df(pd.read_parquet(run_dir / "semantic_findings.parquet"))
+    else:
+        df_semantic = pd.DataFrame()
+    llm_diagnosis = _read_json(run_dir / "llm_diagnosis.json", {})
+    diagnostic_text = (run_dir / "diagnostic_report.md").read_text(encoding="utf-8") if (run_dir / "diagnostic_report.md").exists() else "No diagnostic report yet."
+    return meta, summary, df_align, df_events, df_semantic, llm_diagnosis, diagnostic_text
 
 
-def build_summary_md(meta, summary):
+def build_summary_md(meta, summary, df_semantic: pd.DataFrame | None = None):
     lines = []
     lines.append(f"### Run ID: `{meta.get('run_id')}`")
     lines.append(f"- Model: `{meta.get('model_info')}`")
-
     if "wer_mean" in summary and summary["wer_mean"] is not None:
         lines.append(f"- WER(mean): **{summary['wer_mean']:.4f}**")
-
     if "cer_mean" in summary and summary["cer_mean"] is not None:
         lines.append(f"- CER(mean): **{summary['cer_mean']:.4f}**")
-
     lines.append(f"- S/I/D: `{summary.get('sid_counts', {})}`")
-
     if "top_error_classes" in summary:
         lines.append(f"- Top error classes: `{summary.get('top_error_classes', {})}`")
+    if df_semantic is not None and len(df_semantic) > 0:
+        sem_counts = df_semantic["semantic_judgement"].fillna("不确定").value_counts().to_dict() if "semantic_judgement" in df_semantic.columns else {}
+        high_impact = int((df_semantic.get("business_impact", pd.Series(dtype=str)) == "high").sum()) if "business_impact" in df_semantic.columns else 0
+        lines.append(f"- Semantic judgements: `{sem_counts}`")
+        lines.append(f"- High business impact utterances: **{high_impact}**")
+    return "\n".join(lines)
+
 
+def build_semantic_overview_md(df_semantic: pd.DataFrame, llm_diagnosis: dict):
+    if df_semantic is None or len(df_semantic) == 0:
+        return "### Semantic Overview\n暂无 per-utterance LLM 语义诊断结果。请先用配置了 `OPENAI_API_KEY` 的流程跑分析。"
+    lines = ["### Semantic Overview"]
+    if "semantic_judgement" in df_semantic.columns:
+        counts = df_semantic["semantic_judgement"].fillna("不确定").value_counts().to_dict()
+        lines.append(f"- 语义判断分布: `{counts}`")
+    if "business_impact" in df_semantic.columns:
+        impact = df_semantic["business_impact"].fillna("low").value_counts().to_dict()
+        lines.append(f"- 业务影响分布: `{impact}`")
+    if "semantic_error_types" in df_semantic.columns:
+        flat = []
+        for xs in df_semantic["semantic_error_types"].dropna().tolist():
+            flat.extend(xs if isinstance(xs, list) else [str(xs)])
+        if flat:
+            top_types = pd.Series(flat).value_counts().head(8).to_dict()
+            lines.append(f"- 高频语义错误类型: `{top_types}`")
+    if llm_diagnosis.get("priority_actions"):
+        lines.append("- 优先行动:")
+        for action in llm_diagnosis.get("priority_actions", [])[:5]:
+            lines.append(f"  - {action}")
     return "\n".join(lines)
 
 
-def on_select_run(run_id):
-    if not run_id:
-        return "", pd.DataFrame(), pd.DataFrame(), "No diagnostic report yet."
+def _head_align(df_align: pd.DataFrame) -> pd.DataFrame:
+    if len(df_align) == 0:
+        return pd.DataFrame()
+    cols = [c for c in ["utt_id", "wer", "cer", "ref_text", "hyp_text"] if c in df_align.columns]
+    return df_align[cols].head(50)
 
-    meta, summary, df_align, df_events, diagnostic_text = load_run(run_id)
-    md = build_summary_md(meta, summary)
 
-    align_view = (
-        df_align[["utt_id", "wer", "cer"]].head(50)
-        if len(df_align) and all(c in df_align.columns for c in ["utt_id", "wer", "cer"])
-        else pd.DataFrame()
-    )
+def _head_events(df_events: pd.DataFrame) -> pd.DataFrame:
+    if len(df_events) == 0:
+        return pd.DataFrame()
+    cols = [c for c in ["utt_id", "op_type", "ref", "hyp", "error_class", "level"] if c in df_events.columns]
+    return df_events[cols].head(100)
 
-    if len(df_events) and all(
-        c in df_events.columns for c in ["utt_id", "op_type", "ref", "hyp", "error_class", "level"]
-    ):
-        events_view = df_events[["utt_id", "op_type", "ref", "hyp", "error_class", "level"]].head(100)
-    else:
-        events_view = pd.DataFrame()
 
-    return md, align_view, events_view, diagnostic_text
+def _head_semantic(df_semantic: pd.DataFrame) -> pd.DataFrame:
+    if len(df_semantic) == 0:
+        return pd.DataFrame()
+    cols = [
+        "utt_id", "semantic_judgement", "severity", "business_impact", "wer", "cer",
+        "semantic_error_types_str", "reason", "ref_text", "hyp_text",
+    ]
+    cols = [c for c in cols if c in df_semantic.columns]
+    return df_semantic.sort_values([c for c in ["business_impact", "severity", "cer"] if c in df_semantic.columns], ascending=[True, True, False][:len([c for c in ["business_impact", "severity", "cer"] if c in df_semantic.columns])]).head(100)[cols]
+
+
+def on_select_run(run_id):
+    if not run_id:
+        empty = pd.DataFrame()
+        return "", empty, empty, empty, "", "No diagnostic report yet.", gr.update(choices=[]), gr.update(choices=[])
+
+    meta, summary, df_align, df_events, df_semantic, llm_diagnosis, diagnostic_text = load_run(run_id)
+    md = build_summary_md(meta, summary, df_semantic)
+    semantic_md = build_semantic_overview_md(df_semantic, llm_diagnosis)
+
+    type_choices = ["ALL"]
+    if len(df_semantic) > 0 and "semantic_error_types" in df_semantic.columns:
+        types = set()
+        for xs in df_semantic["semantic_error_types"].dropna().tolist():
+            if isinstance(xs, list):
+                types.update(str(x) for x in xs if x)
+            elif xs:
+                types.add(str(xs))
+        type_choices.extend(sorted(types))
+
+    domain_choices = ["ALL"]
+    if len(df_semantic) > 0 and "domain" in df_semantic.columns:
+        domain_choices.extend(sorted(str(x) for x in df_semantic["domain"].dropna().unique()))
+
+    return (
+        md,
+        _head_align(df_align),
+        _head_events(df_events),
+        _head_semantic(df_semantic),
+        semantic_md,
+        diagnostic_text,
+        gr.update(choices=type_choices, value="ALL"),
+        gr.update(choices=domain_choices, value="ALL"),
+    )
 
 
 def search_events(run_id, error_class, contains):
     if not run_id:
         return pd.DataFrame()
-
-    _, _, _, df_events, _ = load_run(run_id)
+    _, _, _, df_events, _, _, _ = load_run(run_id)
     if df_events is None or len(df_events) == 0:
         return pd.DataFrame()
-
     q = df_events.copy()
-
-    if error_class and error_class != "ALL":
+    if error_class and error_class != "ALL" and "error_class" in q.columns:
         q = q[q["error_class"] == error_class]
-
     if contains:
         contains = str(contains)
         q = q[
             q["ref"].astype(str).str.contains(contains, na=False)
             | q["hyp"].astype(str).str.contains(contains, na=False)
         ]
+    cols = [c for c in ["utt_id", "op_type", "ref", "hyp", "error_class", "level"] if c in q.columns]
+    return q[cols].head(200)
+
+
+def search_semantic(run_id, judgement, severity, business_impact, semantic_type, domain, contains, min_cer):
+    if not run_id:
+        return pd.DataFrame()
+    _, _, _, _, df_semantic, _, _ = load_run(run_id)
+    if df_semantic is None or len(df_semantic) == 0:
+        return pd.DataFrame()
+
+    q = df_semantic.copy()
+    if judgement and judgement != "ALL" and "semantic_judgement" in q.columns:
+        q = q[q["semantic_judgement"] == judgement]
+    if severity and severity != "ALL" and "severity" in q.columns:
+        q = q[q["severity"] == severity]
+    if business_impact and business_impact != "ALL" and "business_impact" in q.columns:
+        q = q[q["business_impact"] == business_impact]
+    if semantic_type and semantic_type != "ALL" and "semantic_error_types_str" in q.columns:
+        q = q[q["semantic_error_types_str"].astype(str).str.contains(str(semantic_type), na=False)]
+    if domain and domain != "ALL" and "domain" in q.columns:
+        q = q[q["domain"].astype(str) == str(domain)]
+    if contains:
+        contains = str(contains)
+        q = q[
+            q["ref_text"].astype(str).str.contains(contains, na=False)
+            | q["hyp_text"].astype(str).str.contains(contains, na=False)
+            | q.get("reason", pd.Series(dtype=str)).astype(str).str.contains(contains, na=False)
+            | q.get("semantic_error_types_str", pd.Series(dtype=str)).astype(str).str.contains(contains, na=False)
+        ]
+    if min_cer is not None and "cer" in q.columns:
+        q = q[q["cer"].fillna(0) >= float(min_cer)]
 
-    cols = ["utt_id", "op_type", "ref", "hyp", "error_class", "level"]
+    order_cols = [c for c in ["business_impact", "severity", "cer"] if c in q.columns]
+    if order_cols:
+        q = q.sort_values(order_cols, ascending=[True, True, False][:len(order_cols)])
+
+    cols = [
+        "utt_id", "semantic_judgement", "severity", "business_impact", "wer", "cer",
+        "semantic_error_types_str", "reason", "improvement_suggestions_str", "domain", "accent",
+        "ref_text", "hyp_text",
+    ]
     cols = [c for c in cols if c in q.columns]
-    return q[cols].head(200)
+    return q[cols].head(300)
 
 
 def run_hf_job(dataset_id, dataset_config, split, text_field, model_repo_id, language, num_samples):
@@ -134,72 +244,49 @@ def run_hf_job(dataset_id, dataset_config, split, text_field, model_repo_id, lan
         "--language", language.strip(),
         "--num", str(int(num_samples)),
     ]
-
     if dataset_config and dataset_config.strip():
         cmd += ["--dataset_config", dataset_config.strip()]
 
     p = subprocess.run(cmd, capture_output=True, text=True)
     out = (p.stdout or "") + ("\n" + (p.stderr or "") if p.stderr else "")
-
     if p.returncode != 0:
-        out += (
-            "\n\n[HINT] If you see 401/403 for Common Voice: "
-            "set HF_TOKEN in Space Settings → Secrets, and accept dataset terms on HF."
-        )
-        return (
-            out,
-            gr.update(),
-            "",
-            pd.DataFrame(),
-            pd.DataFrame(),
-            "No diagnostic report yet.",
-        )
+        out += "\n\n[HINT] If you see 401/403 for Common Voice: set HF_TOKEN in Space Settings → Secrets, and accept dataset terms on HF."
+        empty = pd.DataFrame()
+        return out, gr.update(), "", empty, empty, empty, "", "No diagnostic report yet.", gr.update(), gr.update()
 
     runs = list_runs()
     latest = runs[0] if runs else None
-
     if latest:
-        md, align_view, events_view, diagnostic_text = on_select_run(latest)
+        md, align_view, events_view, semantic_view, semantic_md, diagnostic_text, type_dd, domain_dd = on_select_run(latest)
     else:
-        md, align_view, events_view, diagnostic_text = "", pd.DataFrame(), pd.DataFrame(), "No diagnostic report yet."
+        md, align_view, events_view, semantic_view, semantic_md, diagnostic_text, type_dd, domain_dd = "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), "", "No diagnostic report yet.", gr.update(), gr.update()
 
-    return (
-        out,
-        gr.update(choices=runs, value=latest),
-        md,
-        align_view,
-        events_view,
-        diagnostic_text,
-    )
+    return out, gr.update(choices=runs, value=latest), md, align_view, events_view, semantic_view, semantic_md, diagnostic_text, type_dd, domain_dd
 
 
 with gr.Blocks() as demo:
-    gr.Markdown("# ASR Error Analysis (Stage 1)")
+    gr.Markdown("# ASR LLM Agent UI")
 
     with gr.Accordion("Run from Hugging Face", open=True):
         gr.Markdown(
             "Fill in a dataset and a Whisper model, then click **Run**. "
-            "If the dataset is gated, set `HF_TOKEN` in Space **Settings → Secrets**."
+            "If the dataset is gated, set `HF_TOKEN` in Space **Settings → Secrets**. "
+            "For LLM semantic diagnostics, make sure `OPENAI_API_KEY` is available."
         )
-
         with gr.Row():
             dataset_id = gr.Textbox(label="HF dataset repo id", value="fsicoli/common_voice_22_0")
             dataset_config = gr.Textbox(label="Dataset config (optional)", value="zh-CN")
-
         with gr.Row():
             split = gr.Textbox(label="Split", value="validation")
             text_field = gr.Textbox(label="Transcript field", value="sentence")
             num_samples = gr.Number(label="Num samples", value=50, precision=0)
-
         with gr.Row():
             model_repo_id = gr.Textbox(label="HF model repo id", value="openai/whisper-small")
             language = gr.Textbox(label="Language", value="zh")
-
         run_btn = gr.Button("Run")
         logs = gr.Textbox(label="Logs", lines=16)
 
     gr.Markdown("## Browse Existing Runs")
-
     runs = list_runs()
     run_dd = gr.Dropdown(choices=runs, label="Select run", value=(runs[0] if runs else None))
     summary_md = gr.Markdown()
@@ -210,15 +297,7 @@ with gr.Blocks() as demo:
 
     with gr.Accordion("Search Error Events", open=False):
         error_cls = gr.Dropdown(
-            choices=[
-                "ALL",
-                "number_or_time",
-                "mixed_language",
-                "substitution",
-                "deletion",
-                "insertion",
-                "other",
-            ],
+            choices=["ALL", "number_or_time", "mixed_language", "substitution", "deletion", "insertion", "other"],
             value="ALL",
             label="error_class",
         )
@@ -226,30 +305,53 @@ with gr.Blocks() as demo:
         search_btn = gr.Button("Search")
         result_tbl = gr.Dataframe(label="Search results", interactive=False)
 
+    gr.Markdown("## Per-Utterance Semantic Diagnostics")
+    semantic_overview_md = gr.Markdown("暂无语义诊断结果。")
+    semantic_tbl = gr.Dataframe(label="Semantic findings (head)", interactive=False)
+
+    with gr.Accordion("Filter Semantic Errors", open=True):
+        with gr.Row():
+            semantic_judgement = gr.Dropdown(choices=SEMANTIC_JUDGEMENTS, value="ALL", label="semantic_judgement")
+            semantic_severity = gr.Dropdown(choices=SEVERITIES, value="ALL", label="severity")
+            semantic_business_impact = gr.Dropdown(choices=BUSINESS_IMPACTS, value="ALL", label="business_impact")
+        with gr.Row():
+            semantic_type = gr.Dropdown(choices=["ALL"], value="ALL", label="semantic_error_type")
+            semantic_domain = gr.Dropdown(choices=["ALL"], value="ALL", label="domain")
+            semantic_min_cer = gr.Number(label="min CER", value=0.0)
+        semantic_contains = gr.Textbox(label="contains (ref/hyp/reason/type)")
+        semantic_search_btn = gr.Button("Filter semantic findings")
+        semantic_result_tbl = gr.Dataframe(label="Filtered semantic findings", interactive=False)
+
     with gr.Accordion("Diagnostic Report", open=True):
         diagnostic_md = gr.Markdown("No diagnostic report yet.")
 
     if runs:
-        md0, a0, e0, d0 = on_select_run(runs[0])
+        md0, a0, e0, s0, so0, d0, type0, domain0 = on_select_run(runs[0])
         summary_md.value = md0
         align_tbl.value = a0
         events_tbl.value = e0
+        semantic_tbl.value = s0
+        semantic_overview_md.value = so0
         diagnostic_md.value = d0
+        semantic_type.choices = type0["choices"]
+        semantic_domain.choices = domain0["choices"]
 
     run_dd.change(
         on_select_run,
         inputs=[run_dd],
-        outputs=[summary_md, align_tbl, events_tbl, diagnostic_md],
+        outputs=[summary_md, align_tbl, events_tbl, semantic_tbl, semantic_overview_md, diagnostic_md, semantic_type, semantic_domain],
     )
 
-    search_btn.click(
-        search_events,
-        inputs=[run_dd, error_cls, contains],
-        outputs=[result_tbl],
+    search_btn.click(search_events, inputs=[run_dd, error_cls, contains], outputs=[result_tbl])
+
+    semantic_search_btn.click(
+        search_semantic,
+        inputs=[run_dd, semantic_judgement, semantic_severity, semantic_business_impact, semantic_type, semantic_domain, semantic_contains, semantic_min_cer],
+        outputs=[semantic_result_tbl],
     )
 
     run_btn.click(
         run_hf_job,
         inputs=[dataset_id, dataset_config, split, text_field, model_repo_id, language, num_samples],
-        outputs=[logs, run_dd, summary_md, align_tbl, events_tbl, diagnostic_md],
+        outputs=[logs, run_dd, summary_md, align_tbl, events_tbl, semantic_tbl, semantic_overview_md, diagnostic_md, semantic_type, semantic_domain],
     )