Upload analyze_nanoclaw_mask_trajectories.py

analyze_nanoclaw_mask_trajectories.py

@@ -0,0 +1,578 @@
+#!/usr/bin/env python3
+"""Offline NanoClaw mask-candidate and positive-advantage analysis.
+
+The script reads saved ``conversation_history.json`` files and the reward
+records written under ``step_N/_reward_logs``.  It does not load a model, start
+Ray/vLLM, call a verifier, or modify the old rollout directories.
+
+For every step it reports eight primary quantities:
+
+  1. candidate turns for each of four bad-turn types;
+  2. candidate turns whose group-score advantage is positive for each type.
+
+Token counterparts are emitted as additional columns and plotted as well.
+The positive-advantage decision is reconstructed from the saved final reward
+score within each prompt/task group.  If the historical run used KL-in-reward,
+the exact token-level KL contribution was not saved in conversation history;
+the output therefore labels this reconstruction as ``positive_by_group_score``
+and reports missing/incomplete groups explicitly.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import concurrent.futures
+import json
+import re
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from statistics import fmean
+from typing import Any
+
+try:
+    import orjson  # type: ignore
+except ImportError:
+    orjson = None
+
+
+REASONS = (
+    "looping_response",
+    "budget_exhausted_last_turn",
+    "duplicate_tool_result_turn",
+    "error_tool_result_turn",
+)
+TERMINATION_REASONS = {"max_assistant_response_tokens", "max_response_tokens"}
+STEP_RE = re.compile(r"(?:^|/)step_(\d+)(?:/|$)")
+RESULT_DIR_RE = re.compile(r"^(?P<task>.+)_sample_(?P<sample>\d+)(?:_[A-Za-z0-9]+)?$")
+
+
+@dataclass
+class Sample:
+    history_path: Path
+    result_dir: Path
+    step: int | None
+    task_id: str
+    rollout_n: int | None
+    payload: dict[str, Any]
+    candidate_turns: dict[str, int] = field(default_factory=dict)
+    candidate_tokens: dict[str, int] = field(default_factory=dict)
+    score: float | None = None
+    score_source: str | None = None
+    group_mean: float | None = None
+    group_advantage: float | None = None
+    positive_by_group_score: bool | None = None
+    group_complete: bool = False
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Analyze saved NanoClaw mask candidates by step.")
+    parser.add_argument("workplace_root", type=Path, help="nanoclaw_temp_workplace... root")
+    parser.add_argument("--output-dir", type=Path, default=None, help="Defaults to <root>/mask_analysis")
+    parser.add_argument(
+        "--history-name",
+        "--trajectory-name",
+        dest="history_name",
+        default="conversation_history.json",
+        help="Saved event file to scan (default: conversation_history.json; trajectory.json is also supported)",
+    )
+    parser.add_argument(
+        "--expected-group-size",
+        type=int,
+        default=None,
+        help="Expected GRPO samples per prompt, e.g. 8. Incomplete groups are not used for positive classification.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=8,
+        help="Parallel history readers (default: 8; use 2-4 on a slow shared filesystem).",
+    )
+    parser.add_argument("--no-plot", action="store_true", help="Write CSV/JSON only.")
+    return parser.parse_args()
+
+
+def load_json(path: Path) -> dict[str, Any] | None:
+    try:
+        raw = path.read_bytes()
+        value = orjson.loads(raw) if orjson is not None else json.loads(raw)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def number(value: Any) -> float | None:
+    if isinstance(value, bool):
+        return None
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return None
+    return result if result == result else None
+
+
+def integer(*values: Any) -> int | None:
+    for value in values:
+        if isinstance(value, bool):
+            continue
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            continue
+    return None
+
+
+def events_from_history(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    events = payload.get("events")
+    if isinstance(events, list):
+        return [event for event in events if isinstance(event, dict)]
+    nested = payload.get("conversation_history")
+    if isinstance(nested, dict) and isinstance(nested.get("events"), list):
+        return [event for event in nested["events"] if isinstance(event, dict)]
+    return []
+
+
+def infer_step(path: Path, payload: dict[str, Any]) -> int | None:
+    match = STEP_RE.search(path.as_posix())
+    if match:
+        return int(match.group(1))
+    for container_key in ("rollout", "workspace"):
+        container = payload.get(container_key)
+        if isinstance(container, dict):
+            value = integer(container.get("step"), container.get("rollout_step"))
+            if value is not None:
+                return value
+    return integer(payload.get("rollout_step"), payload.get("step"))
+
+
+def result_dir_and_identity(history_path: Path, payload: dict[str, Any]) -> tuple[Path, str, int | None]:
+    result_dir = history_path.parent
+    task_id = payload.get("task_id")
+    rollout_n = integer(payload.get("rollout_n"), payload.get("rollout_sample_index"))
+    match = RESULT_DIR_RE.match(result_dir.name)
+    if match:
+        task_id = task_id or match.group("task")
+        rollout_n = rollout_n if rollout_n is not None else int(match.group("sample"))
+    if not isinstance(task_id, str) or not task_id:
+        task_id = result_dir.name
+    return result_dir, task_id, rollout_n
+
+
+def event_turn(event: dict[str, Any]) -> int | None:
+    return integer(event.get("assistant_turn"), event.get("turn"))
+
+
+def assistant_events(events: list[dict[str, Any]]) -> dict[int, dict[str, Any]]:
+    result: dict[int, dict[str, Any]] = {}
+    for event in events:
+        if event.get("type") == "assistant":
+            turn = event_turn(event)
+            if turn is not None:
+                result[turn] = event
+    return result
+
+
+def assistant_tokens(event: dict[str, Any] | None) -> int:
+    if not isinstance(event, dict):
+        return 0
+    explicit = integer(event.get("token_count"))
+    if explicit is not None and explicit >= 0:
+        return explicit
+    start = integer(event.get("response_start"))
+    end = integer(event.get("response_end"))
+    return max(0, end - start) if start is not None and end is not None else 0
+
+
+def text_parts(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, list):
+        result: list[str] = []
+        for item in value:
+            result.extend(text_parts(item))
+        return result
+    if isinstance(value, dict):
+        result: list[str] = []
+        for key in ("text", "content"):
+            if key in value:
+                result.extend(text_parts(value[key]))
+        return result
+    return []
+
+
+def is_error_tool_result(event: dict[str, Any]) -> bool:
+    response = event.get("response")
+    content = response.get("content") if isinstance(response, dict) else response
+    if any(re.match(r"^\s*error(?:\b|\s*:)", text, re.IGNORECASE) for text in text_parts(content)):
+        return True
+    result = event.get("result")
+    if not isinstance(result, dict):
+        return False
+    error_value = result.get("error")
+    if error_value is not None and error_value is not False and error_value != "":
+        return True
+    status = result.get("status")
+    return isinstance(status, str) and status.strip().lower() in {"error", "failed", "failure"}
+
+
+def canonical_key(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=repr)
+    except (TypeError, ValueError):
+        return repr(value)
+
+
+def duplicate_turns(events: list[dict[str, Any]]) -> set[int]:
+    seen: set[str] = set()
+    result: set[int] = set()
+    for event in events:
+        if event.get("type") != "tool":
+            continue
+        key = canonical_key({key: event.get(key) for key in ("tool", "arguments", "response", "result")})
+        turn = event_turn(event)
+        if key in seen and turn is not None:
+            result.add(turn)
+        seen.add(key)
+    return result
+
+
+def candidate_counts(payload: dict[str, Any]) -> tuple[dict[str, int], dict[str, int]]:
+    events = events_from_history(payload)
+    assistants = assistant_events(events)
+    turns: dict[str, set[int]] = {reason: set() for reason in REASONS}
+
+    for turn, event in assistants.items():
+        repeats = integer(event.get("looping_repeat_count"), event.get("repeat_count")) or 0
+        if repeats > 0 or event.get("looping_response_mask_candidate") is True:
+            turns["looping_response"].add(turn)
+
+    termination = payload.get("termination_reason")
+    if not isinstance(termination, str) and isinstance(payload.get("summary"), dict):
+        termination = payload["summary"].get("termination_reason")
+    if termination in TERMINATION_REASONS and assistants:
+        turns["budget_exhausted_last_turn"].add(max(assistants))
+
+    turns["duplicate_tool_result_turn"] = duplicate_turns(events)
+    for event in events:
+        if event.get("type") == "tool" and is_error_tool_result(event):
+            turn = event_turn(event)
+            if turn is not None:
+                turns["error_tool_result_turn"].add(turn)
+
+    token_counts = {
+        reason: sum(assistant_tokens(assistants.get(turn)) for turn in reason_turns)
+        for reason, reason_turns in turns.items()
+    }
+    return {reason: len(reason_turns) for reason, reason_turns in turns.items()}, token_counts
+
+
+def score_from_obj(obj: dict[str, Any]) -> tuple[float | None, str | None]:
+    # Training reward logs contain the final reward under score. Prefer it over
+    # verifier-only score_ratio because it includes configured bonuses/penalties.
+    for key in ("score", "reward_score", "nanoclaw_score"):
+        value = number(obj.get(key))
+        if value is not None:
+            return value, key
+    summary = obj.get("score_summary")
+    if isinstance(summary, dict):
+        for key in ("score", "score_ratio"):
+            value = number(summary.get(key))
+            if value is not None:
+                return value, f"score_summary.{key}"
+    return None, None
+
+
+def build_reward_index(root: Path) -> dict[str, list[tuple[float, str, Path]]]:
+    index: dict[str, list[tuple[float, str, Path]]] = defaultdict(list)
+    reward_paths: list[Path] = []
+    for step_dir in root.glob("step_*"):
+        reward_dir = step_dir / "_reward_logs"
+        if reward_dir.is_dir():
+            reward_paths.extend(reward_dir.glob("*.reward.json"))
+    for path in sorted(reward_paths):
+        obj = load_json(path)
+        if not obj:
+            continue
+        score, source = score_from_obj(obj)
+        result_dir = obj.get("result_dir")
+        if score is None or not isinstance(result_dir, str):
+            continue
+        index[Path(result_dir).name].append((score, f"reward_log.{source}", path))
+    return index
+
+
+def load_sample_score(sample: Sample, reward_index: dict[str, list[tuple[float, str, Path]]]) -> None:
+    result_name = sample.result_dir.name
+    candidates = reward_index.get(result_name, [])
+    if candidates:
+        sample.score, sample.score_source, _ = candidates[-1]
+        return
+
+    # Useful when the run was rescored after training or reward logs were moved.
+    for filename in ("score_summary.json", "verifier_result.json"):
+        obj = load_json(sample.result_dir / filename)
+        if obj:
+            sample.score, sample.score_source = score_from_obj(obj)
+            if sample.score is not None:
+                return
+    for container_key in ("score_summary", "verifier"):
+        obj = sample.payload.get(container_key)
+        if isinstance(obj, dict):
+            sample.score, sample.score_source = score_from_obj(obj)
+            if sample.score is not None:
+                return
+
+
+def assign_group_advantages(samples: list[Sample], expected_group_size: int | None) -> dict[str, int]:
+    groups: dict[tuple[int | None, str], list[Sample]] = defaultdict(list)
+    for sample in samples:
+        groups[(sample.step, sample.task_id)].append(sample)
+    diagnostics = {"groups": len(groups), "complete_groups": 0, "incomplete_groups": 0, "missing_score_samples": 0}
+
+    for members in groups.values():
+        scores = [sample.score for sample in members]
+        complete = all(score is not None for score in scores)
+        if expected_group_size is not None and len(members) != expected_group_size:
+            complete = False
+        if not complete:
+            diagnostics["incomplete_groups"] += 1
+            diagnostics["missing_score_samples"] += sum(score is None for score in scores)
+            for sample in members:
+                sample.group_complete = False
+            continue
+
+        diagnostics["complete_groups"] += 1
+        numeric_scores = [float(score) for score in scores if score is not None]
+        # GRPO with a singleton group uses a zero baseline in the reference
+        # implementation; otherwise it uses the group mean.  Sign is unchanged
+        # by positive std normalization.
+        baseline = 0.0 if len(numeric_scores) == 1 else fmean(numeric_scores)
+        for sample in members:
+            assert sample.score is not None
+            sample.group_complete = True
+            sample.group_mean = baseline
+            sample.group_advantage = sample.score - baseline
+            sample.positive_by_group_score = sample.group_advantage > 0.0
+
+    return diagnostics
+
+
+def find_history_paths(root: Path, history_name: str) -> list[Path]:
+    paths: list[Path] = []
+    for step_dir in root.glob("step_*"):
+        if step_dir.is_dir():
+            paths.extend(step_dir.glob(f"*/{history_name}"))
+    if paths:
+        return sorted(path for path in paths if path.is_file())
+    # Compatibility fallback for older/non-canonical workplace layouts.
+    return sorted(path for path in root.rglob(history_name) if path.is_file())
+
+
+def parse_history_sample(path: Path) -> Sample | None:
+    payload = load_json(path)
+    if payload is None:
+        return None
+    result_dir, task_id, rollout_n = result_dir_and_identity(path, payload)
+    turn_counts, token_counts = candidate_counts(payload)
+    return Sample(
+        history_path=path,
+        result_dir=result_dir,
+        step=infer_step(path, payload),
+        task_id=task_id,
+        rollout_n=rollout_n,
+        payload=payload,
+        candidate_turns=turn_counts,
+        candidate_tokens=token_counts,
+    )
+
+
+def scan(root: Path, history_name: str, expected_group_size: int | None, workers: int) -> tuple[list[Sample], dict[str, int]]:
+    histories = find_history_paths(root, history_name)
+    reward_index = build_reward_index(root)
+    samples: list[Sample] = []
+    malformed = 0
+    worker_count = max(1, int(workers))
+    if worker_count == 1 or len(histories) <= 1:
+        parsed_iter = (parse_history_sample(path) for path in histories)
+        executor_context = None
+    else:
+        executor_context = concurrent.futures.ThreadPoolExecutor(max_workers=worker_count)
+        parsed_iter = executor_context.map(parse_history_sample, histories)
+    try:
+        for file_index, sample in enumerate(parsed_iter, start=1):
+            if file_index % 500 == 0 or file_index == len(histories):
+                print(f"[scan] parsed {file_index}/{len(histories)} histories", file=sys.stderr, flush=True)
+            if sample is None:
+                malformed += 1
+                continue
+            load_sample_score(sample, reward_index)
+            # Candidate counts and score metadata are retained; the full JSON
+            # event payload is no longer needed after this point.
+            sample.payload = {}
+            samples.append(sample)
+    finally:
+        if executor_context is not None:
+            executor_context.shutdown(wait=True)
+    diagnostics = {
+        "history_files": len(histories),
+        "loaded": len(samples),
+        "malformed": malformed,
+        "reward_records": sum(map(len, reward_index.values())),
+        "workers": worker_count,
+        "orjson": int(orjson is not None),
+    }
+    diagnostics.update(assign_group_advantages(samples, expected_group_size))
+    return samples, diagnostics
+
+
+def aggregate_rows(samples: list[Sample]) -> list[dict[str, Any]]:
+    grouped: dict[int | None, list[Sample]] = defaultdict(list)
+    for sample in samples:
+        grouped[sample.step].append(sample)
+    rows: list[dict[str, Any]] = []
+    for step in sorted(grouped, key=lambda value: (value is None, value if value is not None else 0)):
+        members = grouped[step]
+        row: dict[str, Any] = {"step": "unknown" if step is None else step, "samples": len(members)}
+        for reason in REASONS:
+            row[f"{reason}_candidate_turns"] = sum(sample.candidate_turns[reason] for sample in members)
+            row[f"{reason}_candidate_tokens"] = sum(sample.candidate_tokens[reason] for sample in members)
+            positive_members = [sample for sample in members if sample.positive_by_group_score is True]
+            row[f"{reason}_positive_masked_turns"] = sum(sample.candidate_turns[reason] for sample in positive_members)
+            row[f"{reason}_positive_masked_tokens"] = sum(sample.candidate_tokens[reason] for sample in positive_members)
+        row["scored_samples"] = sum(sample.score is not None for sample in members)
+        row["positive_group_score_samples"] = sum(sample.positive_by_group_score is True for sample in members)
+        row["incomplete_group_samples"] = sum(not sample.group_complete for sample in members)
+        for reason in REASONS:
+            row[f"{reason}_candidate_turns_per_sample"] = row[f"{reason}_candidate_turns"] / len(members) if members else 0.0
+            row[f"{reason}_positive_masked_turns_per_sample"] = row[f"{reason}_positive_masked_turns"] / len(members) if members else 0.0
+        rows.append(row)
+    return rows
+
+
+def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
+    fields = list(rows[0].keys()) if rows else ["step", "samples"]
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def write_sample_csv(path: Path, samples: list[Sample]) -> None:
+    fields = ["step", "task_id", "rollout_n", "result_dir", "score", "score_source", "group_mean", "group_advantage", "positive_by_group_score", "group_complete"]
+    for reason in REASONS:
+        fields.extend((f"{reason}_candidate_turns", f"{reason}_candidate_tokens"))
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        for sample in samples:
+            row: dict[str, Any] = {
+                "step": "unknown" if sample.step is None else sample.step,
+                "task_id": sample.task_id,
+                "rollout_n": sample.rollout_n,
+                "result_dir": str(sample.result_dir),
+                "score": sample.score,
+                "score_source": sample.score_source,
+                "group_mean": sample.group_mean,
+                "group_advantage": sample.group_advantage,
+                "positive_by_group_score": sample.positive_by_group_score,
+                "group_complete": sample.group_complete,
+            }
+            for reason in REASONS:
+                row[f"{reason}_candidate_turns"] = sample.candidate_turns[reason]
+                row[f"{reason}_candidate_tokens"] = sample.candidate_tokens[reason]
+            writer.writerow(row)
+
+
+def make_plot(output_dir: Path, rows: list[dict[str, Any]]) -> Path | None:
+    known = [row for row in rows if row["step"] != "unknown"]
+    if not known:
+        return None
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError:
+        print("WARNING: matplotlib is unavailable; CSV/JSON were written without plots.", file=sys.stderr)
+        return None
+    colors = {"looping_response": "#d62728", "budget_exhausted_last_turn": "#ff7f0e", "duplicate_tool_result_turn": "#2ca02c", "error_tool_result_turn": "#1f77b4"}
+    labels = {"looping_response": "looping", "budget_exhausted_last_turn": "budget exhausted", "duplicate_tool_result_turn": "duplicate tool", "error_tool_result_turn": "error tool"}
+    steps = [int(row["step"]) for row in known]
+    fig, axes = plt.subplots(2, 2, figsize=(15, 9), sharex="col", constrained_layout=True)
+    for reason in REASONS:
+        color, label = colors[reason], labels[reason]
+        axes[0, 0].plot(steps, [row[f"{reason}_candidate_turns"] for row in known], marker="o", color=color, label=label)
+        axes[0, 1].plot(steps, [row[f"{reason}_positive_masked_turns"] for row in known], marker="o", color=color, label=label)
+        axes[1, 0].plot(steps, [row[f"{reason}_candidate_tokens"] for row in known], marker="o", color=color, label=label)
+        axes[1, 1].plot(steps, [row[f"{reason}_positive_masked_tokens"] for row in known], marker="o", color=color, label=label)
+    axes[0, 0].set_title("candidate bad-turns")
+    axes[0, 1].set_title("positive group-score candidate turns")
+    axes[1, 0].set_title("candidate tokens")
+    axes[1, 1].set_title("positive group-score candidate tokens")
+    for row_axes in axes:
+        for axis in row_axes:
+            axis.grid(True, alpha=0.3)
+            axis.legend()
+    axes[1, 0].set_xlabel("training step")
+    axes[1, 1].set_xlabel("training step")
+    plot_path = output_dir / "nanoclaw_mask_candidates_and_positive_by_step.png"
+    fig.savefig(plot_path, dpi=160)
+    plt.close(fig)
+    return plot_path
+
+
+def main() -> int:
+    args = parse_args()
+    root = args.workplace_root.expanduser().resolve()
+    if not root.is_dir():
+        print(f"ERROR: workplace root is not a directory: {root}", file=sys.stderr)
+        return 2
+    output_dir = (args.output_dir or root / "mask_analysis").expanduser().resolve()
+    samples, diagnostics = scan(root, args.history_name, args.expected_group_size, args.workers)
+    rows = aggregate_rows(samples)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    summary_csv = output_dir / "nanoclaw_mask_8_metrics_by_step.csv"
+    sample_csv = output_dir / "nanoclaw_mask_group_scores_and_candidates.csv"
+    summary_json = output_dir / "nanoclaw_mask_8_metrics_by_step.json"
+    write_csv(summary_csv, rows)
+    write_sample_csv(sample_csv, samples)
+    plot_path = None if args.no_plot else make_plot(output_dir, rows)
+    summary_json.write_text(
+        json.dumps(
+            {
+                "workplace_root": str(root),
+                "history_name": args.history_name,
+                "expected_group_size": args.expected_group_size,
+                "advantage_reconstruction": "score - group_mean; singleton baseline=0; exact KL-in-reward advantage requires saved reward/advantage tensors",
+                "diagnostics": diagnostics,
+                "rows": rows,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    print(f"workplace root: {root}")
+    print(f"history files: {diagnostics['history_files']}, loaded: {diagnostics['loaded']}, malformed: {diagnostics['malformed']}")
+    print(f"history workers: {diagnostics['workers']}, orjson: {diagnostics['orjson']}")
+    print(f"reward records: {diagnostics['reward_records']}, groups: {diagnostics['groups']}, complete groups: {diagnostics['complete_groups']}")
+    print(f"incomplete groups: {diagnostics['incomplete_groups']}, missing-score samples: {diagnostics['missing_score_samples']}")
+    print(f"summary CSV: {summary_csv}")
+    print(f"group/sample CSV: {sample_csv}")
+    print(f"summary JSON: {summary_json}")
+    if plot_path:
+        print(f"plot: {plot_path}")
+    for row in rows:
+        print(
+            f"step={row['step']} samples={row['samples']} "
+            + " ".join(
+                f"{reason}={row[f'{reason}_candidate_turns']}/{row[f'{reason}_positive_masked_turns']} turns"
+                for reason in REASONS
+            )
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())