Upload folder using huggingface_hub

README.md

@@ -0,0 +1,67 @@
+---
+pretty_name: DD1 PB VQA Grounding
+tags:
+  - visual-question-answering
+  - visual-grounding
+  - industrial
+  - additive-manufacturing
+  - sft
+task_categories:
+  - visual-question-answering
+---
+
+# DD1 PB VQA Grounding
+
+Answer-only VQA-style grounding data derived deterministically from the PB
+portion of `DD1_cleaned_grounding`.
+
+## Schema
+
+| field | type | meaning |
+|---|---|---|
+| `query` | string | one of 34 deterministic LPBF PB grounding prompts |
+| `image` | Image | original 1280×1024 JPEG bytes; never cropped |
+| `annot` | string | JSON list `[{"bbox_xywh":[x,y,w,h]}]`, or `[]` |
+| `reasoning` | null | answer-only dataset |
+| `cate` | string | `B` |
+| `task` | string | `T-B1` |
+| `metadata` | string | JSON provenance, hashes, boxes and disclosures |
+
+Coordinates use native pixels with top-left origin. Width and height are
+`xmax-xmin` and `ymax-ymin`.
+
+## Counts
+
+- Records: 2637
+- Positive images: 1529
+- Good/negative images: 1108
+- Total boxes: 5000
+- Query variants: 34
+- Split: train only
+
+## Load
+
+```python
+from datasets import load_dataset
+ds = load_dataset(
+    "parquet",
+    data_files={"train": "data/train-00000-of-00001.parquet"},
+)
+```
+
+`annot` is the direct SFT answer. `reasoning` is null on every row.
+
+## Reproduce
+
+```bash
+python3 -m pip install -r requirements.txt
+python3 build_dd1_pb_vqa.py \
+  --source /path/to/DD1_cleaned_grounding \
+  --output /path/to/DD1_PB_VQA_grounding
+```
+
+## Disclosure
+
+The source uses the generic class label `defects` without a subtype taxonomy.
+`Good` means no author-annotated PB defect under the source labeling rule; it
+does not guarantee absence of every possible manufacturing defect.

build_dd1_pb_vqa.py

@@ -0,0 +1,565 @@
+#!/usr/bin/env python3
+"""Build answer-only VQA grounding data from DD1_cleaned_grounding/PB."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import statistics
+import sys
+import tempfile
+import xml.etree.ElementTree as ET
+from collections import Counter
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Iterator
+
+
+def import_dependencies() -> tuple[Any, Any, Any, Any, Any, Any]:
+    candidates = (
+        Path.cwd() / "tmp_work" / "pydeps",
+        Path(__file__).resolve().parent / "tmp_work" / "pydeps",
+        Path(__file__).resolve().parent.parent / "tmp_work" / "pydeps",
+    )
+    for candidate in candidates:
+        if candidate.is_dir():
+            sys.path.insert(0, str(candidate))
+    try:
+        from datasets import Dataset, Features, Image, Value, load_dataset
+        from PIL import Image as PILImage
+    except ModuleNotFoundError as error:
+        raise SystemExit(
+            "Missing dependencies. Install requirements.txt first."
+        ) from error
+    return Dataset, Features, Image, Value, load_dataset, PILImage
+
+
+Dataset, Features, HFImage, Value, load_dataset, PILImage = import_dependencies()
+
+WIDTH = 1280
+HEIGHT = 1024
+EXPECTED_IMAGES = 2637
+EXPECTED_POSITIVES = 1529
+EXPECTED_NEGATIVES = 1108
+EXPECTED_BOXES = 5000
+QUERY_SALT = "DD1_PB_VQA_QUERY_V1"
+
+OUTPUT_DIRECTIVE = (
+    'Output a JSON list [{"bbox_xywh": [x, y, w, h]}] in native pixels, '
+    "origin top-left, one box per annotated powder-bed defect region, sorted "
+    "by x then y; output [] if none."
+)
+
+QUERY_PREFIXES = (
+    "Inspect this LPBF powder-bed image and locate every annotated defect region.",
+    "Examine this laser powder bed fusion layer image and find all annotated powder-bed defects.",
+    "Review this LPBF powder-bed frame and localize every annotated defect.",
+    "Analyze this powder-bed layer image and identify all annotated defect regions.",
+    "Perform defect localization on this LPBF powder-bed image.",
+    "Check this additive-manufacturing powder-bed image and locate every annotated defect area.",
+    "Inspect this LPBF layer image and return all annotated powder-bed defect boxes.",
+    "Locate all annotated defect regions visible in this LPBF powder-bed layer.",
+    "Examine this powder-bed monitoring image and localize each annotated defect region.",
+    "Review this powder-bed frame from laser powder bed fusion and find every annotated defect.",
+    "Detect and localize all annotated defects in this LPBF powder-bed image.",
+    "Inspect this LPBF build-layer image and identify every annotated powder-bed defect.",
+    "Analyze this powder-bed monitoring image and locate all annotated defect areas.",
+    "Find every annotated defect region in this laser powder bed fusion layer image.",
+    "Perform visual grounding of all annotated defects in this LPBF powder-bed image.",
+    "Examine this powder-bed process image and return every annotated defect location.",
+    "Review the current LPBF powder-bed layer and localize each annotated defect.",
+    "Inspect this additive-manufacturing layer image and locate all annotated powder-bed defects.",
+    "Analyze this LPBF powder-bed frame and ground every annotated defect region.",
+    "Locate each annotated defect region in this powder-bed image of an LPBF build layer.",
+    "Check this LPBF powder-bed layer for annotations and return each corresponding defect region.",
+    "Inspect this powder-bed image and identify the bounding boxes of all annotated defects.",
+    "Examine this LPBF process image and localize all annotated powder-bed defects.",
+    "Review this LPBF build-layer image and find every annotated powder-bed defect region.",
+    "Analyze this powder-bed frame and locate all regions annotated as defects.",
+    "Ground every annotated defect region in this powder-bed monitoring image.",
+    "Inspect this LPBF powder-bed frame and return all annotated defect-region boxes.",
+    "Find and localize every annotated defect area in this powder-bed image.",
+    "Examine the current additive-manufacturing powder bed and locate all annotated defects.",
+    "Review this LPBF powder-bed image and identify every region annotated as defective.",
+    "Perform defect-region grounding in this LPBF powder-bed layer.",
+    "Inspect this view of the LPBF powder bed and localize all annotated defect regions.",
+    "Analyze this LPBF layer image and return every annotated powder-bed defect location.",
+    "Check this LPBF powder-bed monitoring frame and ground all annotated defect regions.",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, default=None)
+    parser.add_argument("--output", type=Path, default=None)
+    return parser.parse_args()
+
+
+def resolve_source(value: Path | None) -> Path:
+    if value is not None:
+        return value.resolve()
+    script = Path(__file__).resolve()
+    for candidate in (
+        Path.cwd() / "DD1_cleaned_grounding",
+        script.parent / "DD1_cleaned_grounding",
+        script.parent.parent / "DD1_cleaned_grounding",
+    ):
+        if (candidate / "PB").is_dir() and (candidate / "PB_label").is_dir():
+            return candidate.resolve()
+    raise SystemExit("Cannot locate DD1_cleaned_grounding; pass --source.")
+
+
+def sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def compact_json(value: Any) -> str:
+    return json.dumps(
+        value, ensure_ascii=False, sort_keys=True, separators=(",", ":")
+    )
+
+
+def parse_build_layer(filename: str) -> tuple[str, int]:
+    parts = Path(filename).stem.split("_")
+    if len(parts) < 3 or not parts[0].startswith("SI"):
+        raise ValueError(f"Cannot parse build/layer from {filename}")
+    return parts[0], int(parts[1])
+
+
+def parse_boxes(xml_path: Path, image_name: str) -> tuple[list[dict[str, list[int]]], str]:
+    root = ET.parse(xml_path).getroot()
+    if root.find("path") is not None:
+        raise ValueError(f"Machine-local path remains in {xml_path}")
+    if root.findtext("filename") != image_name:
+        raise ValueError(f"XML filename mismatch in {xml_path}")
+    size = (
+        int(root.findtext("size/width", "0")),
+        int(root.findtext("size/height", "0")),
+    )
+    if size != (WIDTH, HEIGHT):
+        raise ValueError(f"Unexpected XML size {size} in {xml_path}")
+    boxes: list[dict[str, list[int]]] = []
+    for index, obj in enumerate(root.findall("object")):
+        label = (obj.findtext("name") or "").strip()
+        if label != "defects":
+            raise ValueError(f"Unexpected label {label!r} in {xml_path}")
+        box = obj.find("bndbox")
+        if box is None:
+            raise ValueError(f"Missing bbox {index} in {xml_path}")
+        xmin, ymin, xmax, ymax = (
+            int(float(box.findtext(key, "nan")))
+            for key in ("xmin", "ymin", "xmax", "ymax")
+        )
+        if (
+            xmax <= xmin
+            or ymax <= ymin
+            or xmin < 0
+            or ymin < 0
+            or xmax > WIDTH
+            or ymax > HEIGHT
+        ):
+            raise ValueError(
+                f"Invalid bbox {[xmin, ymin, xmax, ymax]} in {xml_path}"
+            )
+        boxes.append(
+            {"bbox_xywh": [xmin, ymin, xmax - xmin, ymax - ymin]}
+        )
+    if not boxes:
+        raise ValueError(f"Positive XML contains no objects: {xml_path}")
+    boxes.sort(key=lambda item: tuple(item["bbox_xywh"]))
+    return boxes, sha256_file(xml_path)
+
+
+def choose_query(image_sha: str) -> tuple[str, int]:
+    digest = hashlib.sha256(
+        f"{QUERY_SALT}:{image_sha}".encode("utf-8")
+    ).digest()
+    index = int.from_bytes(digest[:8], "big") % len(QUERY_PREFIXES)
+    return f"{QUERY_PREFIXES[index]} {OUTPUT_DIRECTIVE}", index
+
+
+def create_records(
+    source: Path, summary: dict[str, Any]
+) -> Iterator[dict[str, Any]]:
+    images = sorted((source / "PB").glob("*.jpg"))
+    xml_by_stem = {
+        path.stem: path for path in (source / "PB_label").glob("*.xml")
+    }
+    image_stems = {path.stem for path in images}
+    if len(images) != EXPECTED_IMAGES:
+        raise ValueError(f"Expected {EXPECTED_IMAGES} images, got {len(images)}")
+    if len(xml_by_stem) != EXPECTED_POSITIVES:
+        raise ValueError(
+            f"Expected {EXPECTED_POSITIVES} XMLs, got {len(xml_by_stem)}"
+        )
+    if not set(xml_by_stem).issubset(image_stems):
+        raise ValueError("A PB XML has no corresponding image")
+
+    for image_path in images:
+        image_bytes = image_path.read_bytes()
+        with PILImage.open(BytesIO(image_bytes)) as image:
+            if image.size != (WIDTH, HEIGHT):
+                raise ValueError(
+                    f"Unexpected image size {image.size}: {image_path}"
+                )
+            image.verify()
+        image_sha = sha256_bytes(image_bytes)
+        build_id, layer_id = parse_build_layer(image_path.name)
+        xml_path = xml_by_stem.get(image_path.stem)
+        if xml_path is None:
+            boxes: list[dict[str, list[int]]] = []
+            xml_sha = None
+        else:
+            boxes, xml_sha = parse_boxes(xml_path, image_path.name)
+        query, query_variant = choose_query(image_sha)
+        negative = not boxes
+        metadata = {
+            "image_sha256": image_sha,
+            "negative": negative,
+            "n_boxes": len(boxes),
+            "gold_boxes_xywh": boxes,
+            "derivation": "manual_pascal_voc_xml_to_native_xywh",
+            "legibility_floor": None,
+            "fill_floor": None,
+            "gold_scope": (
+                "all author-annotated generic defect regions in the cleaned "
+                "DD1 powder-bed XML"
+            ),
+            "goods_carveout": (
+                "no XML in cleaned DD1 PB; [] means no author-annotated "
+                "powder-bed defect under the source labeling rule"
+            ),
+            "anonymous_class": True,
+            "object_class": "defects",
+            "disclosures": [
+                "the source uses the generic class name 'defects' without a "
+                "defect subtype taxonomy",
+                "Good means no author-annotated PB defect, not guaranteed "
+                "absence of every possible manufacturing defect",
+            ],
+            "family": "DD1",
+            "rung": "PB-grounding",
+            "gate_provenance": {
+                "builder": "build_dd1_pb_vqa.py",
+                "query_salt": QUERY_SALT,
+                "source_cleaning_report": "cleaning_report.json",
+            },
+            "modality": "PB",
+            "build_id": build_id,
+            "layer_id": layer_id,
+            "image_width": WIDTH,
+            "image_height": HEIGHT,
+            "source_image": f"PB/{image_path.name}",
+            "source_xml": (
+                f"PB_label/{xml_path.name}" if xml_path is not None else None
+            ),
+            "source_xml_sha256": xml_sha,
+            "query_variant": query_variant,
+            "coordinate_format": "native_pixel_xywh_top_left",
+            "xywh_derivation": "x=xmin,y=ymin,w=xmax-xmin,h=ymax-ymin",
+            "box_order": "x_then_y",
+            "split": "train",
+        }
+        summary["records"] += 1
+        summary["negative" if negative else "positive"] += 1
+        summary["boxes"] += len(boxes)
+        summary["box_counts"].append(len(boxes))
+        summary["query_variants"][query_variant] += 1
+        summary["builds"][build_id] += 1
+        yield {
+            "query": query,
+            "image": {"bytes": image_bytes, "path": image_path.name},
+            "annot": compact_json(boxes),
+            "reasoning": None,
+            "cate": "B",
+            "task": "T-B1",
+            "metadata": compact_json(metadata),
+        }
+
+
+def validate_parquet(parquet_path: Path) -> dict[str, Any]:
+    cache = parquet_path.parent.parent / ".validation_cache"
+    dataset = load_dataset(
+        "parquet",
+        data_files={"train": str(parquet_path)},
+        split="train",
+        cache_dir=str(cache),
+    )
+    if dataset.column_names != [
+        "query", "image", "annot", "reasoning", "cate", "task", "metadata"
+    ]:
+        raise ValueError(f"Unexpected columns: {dataset.column_names}")
+    counts = Counter()
+    image_hashes: set[str] = set()
+    variants: set[int] = set()
+    for index, row in enumerate(dataset):
+        metadata = json.loads(row["metadata"])
+        boxes = json.loads(row["annot"])
+        if row["reasoning"] is not None:
+            raise ValueError(f"Non-null reasoning at row {index}")
+        if row["cate"] != "B" or row["task"] != "T-B1":
+            raise ValueError(f"cate/task mismatch at row {index}")
+        if not row["query"].endswith(OUTPUT_DIRECTIVE):
+            raise ValueError(f"query mismatch at row {index}")
+        if boxes != metadata["gold_boxes_xywh"]:
+            raise ValueError(f"annot/metadata mismatch at row {index}")
+        if len(boxes) != metadata["n_boxes"]:
+            raise ValueError(f"n_boxes mismatch at row {index}")
+        if (not boxes) != metadata["negative"]:
+            raise ValueError(f"negative mismatch at row {index}")
+        if boxes != sorted(boxes, key=lambda item: tuple(item["bbox_xywh"])):
+            raise ValueError(f"box ordering mismatch at row {index}")
+        for item in boxes:
+            x, y, width, height = item["bbox_xywh"]
+            if (
+                width <= 0 or height <= 0 or x < 0 or y < 0
+                or x + width > WIDTH or y + height > HEIGHT
+            ):
+                raise ValueError(f"Invalid box at row {index}: {item}")
+        image_bytes = row["image"].get("bytes")
+        if image_bytes is None:
+            raise ValueError(f"Missing image bytes at row {index}")
+        image_sha = sha256_bytes(image_bytes)
+        if image_sha != metadata["image_sha256"]:
+            raise ValueError(f"Image hash mismatch at row {index}")
+        if image_sha in image_hashes:
+            raise ValueError(f"Duplicate image content at row {index}")
+        image_hashes.add(image_sha)
+        counts["records"] += 1
+        counts["positive" if boxes else "negative"] += 1
+        counts["boxes"] += len(boxes)
+        variants.add(metadata["query_variant"])
+    expected = {
+        "records": EXPECTED_IMAGES,
+        "positive": EXPECTED_POSITIVES,
+        "negative": EXPECTED_NEGATIVES,
+        "boxes": EXPECTED_BOXES,
+    }
+    actual = {key: counts[key] for key in expected}
+    if actual != expected or len(variants) != len(QUERY_PREFIXES):
+        raise ValueError(
+            f"Aggregate validation failed: {actual}, variants={len(variants)}"
+        )
+    result = {
+        **actual,
+        "unique_images": len(image_hashes),
+        "query_variants_used": len(variants),
+        "features": str(dataset.features),
+    }
+    del dataset
+    shutil.rmtree(cache, ignore_errors=True)
+    return result
+
+
+def make_readme(report: dict[str, Any]) -> str:
+    return f"""---
+pretty_name: DD1 PB VQA Grounding
+tags:
+  - visual-question-answering
+  - visual-grounding
+  - industrial
+  - additive-manufacturing
+  - sft
+task_categories:
+  - visual-question-answering
+---
+
+# DD1 PB VQA Grounding
+
+Answer-only VQA-style grounding data derived deterministically from the PB
+portion of `DD1_cleaned_grounding`.
+
+## Schema
+
+| field | type | meaning |
+|---|---|---|
+| `query` | string | one of 34 deterministic LPBF PB grounding prompts |
+| `image` | Image | original 1280×1024 JPEG bytes; never cropped |
+| `annot` | string | JSON list `[{{"bbox_xywh":[x,y,w,h]}}]`, or `[]` |
+| `reasoning` | null | answer-only dataset |
+| `cate` | string | `B` |
+| `task` | string | `T-B1` |
+| `metadata` | string | JSON provenance, hashes, boxes and disclosures |
+
+Coordinates use native pixels with top-left origin. Width and height are
+`xmax-xmin` and `ymax-ymin`.
+
+## Counts
+
+- Records: {report["records"]}
+- Positive images: {report["positive"]}
+- Good/negative images: {report["negative"]}
+- Total boxes: {report["boxes"]}
+- Query variants: {report["query_variants_used"]}
+- Split: train only
+
+## Load
+
+```python
+from datasets import load_dataset
+ds = load_dataset(
+    "parquet",
+    data_files={{"train": "data/train-00000-of-00001.parquet"}},
+)
+```
+
+`annot` is the direct SFT answer. `reasoning` is null on every row.
+
+## Reproduce
+
+```bash
+python3 -m pip install -r requirements.txt
+python3 build_dd1_pb_vqa.py \\
+  --source /path/to/DD1_cleaned_grounding \\
+  --output /path/to/DD1_PB_VQA_grounding
+```
+
+## Disclosure
+
+The source uses the generic class label `defects` without a subtype taxonomy.
+`Good` means no author-annotated PB defect under the source labeling rule; it
+does not guarantee absence of every possible manufacturing defect.
+"""
+
+
+def main() -> None:
+    if len(QUERY_PREFIXES) != 34 or len(set(QUERY_PREFIXES)) != 34:
+        raise SystemExit("QUERY_PREFIXES must contain 34 unique variants")
+    args = parse_args()
+    source = resolve_source(args.source)
+    output = (
+        args.output.resolve()
+        if args.output is not None
+        else source.parent / "DD1_PB_VQA_grounding"
+    )
+    if output.exists():
+        raise SystemExit(f"Refusing to overwrite existing output: {output}")
+    if not (source / "PB").is_dir() or not (source / "PB_label").is_dir():
+        raise SystemExit(f"Invalid source directory: {source}")
+
+    temporary = Path(
+        tempfile.mkdtemp(prefix=f".{output.name}.tmp-", dir=output.parent)
+    )
+    try:
+        (temporary / "data").mkdir()
+        summary: dict[str, Any] = {
+            "records": 0,
+            "positive": 0,
+            "negative": 0,
+            "boxes": 0,
+            "box_counts": [],
+            "query_variants": Counter(),
+            "builds": Counter(),
+        }
+        features = Features(
+            {
+                "query": Value("string"),
+                "image": HFImage(decode=False),
+                "annot": Value("string"),
+                "reasoning": Value("null"),
+                "cate": Value("string"),
+                "task": Value("string"),
+                "metadata": Value("string"),
+            }
+        )
+        dataset = Dataset.from_generator(
+            lambda: create_records(source, summary),
+            features=features,
+            cache_dir=str(temporary / ".cache"),
+        )
+        expected = {
+            "records": EXPECTED_IMAGES,
+            "positive": EXPECTED_POSITIVES,
+            "negative": EXPECTED_NEGATIVES,
+            "boxes": EXPECTED_BOXES,
+        }
+        if {key: summary[key] for key in expected} != expected:
+            raise ValueError(f"Unexpected generated counts: {summary}")
+        if len(summary["query_variants"]) != len(QUERY_PREFIXES):
+            raise ValueError("Not all query variants were selected")
+
+        parquet = temporary / "data/train-00000-of-00001.parquet"
+        dataset.to_parquet(parquet)
+        shutil.rmtree(temporary / ".cache", ignore_errors=True)
+        validation = validate_parquet(parquet)
+        positives = [count for count in summary["box_counts"] if count]
+        report = {
+            "source": "DD1_cleaned_grounding",
+            "output": "DD1_PB_VQA_grounding",
+            "records": summary["records"],
+            "positive": summary["positive"],
+            "negative": summary["negative"],
+            "empty_answer_prior": round(
+                summary["negative"] / summary["records"], 8
+            ),
+            "boxes": summary["boxes"],
+            "boxes_per_positive_mean": round(statistics.mean(positives), 6),
+            "boxes_per_positive_median": statistics.median(positives),
+            "boxes_per_positive_max": max(positives),
+            "query_variants_used": len(summary["query_variants"]),
+            "query_variant_counts": {
+                str(key): value
+                for key, value in sorted(summary["query_variants"].items())
+            },
+            "build_counts": dict(sorted(summary["builds"].items())),
+            "schema": {
+                "query": "string",
+                "image": "Image",
+                "annot": "string",
+                "reasoning": "null",
+                "cate": "string",
+                "task": "string",
+                "metadata": "string(JSON)",
+            },
+            "coordinate_format": "native_pixel_xywh_top_left",
+            "parquet_sha256": sha256_file(parquet),
+            "builder_sha256": sha256_file(Path(__file__).resolve()),
+            "validation": validation,
+            "status": "pass",
+        }
+        (temporary / "build_report.json").write_text(
+            json.dumps(report, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        (temporary / "query_templates.json").write_text(
+            json.dumps(
+                {
+                    "salt": QUERY_SALT,
+                    "output_directive": OUTPUT_DIRECTIVE,
+                    "prefixes": list(QUERY_PREFIXES),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        (temporary / "README.md").write_text(
+            make_readme(report), encoding="utf-8"
+        )
+        (temporary / "requirements.txt").write_text(
+            "datasets==5.0.0\npyarrow==25.0.0\nPillow>=12.0.0\n",
+            encoding="utf-8",
+        )
+        shutil.copy2(
+            Path(__file__).resolve(), temporary / Path(__file__).name
+        )
+        temporary.rename(output)
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    except Exception:
+        shutil.rmtree(temporary, ignore_errors=True)
+        raise
+
+
+if __name__ == "__main__":
+    main()

build_report.json

@@ -0,0 +1,76 @@
+{
+  "source": "DD1_cleaned_grounding",
+  "output": "DD1_PB_VQA_grounding",
+  "records": 2637,
+  "positive": 1529,
+  "negative": 1108,
+  "empty_answer_prior": 0.42017444,
+  "boxes": 5000,
+  "boxes_per_positive_mean": 3.270111,
+  "boxes_per_positive_median": 3,
+  "boxes_per_positive_max": 12,
+  "query_variants_used": 34,
+  "query_variant_counts": {
+    "0": 73,
+    "1": 67,
+    "2": 82,
+    "3": 67,
+    "4": 74,
+    "5": 86,
+    "6": 81,
+    "7": 70,
+    "8": 88,
+    "9": 96,
+    "10": 89,
+    "11": 72,
+    "12": 77,
+    "13": 76,
+    "14": 67,
+    "15": 74,
+    "16": 80,
+    "17": 80,
+    "18": 70,
+    "19": 88,
+    "20": 96,
+    "21": 77,
+    "22": 66,
+    "23": 73,
+    "24": 78,
+    "25": 78,
+    "26": 71,
+    "27": 79,
+    "28": 72,
+    "29": 72,
+    "30": 85,
+    "31": 74,
+    "32": 81,
+    "33": 78
+  },
+  "build_counts": {
+    "SI383820211201123521": 999,
+    "SI383820240226095904": 271,
+    "SI383820240318120348": 1367
+  },
+  "schema": {
+    "query": "string",
+    "image": "Image",
+    "annot": "string",
+    "reasoning": "null",
+    "cate": "string",
+    "task": "string",
+    "metadata": "string(JSON)"
+  },
+  "coordinate_format": "native_pixel_xywh_top_left",
+  "parquet_sha256": "7a98b1c24e7bcc0b4c4598b94e3c4bb605e607ef27f20e296c1fa3f0fd48b7d0",
+  "builder_sha256": "9fac7bdfe7aa71fd57d6f75436a253f2a7ae77e05e7d4fb88d6398969cc919fa",
+  "validation": {
+    "records": 2637,
+    "positive": 1529,
+    "negative": 1108,
+    "boxes": 5000,
+    "unique_images": 2637,
+    "query_variants_used": 34,
+    "features": "{'query': Value('string'), 'image': Image(mode=None, decode=False), 'annot': Value('string'), 'reasoning': Value('null'), 'cate': Value('string'), 'task': Value('string'), 'metadata': Value('string')}"
+  },
+  "status": "pass"
+}

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a98b1c24e7bcc0b4c4598b94e3c4bb605e607ef27f20e296c1fa3f0fd48b7d0
+size 343539799

query_templates.json

@@ -0,0 +1,40 @@
+{
+  "salt": "DD1_PB_VQA_QUERY_V1",
+  "output_directive": "Output a JSON list [{\"bbox_xywh\": [x, y, w, h]}] in native pixels, origin top-left, one box per annotated powder-bed defect region, sorted by x then y; output [] if none.",
+  "prefixes": [
+    "Inspect this LPBF powder-bed image and locate every annotated defect region.",
+    "Examine this laser powder bed fusion layer image and find all annotated powder-bed defects.",
+    "Review this LPBF powder-bed frame and localize every annotated defect.",
+    "Analyze this powder-bed layer image and identify all annotated defect regions.",
+    "Perform defect localization on this LPBF powder-bed image.",
+    "Check this additive-manufacturing powder-bed image and locate every annotated defect area.",
+    "Inspect this LPBF layer image and return all annotated powder-bed defect boxes.",
+    "Locate all annotated defect regions visible in this LPBF powder-bed layer.",
+    "Examine this powder-bed monitoring image and localize each annotated defect region.",
+    "Review this powder-bed frame from laser powder bed fusion and find every annotated defect.",
+    "Detect and localize all annotated defects in this LPBF powder-bed image.",
+    "Inspect this LPBF build-layer image and identify every annotated powder-bed defect.",
+    "Analyze this powder-bed monitoring image and locate all annotated defect areas.",
+    "Find every annotated defect region in this laser powder bed fusion layer image.",
+    "Perform visual grounding of all annotated defects in this LPBF powder-bed image.",
+    "Examine this powder-bed process image and return every annotated defect location.",
+    "Review the current LPBF powder-bed layer and localize each annotated defect.",
+    "Inspect this additive-manufacturing layer image and locate all annotated powder-bed defects.",
+    "Analyze this LPBF powder-bed frame and ground every annotated defect region.",
+    "Locate each annotated defect region in this powder-bed image of an LPBF build layer.",
+    "Check this LPBF powder-bed layer for annotations and return each corresponding defect region.",
+    "Inspect this powder-bed image and identify the bounding boxes of all annotated defects.",
+    "Examine this LPBF process image and localize all annotated powder-bed defects.",
+    "Review this LPBF build-layer image and find every annotated powder-bed defect region.",
+    "Analyze this powder-bed frame and locate all regions annotated as defects.",
+    "Ground every annotated defect region in this powder-bed monitoring image.",
+    "Inspect this LPBF powder-bed frame and return all annotated defect-region boxes.",
+    "Find and localize every annotated defect area in this powder-bed image.",
+    "Examine the current additive-manufacturing powder bed and locate all annotated defects.",
+    "Review this LPBF powder-bed image and identify every region annotated as defective.",
+    "Perform defect-region grounding in this LPBF powder-bed layer.",
+    "Inspect this view of the LPBF powder bed and localize all annotated defect regions.",
+    "Analyze this LPBF layer image and return every annotated powder-bed defect location.",
+    "Check this LPBF powder-bed monitoring frame and ground all annotated defect regions."
+  ]
+}

requirements.txt

@@ -0,0 +1,3 @@
+datasets==5.0.0
+pyarrow==25.0.0
+Pillow>=12.0.0