Datasets:

legolasflagstaff
/

RobustGenBench

"""Generate README.md (dataset card + viewer configs) from out/manifests/*.json."""
import json
from pathlib import Path

ROOT = Path(__file__).parent / "out"
DATASETS = [  # (config name, display, domain, granularity, upstream url, upstream license)
    ("caltech101", "Caltech-101", "objects", "coarse",
     "https://data.caltech.edu/records/mzrjq-6wc02", "CC BY 4.0"),
    ("fgvc-aircraft-2013b", "FGVC-Aircraft (2013b)", "aircraft", "fine",
     "https://www.robots.ox.ac.uk/~vgg/data/fgvc-aircraft/", "non-commercial research use only"),
    ("flowers-102", "Oxford Flowers-102", "flowers", "fine",
     "https://www.robots.ox.ac.uk/~vgg/data/flowers/102/", "see upstream terms"),
    ("oxford-iiit-pet", "Oxford-IIIT Pet", "pets", "fine",
     "https://www.robots.ox.ac.uk/~vgg/data/pets/", "CC BY-SA 4.0"),
    ("stanford_cars", "Stanford Cars", "cars", "fine",
     "https://ai.stanford.edu/~jkrause/cars/car_dataset.html", "see upstream terms (research use)"),
    ("uc-merced-land-use-dataset", "UC Merced Land Use", "satellite", "coarse",
     "http://weegee.vision.ucmerced.edu/datasets/landuse.html", "USGS public-domain imagery"),
]
SURR = [  # (prefix, display, checkpoint)
    ("clip_vitb16", "CLIP ViT-B/16", "open_clip `ViT-B-16` / `laion2b_s34b_b88k`"),
    ("clip_vith14", "CLIP ViT-H/14", "open_clip `ViT-H-14` / `laion2b_s32b_b79k`"),
    ("metaclip_vith14", "MetaCLIP ViT-H/14", "open_clip `ViT-H-14-quickgelu` / `metaclip_fullcc`"),
    ("siglip2_so400m", "SigLIP2 SO400M", "`google/siglip2-so400m-patch14-384`"),
    ("siglip2_base", "SigLIP2 base", "`google/siglip2-base-patch16-224`"),
]
THREATS = [("l1_75", "ℓ1", "75"), ("l1_300", "ℓ1", "300"), ("l2_2", "ℓ2", "2"),
           ("l2_8", "ℓ2", "8"), ("linf_4", "ℓ∞", "4/255"), ("linf_8", "ℓ∞", "8/255"),
           ("linf_30", "ℓ∞", "30/255")]
ORDER = ["train", "validation", "test", "common", "random_linf_30"] + \
        [f"{s}_{t}" for s, _, _ in SURR for t, _, _ in THREATS]

man = {d[0]: json.loads((ROOT / "manifests" / f"{d[0]}.json").read_text()) for d in DATASETS}

# ── YAML header ──────────────────────────────────────────────────────────────
y = ["---", "license: cc-by-nc-4.0", "language:", "- en", "pretty_name: RobustGenBench",
     "size_categories:", "- 100K<n<1M", "task_categories:", "- image-classification",
     "task_ids:", "- multi-class-image-classification", "tags:",
     "- adversarial-robustness", "- common-corruptions", "- robustness",
     "- benchmark", "- transfer-attacks", "- vision-language-models", "- autoattack",
     "configs:"]
for i, (cfg, *_rest) in enumerate(DATASETS):
    y += [f"- config_name: {cfg}"] + (["  default: true"] if cfg == "caltech101" else []) + ["  data_files:"]
    for sp in [s for s in ORDER if s in man[cfg]["splits"]]:
        y += [f"  - split: {sp}", f"    path: data/{cfg}/{sp}-*.parquet"]
y.append("---")

# ── Coverage table ───────────────────────────────────────────────────────────
def mark(cfg, sp): return "✓" if sp in man[cfg]["splits"] else "–"
cov = ["| Split | " + " | ".join(d[1] for d in DATASETS) + " |",
       "|---|" + "---|" * len(DATASETS)]
for s, disp, _ in SURR:
    for t, n, e in THREATS:
        sp = f"{s}_{t}"
        if any(sp in man[d[0]]["splits"] for d in DATASETS):
            cov.append(f"| `{sp}` | " + " | ".join(mark(d[0], sp) for d in DATASETS) + " |")

ds_rows = "\n".join(
    f"| `{c}` | {disp} | {dom} | {gr} | {man[c]['num_classes']} | "
    f"{man[c]['splits']['train']['num_rows']:,} | {man[c]['splits']['validation']['num_rows']:,} | "
    f"{man[c]['splits']['test']['num_rows']:,} |" for c, disp, dom, gr, *_ in DATASETS)
lic_rows = "\n".join(f"| {disp} | [{u}]({u}) | {lic} |" for c, disp, _, _, u, lic in DATASETS)
surr_rows = "\n".join(f"| `{p}` | {d} | {ck} |" for p, d, ck in SURR)
n_test = sum(m["splits"]["test"]["num_rows"] for m in man.values())
n_pert = sum(v["num_rows"] for m in man.values() for k, v in m["splits"].items()
             if k not in ("train", "validation", "test"))
n_adv = sum(v["num_rows"] for m in man.values() for k, v in m["splits"].items()
            if k.split("_")[0] in ("clip", "metaclip", "siglip2"))

body = f"""
# RobustGenBench
**A standardized benchmark for robust generalization of image classifiers across common and adversarial ($\\ell_1, \\ell_2, \\ell_\\infty$) perturbations.**
📄 Paper · 💻 [Code](https://github.com/legolasflagstaff/robust_training) · 📜 [Citation](#citation)
RobustGenBench evaluates how well a classifier keeps its accuracy on perturbation types it was not trained against. It provides six downstream classification datasets with fixed splits at 224×224 resolution, together with perturbed copies of every test set:
- **Common corruptions** (11 types, severity 3): model-independent, the same images for every model.
- **Random uniform noise** ($\\ell_\\infty \\le 30/255$): a control for the adversarial perturbations.
- **Transfer adversarial perturbations** ({n_adv:,} images): crafted with AutoAttack on 5 open-weight vision-language surrogates, across 7 budgets in $\\ell_1$, $\\ell_2$, $\\ell_\\infty$.
Because the adversarial images are pre-computed, any model, including API-only systems such as vision-enabled LLMs, can be evaluated **by inference alone**, without GPU access. For white-box evaluation, attack your own model on the clean `test` split.
In total: {n_test:,} clean test images and {n_pert:,} perturbed test images.
## Quick start
```python
from datasets import load_dataset
# One config per dataset; one split per perturbation setting.
clean = load_dataset("legolasflagstaff/RobustGenBench", "uc-merced-land-use-dataset", split="test")
adv   = load_dataset("legolasflagstaff/RobustGenBench", "uc-merced-land-use-dataset", split="clip_vith14_linf_30")
row = adv[0]
row["image"]                                  # PIL.Image, 224×224 RGB
adv.features["label"].int2str(row["label"])   # class name
row["image_id"]                               # aligns with the clean image of the same id
```
Evaluate a classifier on every perturbation setting of one dataset:
```python
from datasets import load_dataset, get_dataset_split_names
repo, cfg = "legolasflagstaff/RobustGenBench", "flowers-102"
for split in get_dataset_split_names(repo, cfg):
    if split in ("train", "validation"):
        continue
    ds = load_dataset(repo, cfg, split=split)
    acc = sum(predict(x["image"]) == x["label"] for x in ds) / len(ds)   # your model here
    print(f"{{split:24s}} {{acc:.3f}}")
```
Splits are aligned by `image_id`: row *i* of every perturbed split is a perturbed version of row *i* of `test`, with the same label.
## Datasets
| Config | Dataset | Domain | Granularity | Classes | Train | Validation | Test |
|---|---|---|---|---|---|---|---|
{ds_rows}
Test sets are standardized to at most 1,000 images by uniform sampling, preserving all classes. All images are resized to 224×224×3 and stored as lossless PNG.
## Splits
Each config (dataset) contains the following splits.
| Split | Content |
|---|---|
| `train`, `validation` | Clean images, for fine-tuning. |
| `test` | Clean test images, the reference for all perturbed splits. |
| `common` | Each test image with one of 11 common corruptions at severity 3 (column `corruption`). |
| `random_linf_30` | Uniform random noise with $\\lVert\\delta\\rVert_\\infty \\le 30/255$. |
| `<surrogate>_<norm>_<eps>` | Transfer adversarial images, e.g. `clip_vitb16_linf_30`, `metaclip_vith14_l1_300`. |
### Common corruptions
Shot noise, impulse noise, defocus blur, motion blur, zoom blur, snow, brightness, contrast, elastic transform, pixelate, JPEG compression, all at severity 3 of the ImageNet-C scale. Test image *i* receives corruption *i* mod 11; the assignment is deterministic, so every model is evaluated on identical (image, corruption) pairs.
### Adversarial perturbations
Perturbations are crafted with the standard AutoAttack ensemble (APGD-CE, APGD-T, FAB-T, Square) against zero-shot surrogate classifiers. Each surrogate predicts the class whose text embedding (`"a photo of a {{class}}"`) is closest to the image embedding. AutoAttack only perturbs images the surrogate classifies correctly; other images are copied unchanged (`is_modified = false`).
| Norm | Budgets $\\epsilon$ | Split suffix |
|---|---|---|
| $\\ell_1$ | 75, 300 | `l1_75`, `l1_300` |
| $\\ell_2$ | 2, 8 | `l2_2`, `l2_8` |
| $\\ell_\\infty$ | 4/255, 8/255, 30/255 | `linf_4`, `linf_8`, `linf_30` |
Budgets are expressed on pixel values in $[0, 1]$; the `epsilon` column stores the exact value (e.g. 0.1176 for 30/255).
| Surrogate prefix | Model | Checkpoint |
|---|---|---|
{surr_rows}
### Coverage
SigLIP-family surrogates classify the fine-grained datasets poorly, and a surrogate that misclassifies the clean image provides no attack signal. SigLIP2 SO400M is therefore provided on the three coarse-grained datasets only. SigLIP2 base is provided at $\\ell_\\infty$ 30/255 only; on the fine-grained datasets it leaves most images unmodified (see `is_modified`).
{chr(10).join(cov)}
## Data fields
| Field | Type | Description |
|---|---|---|
| `image` | image | 224×224 RGB PNG. |
| `label` | class label | Ground-truth class (use `features["label"].names` for names). |
| `image_id` | int32 | Index of the source image within its split; aligns perturbed splits with `test`. |
| `perturbation` | string | `clean`, `common_corruption_severity3`, `random_uniform`, or `transfer_autoattack`. |
| `surrogate` | string | Surrogate used to craft the attack (null otherwise). |
| `norm` | string | `l1`, `l2`, or `linf` (null for clean and common). |
| `epsilon` | float32 | Perturbation budget (null for clean and common). |
| `corruption` | string | Common corruption applied (`common` split only). |
| `is_modified` | bool | Whether the image differs from its clean counterpart. |
## Evaluation protocol
RobustGenBench reports accuracy per (dataset, perturbation setting), aggregated with:
- **Sum score**: sum of accuracies over all (dataset, setting) pairs. Pool-independent; use it to compare new models with published results.
- **Borda score**: rank-based consistency across pairs, only meaningful within a fixed pool of models.
The paper uses two sets of settings:
- **Fine-tuned vision models (5 settings):** `test`, `common`, and white-box AutoAttack on the evaluated model at $\\ell_1 = 75$, $\\ell_2 = 2$, $\\ell_\\infty = 4/255$, crafted from the clean `test` split. Maximum sum score: 30.
- **Black-box models, e.g. vision-enabled LLMs (9 settings):** `test`, `common`, and the 7 transfer budgets, taking the strongest surrogate per dataset and setting.
## Intended use and limitations
**Intended use:** held-out evaluation of the robustness of image classifiers, fine-tuned or zero-shot, including API-only models. Do not train on the test or perturbed splits.
**Limitations**
- Transfer attacks give an upper bound on robust accuracy. They are not a substitute for white-box or adaptive attacks when model access is available.
- All surrogates are attention-based, so transfer to convolutional targets is weaker.
- Budgets are not matched across norms; compare norms only at the intensities provided.
- Common corruptions are evaluated at a single severity.
- Coverage is limited to six source taxonomies; results do not imply robustness on open-world imagery.
**Biases.** The source datasets inherit the biases of their collection, for example Western car models (Stanford Cars) and breeds common in the UK (Oxford-IIIT Pet). Some images may incidentally show people or license plates; no additional anonymization was performed.
## License
The perturbed images, splits, and metadata produced for RobustGenBench are released under **[CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)**. This license does not override the terms of the source datasets: every image is a derivative of an upstream image whose rights remain with its owners. Users must comply with both licenses; where they differ, the more restrictive applies.
| Source | Homepage | Upstream terms |
|---|---|---|
{lic_rows}
## Citation
```bibtex
@inproceedings{{heuillet2026robustgenbench,
  title     = {{RobustGenBench: A Benchmark for Robust Generalization to Adversarial and Common Perturbations, with Applications to Vision and Vision-Enabled Large Language Models}},
  author    = {{Heuillet, Maxime and Ngnaw{{\\'e}}, Jonas and Pequignot, Yann and Bhagwatkar, Rishika and Larouche, Alexandre and Gagn{{\\'e}}, Christian and Rish, Irina and Ahmad, Ola and Durand, Audrey}},
  booktitle = {{TODO}},
  year      = {{2026}}
}}
```
Please also cite the six source datasets.
## Versions
- **v2.0** (current): Parquet layout with Dataset Viewer support; restricted to the surrogates reported in the paper.
- **v1.0**: original `.tar.zst` archives, kept for reproducibility under the git tag [`v1.0-archives`](https://huggingface.co/datasets/legolasflagstaff/RobustGenBench/tree/v1.0-archives).
"""
(ROOT / "README.md").write_text("\n".join(y) + "\n" + body)
print("README.md written,", len(y), "YAML lines")

	"""Generate README.md (dataset card + viewer configs) from out/manifests/*.json."""
	import json
	from pathlib import Path

	ROOT = Path(__file__).parent / "out"
	DATASETS = [ # (config name, display, domain, granularity, upstream url, upstream license)
	("caltech101", "Caltech-101", "objects", "coarse",
	"https://data.caltech.edu/records/mzrjq-6wc02", "CC BY 4.0"),
	("fgvc-aircraft-2013b", "FGVC-Aircraft (2013b)", "aircraft", "fine",
	"https://www.robots.ox.ac.uk/~vgg/data/fgvc-aircraft/", "non-commercial research use only"),
	("flowers-102", "Oxford Flowers-102", "flowers", "fine",
	"https://www.robots.ox.ac.uk/~vgg/data/flowers/102/", "see upstream terms"),
	("oxford-iiit-pet", "Oxford-IIIT Pet", "pets", "fine",
	"https://www.robots.ox.ac.uk/~vgg/data/pets/", "CC BY-SA 4.0"),
	("stanford_cars", "Stanford Cars", "cars", "fine",
	"https://ai.stanford.edu/~jkrause/cars/car_dataset.html", "see upstream terms (research use)"),
	("uc-merced-land-use-dataset", "UC Merced Land Use", "satellite", "coarse",
	"http://weegee.vision.ucmerced.edu/datasets/landuse.html", "USGS public-domain imagery"),
	]
	SURR = [ # (prefix, display, checkpoint)
	("clip_vitb16", "CLIP ViT-B/16", "open_clip `ViT-B-16` / `laion2b_s34b_b88k`"),
	("clip_vith14", "CLIP ViT-H/14", "open_clip `ViT-H-14` / `laion2b_s32b_b79k`"),
	("metaclip_vith14", "MetaCLIP ViT-H/14", "open_clip `ViT-H-14-quickgelu` / `metaclip_fullcc`"),
	("siglip2_so400m", "SigLIP2 SO400M", "`google/siglip2-so400m-patch14-384`"),
	("siglip2_base", "SigLIP2 base", "`google/siglip2-base-patch16-224`"),
	]
	THREATS = [("l1_75", "ℓ1", "75"), ("l1_300", "ℓ1", "300"), ("l2_2", "ℓ2", "2"),
	("l2_8", "ℓ2", "8"), ("linf_4", "ℓ∞", "4/255"), ("linf_8", "ℓ∞", "8/255"),
	("linf_30", "ℓ∞", "30/255")]
	ORDER = ["train", "validation", "test", "common", "random_linf_30"] + \
	[f"{s}_{t}" for s, _, _ in SURR for t, _, _ in THREATS]

	man = {d[0]: json.loads((ROOT / "manifests" / f"{d[0]}.json").read_text()) for d in DATASETS}

	# ── YAML header ──────────────────────────────────────────────────────────────
	y = ["---", "license: cc-by-nc-4.0", "language:", "- en", "pretty_name: RobustGenBench",
	"size_categories:", "- 100K<n<1M", "task_categories:", "- image-classification",
	"task_ids:", "- multi-class-image-classification", "tags:",
	"- adversarial-robustness", "- common-corruptions", "- robustness",
	"- benchmark", "- transfer-attacks", "- vision-language-models", "- autoattack",
	"configs:"]
	for i, (cfg, *_rest) in enumerate(DATASETS):
	y += [f"- config_name: {cfg}"] + ([" default: true"] if cfg == "caltech101" else []) + [" data_files:"]
	for sp in [s for s in ORDER if s in man[cfg]["splits"]]:
	y += [f" - split: {sp}", f" path: data/{cfg}/{sp}-*.parquet"]
	y.append("---")

	# ── Coverage table ───────────────────────────────────────────────────────────
	def mark(cfg, sp): return "✓" if sp in man[cfg]["splits"] else "–"
	cov = ["\| Split \| " + " \| ".join(d[1] for d in DATASETS) + " \|",
	"\|---\|" + "---\|" * len(DATASETS)]
	for s, disp, _ in SURR:
	for t, n, e in THREATS:
	sp = f"{s}_{t}"
	if any(sp in man[d[0]]["splits"] for d in DATASETS):
	cov.append(f"\| `{sp}` \| " + " \| ".join(mark(d[0], sp) for d in DATASETS) + " \|")

	ds_rows = "\n".join(
	f"\| `{c}` \| {disp} \| {dom} \| {gr} \| {man[c]['num_classes']} \| "
	f"{man[c]['splits']['train']['num_rows']:,} \| {man[c]['splits']['validation']['num_rows']:,} \| "
	f"{man[c]['splits']['test']['num_rows']:,} \|" for c, disp, dom, gr, *_ in DATASETS)
	lic_rows = "\n".join(f"\| {disp} \| [{u}]({u}) \| {lic} \|" for c, disp, _, _, u, lic in DATASETS)
	surr_rows = "\n".join(f"\| `{p}` \| {d} \| {ck} \|" for p, d, ck in SURR)
	n_test = sum(m["splits"]["test"]["num_rows"] for m in man.values())
	n_pert = sum(v["num_rows"] for m in man.values() for k, v in m["splits"].items()
	if k not in ("train", "validation", "test"))
	n_adv = sum(v["num_rows"] for m in man.values() for k, v in m["splits"].items()
	if k.split("_")[0] in ("clip", "metaclip", "siglip2"))

	body = f"""
	# RobustGenBench

	A standardized benchmark for robust generalization of image classifiers across common and adversarial ($\\ell_1, \\ell_2, \\ell_\\infty$) perturbations.

	📄 Paper · 💻 [Code](https://github.com/legolasflagstaff/robust_training) · 📜 [Citation](#citation)

	RobustGenBench evaluates how well a classifier keeps its accuracy on perturbation types it was not trained against. It provides six downstream classification datasets with fixed splits at 224×224 resolution, together with perturbed copies of every test set:

	- Common corruptions (11 types, severity 3): model-independent, the same images for every model.
	- Random uniform noise ($\\ell_\\infty \\le 30/255$): a control for the adversarial perturbations.
	- Transfer adversarial perturbations ({n_adv:,} images): crafted with AutoAttack on 5 open-weight vision-language surrogates, across 7 budgets in $\\ell_1$, $\\ell_2$, $\\ell_\\infty$.

	Because the adversarial images are pre-computed, any model, including API-only systems such as vision-enabled LLMs, can be evaluated by inference alone, without GPU access. For white-box evaluation, attack your own model on the clean `test` split.

	In total: {n_test:,} clean test images and {n_pert:,} perturbed test images.

	## Quick start

	```python
	from datasets import load_dataset

	# One config per dataset; one split per perturbation setting.
	clean = load_dataset("legolasflagstaff/RobustGenBench", "uc-merced-land-use-dataset", split="test")
	adv = load_dataset("legolasflagstaff/RobustGenBench", "uc-merced-land-use-dataset", split="clip_vith14_linf_30")

	row = adv[0]
	row["image"] # PIL.Image, 224×224 RGB
	adv.features["label"].int2str(row["label"]) # class name
	row["image_id"] # aligns with the clean image of the same id
	```

	Evaluate a classifier on every perturbation setting of one dataset:

	```python
	from datasets import load_dataset, get_dataset_split_names

	repo, cfg = "legolasflagstaff/RobustGenBench", "flowers-102"
	for split in get_dataset_split_names(repo, cfg):
	if split in ("train", "validation"):
	continue
	ds = load_dataset(repo, cfg, split=split)
	acc = sum(predict(x["image"]) == x["label"] for x in ds) / len(ds) # your model here
	print(f"{{split:24s}} {{acc:.3f}}")
	```

	Splits are aligned by `image_id`: row i of every perturbed split is a perturbed version of row i of `test`, with the same label.

	## Datasets

	\| Config \| Dataset \| Domain \| Granularity \| Classes \| Train \| Validation \| Test \|
	\|---\|---\|---\|---\|---\|---\|---\|---\|
	{ds_rows}

	Test sets are standardized to at most 1,000 images by uniform sampling, preserving all classes. All images are resized to 224×224×3 and stored as lossless PNG.

	## Splits

	Each config (dataset) contains the following splits.

	\| Split \| Content \|
	\|---\|---\|
	\| `train`, `validation` \| Clean images, for fine-tuning. \|
	\| `test` \| Clean test images, the reference for all perturbed splits. \|
	\| `common` \| Each test image with one of 11 common corruptions at severity 3 (column `corruption`). \|
	\| `random_linf_30` \| Uniform random noise with $\\lVert\\delta\\rVert_\\infty \\le 30/255$. \|
	\| `<surrogate>_<norm>_<eps>` \| Transfer adversarial images, e.g. `clip_vitb16_linf_30`, `metaclip_vith14_l1_300`. \|

	### Common corruptions

	Shot noise, impulse noise, defocus blur, motion blur, zoom blur, snow, brightness, contrast, elastic transform, pixelate, JPEG compression, all at severity 3 of the ImageNet-C scale. Test image i receives corruption i mod 11; the assignment is deterministic, so every model is evaluated on identical (image, corruption) pairs.

	### Adversarial perturbations

	Perturbations are crafted with the standard AutoAttack ensemble (APGD-CE, APGD-T, FAB-T, Square) against zero-shot surrogate classifiers. Each surrogate predicts the class whose text embedding (`"a photo of a {{class}}"`) is closest to the image embedding. AutoAttack only perturbs images the surrogate classifies correctly; other images are copied unchanged (`is_modified = false`).

	\| Norm \| Budgets $\\epsilon$ \| Split suffix \|
	\|---\|---\|---\|
	\| $\\ell_1$ \| 75, 300 \| `l1_75`, `l1_300` \|
	\| $\\ell_2$ \| 2, 8 \| `l2_2`, `l2_8` \|
	\| $\\ell_\\infty$ \| 4/255, 8/255, 30/255 \| `linf_4`, `linf_8`, `linf_30` \|

	Budgets are expressed on pixel values in $[0, 1]$; the `epsilon` column stores the exact value (e.g. 0.1176 for 30/255).

	\| Surrogate prefix \| Model \| Checkpoint \|
	\|---\|---\|---\|
	{surr_rows}

	### Coverage

	SigLIP-family surrogates classify the fine-grained datasets poorly, and a surrogate that misclassifies the clean image provides no attack signal. SigLIP2 SO400M is therefore provided on the three coarse-grained datasets only. SigLIP2 base is provided at $\\ell_\\infty$ 30/255 only; on the fine-grained datasets it leaves most images unmodified (see `is_modified`).

	{chr(10).join(cov)}

	## Data fields

	\| Field \| Type \| Description \|
	\|---\|---\|---\|
	\| `image` \| image \| 224×224 RGB PNG. \|
	\| `label` \| class label \| Ground-truth class (use `features["label"].names` for names). \|
	\| `image_id` \| int32 \| Index of the source image within its split; aligns perturbed splits with `test`. \|
	\| `perturbation` \| string \| `clean`, `common_corruption_severity3`, `random_uniform`, or `transfer_autoattack`. \|
	\| `surrogate` \| string \| Surrogate used to craft the attack (null otherwise). \|
	\| `norm` \| string \| `l1`, `l2`, or `linf` (null for clean and common). \|
	\| `epsilon` \| float32 \| Perturbation budget (null for clean and common). \|
	\| `corruption` \| string \| Common corruption applied (`common` split only). \|
	\| `is_modified` \| bool \| Whether the image differs from its clean counterpart. \|

	## Evaluation protocol

	RobustGenBench reports accuracy per (dataset, perturbation setting), aggregated with:

	- Sum score: sum of accuracies over all (dataset, setting) pairs. Pool-independent; use it to compare new models with published results.
	- Borda score: rank-based consistency across pairs, only meaningful within a fixed pool of models.

	The paper uses two sets of settings:

	- Fine-tuned vision models (5 settings): `test`, `common`, and white-box AutoAttack on the evaluated model at $\\ell_1 = 75$, $\\ell_2 = 2$, $\\ell_\\infty = 4/255$, crafted from the clean `test` split. Maximum sum score: 30.
	- Black-box models, e.g. vision-enabled LLMs (9 settings): `test`, `common`, and the 7 transfer budgets, taking the strongest surrogate per dataset and setting.

	## Intended use and limitations

	Intended use: held-out evaluation of the robustness of image classifiers, fine-tuned or zero-shot, including API-only models. Do not train on the test or perturbed splits.

	Limitations
	- Transfer attacks give an upper bound on robust accuracy. They are not a substitute for white-box or adaptive attacks when model access is available.
	- All surrogates are attention-based, so transfer to convolutional targets is weaker.
	- Budgets are not matched across norms; compare norms only at the intensities provided.
	- Common corruptions are evaluated at a single severity.
	- Coverage is limited to six source taxonomies; results do not imply robustness on open-world imagery.

	Biases. The source datasets inherit the biases of their collection, for example Western car models (Stanford Cars) and breeds common in the UK (Oxford-IIIT Pet). Some images may incidentally show people or license plates; no additional anonymization was performed.

	## License

	The perturbed images, splits, and metadata produced for RobustGenBench are released under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/). This license does not override the terms of the source datasets: every image is a derivative of an upstream image whose rights remain with its owners. Users must comply with both licenses; where they differ, the more restrictive applies.

	\| Source \| Homepage \| Upstream terms \|
	\|---\|---\|---\|
	{lic_rows}

	## Citation

	```bibtex
	@inproceedings{{heuillet2026robustgenbench,
	title = {{RobustGenBench: A Benchmark for Robust Generalization to Adversarial and Common Perturbations, with Applications to Vision and Vision-Enabled Large Language Models}},
	author = {{Heuillet, Maxime and Ngnaw{{\\'e}}, Jonas and Pequignot, Yann and Bhagwatkar, Rishika and Larouche, Alexandre and Gagn{{\\'e}}, Christian and Rish, Irina and Ahmad, Ola and Durand, Audrey}},
	booktitle = {{TODO}},
	year = {{2026}}
	}}
	```

	Please also cite the six source datasets.

	## Versions

	- v2.0 (current): Parquet layout with Dataset Viewer support; restricted to the surrogates reported in the paper.
	- v1.0: original `.tar.zst` archives, kept for reproducibility under the git tag [`v1.0-archives`](https://huggingface.co/datasets/legolasflagstaff/RobustGenBench/tree/v1.0-archives).
	"""
	(ROOT / "README.md").write_text("\n".join(y) + "\n" + body)
	print("README.md written,", len(y), "YAML lines")