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, 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
├── utils.py                 # parses raw model text into a structured answer
└── eval.py                  # scores parsed answers against the ground truth

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 — pairs are first{N}.png / second{N}.png, and id is second{N}.png.
• colours_present — pairs are first{N}.png / {N}.png, and id is {N}.png.

In both cases the partner image is recovered from the id by swapping the prefix.

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	2	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))
        elif os.path.exists(p2 := os.path.join(root, task, "data", "first" + r["id"])):
            paths.insert(0, p2)                               # colours_present
        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 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.

Licence

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