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

213

Woven-fabric surface anomaly detection over 4 fabric categories (binary; antialiased segmentation 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

4,101 records (test=444 · train=3657). 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: the plain-text image-level label `good` or `anomalous`. The task is binary by necessity: only `grey_cloth` names its defect types upstream (contaminated / flecked / line / string); grid_cloth, pink_flower and yellow_cloth ship a single unnamed `defect` folder, so a `{label, defect_type}` answer would be answerable for one category and degenerate for three. The source folder name is preserved in `metadata.defect_type` (`defect` where upstream does not name it). The `mask` column is deferred localization GT and is antialiased greyscale, not binary — see Task, mask & 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

Task, mask & split

What this is. WFDD (Woven Fabric Defect Detection), released alongside GLASS (Chen et al., "A Unified Anomaly Synthesis Strategy with Gradient Ascent for Industrial Anomaly Detection and Localization", ECCV 2024) under the MIT licence. 4,101 images over four woven-fabric categories: grey_cloth, grid_cloth, yellow_cloth (WEIQIAO Textile production lines) and pink_flower (a public Cloth Flaw Dataset). Standard unsupervised-AD layout: train is good-only, test mixes good and defective. Defects are block-shaped, point-like and line-type.

Task & answer. Binary image-level anomaly detection. query is our own template (the source ships no natural-language question): it names the fabric and asks whether it is good or anomalous. annot is the bare label. Why binary and not {label, defect_type}: only grey_cloth names its defect types upstream (contaminated / flecked / line / string); the other three categories ship one unnamed defect folder. Asking for a type would be answerable for one category and degenerate for three, so the type is preserved in metadata.defect_type instead of being asked — the same call 187/MPDD makes for the same reason.

⚠ The mask is antialiased greyscale, not binary. Ground-truth PNGs are mode-L carrying a full 0–255 ramp at defect boundaries (interior 255, background 0, soft edge between), not a two-valued mask. Any area, instance count or bounding box derived from them depends on the binarisation threshold, and any reported figure must state the threshold it used — numbers computed at different thresholds are not comparable. The mask is published exactly as upstream released it (we do not binarise: that would discard information the consumer may want); each record carries metadata.mask_is_antialiased = true.

⚠ 146 test images are byte-identical copies of train images — upstream, not from this conversion. The official release holds 4,101 images but only 3,942 distinct ones. Every good image in the test split of grid_cloth, pink_flower and yellow_cloth also appears in that category's train split (verified by SHA-256 over the original tarball). We publish the splits exactly as released and expose metadata.image_sha256; deduplicate before evaluating, or part of the test score is measured on images the model was trained on.

Lazy-baseline floors (report any accuracy against these, not against 50%).

test set	n	majority class	floor
as published	444	`anomalous` (241)	54.3%
after dropping the 146 train-duplicate images	294	`anomalous` (241)	82.0%

Deduplicating removes 150 good images and no anomalous ones, so the honest test set is heavily anomaly-skewed and the floor is high. A binary accuracy near 80% on the deduplicated split is at chance.

⚠ Do not substitute the HuggingFace mirror XimiaoZhang/WFDD. Compared against the official release it drops 15 images (4,086 vs 4,101 — 3 pink_flower and 12 yellow_cloth defects), asserts per-defect type names for the three categories the original authors left unnamed, and re-encodes the antialiased masks as category-local class indices (string = 4 in grey_cloth but 2 in grid_cloth). It carries the same 146-image duplication. This repo is built from the official tarball.

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 11-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 (11 templates in use, top share 9.4%).

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.

⚠ Approved deviation — no answer-format directive in v1. v1's query gave no answer-format directive; from v2 every query states it (Answer with a single word: good or anomalous.). The gold was always the single word.

Template ↔ gold independence on this build: 4,101 records, 11 templates, worst template p = 0.0222, alpha 9.1e-04, 0 flagged; 10 roles, worst role p = 0.0387, 0 flagged → PASS.

Frame-size floor (common/lazy_floors.py, the standing (width, height)-only row): balanced accuracy 0.500 vs 0.500 chance (plain 0.457 vs 0.543 majority), 2 distinct frame sizes — no signal.

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: WFDD (Woven Fabric Defect Detection). Upstream license: MIT (WFDD, released with GLASS — Chen et al., ECCV 2024) (this card is license: other; respect the upstream terms). Converted read-only from the raw source into the unified schema; conversion code under 213/ (with publish/push_to_hf.py) in AI4Manufacturing/forge_model.

Overlap / de-duplication (§8)

No overlap with any other dataset in this corpus. ⚠ 146 of the 444 test images are byte-identical to train images upstream — see the split 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 checked	4,101
distinct by decoded pixels	3,942
images carrying more than one record	151
images on both sides of the split	146

⚠ This dataset declares a exempt image-identity policy, so the row above is expected to be non-zero: UPSTREAM, documented on this card since v1: the official WFDD release ships 146 test images that are byte-identical copies of train images (every good test image of grid_cloth, pink_flower and yellow_cloth; 146 groups, labels agreeing, 4 of them 4-way). The splits are published exactly as released so the official protocol stays reproducible; deduplicate on metadata.image_sha256 (or 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`	`10730dfa7d9bc9c5`

Provenance and verification


records	4,101
carrying a geometry block	4,101 / 4,101
instances per record	`0`: 3,860, `1`: 187, `2`: 46, `3`: 2, `4`: 3, `5+`: 3
total instances	330
image dimensions	512×512 (4,100), 513×512 (1)
`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)	512×512 → 504×504, 513×512 → 504×504
shipped boxes	330
legible at that render (>=16px there)	263 (79.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 512×512 is rendered 504×504 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: 63

Total file size:

681 MB

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