| """Pinned Hugging Face materialization for untouched retention benchmarks. |
| |
| The legacy freeze path consumed hand-exported ``native rows`` whose fixture |
| shape did not match the real repositories (MMMU-Pro has ``image_1..image_7`` |
| and stringified options; MathVista uses ``pid``; MMLU-Pro uses |
| ``question_id``). This module loads the exact revisions in resources.yaml and |
| normalizes the real schemas directly into the common evaluation manifest. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import ast |
| import io |
| from collections import Counter |
| from collections.abc import Callable, Mapping, Sequence |
| from pathlib import Path |
| from typing import Any, cast |
|
|
| from ..atomic_io import atomic_write_bytes, atomic_write_jsonl |
| from ..config import ResourcesManifest |
| from ..hashing import canonical_json_hash |
| from ..ingest.base import canonicalize_mc_answer, infer_open_answer_type, mc_choices |
| from .core import ( |
| EvaluationError, |
| flatten_retention_items, |
| load_evaluation_manifest, |
| ) |
|
|
| RETENTION_SOURCES: tuple[str, ...] = ( |
| "mmmu_pro", |
| "mathvision", |
| "mathvista", |
| "mmlu_pro_text", |
| ) |
|
|
| _SOURCE_SPECS: dict[str, tuple[str, str, int]] = { |
| "mmmu_pro": ("standard (10 options)", "test", 1_730), |
| "mathvision": ("default", "testmini", 304), |
| "mathvista": ("default", "testmini", 1_000), |
| "mmlu_pro_text": ("default", "test", 12_032), |
| } |
|
|
| DatasetLoader = Callable[..., Sequence[Mapping[str, Any]]] |
|
|
|
|
| def _load_dataset( |
| repo_id: str, |
| config: str, |
| *, |
| split: str, |
| revision: str, |
| cache_dir: str | None, |
| ) -> Sequence[Mapping[str, Any]]: |
| try: |
| from datasets import load_dataset |
| except ImportError as exc: |
| raise EvaluationError(f"datasets is required for retention download: {exc}") from exc |
| return cast( |
| Sequence[Mapping[str, Any]], |
| load_dataset( |
| repo_id, |
| config, |
| split=split, |
| revision=revision, |
| cache_dir=cache_dir, |
| ), |
| ) |
|
|
|
|
| def _options(value: Any, *, source: str, native_id: str) -> list[str]: |
| if value in (None, ""): |
| return [] |
| parsed = value |
| if isinstance(value, str): |
| try: |
| parsed = ast.literal_eval(value) |
| except (SyntaxError, ValueError) as exc: |
| raise EvaluationError( |
| f"{source}/{native_id}: options string is not a Python list literal" |
| ) from exc |
| if not isinstance(parsed, Sequence) or isinstance(parsed, str | bytes | bytearray): |
| raise EvaluationError(f"{source}/{native_id}: options must be a sequence") |
| result = [str(option) for option in parsed] |
| if any(not option for option in result): |
| raise EvaluationError(f"{source}/{native_id}: options contain an empty value") |
| return result |
|
|
|
|
| def _native_id(source: str, row: Mapping[str, Any]) -> str: |
| field = { |
| "mmmu_pro": "id", |
| "mathvision": "id", |
| "mathvista": "pid", |
| "mmlu_pro_text": "question_id", |
| }[source] |
| value = row.get(field) |
| if value is None or not str(value): |
| raise EvaluationError(f"{source}: row has no {field}") |
| return str(value) |
|
|
|
|
| def _image_values(source: str, row: Mapping[str, Any]) -> list[Any]: |
| if source == "mmmu_pro": |
| return [row.get(f"image_{index}") for index in range(1, 8) if row.get(f"image_{index}")] |
| if source in {"mathvision", "mathvista"}: |
| value = row.get("decoded_image") |
| return [value] if value is not None else [] |
| return [] |
|
|
|
|
| def _png_bytes(value: Any, *, label: str) -> bytes: |
| try: |
| from PIL import Image, ImageOps |
| except ImportError as exc: |
| raise EvaluationError(f"Pillow is required for retention images: {exc}") from exc |
| image: Any |
| try: |
| if isinstance(value, Image.Image): |
| image = value.copy() |
| elif isinstance(value, Mapping) and isinstance(value.get("bytes"), bytes): |
| image = Image.open(io.BytesIO(value["bytes"])).copy() |
| elif isinstance(value, Mapping) and isinstance(value.get("path"), str): |
| image = Image.open(str(value["path"])).copy() |
| elif isinstance(value, str | Path): |
| image = Image.open(str(value)).copy() |
| else: |
| raise EvaluationError(f"{label}: unsupported decoded image value") |
| image = ImageOps.exif_transpose(image).convert("RGB") |
| buffer = io.BytesIO() |
| image.save(buffer, format="PNG", optimize=False) |
| return buffer.getvalue() |
| except (OSError, ValueError) as exc: |
| raise EvaluationError(f"{label}: cannot decode image: {exc}") from exc |
|
|
|
|
| def _store_images( |
| source: str, |
| row_index: int, |
| native_id: str, |
| values: Sequence[Any], |
| asset_root: Path, |
| ) -> list[str]: |
| if source != "mmlu_pro_text" and not values: |
| raise EvaluationError(f"{source}/{native_id}: visual retention row has no image") |
| paths: list[str] = [] |
| for image_index, value in enumerate(values): |
| relative = Path(source) / f"{row_index:06d}" / f"image-{image_index}.png" |
| atomic_write_bytes( |
| asset_root / relative, |
| _png_bytes(value, label=f"{source}/{native_id} image {image_index}"), |
| fsync_dir=False, |
| ) |
| paths.append(relative.as_posix()) |
| return paths |
|
|
|
|
| def _item( |
| source: str, |
| row: Mapping[str, Any], |
| *, |
| row_index: int, |
| revision: str, |
| config: str, |
| split: str, |
| asset_root: Path, |
| ) -> dict[str, Any]: |
| native_id = _native_id(source, row) |
| question = row.get("question") |
| answer = row.get("answer") |
| if not isinstance(question, str) or not question.strip(): |
| raise EvaluationError(f"{source}/{native_id}: question is empty") |
| if answer is None or not str(answer).strip(): |
| raise EvaluationError(f"{source}/{native_id}: answer is empty") |
| raw_options = _options( |
| row.get("options") if source != "mathvista" else row.get("choices"), |
| source=source, |
| native_id=native_id, |
| ) |
| choices = [choice.to_dict() for choice in mc_choices(raw_options)] |
| if choices: |
| answer_type = "multiple_choice" |
| canonical_answer = canonicalize_mc_answer(str(answer), mc_choices(raw_options)) |
| else: |
| answer_type = infer_open_answer_type(str(answer)) |
| canonical_answer = str(answer) |
| image_paths = _store_images( |
| source, |
| row_index, |
| native_id, |
| _image_values(source, row), |
| asset_root, |
| ) |
| return { |
| "base_id": canonical_json_hash( |
| { |
| "source": source, |
| "revision": revision, |
| "config": config, |
| "split": split, |
| "native_id": native_id, |
| } |
| ), |
| "source": source, |
| "source_revision": revision, |
| "source_config": config, |
| "source_split": split, |
| "question": question, |
| "choices": choices, |
| "image_paths": image_paths, |
| "answer_type": answer_type, |
| "answer_canonical": canonical_answer, |
| "subject": str(row.get("subject") or row.get("category") or "unknown"), |
| } |
|
|
|
|
| def _existing_summary( |
| output_path: Path, |
| asset_root: Path, |
| *, |
| expected_sources: Sequence[str], |
| ) -> dict[str, Any]: |
| rows = load_evaluation_manifest(output_path) |
| for row in rows: |
| images = row.get("images") |
| if not isinstance(images, list): |
| raise EvaluationError("existing retention row images are malformed") |
| for image in images: |
| if not isinstance(image, Mapping) or not isinstance(image.get("path"), str): |
| raise EvaluationError("existing retention image record is malformed") |
| if not (asset_root / str(image["path"])).is_file(): |
| raise EvaluationError(f"existing retention image is missing: {image['path']}") |
| source_counts = Counter(str(row["source"]) for row in rows) |
| if set(source_counts) != set(expected_sources): |
| raise EvaluationError( |
| "existing retention manifest sources differ from the requested source set" |
| ) |
| return { |
| "schema_version": 1, |
| "kind": "pinned_hf_retention_evaluation_manifest", |
| "status": "reused", |
| "path": str(output_path.resolve()), |
| "item_count": len(rows), |
| "source_counts": dict(sorted(source_counts.items())), |
| } |
|
|
|
|
| def materialize_hf_retention( |
| resources: ResourcesManifest, |
| output_path: Path, |
| asset_root: Path, |
| *, |
| cache_dir: Path | None = None, |
| sources: Sequence[str] = RETENTION_SOURCES, |
| dataset_loader: DatasetLoader = _load_dataset, |
| expected_counts: Mapping[str, int] | None = None, |
| ) -> dict[str, Any]: |
| """Download pinned untouched sources and freeze the common eval manifest.""" |
|
|
| selected = tuple(dict.fromkeys(sources)) |
| if not selected or any(source not in RETENTION_SOURCES for source in selected): |
| raise EvaluationError(f"retention sources must come from {RETENTION_SOURCES}") |
| if output_path.exists(): |
| return _existing_summary(output_path, asset_root, expected_sources=selected) |
| asset_root.mkdir(parents=True, exist_ok=True) |
| items: list[dict[str, Any]] = [] |
| counts: dict[str, int] = {} |
| for source in selected: |
| config, split, registered_count = _SOURCE_SPECS[source] |
| resource = resources.dataset(source) |
| if resource.role not in {"untouched_eval_only", "untouched_text_reasoning_retention_eval"}: |
| raise EvaluationError(f"{source} is not registered as untouched evaluation") |
| rows = dataset_loader( |
| resource.repo_id, |
| config, |
| split=split, |
| revision=resource.revision, |
| cache_dir=str(cache_dir) if cache_dir is not None else None, |
| ) |
| count = len(rows) |
| wanted = ( |
| expected_counts[source] |
| if expected_counts is not None and source in expected_counts |
| else registered_count |
| ) |
| if count != wanted: |
| raise EvaluationError(f"{source}: pinned split has {count} rows, expected {wanted}") |
| counts[source] = count |
| items.extend( |
| _item( |
| source, |
| row, |
| row_index=index, |
| revision=resource.revision, |
| config=config, |
| split=split, |
| asset_root=asset_root, |
| ) |
| for index, row in enumerate(rows) |
| ) |
| evaluation_rows = flatten_retention_items(items) |
| atomic_write_jsonl(output_path, evaluation_rows) |
| return { |
| "schema_version": 1, |
| "kind": "pinned_hf_retention_evaluation_manifest", |
| "status": "completed", |
| "path": str(output_path.resolve()), |
| "asset_root": str(asset_root.resolve()), |
| "item_count": len(evaluation_rows), |
| "source_counts": dict(sorted(counts.items())), |
| } |
|
|
