Percept-V

Percept-V is a benchmark of 30 synthetic visual perception tasks, 200 samples each (6,000 samples total), designed to isolate perception from reasoning in vision-language models. Every task is procedurally generated from simple primitives — circles, lines, grids, shapes, colours — so a model that genuinely sees the image should solve it near-perfectly, and failures point at perceptual rather than reasoning limits.

Tasks span counting, colour identification, shape identification, spatial localisation, layering/occlusion, grid navigation, and two-image comparison. Each task ships with its images, ground truth, prompts, the script that generated them, and the exact parsing and scoring scripts used to evaluate it.

Repository layout

Each task is a self-contained directory:

<task_name>/
├── data/                    # 200 images (or 400 for two-image tasks)
│   ├── 1.png ... 200.png
├── data.json                # 200 ground-truth records, one per sample
├── prompts/
│   ├── input_prompt.txt     # describes what the image contains
│   ├── rules.txt            # the task the model must perform
│   └── output_prompt.txt    # required output format
├── script.py                # generator that produced data/ and data.json
├── utils.py                 # parses raw model text into a structured answer
└── eval.py                  # scores parsed answers against the ground truth

colours_present, layered_colours and list_colours also contain swatches.png, the colour reference strip their generator appends below each image.

Prompt construction

The three prompt files are fragments meant to be concatenated into a single instruction, e.g. for sort_lines:

• input_prompt.txt — "The image has several parallel lines of varying lengths. The image may also contain only a single line."
• rules.txt — "Sort these lines by length, from shortest to longest. If there is only a single line, give the number of that line."
• output_prompt.txt — "Last line of the output must only contain the space separated labels of the lines in their sorted order by length and nothing else."

output_prompt.txt constrains the last line of the response, which is what evaluation parses. This keeps free-form chain-of-thought compatible with exact-match scoring.

Ground truth

data.json is a list of 200 objects. The id field names the image file; the remaining fields hold the answer plus the generation parameters used to control difficulty.

Answer-field naming is not uniform across tasks (Gold_output, gold_output, answer, or a task-specific field such as num_objects). Fields like Rows, num_objects, or n are generation metadata — useful for slicing results by difficulty, not part of the expected answer.

Two-image tasks

Six tasks present a pair of images and ask about the difference between them. There, data/ holds 400 files and data.json has one record per pair, keyed by the second image:

• change_colour, match_outline, match_shadow, mirror_image, vanishing_objects, water_image — pairs are first{N}.png / second{N}.png, and id is second{N}.png.

The partner image is recovered from the id by replacing the second prefix with first.

Tasks

The last column is the field eval.py buckets by when reporting category-wise accuracy — in practice a difficulty axis for that task.

Task	Images/sample	id format	data.json fields	Difficulty axis
change_colour	2	second1.png	num_differences	num_differences
circle_boxes	1	1.png	answer, num_objects	num_objects
circle_location	1	1.png	count, num_objects, quadrant	num_objects
circle_right_triangle	1	1.png	circles, cols, right, rows, triangles	rows
colours_present	1	1.png	colours_present, num_objects	num_objects
comparing_size	1	1.png	Gold_output, Rows	Rows
count_coloured_circles	1	1.png	num_objects, red_circle	num_objects
counting_circles	1	1.png	num_objects	num_objects
counting_locations	1	1.png	num_objects_over_table, num_objects_under_table	num_objects_over_table
counting_shapes	1	1.png	circles, squares, triangles	circles
cross_and_knots	1	1.png	cross_positions, crosses, gold_output, n	n
graph_counting	1	1.png	num_edges, num_nodes	num_nodes
grid_path	1	1.png	gold_output, path_size, rows	rows
identifying_shapes	1	1.png	Gold_output, Gold_side, Rows	Rows
inside_circles	1	1.png	inside_circles, num_circles	num_circles
layered_colours	1	1.png	colors, num_layers	num_layers
layered_shapes	1	1.png	num_layers, order	num_layers
list_colours	1	1.png	list_colours, num_objects	num_objects
list_shapes	1	1.png	list_shapes, num_objects	num_objects
locate_circles_colour	1	1.png	gold_output, n_circles, rows	n_circles
locate_circles_shape	1	1.png	gold_output, n_circles, rows	n_circles
match_outline	2	second1.png	Gold_output, Rows	Rows
match_shadow	2	second1.png	Gold_output, Rows	Rows
maze_solving	1	1.png	Columns, Rows, path	len(path) - 2
mirror_image	2	second1.png	mirror_image, num_objects	num_objects
numbered_shapes	1	1.png	circles, num_objects, pentagons, rectangles, triangles	num_objects
sort_circles	1	1.png	Gold_output, Rows	Rows
sort_lines	1	1.png	Gold_output, Lines	Lines
vanishing_objects	2	second1.png	circles, squares, triangles, vanished	circles
water_image	2	second1.png	num_objects, water_image	num_objects

Usage

The repository is a plain file tree, so the simplest route is a snapshot download:

import json, os
from huggingface_hub import snapshot_download
from PIL import Image

root = snapshot_download("aggr8/Percept-V", repo_type="dataset")

def load_task(task):
    p = os.path.join(root, task, "prompts")
    prompt = "\n".join(
        open(os.path.join(p, f)).read().strip()
        for f in ("input_prompt.txt", "rules.txt", "output_prompt.txt")
    )
    records = json.load(open(os.path.join(root, task, "data.json")))
    for r in records:
        paths = [os.path.join(root, task, "data", r["id"])]
        if r["id"].startswith("second"):                      # paired task
            paths.insert(0, paths[0].replace("second", "first", 1))
        yield {
            "prompt": prompt,
            "images": [Image.open(x) for x in paths],
            "label": {k: v for k, v in r.items() if k != "id"},
        }

for sample in load_task("counting_circles"):
    ...

To fetch a single task instead of all 226 MB, pass allow_patterns="counting_circles/*".

Evaluation

Each task ships the two scripts used to produce the numbers in the paper: utils.py (answer parsing) and eval.py (scoring). They are per-task — parsing and correctness rules differ across tasks — so always use the pair from the task directory you are scoring. Both are plain Python with no dependencies beyond the standard library.

Evaluation runs in three steps.

1. Inference. For each sample, build the prompt and record the model's raw text in a field named gpt_response, alongside all the original data.json fields. Write the list to answer_<model>.json:

[
  {"id": "1.png", "num_objects": 1, "gpt_response": "COUNT:1"},
  ...
]

2. Parse. utils.output_from_text(text) extracts the structured answer from the raw response, returning {"OUTPUT": ..., "ERROR": ...}. OUTPUT is None and ERROR is set when the response does not follow the format required by output_prompt.txt. Copy these into Output and ERROR on each record:

import json, importlib.util

task = "counting_circles"
spec = importlib.util.spec_from_file_location("u", f"{task}/utils.py")
utils = importlib.util.module_from_spec(spec); spec.loader.exec_module(utils)

records = json.load(open(f"{task}/answer_mymodel.json"))
for r in records:
    parsed = utils.output_from_text(r["gpt_response"])
    r["Output"], r["ERROR"] = parsed["OUTPUT"], parsed["ERROR"]
json.dump(records, open(f"{task}/answer_mymodel.json", "w"), indent=4)

3. Score.

python counting_circles/eval.py \
    -a counting_circles/answer_mymodel.json \
    -o counting_circles/eval_mymodel.json

eval.py compares Output against the ground-truth fields already present in each record (except colours_present, whose eval.py reads the gold labels from the task's data.json by id; see the changelog) and writes:

{
  "Overall Accuracy": 42.5,
  "Category-wise Accuracy": {
    "1": 100.0, "2": 100.0, "3": 90.0, "4": 100.0, "5": 70.0,
    "...": "...",
    "16": 10.0, "17": 10.0, "18": 0.0, "19": 0.0, "20": 20.0
  }
}

The shape of that result is typical: near-ceiling on the smallest instances, collapsing as the count grows — which is the separation between perception and reasoning the benchmark is built to expose.

Unparseable responses (Output absent or None) count as incorrect rather than being dropped, so Overall Accuracy is over all 200 samples and format failures are penalised. The category keys are the difficulty axis listed in the table above.

Eight tasks — circle_right_triangle, cross_and_knots, graph_counting, grid_path, identifying_shapes, inside_circles, maze_solving, sort_circles — additionally expose gold_to_output(i) in utils.py, which renders the gold answer for sample i in the exact format output_prompt.txt asks for. This is useful for building few-shot exemplars.

Notes

• eval.py takes --answer/-a and --output/-o; the defaults refer to files that are not shipped here, so pass both explicitly.
• Several utils.py files contain a second, commented-out output_from_text inside a triple-quoted string, left over from earlier prompt formats. Only the live top-level definition is used.

Regenerating the data

<task>/script.py is the generator used for the released data. The one exception is colours_present/script.py, which includes the 2026-09-11 fix, so its output now matches the corrected labels. Each task was produced by a single call with 10 images per difficulty level:

mkdir -p gen/counting_circles && cd gen/counting_circles      # use an empty directory
cp <path-to-Percept-V>/counting_circles/script.py .
python script.py --num_images 10 --num_sizes 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

• Difficulty levels: --num_sizes is 1–20 for every task except grid_path and maze_solving, which use 3–22. circle_right_triangle, cross_and_knots, grid_path, locate_circles_colour and locate_circles_shape use their default --grid_size 6.
• Output location: the script writes data/ and data.json into the current directory, overwriting existing ones, so do not run it inside a downloaded copy of this dataset. File numbering starts at --file (default 1).
• No fixed random seeds: a run produces a new sample from the same distribution, not the released images.
• Requirements: Python 3 with numpy, matplotlib and Pillow, plus opencv-python (imported by colours_present, layered_colours, list_colours, mirror_image, water_image) and networkx (graph_counting).
• Files the scripts read from the working directory:
  • swatches.png, for colours_present, layered_colours and list_colours: copy it from the task directory.
  • An Arial font file, named arial.ttf (grid_path, locate_circles_colour, locate_circles_shape) or ARIAL.ttf (sort_lines). It is not included in this repository. If Pillow finds it neither in the working directory nor in the system font folders, grid_path and sort_lines stop with an error, and the two locate_circles tasks fall back to Pillow's much smaller default font.
  • Background images background_image/bg_1.png … bg_10.png, for list_colours and list_shapes. These are not included in this repository.

Changelog

• 2026-09-11 — Generation scripts added. Every task directory now includes its script.py, plus swatches.png where the generator needs it. See "Regenerating the data".

• 2026-09-11 — colours_present ground truth corrected. In earlier versions of colours_present/data.json, the 20 yes/no answers were listed in a different colour order from the one given in rules.txt, so 183 of the 200 records had wrong labels. Scores on this task computed before this date are not valid. colours_present/eval.py now takes the gold labels from data.json (matched on id) instead of from the answer file, so re-running it on existing answer files gives corrected scores without repeating inference. It prints a note when an answer file still carries the old labels, and accepts --gold to point at a different data.json. The task is single-image; the table and loader above are updated accordingly.

Licence

Released under CC BY 4.0. All images are procedurally generated; the benchmark contains no personal data and no third-party image content.