| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| import pandas as pd |
| from PIL import Image |
|
|
| REQUIRED_COLUMNS = ( |
| "sample_id", |
| "edit_type", |
| "before", |
| "after", |
| "instruction_pos", |
| "instruction_neg_list", |
| "instruction_neg_types", |
| ) |
|
|
| PATH_COLUMNS = ("before", "after") |
|
|
|
|
| def load_dataset(dataset_root: str | Path) -> pd.DataFrame: |
| dataset_root = Path(dataset_root) |
| parquet_path = dataset_root / "benchmark.parquet" |
| if not parquet_path.exists(): |
| raise FileNotFoundError(f"Missing dataset parquet: {parquet_path}") |
| return pd.read_parquet(parquet_path) |
|
|
|
|
| def as_list(value: Any) -> list[Any]: |
| if value is None: |
| return [] |
| if isinstance(value, float) and np.isnan(value): |
| return [] |
| if isinstance(value, np.ndarray): |
| return value.tolist() |
| if isinstance(value, (list, tuple)): |
| return list(value) |
| return [value] |
|
|
|
|
| def parse_metadata(value: Any) -> dict[str, Any]: |
| if isinstance(value, dict): |
| return value |
| if isinstance(value, str): |
| try: |
| parsed = json.loads(value) |
| return parsed if isinstance(parsed, dict) else {} |
| except json.JSONDecodeError: |
| return {} |
| return {} |
|
|
|
|
| def expand_triplets(df: pd.DataFrame) -> pd.DataFrame: |
| """Expand edit-level rows into positive/negative verification triplets.""" |
| rows: list[dict[str, Any]] = [] |
| for row_index, row in df.reset_index(drop=True).iterrows(): |
| sample_id = row.get("sample_id", f"row-{row_index:05d}") |
| base = { |
| "sample_id": sample_id, |
| "parquet_row_index": int(row.get("parquet_row_index", row_index)), |
| "edit_type": row["edit_type"], |
| "before": row["before"], |
| "after": row["after"], |
| } |
| rows.append( |
| { |
| **base, |
| "instruction": row["instruction_pos"], |
| "label": 1, |
| "ground_truth": True, |
| "example_type": "positive", |
| "negative_type": "positive", |
| "negative_index": -1, |
| } |
| ) |
|
|
| negs = as_list(row["instruction_neg_list"]) |
| neg_types = as_list(row["instruction_neg_types"]) |
| if len(negs) != len(neg_types): |
| raise ValueError(f"Negative instruction/type length mismatch for {sample_id}") |
| for neg_index, (instruction, negative_type) in enumerate(zip(negs, neg_types)): |
| rows.append( |
| { |
| **base, |
| "instruction": instruction, |
| "label": 0, |
| "ground_truth": False, |
| "example_type": "negative", |
| "negative_type": str(negative_type), |
| "negative_index": neg_index, |
| } |
| ) |
| return pd.DataFrame(rows) |
|
|
|
|
| def _is_portable_relative_path(value: Any) -> bool: |
| if value is None: |
| return False |
| path = Path(str(value)) |
| return not path.is_absolute() and ".." not in path.parts |
|
|
|
|
| def validate_dataset(dataset_root: str | Path, strict_core: bool = True) -> dict[str, Any]: |
| """Validate the public Hugging Face dataset layout.""" |
| dataset_root = Path(dataset_root) |
| df = load_dataset(dataset_root) |
| report: dict[str, Any] = { |
| "row_count": int(len(df)), |
| "required_missing": [col for col in REQUIRED_COLUMNS if col not in df.columns], |
| "edit_type_counts": df["edit_type"].value_counts().sort_index().to_dict() |
| if "edit_type" in df.columns |
| else {}, |
| } |
|
|
| before_exists = df["before"].map(lambda p: (dataset_root / str(p)).exists()) |
| after_exists = df["after"].map(lambda p: (dataset_root / str(p)).exists()) |
| report["before_paths_resolvable"] = int(before_exists.sum()) |
| report["after_paths_resolvable"] = int(after_exists.sum()) |
|
|
| length_matches = [] |
| for _, row in df.iterrows(): |
| length_matches.append( |
| len(as_list(row["instruction_neg_list"])) == len(as_list(row["instruction_neg_types"])) |
| ) |
| report["negative_instruction_lengths_match"] = int(sum(length_matches)) |
|
|
| non_portable_paths: dict[str, int] = {} |
| for col in PATH_COLUMNS: |
| if col in df.columns: |
| bad_count = int((~df[col].map(_is_portable_relative_path)).sum()) |
| if bad_count: |
| non_portable_paths[col] = bad_count |
| report["non_portable_path_columns"] = non_portable_paths |
|
|
| dimensions: dict[str, int] = {} |
| for path_text in pd.concat([df["before"], df["after"]]).head(100): |
| path = dataset_root / str(path_text) |
| if path.exists(): |
| with Image.open(path) as image: |
| key = f"{image.width}x{image.height}" |
| dimensions[key] = dimensions.get(key, 0) + 1 |
| report["sampled_image_dimension_counts"] = dimensions |
|
|
| checks = [ |
| not report["required_missing"], |
| report["before_paths_resolvable"] == len(df), |
| report["after_paths_resolvable"] == len(df), |
| report["negative_instruction_lengths_match"] == len(df), |
| not report["non_portable_path_columns"], |
| ] |
| if strict_core: |
| checks.extend( |
| [ |
| len(df) == 1500, |
| set(report["edit_type_counts"].values()) == {150}, |
| ] |
| ) |
| report["passed"] = bool(all(checks)) |
| return report |
|
|
