RAVEN3D

RAVEN3D is a benchmark for abstract visual reasoning in 3D scenes. It extends Raven's Progressive Matrices from flat 2D patterns to rendered 3D scenes with hierarchical composition, controlled viewpoint variation, and relational rule induction. This repository provides NPZ samples packaged in six ZIP archives, with separate Parquet metadata indexes.

The benchmark is designed as a diagnostic instrument. It separates perceptual variation from invariant relational rules and measures how reasoning degrades as the structural complexity of a scene increases.

Each sample is stored as one NPZ file with two arrays:

• image: 16 RGB panels with shape (16, 320, 320, 3) and dtype uint8.
• target: the correct candidate index in the range 1–8.

The first eight panels are the observed context panels: the first eight cells of a 3×3 matrix, with the ninth cell hidden. The last eight panels are candidate completions. Exactly one candidate is correct.

This release contains 105,000 training samples and 3,000 test samples. No separate validation split is provided. The paper describes a 102,000/3,000/3,000 train/validation/test protocol; the released training directory has not been verified against those original split assignments.

The three task families are:

• Single: reasoning over one hierarchical entity stacked across one to three tiers.
• Double: reasoning over two entities arranged in left–right or up–down layouts.
• Triple: reasoning over three-entity layouts, including 1-2-3 and 3-Shuffle.

Scenes are generated from seven attribute dimensions: Number, Color, Type, Size, Position, Viewpoint, and Tier. The five relation types are Constant, Progression, Arithmetic, Distribute_Three, and Shuffle. Rendered viewpoints are sampled from FrontView, LeftView, and RightView.

Dataset statistics

Split	Samples	Families
train	105,000	Double, Single, Triple
test	3,000	Double, Single, Triple
total	108,000

Each family contributes 36,000 samples in total. In this package, each family contributes 35,000 training samples and 1,000 test samples.

The test split contains 12 configurations:

Double-Left-Right-1-layer
Double-Left-Right-2-layer
Double-Up-down-1-layer
Double-Up-down-2-layer
Single-1-layer
Single-2-layer
Single-3-layer-ind
Single-3-layer-uni
Triple-Fixed-1-layer
Triple-Fixed-2-layer
Triple-Shuffle-1-layer
Triple-Shuffle-2-layer

The paper uses a controlled distribution shift for testing. Half of the rule configurations are held out from training, and selected visual attributes are changed between splits so that models cannot solve the benchmark by memorizing a fixed appearance.

Repository layout

README.md
train.parquet
test.parquet
RAVEN3D_train_Double.zip
RAVEN3D_train_Single.zip
RAVEN3D_train_Triple.zip
RAVEN3D_test_Double.zip
RAVEN3D_test_Single.zip
RAVEN3D_test_Triple.zip

Each ZIP is a standalone archive for one split and task family. Extract the archives into the same local directory to obtain:

data/
  train/
    Double/*.npz
    Single/*.npz
    Triple/*.npz
  test/
    Double/<configuration>/*.npz
    Single/<configuration>/*.npz
    Triple/<configuration>/*.npz

The Parquet files are metadata indexes and contain no image arrays. Their npz_path values refer to paths inside the archives, relative to the extraction directory. Individual NPZ files are not available as standalone Hub downloads in this repository. Download and extract the corresponding ZIP first.

Metadata fields

Field	Description
id	Sample identifier relative to the extraction directory without the .npz suffix
split	train or test
family	Double, Single, or Triple
configuration	Detailed test configuration; equal to family for training samples
npz_path	NPZ path relative to the extraction directory
target	Original 1–8 candidate index
label_idx	Zero-based label, target - 1
num_panels	Always 16
image_shape	Always [16, 320, 320, 3]
image_dtype	Always uint8

Install dependencies

pip install -U huggingface_hub datasets numpy pillow openai

Load the metadata from the Hub

from datasets import load_dataset

repo_id = "hznuer/Raven3D-shards"
dataset = load_dataset(repo_id)
print(dataset)
print(dataset["test"][0])

This loads the metadata only. Download the ZIP archives separately to access the panels.

Download and extract samples

The following example downloads all three test archives and extracts them into RAVEN3D_local. Keep sufficient free space for both the downloaded archives and the extracted NPZ files. The six archives together contain about 43.3 GB of data.

from pathlib import Path
from zipfile import ZipFile
from huggingface_hub import hf_hub_download

repo_id = "hznuer/Raven3D-shards"
data_root = Path("RAVEN3D_local")
data_root.mkdir(parents=True, exist_ok=True)

def download_split(split):
    for family in ("Double", "Single", "Triple"):
        archive_path = hf_hub_download(
            repo_id=repo_id,
            filename=f"RAVEN3D_{split}_{family}.zip",
            repo_type="dataset",
        )
        with ZipFile(archive_path) as archive:
            archive.extractall(data_root)

download_split("test")
# To obtain training samples as well:
# download_split("train")

To download only one family, use its archive name, such as RAVEN3D_test_Double.zip. Each archive preserves the data/<split>/<family>/... directory structure. Extracting all archives into the same data_root makes the metadata paths resolve correctly.

Load one local sample

After loading the metadata and extracting the matching archive:

import numpy as np

row = dataset["test"][0]
with np.load(data_root / row["npz_path"], allow_pickle=False) as sample:
    images = sample["image"]
    target = int(sample["target"].item())

context = images[:8]
candidates = images[8:]
label_idx = target - 1

print(images.shape)  # (16, 320, 320, 3)
print(target)        # 1..8

Evaluate a model

Download and extract the test archives before evaluation. The prediction function receives all 16 panels and should return a zero-based candidate index from 0 to 7. Accuracy is the fraction of correct predictions.

from pathlib import Path
import numpy as np

def evaluate(model_predict, rows, data_root, max_samples=None):
    data_root = Path(data_root)
    correct = 0
    total = 0

    for row in rows:
        if max_samples is not None and total >= max_samples:
            break

        with np.load(data_root / row["npz_path"], allow_pickle=False) as sample:
            images = sample["image"]
        prediction = int(model_predict(images))

        if not 0 <= prediction <= 7:
            raise ValueError(f"Prediction must be in 0..7, got {prediction}")

        correct += int(prediction == int(row["label_idx"]))
        total += 1

    return correct / total if total else 0.0


def model_predict(images):
    # Replace this with your local model or remote model API call.
    raise NotImplementedError


# After implementing model_predict:
# accuracy = evaluate(model_predict, dataset["test"], data_root, max_samples=100)
# print(f"accuracy={accuracy:.4f}")

Test with an OpenAI-compatible vision API

The following example sends all 16 panels to a vision model. Set OPENAI_API_KEY, and optionally set OPENAI_BASE_URL for an OpenAI-compatible provider.

import base64
import io
import os
import re

from openai import OpenAI
from PIL import Image


client_kwargs = {"api_key": os.environ["OPENAI_API_KEY"]}
if os.getenv("OPENAI_BASE_URL"):
    client_kwargs["base_url"] = os.environ["OPENAI_BASE_URL"]
client = OpenAI(**client_kwargs)


def image_data_url(array):
    buffer = io.BytesIO()
    Image.fromarray(array).save(buffer, format="PNG")
    encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
    return f"data:image/png;base64,{encoded}"


def model_predict(images, model="gpt-4o-mini"):
    content = [{
        "type": "text",
        "text": (
            "This is a visual matrix reasoning problem. "
            "Panels 1-8 are the context panels and panels 9-16 are candidates A-H. "
            "Return only the correct candidate number from 1 to 8."
        ),
    }]

    for index, image in enumerate(images, start=1):
        content.append({"type": "text", "text": f"Panel {index}"})
        content.append({
            "type": "image_url",
            "image_url": {"url": image_data_url(image), "detail": "low"},
        })

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": content}],
        temperature=0,
    )

    text = response.choices[0].message.content or ""
    match = re.search(r"[1-8]", text)
    if not match:
        raise ValueError(f"Could not parse a candidate index from: {text!r}")
    return int(match.group()) - 1

For a quick API smoke test, evaluate a small number of samples first:

accuracy = evaluate(
    lambda images: model_predict(images, model="gpt-4o-mini"),
    dataset["test"],
    data_root,
    max_samples=20,
)
print(f"API smoke-test accuracy={accuracy:.4f}")