Datasets:

visual-abstention
/

VisTA-Train

license: apache-2.0
language:
  - en
pretty_name: VisTA-Train
size_categories:
  - 10K<n<100K
task_categories:
  - image-to-image
tags:
  - visual-abstention
  - abstention
  - refusal
  - image-editing
  - unified-multimodal-models
  - multimodal-reasoning
  - chain-of-thought
  - training-data
  - maze
configs:
  - config_name: material_modification
    data_files:
      - split: train
        path: material_modification/instruction.jsonl
  - config_name: medium_interaction
    data_files:
      - split: train
        path: medium_interaction/instruction.jsonl
  - config_name: motion_state_change
    data_files:
      - split: train
        path: motion_state_change/instruction.jsonl
  - config_name: pose_adjustment
    data_files:
      - split: train
        path: pose_adjustment/instruction.jsonl
  - config_name: spatial_arrangement
    data_files:
      - split: train
        path: spatial_arrangement/instruction.jsonl
  - config_name: temporal_evolution
    data_files:
      - split: train
        path: temporal_evolution/instruction.jsonl
  - config_name: maze
    data_files:
      - split: train
        path: maze/instruction.jsonl

VisTA-Train

This is the official training-data repository of Visual Abstention in Unified Multimodal Models. VisTA-Train holds the paired feasible and infeasible examples used to train VisTA-BAGEL. 🌐 Website · 💻 Code · 📃 Paper

1. Data Overview

Every example is a request (input image + instruction) with a target response. The data comes in feasible–infeasible pairs, so a model learns to judge feasibility before it decides whether to draw:

feasible: a reasoning block <think>...</think> that plans the edit, followed by the target image;
infeasible: a reasoning block that explains which requirement cannot be met and ends with the plain-text marker [ABSTAIN] (<think>... [ABSTAIN]</think>), with no target image.

Visual abstention in a maze task: draw a path when one exists, decline when none exists

2. Data Statistics

38,224 pairs, 76,448 examples, one split (train). Every pair that passed the checks is kept, so the categories are not balanced.

Category	Pairs	Examples	Pairing	Source
material modification	5,958	11,916	same image, different instruction	UniREdit-Data-100K
medium interaction	5,573	11,146	same image, different instruction	UniREdit-Data-100K
motion state change	5,512	11,024	same image, different instruction	UniREdit-Data-100K
pose adjustment	5,695	11,390	same image, different instruction	UniREdit-Data-100K
spatial arrangement	5,837	11,674	same image, different instruction	UniREdit-Data-100K
temporal evolution	4,449	8,898	same image, different instruction	UniREdit-Data-100K
maze	5,200	10,400	same instruction, different map	generated by the authors
Total	38,224	76,448

Maze grids are 7×7 (446 pairs), 9×9 (2,503) or 11×11 (2,251), counting the outer wall. There are 114,672 PNG images.

3. Construction

Real-world categories (33,024 pairs). Each feasible example keeps its UniREdit-Data-100K instruction, chain of thought, input image and target image unchanged. For each source example, Gemini3.8 Flash and Kimi-K3 each proposed one infeasible instruction on the same image; a candidate was retained only if both models confirmed infeasibility (a second round covered the 0.5% of sources without a retained candidate), and one was chosen at random. Kimi-K3 wrote the reasoning of the infeasible example, and both models reviewed it against the image, instruction and constraints, with feedback for revision.
Maze (5,200 pairs). New map pairs generated as for DoD: both maps share the instruction and endpoints and differ in one corridor cell; BFS verifies that the feasible map has a path and the infeasible one has none. Kimi-K3 wrote and reviewed the reasoning for both maps.
Quality and separation from DoD. The data was not verified in full by humans. A human audit of 300 random pairs found 2 unusable pairs (99.3% acceptance); they were kept unchanged, so the released data is what the paper's model was trained on. Every training input and target image was compared pixel-wise with all DoD images, and training mazes whose wall layout matches a DoD maze under rotation or reflection were excluded. These checks detect exact overlap, not semantically similar scenes.

See Sec. 5.2 and Appx. C of the paper for details.

4. Download Link

Download the whole dataset into the data/train folder of the code repository, which is where the code reads it:

cd visual-abstention   # the root of the code repository
python data/download.py train   # downloads and extracts the image shards into data/train/image/
# or: huggingface-cli download visual-abstention/VisTA-Train --repo-type dataset --local-dir data/train

Layout:

<category>/instruction.jsonl            requests, one folder per category (7 folders)
<category>/ground_truth_criteria.jsonl  labels and target responses
images/*.tar                            uncompressed tar shards with all images
images/manifest.json                    description of the shards

Extract all shards into one directory (the dataset root) to recreate image/...; the image paths in the JSONL files (image/<name>.png) are relative to that directory. Both examples of a real-world pair have their own input file (<category>-<id>-feasible.png, <category>-<id>-infeasible.png) holding the same image; the target is <category>-<id>-target.png. Maze pairs use matched-maze-<nnnnn>-A.png (feasible), -B.png (infeasible) and -target.png (solved feasible map).

import json, tarfile
from pathlib import Path
from huggingface_hub import snapshot_download
from PIL import Image

root = Path(snapshot_download("visual-abstention/VisTA-Train", repo_type="dataset"))
for shard in sorted((root / "images").glob("*.tar")):      # recreates root/image/...
    with tarfile.open(shard) as tar:
        tar.extractall(root, filter="data")

category = "maze"
requests = [json.loads(l) for l in open(root / category / "instruction.jsonl")]
targets = {r["case_id"]: r for r in map(json.loads, open(root / category / "ground_truth_criteria.jsonl"))}

req = requests[0]
tgt = targets[req["case_id"]]
image = Image.open(root / req["input_image"])
output = tgt["training_output_image"] and Image.open(root / tgt["training_output_image"])
print(req["prompt_en"], tgt["training_response"])

5. Data Fields

`instruction.jsonl`

Field	Description
`case_id`	`<pair_id>-feasible` or `<pair_id>-infeasible`
`task`	always `training_editing`
`input_mode`	always `image_editing`
`input_image`	path of the input image
`input_images`	maze only: list with the same single path
`prompt_en`	the instruction given to the model (without the reminder). For maze: `rules + "\n\n" + instruction_en`
`instruction_en`	the instruction alone; present for maze and for real-world infeasible examples (for real-world feasible examples, `prompt_en` is the official instruction)
`rules`	task rules; empty for real-world examples
`subset`	the category
`split`	always `train`

`ground_truth_criteria.jsonl`

Field	Description
`schema`	`training_pair_v1`
`case_id`, `pair_id`, `paired_case_id`	identifiers; the two examples of a pair point to each other
`split`	always `train`
`ground_truth.feasible`	the feasibility label
`ground_truth.reason`	short explanation of the label; present for real-world infeasible examples and for all maze examples
`expected_response`	`generate_image` (feasible) or `cot_abstain_then_eos` (infeasible)
`training_response`	the target text: `<think>...</think>`; infeasible responses end with `[ABSTAIN]</think>`
`training_output_image`	path of the target image (feasible), `null` (infeasible)
`reference_image`	same as `training_output_image`
`source`	provenance. Real-world: `dataset` (`maplebb/UniREdit-Data-100K`), `revision` (dataset commit), `category`, `id`, `original_image_path`, `edited_image_path` in that dataset, and `synthetic_input` (`false`) on infeasible examples. Maze: `dataset`, `category`, `category_en`, `id`, `origin`, `official_image` (`false`), `seed`, `instruction_origin`, `matched_pair`, `difference`
`program_verification`	maze only: BFS verification record (0-based `[row, column]` including the outer wall): start, end, the changed cell, the unique feasible path, the reachable sets of both endpoints on the infeasible map, distances of the cut from both endpoints, and pixel-difference checks

6. Training Recipe

VisTA-BAGEL starts from the official UniREdit-BAGEL weights and is trained on all 76,448 examples for 16,384 steps (learning rate 2e-6, 8 examples per step: 4 feasible and 4 infeasible, the two examples of a pair in the same step). The text loss covers the reasoning, including [ABSTAIN] and the end-of-sequence token for infeasible examples; the image loss covers the target images of feasible examples only. In every step, half of the instructions get the reminder "If no solution exists under these constraints, state that no solution exists and briefly explain why." appended at training time; the reminder is not stored in prompt_en. The full recipe and the training code are in the paper (Appx. C) and the code repository. Model weights are not part of this release.

7. Evaluation

This dataset is for training only. Evaluate on Draw-or-Decline, whose images and mazes do not overlap exactly with this data (see above).

Note on translated fields. ground_truth.reason for maze examples (and a few real-world ones), and 4 reasoning passages of feasible examples, were written partly in Chinese and machine-translated to English by Kimi-K3 for this release. All other text, including almost all training_response fields, is unchanged. The paper's model was trained on the original training_response texts; ground_truth.reason is not part of the training target.

8. Citation

@article{shi2026visual,
  title   = {Visual Abstention in Unified Multimodal Models},
  author  = {Shi, Chufan and Yang, Cheng and Yang, Tiannuo and White, Isadora and Chen, Yiwei and Berg-Kirkpatrick, Taylor and Ma, Xuezhe},
  journal = {arXiv preprint arXiv:<ARXIV_ID>},
  year    = {2026}
}

@inproceedings{han2026unireditbench,
  title     = {UniREditBench: A Unified Reasoning-based Image Editing Benchmark},
  author    = {Han, Feng and Wang, Yibin and Li, Chenglin and Liang, Zheming and Wang, Dianyi and Jiao, Yang and Wei, Zhipeng and Gong, Chao and Jin, Cheng and Wang, Jiaqi},
  booktitle = {European Conference on Computer Vision},
  pages     = {287--304},
  year      = {2026}
}

License

The new annotations (infeasible instructions, infeasible reasoning, maze maps, maze reasoning, explanations and verification records) are released under the Apache License 2.0.

The real-world input images, target images, feasible instructions and feasible chains of thought come from UniREdit-Data-100K (maplebb/UniREdit-Data-100K, Apache-2.0) and are unchanged, except that Chinese passages in 4 feasible chains of thought were translated to English; source.revision records the dataset commit. Please cite it as well. The maze images are generated by the authors.

Limitations

Infeasible instructions and their reasoning were written by models and checked by models; only a 300-pair sample was audited by humans, and the 2 pairs it flagged remain in the data.
Feasible real-world examples inherit the instructions, reasoning and target images of UniREdit-Data-100K as they are.
The categories are unbalanced, and the data covers single-step image editing in 7 categories only.
The separation from DoD rules out exact image and maze overlap, not semantically similar scenes.
Some explanation fields are machine translations (see above).