judge_training/data/build_from_claude_cot.py

"""Convert Claude CoT eval results to ms-swift JSONL training data.

Reads Claude eval JSON files (produced with cotnosubq.yaml), extracts
reasoning + scores, and builds TrainingSample records.

Usage:
    python -m judge_training.data.build_from_claude_cot convert \
        --prompt-config cotnosubq.yaml \
        --eval-dir data/scores/claude \
        --pattern 'eval_claude_cot_*.json'
"""

from __future__ import annotations

import argparse
import glob
import json
import logging
import sys
from pathlib import Path
from typing import Any

from evals.physics_criteria import get_criteria_text
from evals.prompts import GENERAL_DIMS, PromptConfig
from judge_training.data.sample import TrainingSample
from judge_training.data.build_records_from_db import build_records
from judge_training.data.build_swift_data import (
    add_common_convert_args,
    append_val_command_args,
    run_convert,
    validate_cli,
    write_test_splits,
)
from judge_training.data.naming import (
    prompt_config_stem,
    swift_train_path,
    swift_val_path,
)

logger = logging.getLogger(__name__)

MODULE = "judge_training.data.build_from_claude_cot"


def _parse_rationale(raw: Any) -> dict[str, str]:
    """Parse a rationale field that may be a JSON string or dict."""
    if isinstance(raw, dict):
        return raw
    if isinstance(raw, str):
        try:
            return json.loads(raw)
        except json.JSONDecodeError:
            return {}
    return {}


def _load_eval_results(eval_dir: str, pattern: str) -> list[dict[str, Any]]:
    """Load all eval result JSONs matching pattern, dedup by video stem."""
    files = sorted(glob.glob(str(Path(eval_dir) / pattern)))
    if not files:
        raise FileNotFoundError(f"No files matching {pattern} in {eval_dir}")

    seen: dict[str, dict[str, Any]] = {}
    for fpath in files:
        with open(fpath) as f:
            data = json.load(f)
        for result in data.get("results", []):
            video = result.get("video", "")
            if video:
                seen[video] = result
    logger.info("Loaded %d unique videos from %d files", len(seen), len(files))
    return list(seen.values())


def _build_human_score_lookup(
    db_path: str,
) -> dict[tuple[str, str], int]:
    """Build a lookup from (video_path, dim_or_law) -> human score."""
    records = build_records(db_path, active_only=False)
    lookup: dict[tuple[str, str], int] = {}
    for rec in records:
        vp = rec["video_path"]
        for dim, score in rec["general_scores"].items():
            lookup[(vp, dim)] = score
        for law, score in rec["physical_scores"].items():
            lookup[(vp, law)] = score
    return lookup


def _extract_cot_samples(
    results: list[dict[str, Any]],
    prompt_cfg: PromptConfig,
    model_prefix: str,
    base_dir: str,
    human_scores: dict[tuple[str, str], int],
) -> list[TrainingSample]:
    """Extract CoT training samples, keeping only where Claude score == human score."""
    samples: list[TrainingSample] = []
    skipped_no_reasoning = 0
    skipped_score_mismatch = 0
    skipped_no_human = 0

    for result in results:
        video_stem = result.get("video", "")
        prompt_text = result.get("prompt", "")
        if not video_stem or not prompt_text:
            continue

        video_path = f"data/videos/{model_prefix}/{video_stem}.mp4"

        rationale_general = _parse_rationale(result.get("rationale_general", "{}"))
        rationale_physical = _parse_rationale(result.get("rationale_physical", "{}"))

        for dim in GENERAL_DIMS:
            score = result.get(dim)
            if score is None or not isinstance(score, (int, float)):
                continue
            score = int(score)
            reasoning = rationale_general.get(dim, "")
            if not reasoning:
                skipped_no_reasoning += 1
                continue

            human = human_scores.get((video_path, dim))
            if human is None:
                skipped_no_human += 1
                continue
            if score != human:
                skipped_score_mismatch += 1
                continue

            try:
                samples.append(
                    TrainingSample.cot(
                        system=prompt_cfg.system_prompt,
                        user=prompt_cfg.build_training_prompt(prompt_text, dim),
                        video_path=video_path,
                        key=dim,
                        score=score,
                        reasoning=reasoning,
                        base_dir=base_dir,
                    )
                )
            except ValueError as e:
                logger.warning("Skip %s/%s: %s", video_stem, dim, e)

        physical_laws = result.get("physical_laws", [])
        physical_data = result.get("physical", {})
        laws_dict = physical_data.get("laws", {}) if isinstance(physical_data, dict) else {}

        for law in physical_laws:
            law_info = laws_dict.get(law, {})
            score = law_info.get("score")
            if score is None or not isinstance(score, (int, float)):
                continue
            score = int(score)

            reasoning = rationale_physical.get(law, "")
            if not reasoning:
                skipped_no_reasoning += 1
                continue

            human = human_scores.get((video_path, law))
            if human is None:
                skipped_no_human += 1
                continue
            if score != human:
                skipped_score_mismatch += 1
                continue

            criteria_text = get_criteria_text(law)
            if not criteria_text:
                continue

            try:
                samples.append(
                    TrainingSample.cot(
                        system=prompt_cfg.system_prompt,
                        user=prompt_cfg.build_physical_prompt(
                            prompt_text, law, criteria_text,
                        ),
                        video_path=video_path,
                        key=law,
                        score=score,
                        reasoning=reasoning,
                        base_dir=base_dir,
                    )
                )
            except ValueError as e:
                logger.warning("Skip %s/%s: %s", video_stem, law, e)

    if skipped_no_reasoning:
        logger.info("Skipped %d samples with empty reasoning", skipped_no_reasoning)
    if skipped_no_human:
        logger.info("Skipped %d samples with no human score", skipped_no_human)
    if skipped_score_mismatch:
        logger.info("Skipped %d samples where Claude != human score", skipped_score_mismatch)
    return samples


def _build_eval_records(
    eval_dir: str,
    pattern: str,
    model_prefixes: list[str],
) -> list[dict[str, Any]]:
    """Load eval results into prompt/model records for split assignment."""
    records: list[dict[str, Any]] = []

    for prefix in model_prefixes:
        model_pattern = pattern.replace("*", f"*{prefix}*")
        try:
            results = _load_eval_results(eval_dir, model_pattern)
        except FileNotFoundError:
            logger.warning("No files for %s, skipping", prefix)
            continue

        n_records = 0
        for result in results:
            prompt_text = result.get("prompt", "")
            video_stem = result.get("video", "")
            if not prompt_text or not video_stem:
                continue

            records.append(
                {
                    "prompt": prompt_text,
                    "video_model": prefix,
                    "result": result,
                }
            )
            n_records += 1

        logger.info("  %s: %d eval records", prefix, n_records)

    return records


def _records_to_samples(
    records: list[dict[str, Any]],
    prompt_cfg: PromptConfig,
    base_dir: str,
    human_scores: dict[tuple[str, str], int],
) -> list[TrainingSample]:
    """Convert split-assigned eval records into training samples."""
    model_to_results: dict[str, list[dict[str, Any]]] = {}
    for rec in records:
        model_to_results.setdefault(rec["video_model"], []).append(rec["result"])

    samples: list[TrainingSample] = []
    for model_prefix in sorted(model_to_results):
        model_results = model_to_results[model_prefix]
        model_samples = _extract_cot_samples(
            model_results,
            prompt_cfg,
            model_prefix,
            base_dir,
            human_scores,
        )
        logger.info(
            "    %s: %d results -> %d samples",
            model_prefix,
            len(model_results),
            len(model_samples),
        )
        samples.extend(model_samples)

    return samples


def _metadata(prompt_config: str) -> dict[str, object]:
    return {
        "prompt_config": prompt_config,
        "prompt_config_source": "cli",
        "label_source": "claude_cot",
        "target_format": "cot",
        "dims": [*GENERAL_DIMS, "physical_laws"],
        "score_scale": "1-5",
    }


def _build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Convert Claude CoT eval results to ms-swift JSONL.",
    )
    subparsers = parser.add_subparsers(dest="command")

    convert = subparsers.add_parser("convert", help="Build JSONL from Claude CoT evals")
    convert.add_argument("--output", default=None)
    convert.add_argument("--eval-dir", default="data/scores/claude")
    convert.add_argument("--pattern", default="eval_claude_cot_*.json")
    convert.add_argument("--model-prefix", action="append", dest="model_prefixes",
                         help="Model prefix(es) to include (repeat for multiple). "
                              "Default: infer from filenames.")
    convert.add_argument("--prompt-config", dest="prompt_config", required=True)
    convert.add_argument("--db-path", default="evals/human_eval/human_eval_filtered.db",
                         help="Path to human eval DB for score filtering")
    convert.add_argument(
        "--holdout-prompt-ratio",
        dest="holdout_prompt_ratio",
        type=float,
        default=0.1,
        help="Fraction of prompts to hold out (default: 0.1).",
    )
    convert.add_argument(
        "--prompt-seed",
        dest="prompt_seed",
        type=int,
        default=42,
        help="Random seed for prompt holdout sampling (default: 42)",
    )
    add_common_convert_args(convert)

    validate = subparsers.add_parser("validate", help="Validate a JSONL file")
    validate.add_argument("jsonl")
    return parser


def main(argv: list[str] | None = None) -> int:
    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
    parser = _build_parser()
    args = parser.parse_args(argv)

    if args.command == "validate":
        return validate_cli(args.jsonl)

    if args.command == "convert":
        stem = prompt_config_stem(args.prompt_config)
        data_stem = f"{stem}_claude_cot"
        if args.output is None:
            args.output = swift_train_path(data_stem)
        if args.val_output is None:
            args.val_output = swift_val_path(data_stem)

        prompt_cfg = PromptConfig.load(args.prompt_config)

        all_files = sorted(glob.glob(str(Path(args.eval_dir) / args.pattern)))
        if not all_files:
            logger.error("No files matching %s in %s", args.pattern, args.eval_dir)
            return 1

        if args.model_prefixes:
            prefixes = args.model_prefixes
        else:
            prefixes = set()
            for fpath in all_files:
                name = Path(fpath).stem
                parts = name.split("_humaneval_set_")
                if len(parts) == 2:
                    model = parts[1].rsplit("_", 2)[0]
                    prefixes.add(model)
            prefixes = sorted(prefixes)
            logger.info("Auto-detected model prefixes: %s", prefixes)

        human_scores = _build_human_score_lookup(args.db_path)
        logger.info("Loaded %d human score entries", len(human_scores))
        eval_records = _build_eval_records(args.eval_dir, args.pattern, prefixes)
        logger.info("Loaded %d eval records for split assignment", len(eval_records))

        from judge_training.data.build_records_from_db import split_by_prompt_and_model

        record_splits = split_by_prompt_and_model(
            eval_records,
            args.holdout_model,
            args.holdout_prompt_ratio,
            args.prompt_seed,
        )

        sample_splits = {
            name: _records_to_samples(recs, prompt_cfg, args.base_dir, human_scores)
            for name, recs in record_splits.items()
        }
        write_test_splits(sample_splits, data_stem)

        train_samples = sample_splits["train"]

        command_args = [
            "--eval-dir", args.eval_dir,
            "--pattern", args.pattern,
            "--prompt-config", args.prompt_config,
            "--db-path", args.db_path,
            "--holdout-prompt-ratio", str(args.holdout_prompt_ratio),
            "--prompt-seed", str(args.prompt_seed),
            "--output", args.output,
        ]
        if args.model_prefixes:
            for prefix in args.model_prefixes:
                command_args.extend(["--model-prefix", prefix])
        append_val_command_args(command_args, args)

        return run_convert(
            samples=train_samples,
            args=args,
            metadata=_metadata(args.prompt_config),
            module=MODULE,
            command_args=command_args,
        )

    parser.print_help()
    return 1


if __name__ == "__main__":
    sys.exit(main())