step_train/src/train/rl/trajectory.py

"""Anchor / Trajectory dataclasses for DAPO (rl_design §2.2 + single-sequence
token bookkeeping, Search-R1 style).

A Trajectory is ONE continuous interleaved sequence:
    decision-prompt + decision-generation + [RETRIEVED]…[/RETRIEVED] + answer-gen
recorded as full_ids (flat token id list) with an equal-length policy_token_mask
(True only for model-GENERATED decision tokens and answer tokens; prompt, retrieved
block, [ANS] marker, and the cartridge KV are all False — Search-R1 retrieved-token
masking). behavior_logprobs are computed AFTER rollout completes, BEFORE any optimizer
step, by a teacher-forcing recompute over full_ids (see rollout / logprob_recompute).

Decoupled DAPO adds:
  - forced_act: which strategy was forced (None = free)
  - loss_token_mask: superset of policy_token_mask (includes forced decision tokens)
  - decision_loss_mask / query_content_mask / answer_loss_mask: three disjoint segments
    that partition loss_token_mask exactly.
"""

from dataclasses import dataclass, field
from typing import List, Optional

import torch


@dataclass
class Anchor:
    user_id: str
    query: str
    gold_answer: str
    gold_aliases: List[str]
    gold_evidence_ids: List[str]
    oracle_label: str          # FIR ms_label (SM/PM/VM/NM)
    cartridge_path: str
    base_rank: int             # BGE-M3 top-10 window rank of original query (-1 outside)
    memory_bank_texts: List[str] = field(default_factory=list)  # for hallucination check
    question_date: Optional[str] = None


@dataclass
class Trajectory:
    anchor: Anchor

    # semantic decision fields
    ms: Optional[str] = None
    act: Optional[str] = None
    query_text: str = ""
    ms_logprob: Optional[float] = None  # sum of [MS:*] span token logprobs

    # retrieval
    retrieved: List[str] = field(default_factory=list)   # retrieved session_ids
    retrieved_tokens: int = 0
    retrieval_calls: int = 0
    new_rank: Optional[int] = None      # top-10 window rank after this query (-1 outside)

    # answer
    answer: str = ""
    answer_correct: bool = False
    answer_partial: bool = False   # token_f1 > threshold but not exact
    answer_f1: float = 0.0
    # LLM judge (filled by trainer/eval BEFORE compute_reward; None → fall back to EM/F1)
    judge_verdict: Optional[str] = None   # "correct" | "partial" | "wrong"
    judge_ok: bool = False                # True if the LLM judge returned (for fail-rate TB)
    gen_token_count: int = 0   # exact # answer tokens generated (before left-truncation)

    # single interleaved sequence bookkeeping
    full_ids: List[int] = field(default_factory=list)
    policy_token_mask: List[bool] = field(default_factory=list)
    ms_span_mask: List[bool] = field(default_factory=list)  # True over the [MS:*] tokens

    # --- decoupled DAPO masks (populated by rollout_one when forced_act is set) ---
    forced_act: Optional[str] = None  # None=free, "DIRECT"/"RETRIEVE"/"REWRITE"/"CLUE"
    loss_token_mask: List[bool] = field(default_factory=list)
    decision_loss_mask: List[bool] = field(default_factory=list)
    query_content_mask: List[bool] = field(default_factory=list)
    answer_loss_mask: List[bool] = field(default_factory=list)

    # logprobs (filled by logprob_recompute)
    behavior_logprobs: Optional[List[float]] = None   # detached, len == #True in mask

    # diagnostics
    format_valid: bool = True
    reward_breakdown: Optional[dict] = None

    def n_policy_tokens(self) -> int:
        return sum(self.policy_token_mask)

    def n_loss_tokens(self) -> int:
        """Number of tokens participating in policy loss (decoupled mode)."""
        if self.loss_token_mask:
            return sum(self.loss_token_mask)
        return self.n_policy_tokens()

    def get_decision_mask_in_loss(self) -> torch.Tensor:
        """Boolean mask over loss tokens: True at decision positions."""
        ltm = self.loss_token_mask or self.policy_token_mask
        dec = self.decision_loss_mask
        if not dec:
            return torch.zeros(sum(ltm), dtype=torch.bool)
        return torch.tensor([dec[i] for i, v in enumerate(ltm) if v], dtype=torch.bool)

    def get_query_content_mask_in_loss(self) -> torch.Tensor:
        """Boolean mask over loss tokens: True at query content positions."""
        ltm = self.loss_token_mask or self.policy_token_mask
        qcm = self.query_content_mask
        if not qcm:
            return torch.zeros(sum(ltm), dtype=torch.bool)
        return torch.tensor([qcm[i] for i, v in enumerate(ltm) if v], dtype=torch.bool)

    def get_answer_mask_in_loss(self) -> torch.Tensor:
        """Boolean mask over loss tokens: True at answer positions."""
        ltm = self.loss_token_mask or self.policy_token_mask
        alm = self.answer_loss_mask
        if not alm:
            return torch.ones(sum(ltm), dtype=torch.bool)
        return torch.tensor([alm[i] for i, v in enumerate(ltm) if v], dtype=torch.bool)