stepprobe/diagnose.py

"""
StepProbe: Step-Level Error Diagnosis

Uses an LLM judge (GPT-4o or Claude) to classify each divergent step
into one of four error types: conceptual, methodological, executional, logical.
Also determines the correctness of each step independently.
"""

import json
import os
import time
from typing import List, Dict, Optional, Tuple
from dataclasses import dataclass

from stepprobe.align import align_steps, StepAlignment
from stepprobe.utils import load_jsonl, save_jsonl, check_answer, extract_number


# ============================================================
# LLM Judge Prompts
# ============================================================

STEP_CORRECTNESS_PROMPT = """You are an expert mathematics and reasoning evaluator. You will be given:
1. A math/reasoning problem
2. The ground-truth solution (from a full-precision model)
3. A single reasoning step from a quantized model

Your task: Determine if the quantized model's step is CORRECT or INCORRECT.

A step is CORRECT if:
- The mathematical operations are valid
- The logic follows from previous steps
- No arithmetic errors are present
- The concept/method applied is appropriate

A step is INCORRECT if ANY of the above are violated.

Problem:
{problem}

Ground-truth solution context:
{ref_context}

Step to evaluate (from quantized model):
{hyp_step}

Respond with EXACTLY one of:
CORRECT
INCORRECT

Your judgment:"""

ERROR_CLASSIFICATION_PROMPT = """You are an expert at diagnosing reasoning errors in language models. You will be given:
1. A math/reasoning problem
2. The correct reasoning step (from a full-precision model)
3. The incorrect reasoning step (from a quantized model)

Classify the error into EXACTLY ONE of these four categories:

CONCEPTUAL: Wrong mathematical concept or theorem applied.
  Examples: Using addition instead of multiplication, applying wrong formula entirely,
  confusing probability with frequency, wrong theorem.

METHODOLOGICAL: Correct concept but wrong approach, setup, or formula application.
  Examples: Correct integration concept but wrong substitution, setting up equation
  incorrectly, wrong order of operations in a valid approach.

EXECUTIONAL: Correct method but arithmetic/computation errors.
  Examples: 7 × 8 = 54, carrying errors, decimal point mistakes, sign errors,
  simplification mistakes.

LOGICAL: Invalid logical inference or reasoning jump.
  Examples: Concluding A > C from A > B without B > C, circular reasoning,
  non-sequitur conclusions, ignoring edge cases, invalid generalizations.

Problem:
{problem}

Correct step (reference):
{ref_step}

Incorrect step (quantized):
{hyp_step}

Respond with EXACTLY one word from: CONCEPTUAL, METHODOLOGICAL, EXECUTIONAL, LOGICAL

Error type:"""


# ============================================================
# LLM Judge Interface
# ============================================================

class LLMJudge:
    """Interface for LLM-based step evaluation."""

    def __init__(self, provider: str = "openai", model: str = "gpt-4o", temperature: float = 0.0):
        self.provider = provider
        self.model = model
        self.temperature = temperature
        self._client = None

    def _get_client(self):
        if self._client is not None:
            return self._client
        if self.provider == "openai":
            from openai import OpenAI
            self._client = OpenAI()
        elif self.provider == "anthropic":
            from anthropic import Anthropic
            self._client = Anthropic()
        else:
            raise ValueError(f"Unknown provider: {self.provider}")
        return self._client

    def _call(self, prompt: str) -> str:
        client = self._get_client()
        for attempt in range(3):
            try:
                if self.provider == "openai":
                    resp = client.chat.completions.create(
                        model=self.model,
                        messages=[{"role": "user", "content": prompt}],
                        temperature=self.temperature,
                        max_tokens=50,
                    )
                    return resp.choices[0].message.content.strip()
                elif self.provider == "anthropic":
                    resp = client.messages.create(
                        model=self.model,
                        max_tokens=50,
                        temperature=self.temperature,
                        messages=[{"role": "user", "content": prompt}],
                    )
                    return resp.content[0].text.strip()
            except Exception as e:
                print(f"  [Judge] Attempt {attempt+1} failed: {e}")
                time.sleep(2 ** attempt)
        return "ERROR"

    def judge_correctness(self, problem: str, ref_context: str, hyp_step: str) -> bool:
        """Judge whether a single step is correct."""
        prompt = STEP_CORRECTNESS_PROMPT.format(
            problem=problem,
            ref_context=ref_context,
            hyp_step=hyp_step,
        )
        result = self._call(prompt).upper()
        return "CORRECT" in result

    def classify_error(self, problem: str, ref_step: str, hyp_step: str) -> str:
        """Classify an incorrect step into one of four error types."""
        prompt = ERROR_CLASSIFICATION_PROMPT.format(
            problem=problem,
            ref_step=ref_step,
            hyp_step=hyp_step,
        )
        result = self._call(prompt).upper()
        for etype in ["CONCEPTUAL", "METHODOLOGICAL", "EXECUTIONAL", "LOGICAL"]:
            if etype in result:
                return etype.lower()
        return "executional"  # default fallback


class RuleBasedJudge:
    """
    Fast, free, heuristic-based judge for initial screening.
    Uses the reference answer to determine final-answer correctness,
    and simple heuristics for step-level checks.
    """

    def judge_correctness(self, problem: str, ref_context: str, hyp_step: str) -> bool:
        """Heuristic: check if key numbers from reference appear in hypothesis."""
        import re
        ref_nums = set(re.findall(r"-?\d+\.?\d*", ref_context))
        hyp_nums = set(re.findall(r"-?\d+\.?\d*", hyp_step))
        # If the step introduces a number not in the reference, flag it
        novel_nums = hyp_nums - ref_nums
        # Very rough heuristic: if many novel numbers, likely wrong
        if len(novel_nums) > 3:
            return False
        return True

    def classify_error(self, problem: str, ref_step: str, hyp_step: str) -> str:
        """Heuristic classification based on text patterns."""
        import re
        hyp_lower = hyp_step.lower()

        # Check for arithmetic errors
        ref_nums = re.findall(r"\d+\s*[+\-*/×÷]\s*\d+\s*=\s*(\d+)", ref_step)
        hyp_nums = re.findall(r"\d+\s*[+\-*/×÷]\s*\d+\s*=\s*(\d+)", hyp_step)
        if ref_nums and hyp_nums and ref_nums != hyp_nums:
            return "executional"

        # Check for method keywords divergence
        method_words = ["substitute", "integrate", "differentiate", "factor", "expand", "simplify"]
        ref_methods = [w for w in method_words if w in ref_step.lower()]
        hyp_methods = [w for w in method_words if w in hyp_lower]
        if ref_methods and hyp_methods and set(ref_methods) != set(hyp_methods):
            return "methodological"

        # Check for logical connectors misuse
        logic_words = ["therefore", "because", "since", "implies", "hence", "thus"]
        if any(w in hyp_lower for w in logic_words):
            return "logical"

        return "conceptual"


# ============================================================
# Diagnosis Pipeline
# ============================================================

def diagnose_single_problem(
    problem_text: str,
    gold_answer: str,
    ref_trace: dict,
    hyp_trace: dict,
    judge: LLMJudge = None,
    alignment_method: str = "dtw",
) -> dict:
    """
    Diagnose a single problem: align steps, judge correctness, classify errors.

    Returns:
        Updated hyp_trace dict with is_correct and error_type filled in for each step.
    """
    ref_steps = ref_trace.get("steps", [])
    hyp_steps = hyp_trace.get("steps", [])

    # Check final answer correctness
    hyp_answer = hyp_trace.get("final_answer", "")
    is_correct_final = check_answer(hyp_answer, gold_answer)

    # If final answer is correct, assume all steps are correct (optimistic)
    if is_correct_final:
        for step in hyp_steps:
            step["is_correct"] = True
            step["error_type"] = None
        hyp_trace["is_correct_final"] = True
        hyp_trace["steps"] = hyp_steps
        return hyp_trace

    # Final answer is wrong: find where it went wrong
    hyp_trace["is_correct_final"] = False

    # Align steps
    alignments = align_steps(ref_steps, hyp_steps, method=alignment_method)

    # Build reference context (full solution)
    ref_context = "\n".join(s["text"] for s in ref_steps)

    # Judge each step
    found_first_error = False
    for alignment in alignments:
        if alignment.hyp_index is None:
            continue  # deleted step, skip

        hyp_step_dict = None
        for s in hyp_steps:
            if s["index"] == alignment.hyp_index:
                hyp_step_dict = s
                break
        if hyp_step_dict is None:
            continue

        if alignment.alignment_type == "match" and alignment.similarity > 0.85:
            # High similarity to reference -> likely correct
            hyp_step_dict["is_correct"] = True
            hyp_step_dict["error_type"] = None
        elif judge is not None:
            # Use LLM judge
            is_correct = judge.judge_correctness(
                problem=problem_text,
                ref_context=ref_context,
                hyp_step=hyp_step_dict["text"],
            )
            hyp_step_dict["is_correct"] = is_correct

            if not is_correct:
                found_first_error = True
                ref_text = alignment.ref_text if alignment.ref_text else ref_context
                error_type = judge.classify_error(
                    problem=problem_text,
                    ref_step=ref_text,
                    hyp_step=hyp_step_dict["text"],
                )
                hyp_step_dict["error_type"] = error_type
            else:
                hyp_step_dict["error_type"] = None
        else:
            # No judge: use alignment similarity as proxy
            if alignment.similarity > 0.6:
                hyp_step_dict["is_correct"] = True
                hyp_step_dict["error_type"] = None
            else:
                hyp_step_dict["is_correct"] = False
                # Use rule-based classification
                rb = RuleBasedJudge()
                hyp_step_dict["error_type"] = rb.classify_error(
                    problem=problem_text,
                    ref_step=alignment.ref_text,
                    hyp_step=hyp_step_dict["text"],
                )

    # If final answer is wrong but we found no step-level error, mark last step
    if not is_correct_final and not any(s.get("is_correct") == False for s in hyp_steps):
        if hyp_steps:
            hyp_steps[-1]["is_correct"] = False
            hyp_steps[-1]["error_type"] = "executional"

    hyp_trace["steps"] = hyp_steps
    return hyp_trace


def diagnose_batch(
    ref_traces: List[dict],
    hyp_traces: List[dict],
    problems: List[dict],
    judge: LLMJudge = None,
    alignment_method: str = "dtw",
    verbose: bool = True,
) -> List[dict]:
    """
    Diagnose a batch of problems.

    Args:
        ref_traces: Segmented FP16 traces (list of dicts)
        hyp_traces: Segmented quantized traces (list of dicts)
        problems: Original problems with gold answers
        judge: LLMJudge instance (None = use heuristic)
        alignment_method: "dtw" or "index"

    Returns:
        List of diagnosed hyp_traces with is_correct and error_type filled in
    """
    # Build lookup by problem_id
    ref_by_id = {t["problem_id"]: t for t in ref_traces}
    prob_by_id = {p.get("problem_id", p.get("id", "")): p for p in problems}

    diagnosed = []
    n_correct = 0
    n_total = 0

    from tqdm import tqdm
    iterator = tqdm(hyp_traces, desc="Diagnosing") if verbose else hyp_traces

    for hyp_trace in iterator:
        pid = hyp_trace["problem_id"]
        ref_trace = ref_by_id.get(pid)
        prob = prob_by_id.get(pid, {})

        if ref_trace is None:
            print(f"  [WARN] No reference trace for {pid}, skipping")
            continue

        gold_answer = prob.get("gold_answer", prob.get("answer", ""))
        problem_text = prob.get("question", prob.get("problem", ""))

        result = diagnose_single_problem(
            problem_text=problem_text,
            gold_answer=gold_answer,
            ref_trace=ref_trace,
            hyp_trace=hyp_trace,
            judge=judge,
            alignment_method=alignment_method,
        )
        diagnosed.append(result)

        n_total += 1
        if result.get("is_correct_final"):
            n_correct += 1

    if verbose:
        if n_total > 0:
            print(f"\nDiagnosis complete: {n_correct}/{n_total} correct ({n_correct/n_total:.1%})")
        else:
            print("\nDiagnosis complete: no hypothesis traces matched a reference — check that "
                  "ref/hyp jsonls share problem_ids and filenames.")

    return diagnosed


# ============================================================
# CLI
# ============================================================

if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Diagnose step-level errors in quantized reasoning traces")
    parser.add_argument("--ref", required=True, help="Directory with segmented FP16 traces")
    parser.add_argument("--hyp", required=True, help="Directory with segmented quantized traces")
    parser.add_argument("--problems", default=None, help="JSONL file with original problems + gold answers")
    parser.add_argument("--output", required=True, help="Output directory")
    parser.add_argument("--judge", default="none", choices=["openai", "anthropic", "none"],
                        help="LLM judge provider (none = heuristic only)")
    parser.add_argument("--judge-model", default="gpt-4o", help="Judge model name")
    parser.add_argument("--alignment", default="dtw", choices=["dtw", "index"])
    args = parser.parse_args()

    os.makedirs(args.output, exist_ok=True)

    # Set up judge
    judge = None
    if args.judge != "none":
        judge = LLMJudge(provider=args.judge, model=args.judge_model)
        print(f"Using LLM judge: {args.judge}/{args.judge_model}")
    else:
        print("Using heuristic-based diagnosis (no API calls)")

    # Load traces. Pair ref/hyp by FILENAME, not by position — pairing by
    # position breaks when ref and hyp have different numbers of files (e.g.
    # ref holds {gsm8k, math500, gpqa}.jsonl but hyp only has math500.jsonl,
    # which would otherwise silently pair gsm8k-ref with math500-hyp).
    import glob
    ref_files = sorted(glob.glob(os.path.join(args.ref, "*.jsonl")))
    hyp_files = sorted(glob.glob(os.path.join(args.hyp, "*.jsonl")))
    ref_by_name = {os.path.basename(f): f for f in ref_files}

    for hyp_f in hyp_files:
        ref_f = ref_by_name.get(os.path.basename(hyp_f))
        if ref_f is None:
            print(f"  [SKIP] No matching reference for {os.path.basename(hyp_f)}")
            continue
        print(f"\nProcessing: {os.path.basename(ref_f)} vs {os.path.basename(hyp_f)}")

        ref_traces = load_jsonl(ref_f)
        hyp_traces = load_jsonl(hyp_f)

        # Load problems if provided, otherwise reconstruct from traces
        if args.problems:
            problems = load_jsonl(args.problems)
        else:
            problems = []
            for t in ref_traces:
                problems.append({
                    "problem_id": t["problem_id"],
                    "question": t.get("raw_output", "")[:200],
                    "gold_answer": t.get("final_answer", ""),
                })

        diagnosed = diagnose_batch(
            ref_traces=ref_traces,
            hyp_traces=hyp_traces,
            problems=problems,
            judge=judge,
            alignment_method=args.alignment,
        )

        out_path = os.path.join(args.output, os.path.basename(hyp_f))
        save_jsonl(diagnosed, out_path)
        print(f"  Saved {len(diagnosed)} diagnosed traces -> {out_path}")

    print("\nDiagnosis pipeline complete!")