This dataset is released for research use. Access is reviewed and granted manually by the maintainers. Please state your name, affiliation, and intended use.

Roles

Roles: canon repo — annot is the source label, kept machine-parseable as the gold for verification and reward parsing; there is no reasoning column and this repo is not itself a training view. Derived repos (-annotated, -grounding, -region, -mcq) each state their own regime on their own card. Geometry for every record lives in metadata.geometry (below).

192-single

Multi-view industrial anomaly detection — SINGLE-IMAGE version (one camera view per row; image-level binary; per-image mask kept as GT). Category B, task T-B1, in the unified Smart-Manufacturing SFT schema.

The repository name is an internal task code. See Provenance below for the underlying dataset.

Records

151,050 records (test=57250 · train=93800). Pixel masks are embedded as a mask image column.

(2026-09-25, stated) Re-split: 57,335 evaluation records moved to train. They are the evaluation anomalies the re-split moves (with any good in the same identity group), one record per image; they now live in the new train shard data/train-00001-of-00002.parquet. On each, metadata.split is now train and metadata.eval_lock was re-computed by common/overlap.py (locked: false; manifest revision fe6e286912b0 unchanged). Every other cell of every column, and every other record, is byte-identical to the parent revision 30e4edcb8a3a. Splits: test 114,585 → 57,250; train 36,465 → 93,800. Basis: the user's ruling resplit: r 70, floor 100, N max (typed 2026-09-25 08:29 UTC), executed from the plan 192.json.gz (payload sha16 5c45b64d584a62f9) written by tools/resplit_analyze.py; the method and every figure are in reports/ad_good_only_splits/resplit_tool_2026-09-25/. Statements elsewhere on this card that describe the split (counts, which images each split holds, test-split baselines) describe the layout before this revision. (measured on the live records, 2026-09-25) 2026-09-25: section Records rewritten in this revision; the previous text is superseded (1 of 1 lines replaced).

Unified SFT schema

field	type	meaning
`query`	str	the question / instruction (model input)
`image`	Image	the input image (bytes embedded); for multi-image rows, a preview of the first view
`images`	list[Image]	(multi-image rows) all input views / modalities for the row, bytes embedded
`annot`	str	the answer — for this dataset: the plain-text image-level label `good` or `anomalous`. Real-IAD labels each view separately (a view of an NG object may itself be `good` — the invisible-view effect), so this is faithful per image. The per-image defect `mask` (None for good) is attached but NOT referenced in the query; the defect code/name are in `metadata.defect_code`/`defect_name` — see Versions, task & split below
`reasoning`	null	no native CoT in these datasets
`cate`	"B"	SFT category
`task`	"T-xx"	unified task id
`metadata`	str (JSON)	split, provenance, `image_path`, `image_sha256` (dedup key)
`mask`	Image \| null	(T-B1/T-B2 only) the pixel ground-truth mask, bytes embedded
`masks`	list[Image]	(multi-image T-B1 / D21) per-view masks aligned with `images` (None where a view has no defect), or multi-region masks

Versions, task & split

What this is. Real-IAD (Wang et al., Real-IAD: A Real-World Multi-View Dataset for Benchmarking Versatile Industrial Anomaly Detection, CVPR 2024) — 30 manufactured objects imaged from five synchronised camera views (C1 top-down + C2-C5 at 45°) on a real production line, with pixel defect masks. This is the 256-px release (realiad_256).

Two published versions (same images, different unit). Real-IAD supports an image-level and a sample-level protocol, so we publish two datasets from the same underlying images:

192-single (this repo) — one camera view per row, image-level binary AD (Real-IAD I-AUROC).
192-object — one object = 5 views per row, sample-level binary AD (Real-IAD's headline S-AUROC). They are the same photos re-grouped — keep the two on the same side of any train/eval split.

Query & answer. query (our own template, per category) asks only good vs anomalous; annot is the plain-text label. Real-IAD labels each view separately, so a view of a defective object on which the defect is not visible is itself labelled good (the invisible-view effect) — the per-image label is faithful. annot = anomalous iff that image carries a defect annotation.

Mask (deferred localization GT). The per-image defect mask (None for good) is attached in the mask column but not referenced in the query. The defect type is metadata.defect_code (one of Real-IAD's 8 types AK/BX/CH/HS/PS/QS/YW/ZW) with a plain-English metadata.defect_name; the camera view and sample id are metadata.camera_view / metadata.sample_id.

Split. The dataset's main split is published: train = normal-only (36,465 images; the unsupervised-AD protocol trains only on good images), test = mixed (114,585 images). Total 151,050 images. (Real-IAD also defines FUIAD noisy-train splits; only the main split is published.)

Query text — pooled paraphrases (v2)

Every record's query is drawn from common/vision_query_pools.json[F3/verdict_word], a pool of 40 gate-verified paraphrases of the shipped wording (this repository draws from the 8-template family of the ask it shipped; the other families describe inputs of a different shape), assigned by a stable hash of the source image path and recorded as metadata.query_template (8 templates in use, top share 12.6%).

The opening sentence is drawn separately (metadata.query_role, a 10-way hand-written pool _role/examining): the shipped sentence "You are an industrial visual-inspection model examining ." is index 0, index 1 is the noun phrase alone as a caption, the rest vary the frame around it — the noun phrase naming the input is this repository's own, verbatim, on every record. Role and ask are hashed independently.

Template 3 is v1's wording byte for byte (1,937 records keep it); the pass asserted that on every record before rewriting anything.

Template ↔ gold independence on this build: 151,050 records, 8 templates, worst template p = 0.00287, alpha 1.3e-03, 0 flagged; 10 roles, worst role p = 0.0908, 0 flagged → PASS.

Frame-size floor (common/lazy_floors.py, the standing (width, height)-only row): vacuous by construction — all 151,050 images share one frame size.

Answers, images, masks, split and every other field are byte-identical to v1: this revision was issued from the published parquet itself (tools/requery_published.py), not rebuilt from source, and the pixel-identity guard ran on the embedded images (§8 below).

Provenance

Underlying dataset: Real-IAD. Upstream license: CC BY-NC-SA 4.0 (this card is license: other; respect the upstream terms). Converted read-only from the raw source into the unified schema; conversion code under 192/ (with publish/push_to_hf.py) in AI4Manufacturing/forge_model.

Overlap / de-duplication (§8)

Same underlying images as the object-level companion 192-object (this is the per-image flattening) — keep the two on the same side of any split. Published main split only.

Two identities, and they answer different questions. metadata.image_sha256 hashes the file bytes: it finds byte-identical copies and is blind to a re-encode. metadata.pixel_sha256 hashes the decoded image (mode | size | pixels): it finds the same photograph saved twice. Only the second one settles whether an image is duplicated.

Measured at build time, not asserted afterwards — a violation aborts the build and names the offending records:


images checked	151,050
distinct by decoded pixels	151,049
images carrying more than one record	1
images on both sides of the split	0

⚠ This dataset declares a many image-identity policy, so the row above is expected to be non-zero: UPSTREAM (Real-IAD 256 release): one file is shipped twice under two different objects with contradictory labels — button_battery/OK/S0183/button_battery_0183_OK_C1_20230921083621.jpg (good) and phone_battery/NG/HS/S0039/phone_battery_0039_NG_HS_C5_20230919152207.jpg (anomalous) are byte-identical (file hash f256db31…), both in test. Both records are kept exactly as published; one of the two labels is wrong. Recorded for the next data revision Images are still forbidden from crossing the split, and none do.

Cross-family evaluation lock — metadata.eval_lock (stamped 2026-09-20; manifest revision fe6e286912b0, generated 2026-09-08). Every record of this repository, locked or not, carries metadata.eval_lock, computed by forge_model/common/overlap.py::Overlap.stamp_for against common/overlap_manifest.json at that revision — so within this repository the absence of the key cannot occur. Shape: {"locked": bool, "against": [{"repo": …, "split": …}, …], "own_split": …, "manifest_revision": …, "manifest_generated": …}. locked is true when the image is evaluation material anywhere in the corpus; against names every repository and split in which it is (sorted; [] when not locked; it includes the record's own family where that is so); own_split marks a record locked by its own split. The per-record field is the authority — the count here is quoted once, at this revision, and a later manifest may change it: 114,585 of 151,050 records (114,584 distinct images) are locked — by column: 0 by the cross-family manifest, 114,585 by their own split, 0 both ways and counted once; counterparts (records per counterpart; a record can appear under several): none — every lock here is by the record's own split; 114,585 locked by their own split: test. In words: 114,585 of the 151,050 records in this repository are evaluation material by their own metadata.split (test: 114,585) and sit inside the HF split named test / train — under the uniform-split convention the HF split name is a container name, and metadata.split together with metadata.eval_lock carries the truth; a train pool must exclude them. A stamp whose manifest_revision differs from the current manifest is stale, not wrong — recompute it (Overlap.stamp_is_current); a record with no stamp has not been checked against the corpus as it now is. Overlap.partition / assert_train_pool_clean read the field: a train pool built from this repository must exclude every locked record.

Geometry (`metadata.geometry`)

Every record carries a geometry block inside the existing metadata JSON string, so that its gold can be re-derived at any render size. No schema column changed; existing loaders are unaffected.

Coordinates are native pixels of the image in that record (coords_frame: "record_image"). scale is 1.0 throughout — this repo publishes at source resolution, nothing was downscaled at publish time.

"geometry": {
  "image_wh":  [W, H],        // dims of the image in THIS record
  "source_wh": [W, H],        // dims of the original source image
  "scale": 1.0,               // image_wh / source_wh; < 1.0 would disclose a publish-time downscale
  "n_instances": 2,
  "instances": [
    { "instance_id": 1, "bbox_xywh": [x, y, w, h], "min_side_px": 65, "class": null }
  ],
  "n_dropped_subminimum": 0,  // components removed by the filters below
  "union_box_fallback": false,// true => boxes are per-class unions, NOT real instances
  "conventions": { ... }      // see table
}

instances is present even when empty. [] means the record genuinely has no defects; an absent block would mean geometry could not be recovered. Those are different states and are never conflated.

Conventions used to derive it

There is no universal definition of "one defect instance" — it depends on the mask the source shipped. This repo's is stated, not implied:

field	value
`algorithm`	`dilate_cc`
`binarisation`	`gt:127`
`connectivity`	`4`
`merge`	`mask_dilate:1pct`
`min_area_px`	`15`
`max_instances`	`None`
`artifact`	`fine`
`fill_floor`	`None`
`legibility_floor_px`	`None`
`min_side_floor_px`	`None`
`spec_sha`	`00773c9990c30d85`

Provenance and verification


records	151,050
carrying a geometry block	151,050 / 151,050
instances per record	`0`: 99,809, `1`: 48,855, `2`: 2,070, `3`: 246, `4`: 49, `5+`: 21
total instances	54,042
image dimensions	256×256 (151,050)
`scale` values present	[1.0]

Derived from the AI4Manufacturing/192 masks and verified against this repo's own published answers before it was written — a recomputation that disagreed with the shipped gold would have aborted the update rather than overwritten it.

⚠ The 16px floor applies at the RENDER, not at native

min_side_px is in native pixels. The model does not see native: Qwen2-VL caps by megapixels AND snaps each dimension to a multiple of 28. So min_side_px >= 16 is the floor tested in the wrong frame. Measured on this repo:


native → rendered (qwen2_vl @ 2.36MP)	256×256 → 252×252
shipped boxes	54,042
legible at that render (>=16px there)	13,874 (25.7%)

⚠ An earlier version of this section reported the inverse — boxes clearing 16px at native and failing at the render — and that number was misleading. It is frame-relative: publishing at a larger native size lets more boxes clear 16 in the published frame, so more can "fail", which penalises exactly the choice that helps. Measured on 179: publishing native (3024) means a box needs >=32px native to be legible at the render and 86.7% qualify; the previous 1024 publish needed >=47px native and only 69.5% qualified. The native republish improved rendered legibility by 17 points while the old metric scored it as 12.5% "broken". The figure above is the comparable one.

Nothing in the data is frame-dependent — geometry is native and complete. Use forge_model/common/adapt_engine.py, which applies the floor at whatever size the consumer renders.

Using it

Coordinates only stay correct if they are rescaled with the image. A patch-based VLM does not render at native size: Qwen2-VL's processor snaps both dimensions to a multiple of 28, so this repo's 256×256 is rendered 252×252 and native-pixel boxes are then wrong by a few pixels. forge_model/common/adapt_engine.py regenerates coordinates for a target render size, re-derives counts, and drops records whose gold no longer holds there.

Downloads last month: 143

Total file size:

4.33 GB

You need to agree to share your contact information to access this dataset