"""Generation-based val metrics after each Trainer evaluate() call.""" from __future__ import annotations import json import logging import time from pathlib import Path import torch from transformers import TrainerCallback from physics_model.eval import generate_many, summarize from physics_sft.metrics import flatten_eval_metrics, format_eval_table, score_prediction logger = logging.getLogger(__name__) _GLOO_GROUP = None class PhysicsValMetricsCallback(TrainerCallback): """After loss eval, greedy-decode a mixed val subset and log answer metrics.""" def __init__( self, processor, collator, eval_rows: list[dict], *, output_dir: Path, max_new_tokens: int = 512, max_samples: int | None = 32, gen_batch_size: int = 4, ) -> None: self.processor = processor self.collator = collator self.eval_rows = _take_mixed(list(eval_rows), max_samples) self.output_dir = Path(output_dir) self.max_new_tokens = int(max_new_tokens) self.gen_batch_size = max(1, int(gen_batch_size)) self._trainer = None self._last_summary: dict = {} def set_trainer(self, trainer) -> None: self._trainer = trainer def on_evaluate(self, args, state, control, metrics=None, **kwargs): if self._trainer is None and hasattr(self, "trainer"): self._trainer = self.trainer trainer = self._trainer if trainer is None or not self.eval_rows: return extra: dict = {} try: logger.info( "step %s: starting generation val on %s rows (batch=%s, max_new_tokens=%s)", state.global_step, len(self.eval_rows), self.gen_batch_size, self.max_new_tokens, ) t0 = time.time() extra = self._run(trainer, state.global_step) logger.info("step %s: generation val finished in %.1fs", state.global_step, time.time() - t0) if extra and trainer.accelerator.is_main_process: logger.info("\n%s", format_eval_table(self._last_summary, step=state.global_step)) except Exception: logger.exception("generation val failed; continuing training") extra = {} _cpu_barrier() if metrics is not None and extra: metrics.update(extra) if extra and trainer.accelerator.is_main_process: trainer.log(extra) @torch.no_grad() def _run(self, trainer, step: int) -> dict: accelerator = trainer.accelerator rank = int(accelerator.process_index) world = int(accelerator.num_processes) model = accelerator.unwrap_model(trainer.model) restore = _enable_fast_generate(model) was_training = model.training model.eval() _gloo_group() local_error = None detailed_part: list[dict] = [] my_rows = self.eval_rows[rank::world] try: preds = generate_many( model, self.processor, self.collator, my_rows, self.max_new_tokens, device=accelerator.device, batch_size=self.gen_batch_size, synced_gpus=False, ) detailed_part = [score_prediction(row, pred) for row, pred in zip(my_rows, preds)] logger.info("rank %s val generate %s/%s", rank, len(my_rows), len(self.eval_rows)) except Exception as exc: local_error = f"{type(exc).__name__}: {exc}" logger.exception("rank %s generation val failed", rank) finally: restore() if was_training: model.train() trainer.model.train() gathered = _all_gather_object({"rows": detailed_part, "error": local_error}) if any(part.get("error") for part in gathered): logger.warning("skipping val metrics because at least one rank failed") return {} detailed = _merge_sharded_rows(self.eval_rows, gathered, world) summary = summarize(detailed) self._last_summary = summary flat = {k: (None if _is_nan(v) else v) for k, v in flatten_eval_metrics(summary, prefix="eval").items()} if accelerator.is_main_process: payload = { "step": step, "n": len(detailed), "summary": summary, "metrics": flat, "rows": detailed, } self.output_dir.mkdir(parents=True, exist_ok=True) path = self.output_dir / f"eval_step_{step}.json" path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") logger.info("wrote val predictions %s", path) return flat def _enable_fast_generate(model): """Turn on KV cache and turn off checkpointing for decode; restore afterwards.""" modules = [] seen = set() stack = [model] if hasattr(model, "get_base_model"): stack.append(model.get_base_model()) if hasattr(model, "base_model"): stack.append(model.base_model) for module in stack: ident = id(module) if ident in seen: continue seen.add(ident) modules.append(module) snapshot = [] for module in modules: cfg = getattr(module, "config", None) snapshot.append( ( module, bool(getattr(cfg, "use_cache", False)) if cfg is not None else False, bool(getattr(module, "is_gradient_checkpointing", False)), ) ) if cfg is not None: cfg.use_cache = True if hasattr(module, "gradient_checkpointing_disable"): module.gradient_checkpointing_disable() def restore() -> None: for module, use_cache, had_gc in snapshot: cfg = getattr(module, "config", None) if cfg is not None: cfg.use_cache = use_cache if had_gc and hasattr(module, "gradient_checkpointing_enable"): module.gradient_checkpointing_enable() return restore def _gloo_group(): global _GLOO_GROUP import torch.distributed as dist if not dist.is_available() or not dist.is_initialized() or dist.get_world_size() <= 1: return None if _GLOO_GROUP is None: _GLOO_GROUP = dist.new_group(backend="gloo") return _GLOO_GROUP def _all_gather_object(obj): import torch.distributed as dist if not dist.is_available() or not dist.is_initialized() or dist.get_world_size() <= 1: return [obj] group = _gloo_group() gathered = [None] * dist.get_world_size() dist.all_gather_object(gathered, obj, group=group) return gathered def _cpu_barrier() -> None: import torch.distributed as dist if not dist.is_available() or not dist.is_initialized() or dist.get_world_size() <= 1: return dist.barrier(group=_gloo_group()) def _take_mixed(rows: list[dict], max_samples: int | None) -> list[dict]: if max_samples is None: return rows limit = max(0, int(max_samples)) if limit == 0 or len(rows) <= limit: return rows[:limit] images = [r for r in rows if r.get("has_image")] texts = [r for r in rows if not r.get("has_image")] n_img = min(len(images), limit // 2) n_txt = min(len(texts), limit - n_img) picked = images[:n_img] + texts[:n_txt] if len(picked) < limit: leftover = [r for r in rows if r not in picked] picked.extend(leftover[: limit - len(picked)]) return picked def _merge_sharded_rows(eval_rows: list[dict], gathered: list[dict], world: int) -> list[dict]: merged: list[dict | None] = [None] * len(eval_rows) for rank, part in enumerate(gathered): rows = part.get("rows") or [] idxs = range(rank, len(eval_rows), world) for idx, item in zip(idxs, rows): merged[idx] = item return [item for item in merged if item is not None] def _is_nan(value) -> bool: try: return value != value except Exception: return False