| |
| """Reconstruct GQA locally from user-obtained upstream data; no downloads/uploads.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
| from hf_release_common import ( |
| apply_changes, |
| canonical_digest, |
| digest, |
| read_json, |
| read_rows, |
| write_json, |
| write_rows, |
| ) |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src")) |
|
|
|
|
| def reconstruct(dataset, questions_path, graphs_path, images, output): |
| from explicit_learning.executors.gqa import GQASemanticExecutor, compile_gqa_program |
| from explicit_learning.renderers.gqa import normalize_gqa_source_image, render_gqa_observation |
| from explicit_learning.sources.gqa import build_gqa_world |
|
|
| recipes = read_rows(dataset / "evidence/gqa/reconstruction.jsonl.gz") |
| if len(recipes) != 3000 or len({row["item_id"] for row in recipes}) != 3000: |
| raise ValueError("Expected exactly 3,000 GQA view recipes") |
| questions, graphs = read_json(questions_path), read_json(graphs_path) |
| output.mkdir(parents=True, exist_ok=False) |
| (output / "images").mkdir() |
| cache, records, evidence, view_ids = {}, [], [], set() |
| executor = GQASemanticExecutor() |
| for recipe in recipes: |
| qid, image_id = recipe["source_question_id"], recipe["source_image_id"] |
| if qid not in cache: |
| source_question = questions[qid] |
| if str(source_question["imageId"]) != image_id: |
| raise ValueError("Upstream question/image identity differs") |
| if digest(source_question["question"].encode()) != recipe["question_sha256"]: |
| raise ValueError("Upstream question text differs from evaluated question") |
| world = build_gqa_world(graphs[image_id], image_id=image_id, question_id=qid) |
| if canonical_digest(world) != recipe["source_world_sha256"]: |
| raise ValueError("Upstream scene graph differs from evaluated graph") |
| program = compile_gqa_program(qid, source_question) |
| if canonical_digest(program.to_dict()) != recipe["program_sha256"]: |
| raise ValueError("Upstream program differs from evaluated program") |
| source_image = images / (image_id + ".jpg") |
| source_image.resolve().relative_to(images.resolve()) |
| normalized = normalize_gqa_source_image( |
| source_image.read_bytes(), width=recipe["width"], height=recipe["height"] |
| ) |
| if digest(normalized) != recipe["normalized_source_sha256"]: |
| raise ValueError( |
| "Source photograph/codec differs; use the frozen Pillow environment and original GQA/VG JPEG" |
| ) |
| cache[qid] = (source_question["question"], world, program, normalized) |
| question, before, program, normalized = cache[qid] |
| after = apply_changes(before, recipe["world_edits"]) |
| rendered = render_gqa_observation( |
| normalized, after, masked_node_id=recipe["masked_node_id"], seed=recipe["seed"] |
| ) |
| if digest(rendered.image_jpeg) != recipe["image_sha256"]: |
| raise ValueError("Reconstructed view is not byte-identical to the evaluated image") |
| execution = executor.execute(program, world=after) |
| expected = recipe["executor_evidence"]["after"] |
| if ( |
| execution.status != expected["status"] |
| or execution.answer_canonical != expected["answer_canonical"] |
| ): |
| raise ValueError("Source-program evidence replay differs") |
| completions = { |
| key: apply_changes(before, edits) for key, edits in recipe["completion_edits"].items() |
| } |
| if completions: |
| answers = [executor.execute(program, world=world) for world in completions.values()] |
| if ( |
| len(answers) != 2 |
| or any(answer.status != "UNIQUE" for answer in answers) |
| or answers[0].answer_canonical == answers[1].answer_canonical |
| ): |
| raise ValueError("Symbolic scene alternatives do not yield distinct answers") |
| item_id = recipe["item_id"] |
| if item_id in view_ids or Path(item_id).name != item_id: |
| raise ValueError("Duplicate or unsafe item ID") |
| view_ids.add(item_id) |
| (output / "images" / (item_id + ".jpg")).write_bytes(rendered.image_jpeg) |
| records.append( |
| { |
| "file_name": "images/" + item_id + ".jpg", |
| "item_id": item_id, |
| "group_id": recipe["group_id"], |
| "question": question, |
| "state": recipe["state"], |
| "target": recipe["target"], |
| "answerable": recipe["answerable"], |
| "source": "gqa", |
| } |
| ) |
| evidence.append( |
| { |
| "item_id": item_id, |
| "program": program.to_dict(), |
| "world_before": before, |
| "world_after": after, |
| **completions, |
| } |
| ) |
| write_rows(output / "metadata.jsonl", records) |
| write_rows(output / "source-label-evidence.jsonl.gz", evidence) |
| result = { |
| "status": "passed", |
| "views": len(records), |
| "groups": len(cache), |
| "byte_identical_images": len(records), |
| "upstream_question_program_graph_joins": len(cache), |
| "source_program_replays": len(records), |
| "scope": "Scene-program/edit evidence only; no photographic complete-world pixel proof is claimed.", |
| "publication_performed": False, |
| } |
| write_json(output / "reconstruction-validation.json", result) |
| return result |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument( |
| "--questions", type=Path, required=True, help="GQA v1.2 val_balanced_questions.json" |
| ) |
| parser.add_argument("--scene-graphs", type=Path, required=True, help="GQA val_sceneGraphs.json") |
| parser.add_argument( |
| "--images", |
| type=Path, |
| required=True, |
| help="Directory of original upstream {image_id}.jpg files", |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| required=True, |
| help="New local directory, outside the upload candidate", |
| ) |
| args = parser.parse_args() |
| if args.output.resolve().is_relative_to(args.dataset.resolve()): |
| parser.error( |
| "Reconstruct outside the upload candidate to preserve its redistribution boundary" |
| ) |
| print( |
| json.dumps( |
| reconstruct(args.dataset, args.questions, args.scene_graphs, args.images, args.output) |
| ) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
