| import csv |
| from pathlib import Path |
| from datetime import datetime |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| RESULTS = ROOT / "results" |
| REPORTS = ROOT / "reports" |
| FIGURES = ROOT / "figures" |
|
|
| REPORTS.mkdir(parents=True, exist_ok=True) |
| OUT = REPORTS / "tbg_cot_experiment_report.md" |
|
|
|
|
| def read_metric_file(path: Path) -> dict: |
| metrics = {} |
| if not path.exists(): |
| return metrics |
|
|
| with path.open("r", encoding="utf-8") as f: |
| reader = csv.DictReader(f) |
| for row in reader: |
| try: |
| metrics[row["metric"]] = float(row["value"]) |
| except Exception: |
| continue |
| return metrics |
|
|
|
|
| def read_rows(path: Path) -> list[dict]: |
| if not path.exists(): |
| return [] |
| with path.open("r", encoding="utf-8") as f: |
| return list(csv.DictReader(f)) |
|
|
|
|
| def fmt(value, digits=4): |
| if value is None: |
| return "N/A" |
| try: |
| return f"{float(value):.{digits}f}" |
| except Exception: |
| return str(value) |
|
|
|
|
| def method_rows(): |
| baseline = read_metric_file(RESULTS / "converter_eval_summary.csv") |
| scenario = read_metric_file(RESULTS / "ollama_eval_summary.csv") |
| stepwise = read_metric_file(RESULTS / "stepwise_ollama_eval_summary.csv") |
| order_v3 = read_metric_file(RESULTS / "order_v3_eval_summary.csv") |
| cumulative_v4 = read_metric_file(RESULTS / "cumulative_v4_eval_summary.csv") |
|
|
| return [ |
| { |
| "method": "Rule-based baseline converter", |
| "parse_success": 1.0 if baseline else None, |
| "primary_metric": "direction_accuracy", |
| "primary_value": baseline.get("direction_accuracy"), |
| "secondary": f"strength_mae={fmt(baseline.get('strength_mae'))}, source_weight_mae={fmt(baseline.get('source_weight_mae'))}", |
| "coverage": f"{int(baseline.get('num_steps', 0))}/52", |
| }, |
| { |
| "method": "EXAONE scenario-level CoT", |
| "parse_success": scenario.get("num_evaluated_steps", 0) / 52.0 if scenario else None, |
| "primary_metric": "direction_accuracy", |
| "primary_value": scenario.get("direction_accuracy"), |
| "secondary": f"confidence_mae={fmt(scenario.get('confidence_mae'))}, verdict_accuracy={fmt(scenario.get('verdict_accuracy'))}", |
| "coverage": f"{int(scenario.get('num_evaluated_steps', 0))}/52", |
| }, |
| { |
| "method": "EXAONE step-wise evidence v2.1", |
| "parse_success": stepwise.get("parse_success_rate"), |
| "primary_metric": "direction_accuracy", |
| "primary_value": stepwise.get("direction_accuracy"), |
| "secondary": f"confidence_mae={fmt(stepwise.get('confidence_mae'))}, verdict_accuracy={fmt(stepwise.get('verdict_accuracy'))}", |
| "coverage": f"{int(stepwise.get('num_parsed_steps', 0))}/52", |
| }, |
| { |
| "method": "EXAONE order-classification v3", |
| "parse_success": order_v3.get("parse_success_rate"), |
| "primary_metric": "direction_accuracy", |
| "primary_value": order_v3.get("direction_accuracy"), |
| "secondary": f"confidence_mae={fmt(order_v3.get('confidence_mae'))}, verdict_accuracy={fmt(order_v3.get('verdict_accuracy'))}", |
| "coverage": f"{int(order_v3.get('num_parsed_steps', 0))}/52", |
| }, |
| { |
| "method": "EXAONE cumulative belief v4", |
| "parse_success": cumulative_v4.get("parse_success_rate"), |
| "primary_metric": "trajectory_verdict_accuracy", |
| "primary_value": cumulative_v4.get("trajectory_verdict_accuracy"), |
| "secondary": f"p_forward_mae={fmt(cumulative_v4.get('p_forward_mae'))}", |
| "coverage": f"{int(cumulative_v4.get('num_parsed_steps', 0))}/52", |
| }, |
| ] |
|
|
|
|
| def render_method_table() -> str: |
| lines = [ |
| "| Method | Parse success | Primary metric | Primary value | Secondary metrics | Coverage |", |
| "|---|---:|---|---:|---|---:|", |
| ] |
|
|
| for row in method_rows(): |
| lines.append( |
| f"| {row['method']} | {fmt(row['parse_success'])} | {row['primary_metric']} | " |
| f"{fmt(row['primary_value'])} | {row['secondary']} | {row['coverage']} |" |
| ) |
|
|
| return "\n".join(lines) |
|
|
|
|
| def render_scenario_summary(path: Path, title: str) -> str: |
| rows = read_rows(path) |
| if not rows: |
| return f"## {title}\n\nNo data found at `{path.relative_to(ROOT)}`.\n" |
|
|
| lines = [ |
| f"## {title}", |
| "", |
| "| Scenario | Final p_forward | Verdict | Parse / coverage |", |
| "|---|---:|---|---|", |
| ] |
|
|
| for row in rows: |
| sid = row.get("scenario_id", "") |
| final_p = row.get("final_p", "") |
| verdict = row.get("verdict", "") |
| parsed = row.get("parsed_steps", "") |
| total = row.get("total_steps", "") |
| rate = row.get("parse_success_rate", "") |
|
|
| coverage = "" |
| if parsed or total or rate: |
| coverage = f"{parsed}/{total}, rate={rate}" |
|
|
| lines.append(f"| {sid} | {fmt(final_p)} | {verdict} | {coverage} |") |
|
|
| return "\n".join(lines) |
|
|
|
|
| def render_assets() -> str: |
| candidates = [ |
| "figures/converter_direction_accuracy.png", |
| "figures/gold_trajectories.png", |
| "figures/stepwise_vs_baseline_accuracy.png", |
| "figures/stepwise_parse_success.png", |
| "figures/order_v3_accuracy_comparison.png", |
| "figures/order_v3_parse_success_comparison.png", |
| "figures/cumulative_v4_accuracy_comparison.png", |
| ] |
|
|
| lines = ["## Generated Assets", ""] |
| for rel in candidates: |
| path = ROOT / rel |
| status = "available" if path.exists() else "missing" |
| lines.append(f"- `{rel}` — {status}") |
| return "\n".join(lines) |
|
|
|
|
| def main(): |
| baseline = read_metric_file(RESULTS / "converter_eval_summary.csv") |
| stepwise = read_metric_file(RESULTS / "stepwise_ollama_eval_summary.csv") |
| cumulative = read_metric_file(RESULTS / "cumulative_v4_eval_summary.csv") |
|
|
| baseline_acc = baseline.get("direction_accuracy") |
| stepwise_acc = stepwise.get("direction_accuracy") |
| stepwise_parse = stepwise.get("parse_success_rate") |
| cumulative_parse = cumulative.get("parse_success_rate") |
| cumulative_acc = cumulative.get("trajectory_verdict_accuracy") |
|
|
| report = f"""# TBG-CoT-Bench Local Experiment Report |
| |
| Generated at: `{datetime.now().isoformat(timespec="seconds")}` |
| |
| ## Overview |
| |
| This report summarizes a local application benchmark for temporal belief tracking. |
| |
| The benchmark tests whether a system can track evidence about the temporal claim: |
| |
| > Event A occurred before Event B. |
| |
| The current project should be interpreted as an **application-level benchmark / usage test**, not as a full internal unit test suite for the upstream `temporal-belief-graph` package. |
| |
| ## Compared Methods |
| |
| {render_method_table()} |
| |
| ## Main Finding |
| |
| The strongest current method is: |
| |
| **EXAONE step-wise evidence v2.1** |
| |
| It achieved: |
| |
| - parse success rate: `{fmt(stepwise_parse)}` |
| - direction accuracy: `{fmt(stepwise_acc)}` |
| - rule-based baseline direction accuracy: `{fmt(baseline_acc)}` |
| |
| This suggests that local EXAONE becomes useful when the task is decomposed into small structured evidence judgments. |
| |
| ## Negative Result |
| |
| The cumulative v4 method was conceptually closer to belief trajectory tracking, but performed worse in this run: |
| |
| - cumulative v4 parse success rate: `{fmt(cumulative_parse)}` |
| - cumulative v4 trajectory verdict accuracy: `{fmt(cumulative_acc)}` |
| |
| This indicates that cumulative prompting can overload the local model and reduce structured-output stability. |
| |
| ## Interpretation |
| |
| The experiment supports the following conclusion: |
| |
| 1. Scenario-level CoT is unstable for local EXAONE in this setup. |
| 2. Step-wise extraction substantially improves structured-output reliability. |
| 3. Order classification alone tends to create `UNCLEAR` collapse. |
| 4. Cumulative belief prompting is not yet reliable with this local model/configuration. |
| 5. The best current architecture is a modular pipeline: |
| - evidence extraction |
| - structured parsing |
| - trajectory update |
| - result visualization |
| |
| {render_scenario_summary(RESULTS / "stepwise_ollama_scenario_summary.csv", "Step-wise v2.1 Scenario Summary")} |
| |
| {render_scenario_summary(RESULTS / "cumulative_v4_scenario_summary.csv", "Cumulative v4 Scenario Summary")} |
| |
| {render_assets()} |
| |
| ## Recommended Next Step |
| |
| Freeze **EXAONE step-wise evidence v2.1** as the current best local method. |
| |
| Next development should focus on: |
| |
| - application-level regression tests |
| - reproducible reports |
| - HuggingFace notebook packaging |
| - optional integration tests against the actual `temporal-belief-graph` package |
| |
| """ |
|
|
| OUT.write_text(report, encoding="utf-8") |
| print(f"Saved: {OUT}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
