| """Optional-image chat collator with assistant-only loss and left-prompt truncate.""" |
|
|
| from __future__ import annotations |
|
|
| import logging |
| from pathlib import Path |
| from typing import Any |
|
|
| import torch |
| from PIL import Image |
|
|
| from physics_sft.prompts import build_system_prompt |
|
|
| from .load import VISION_TOKEN_IDS |
|
|
| logger = logging.getLogger(__name__) |
|
|
| IGNORE_INDEX = -100 |
| SYSTEM_PROMPT = build_system_prompt() |
|
|
|
|
| def resolve_image_file(image_path: str | None, repo_root: Path) -> Path | None: |
| if not image_path: |
| return None |
| path = Path(image_path) |
| if path.is_file(): |
| return path |
| candidate = repo_root / image_path |
| if candidate.is_file(): |
| return candidate |
| raise FileNotFoundError(f"image_path does not exist: {image_path}") |
|
|
|
|
| def build_messages( |
| question: str, |
| assistant: str | None, |
| *, |
| has_image: bool, |
| ) -> list[dict[str, Any]]: |
| user_content: list[dict[str, Any]] = [] |
| if has_image: |
| user_content.append({"type": "image"}) |
| user_content.append({"type": "text", "text": question}) |
| messages: list[dict[str, Any]] = [ |
| {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]}, |
| {"role": "user", "content": user_content}, |
| ] |
| if assistant is not None: |
| messages.append({"role": "assistant", "content": [{"type": "text", "text": assistant}]}) |
| return messages |
|
|
|
|
| class PhysicsVLCollator: |
| def __init__( |
| self, |
| processor, |
| *, |
| repo_root: str | Path, |
| max_length: int = 4096, |
| log_overflow: bool = True, |
| ) -> None: |
| self.processor = processor |
| self.repo_root = Path(repo_root) |
| self.max_length = max_length |
| self.log_overflow = log_overflow |
| self.overflow_count = 0 |
| self.seen = 0 |
| self.tokenizer = processor.tokenizer |
| if self.tokenizer.pad_token_id is None: |
| self.tokenizer.pad_token = self.tokenizer.eos_token |
| self.tokenizer.padding_side = "right" |
|
|
| def reset_stats(self) -> None: |
| self.overflow_count = 0 |
| self.seen = 0 |
|
|
| def _open_image(self, example: dict[str, Any]) -> Image.Image | None: |
| if not example.get("has_image"): |
| return None |
| path = resolve_image_file(example.get("image_path"), self.repo_root) |
| if path is None: |
| raise ValueError(f"has_image=true but image_path is empty for id={example.get('id')}") |
| return Image.open(path).convert("RGB") |
|
|
| def _encode_text( |
| self, |
| messages: list[dict[str, Any]], |
| image: Image.Image | None, |
| add_generation_prompt: bool, |
| ) -> dict[str, torch.Tensor]: |
| text = self.processor.apply_chat_template( |
| messages, |
| tokenize=False, |
| add_generation_prompt=add_generation_prompt, |
| ) |
| kwargs: dict[str, Any] = { |
| "text": [text], |
| "return_tensors": "pt", |
| "padding": False, |
| } |
| if image is not None: |
| kwargs["images"] = [image] |
| encoded = self.processor(**kwargs) |
| return encoded |
|
|
| def encode_example(self, example: dict[str, Any], *, include_assistant: bool = True) -> dict[str, torch.Tensor]: |
| has_image = bool(example.get("has_image")) |
| image = self._open_image(example) if has_image else None |
| assistant = example.get("assistant") if include_assistant else None |
| full_messages = build_messages(example["question"], assistant, has_image=has_image) |
| prompt_messages = build_messages(example["question"], None, has_image=has_image) |
|
|
| full = self._encode_text(full_messages, image, add_generation_prompt=not include_assistant) |
| prompt = self._encode_text(prompt_messages, image, add_generation_prompt=True) |
|
|
| input_ids = full["input_ids"][0] |
| attention_mask = full["attention_mask"][0] |
| prompt_len = int(prompt["input_ids"].shape[-1]) |
| if prompt_len > int(input_ids.shape[-1]): |
| prompt_len = int(input_ids.shape[-1]) |
|
|
| input_ids, attention_mask, prompt_len = self._left_truncate_prompt(input_ids, attention_mask, prompt_len) |
|
|
| labels = input_ids.clone() |
| labels[:prompt_len] = IGNORE_INDEX |
| pad_id = self.tokenizer.pad_token_id |
| if pad_id is not None: |
| labels[input_ids == pad_id] = IGNORE_INDEX |
| for token_id in VISION_TOKEN_IDS: |
| labels[input_ids == token_id] = IGNORE_INDEX |
|
|
| out: dict[str, torch.Tensor] = { |
| "input_ids": input_ids, |
| "attention_mask": attention_mask, |
| "labels": labels, |
| } |
| |
| if "pixel_values" in full: |
| out["pixel_values"] = full["pixel_values"] |
| if "image_grid_thw" in full: |
| out["image_grid_thw"] = full["image_grid_thw"] |
| return out |
|
|
| def _left_truncate_prompt( |
| self, |
| input_ids: torch.Tensor, |
| attention_mask: torch.Tensor, |
| prompt_len: int, |
| ) -> tuple[torch.Tensor, torch.Tensor, int]: |
| total = int(input_ids.shape[-1]) |
| self.seen += 1 |
| if total <= self.max_length: |
| return input_ids, attention_mask, prompt_len |
| self.overflow_count += 1 |
| assistant_len = total - prompt_len |
| if assistant_len >= self.max_length: |
| if self.log_overflow: |
| logger.warning( |
| "assistant span %s >= max_length %s; keeping assistant tail", |
| assistant_len, |
| self.max_length, |
| ) |
| return input_ids[-self.max_length :], attention_mask[-self.max_length :], 0 |
| drop = total - self.max_length |
| keep_prompt = prompt_len - drop |
| if self.log_overflow and self.overflow_count <= 8: |
| logger.warning("left-truncating prompt by %s tokens (total=%s)", drop, total) |
| return input_ids[drop:], attention_mask[drop:], keep_prompt |
|
|
| def __call__(self, examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]: |
| flags = [bool(ex.get("has_image")) for ex in examples] |
| if len(set(flags)) > 1: |
| raise ValueError("mixed image/text batch: bucket by has_image before collating") |
| encoded = [self.encode_example(ex, include_assistant=True) for ex in examples] |
| return self.pad_batch(encoded) |
|
|
| def pad_batch(self, encoded: list[dict[str, torch.Tensor]]) -> dict[str, torch.Tensor]: |
| pad_id = self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else 0 |
| max_len = max(int(item["input_ids"].shape[-1]) for item in encoded) |
| input_ids = [] |
| attention_mask = [] |
| labels = [] |
| for item in encoded: |
| pad = max_len - int(item["input_ids"].shape[-1]) |
| if pad: |
| input_ids.append(torch.nn.functional.pad(item["input_ids"], (0, pad), value=pad_id)) |
| attention_mask.append(torch.nn.functional.pad(item["attention_mask"], (0, pad), value=0)) |
| labels.append(torch.nn.functional.pad(item["labels"], (0, pad), value=IGNORE_INDEX)) |
| else: |
| input_ids.append(item["input_ids"]) |
| attention_mask.append(item["attention_mask"]) |
| labels.append(item["labels"]) |
| batch: dict[str, torch.Tensor] = { |
| "input_ids": torch.stack(input_ids, dim=0), |
| "attention_mask": torch.stack(attention_mask, dim=0), |
| "labels": torch.stack(labels, dim=0), |
| } |
| if "pixel_values" in encoded[0]: |
| batch["pixel_values"] = torch.cat([item["pixel_values"] for item in encoded], dim=0) |
| if "image_grid_thw" in encoded[0]: |
| batch["image_grid_thw"] = torch.cat([item["image_grid_thw"] for item in encoded], dim=0) |
| return batch |
|
|
|
|
| def summarize_label_mask(batch: dict[str, torch.Tensor]) -> dict[str, Any]: |
| labels = batch["labels"] |
| input_ids = batch["input_ids"] |
| vision = torch.zeros_like(input_ids, dtype=torch.bool) |
| for token_id in VISION_TOKEN_IDS: |
| vision |= input_ids == token_id |
| pad_id = None |
| stats = { |
| "n": int(labels.shape[0]), |
| "seq_len": int(labels.shape[1]), |
| "n_ignored": int((labels == IGNORE_INDEX).sum().item()), |
| "n_supervised": int((labels != IGNORE_INDEX).sum().item()), |
| "vision_unmasked": int(((labels != IGNORE_INDEX) & vision).sum().item()), |
| } |
| if pad_id is not None: |
| stats["pad_unmasked"] = int(((labels != IGNORE_INDEX) & (input_ids == pad_id)).sum().item()) |
| return stats |
|
|
|
|
| def tensors_for_generate(encoded: dict[str, torch.Tensor], device: torch.device | str) -> dict[str, torch.Tensor]: |
| """Move one encoded example onto device for greedy decode. Do not batch-unsqueeze vision tensors.""" |
| batch: dict[str, torch.Tensor] = {} |
| for key, value in encoded.items(): |
| if key == "labels" or not torch.is_tensor(value): |
| continue |
| tensor = value |
| if key in {"input_ids", "attention_mask"} and tensor.dim() == 1: |
| tensor = tensor.unsqueeze(0) |
| batch[key] = tensor.to(device) |
| return batch |
|
|
|
|
| def token_length_percentiles(lengths: list[int]) -> dict[str, float]: |
| if not lengths: |
| return {"p50": 0.0, "p95": 0.0, "max": 0.0, "n": 0} |
| ordered = sorted(lengths) |
| n = len(ordered) |
|
|
| def pct(p: float) -> float: |
| idx = min(n - 1, max(0, int(round((p / 100.0) * (n - 1))))) |
| return float(ordered[idx]) |
|
|
| return {"p50": pct(50), "p95": pct(95), "max": float(ordered[-1]), "n": n} |
|
|
