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).

209

Multi-view tiny-object anomaly detection over 38 categories in 5 domains (every image is a 5-view montage). 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

135,365 records (test=25865 · train=109500). Pixel masks are embedded as a mask image column.

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: plain-text `{label, defect_type}` — `{good, null}` or `{anomalous, <defect>}`, the defect name from THAT category's own closed set (enumerated in the query), following D20/D22. `multi_anomalies` is a meta-label, not a defect type. The binary `mask` column is deferred localization GT; `metadata.views_with_defect` says which of the 5 views the mask actually marks
`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

Task, multi-view geometry, mask & split

What this is. MANTA (Fan, Fan, Hu, Ding, Di, Yi, Pagnucco, Song, "MANTA: A Large-Scale Multi-View and Visual-Text Anomaly Detection Dataset for Tiny Objects", CVPR 2025) — 38 categories of tiny objects across five domains: agriculture (48,027 records), medicine (33,219), mechanics (24,635), electronics (24,058), groceries (5,426). MVTec-AD-style layout: train = 109,500 good only; test = 25,865 (17,248 good + 8,617 defective), each defective image with a binary pixel mask.

⚠ EVERY IMAGE IS A HORIZONTAL MONTAGE OF 5 CAMERA VIEWS OF THE SAME OBJECT — not a single photograph. This is the dataset's defining property and it is invisible from the file layout: the files are ordinary PNGs with sequential names, and an 855x279 paddy image is five 171x279 tiles side by side. Image sizes vary widely (598 distinct view widths across the corpus), so the tile width is per-record, not a constant.

Two consequences:

The image-level label is an object-level label, and over half the defects are not visible from every camera. Measured over all 8,617 anomalous records (read off the masks, not asserted):

views showing the defect records share

5 of 5 4,180 48.5%

4 2,621 30.4%

3 359 4.2%

2 306 3.6%

1 of 5 1,151 13.4%

So for ~51% of anomalous records the evidence occupies a fraction of the frame, and for one in eight a single tile. This is Real-IAD's "invisible view" effect folded inside one image. Every record carries metadata.views_with_defect (1-indexed) so you can select or stratify on it.
Each view is narrow, and legibility must be judged per view. metadata.view_width, view_size and montage_size give the geometry for a deterministic split into 5 tiles. Judging defect legibility from the montage width overstates the available resolution fivefold — which matters here more than anywhere else in this corpus, because these are deliberately tiny objects.

We publish the montage exactly as released rather than pre-cropping it: cropping would discard the cross-view comparison the dataset was built to support.

Task & answer. query names the object and its domain, states that five viewpoints are shown side by side, and asks for {label, defect_type} from that category's own closed set. annot is plain text {good, null} / {anomalous, <defect>}.

⚠ multi_anomalies is a meta-label, not a defect type (1,006 records) — the same situation as 3CAD's Multiple-defects. It marks objects carrying several defect types at once; the individual types are not recoverable from the release. metadata.multi_defect flags it, and a type-classifier should keep it as its own class or drop it rather than treat it as one more defect name.

⚠ Record count differs from the paper. The release ships 135,365 images and all of them are converted here; the paper reports 137,338. We could not reconcile the 1,973-image difference from the released files and publish what the files contain. The 8,617 mask count matches the paper exactly.

⚠ Licence: the authors state three different ones. figshare (which hosts the data) says CC BY 4.0; the project page says CC BY-NC-SA 4.0 and "All data must not be used for commercial purposes"; the arXiv posting is CC BY-NC-ND 4.0. We inherit the most restrictive reading and treat MANTA as non-commercial rather than picking the permissive one. Confirm with the authors before any commercial use.

Lazy-baseline floor. The test split is 17,248 good vs 8,617 anomalous, so always answering {good, null} scores 66.7% — which is also the full {label, defect_type} floor. Report against that, not against 50%.

Not used: the 256x256 manta-tiny variant. These are tiny objects in a five-view montage; downscaling to 256 px would put most defects below this corpus's validated 16 px legibility floor. The full-resolution release is converted instead.

Query text — pooled paraphrases (v2)

Every record's query is drawn from common/vision_query_pools.json[F2a/label_type], a pool of 39 gate-verified paraphrases of the shipped wording, assigned by a stable hash of the source image path and recorded as metadata.query_template (39 templates in use, top share 2.7%).

The opening role sentence is drawn separately (metadata.query_role, a 10-way hand-written pool _role/sentence; index 0 is this repository's own sentence, index 1 is none); the subject sentence is this repository's own, verbatim, on every record. Role and ask are hashed independently.

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

Template ↔ gold independence on this build: 135,365 records, 39 templates, worst template p = 0.0444, alpha 2.6e-04, 0 flagged; 10 roles, worst role p = 0.0101, 0 flagged → PASS.

Frame-size floor (common/lazy_floors.py, the standing (width, height)-only row): balanced accuracy 0.512 vs 0.500 chance (plain 0.542 vs 0.667 majority; permutation p = 0.005, 200 shuffles), 9628 distinct frame sizes — a shortcut of +1.2 pp balanced, report against it (5-fold within the test split because the training split holds a single class (all 109,499 records), so a train→test probe can only predict that class; not comparable to train→test rows on other cards).

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: MANTA. Upstream license: non-commercial — the authors state three different licences; see the card (this card is license: other; respect the upstream terms). Converted read-only from the raw source into the unified schema; conversion code under 209/ (with publish/push_to_hf.py) in AI4Manufacturing/forge_model.

Overlap / de-duplication (§8)

No overlap with any other dataset in this corpus. ⚠ Every image is a horizontal montage of 5 camera views of one object, so the image-level label is an object-level label — see the multi-view note below.

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 that could NOT be decoded (no pixel identity; left exactly as published)	1
images checked	135,364
distinct by decoded pixels	135,363
images carrying more than one record	1
images on both sides of the split	1

⚠ Undecodable image bytes, upstream. Data/new/MANTA/extracted/wheat/train/good/grain_wheat_14437.png — OSError: image file is truncated. These records are published exactly as released and a query-only republish cannot repair them; they carry no pixel_sha256, and any training or evaluation run should skip them (an image that will not decode is not a sample).

⚠ This dataset declares a exempt image-identity policy, so the row above is expected to be non-zero: UPSTREAM (MANTA release): ONE image is published in both splits — copper_standoff/test/good/electronics_copper_standoff_02127.png is pixel-identical (and byte-identical) to copper_standoff/train/good/electronics_copper_standoff_00400.png, both labelled good. Every other one of the 135,364 decodable images appears exactly once. The split is published exactly as released; drop the test copy (metadata.pixel_sha256) before evaluating. Recorded for the next data revision Images are still forbidden from crossing the split — and that rule too is exempted here, which is why the last row may be non-zero.

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:0`
`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`	`cb8b9b26d69d56d4`

Provenance and verification


records	135,365
carrying a geometry block	135,365 / 135,365
instances per record	`0`: 126,748, `1`: 997, `2`: 383, `3`: 337, `4`: 2,274, `5+`: 4,626
total instances	42,522
image dimensions	1635×309 (348), 1640×331 (320), 1805×361 (286)
`scale` values present	[1.0]

Computed from this repo's own 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)	645×258 → 644×252, 645×267 → 644×280, 645×276 → 644×280
shipped boxes	42,522
legible at that render (>=16px there)	39,775 (93.5%)

⚠ 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 645×258 is rendered 644×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: 182

Total file size:

129 GB

views showing the defect	records	share
5 of 5	4,180	48.5%
4	2,621	30.4%
3	359	4.2%
2	306	3.6%
1 of 5	1,151	13.4%

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