README.md

metadata

pretty_name: CloudAVR Point-Cloud Matrix Reasoning
size_categories:
  - 100K<n<1M
tags:
  - point-cloud
  - 3d
  - visual-reasoning
  - synthetic
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*.parquet
      - split: validation
        path: data/validation-*.parquet
      - split: test
        path: data/test-*.parquet
  - config_name: meshes
    data_files:
      - split: train
        path: data/meshes-*.parquet
  - config_name: archives
    data_files:
      - split: train
        path: data/archives-*.parquet

CloudAVR Point-Cloud Matrix Reasoning

CloudAVR is a procedurally generated benchmark for 3×3 matrix completion with native colored 3D point clouds. Each puzzle hides the bottom-right cell and asks the model to select the correct completion from four candidates.

CloudAVR comprises 108,000 puzzles in the full benchmark, evenly split across six rule families, with a 104,400/1,800/1,800 train/validation/test split. The Hub upload is still in progress; while files are being transferred, the repository file list and Dataset Viewer may temporarily show fewer examples than the final release described here.

The complete CloudAVR dataset and source code will be fully open-sourced upon acceptance of the paper. Until then, this Hub repository should be treated as a pre-release distribution while the full asset upload is being completed.

Dataset contents

• 108,000 puzzles in the full release.
• Six rule templates: Conservation, Count, Distribute-three, Permutation, Progression, and Symmetry. Count is the directory name used here for the paper's Arithmetic rule, whose governed attribute is object count.
• 18,000 puzzles per rule (uniformly distributed across six rules).
• Stratified deterministic splits with seed 42: 104,400 train, 1,800 validation, and 1,800 test examples (17,400/300/300 per rule).
• Each puzzle contains eight observed grid point clouds and four candidate point clouds, for 12 ASCII PLY files per puzzle.
• PLY vertices contain x y z red green blue fields. The generated point count can vary by density setting; consumers should read the PLY header.

Layout

data/train-00000-of-00001.parquet
data/validation-00000-of-00001.parquet
data/test-00000-of-00001.parquet
archives/<RuleName>.tar.zst
<RuleName>/meta.json
<RuleName>/sample_XXXXXX/meta.json
<RuleName>/sample_XXXXXX/grid_<row>_<col>.ply
<RuleName>/sample_XXXXXX/cand_<index>.ply

The Parquet files are the compact, viewer-friendly annotation index. All paths in them are relative to the repository root. The per-sample JSON files retain the full generated rule, entity, matrix-relation, and perturbation metadata.

mesh_path is included as a compatibility alias for the puzzle directory. CloudAVR does not contain one single mesh per puzzle: the actual assets are the 12 PLY point clouds listed in mesh_paths, grid_paths, and candidate_paths. All six rule names are encoded in id, sample_path, and the asset paths.

The optional meshes configuration is a conventional one-row-per-PLY view. After the full upload, its mesh_path column contains 1,296,000 concrete PLY paths across all six rules; use it with load_dataset("ShowRison/CloudAVR", "meshes").

For bulk distribution, the archives configuration lists one compressed TAR shard per rule. Each shard contains the complete <RuleName>/... tree, so its member names match the root-relative mesh_path values in the meshes view. Download an archive with hf_hub_download, then extract it with a TAR/Zstandard tool when a full rule is needed. This avoids requiring a repository checkout of hundreds of thousands of small files.

Implementation details

The following summarizes the construction and reference implementation in Sections 3–5.1.2 of the CloudAVR paper.

Puzzle construction

Each sample is a 3×3 matrix of native point-cloud panels: eight observed context panels and one withheld bottom-right target. The four options contain one correct completion and three controlled distractors:

• Rule-analogous: follows the same high-level rule but uses an incorrect attribute instantiation.
• Perceptually plausible: resembles the target locally but violates the relational rule.
• Random valid: a valid scene sampled to increase answer-set diversity.

The generator uses predefined 3D primitives and controls the volumetric intersection ratio between adjacent primitives, ranging from separated scenes to partially or moderately intersecting scenes. This gives a difficulty axis for geometric disentanglement before rule reasoning.

The native attribute space has seven dimensions: Count, Position, Size, Shape, Color, Pose, and Perturbation. Pose represents continuous 6-DoF orientation. Perturbation models sensor degradation using density downsampling, jitter, quantization, and outlier replacement. The governed attribute is sampled under consistency constraints; the model is not told which attribute controls a particular puzzle.

The paper's rule-to-attribute mapping is:

Paper rule	Governed attribute(s)	Snapshot directory
Arithmetic	Count	Count
Distribute-3	Color, Size, Shape	Distribute-three
Progression	Pose, Position, Size	Progression
Symmetry	Pose, Size	Symmetry
Conservation	Size	Conservation
Permutation	Position	Permutation

Automatic checks validate primitive geometry, perturbation correctness, rule uniqueness, question/option alignment, duplicate candidates, and accidentally valid distractors. The paper also reports a manual audit of 5,400 puzzles by 10 3D-vision experts; flagged samples were corrected or regenerated.

PCRFormer reference model

The paper's learnability baseline is PCRFormer, an induce-and-verify model:

1. Each of the eight context panels and four candidates is independently encoded into a shared 384-dimensional embedding. Every point cloud is uniformly sampled to 2,048 points, retaining six per-point channels and 14 global features.

2. The encoder fuses a frozen pretrained Point-MAE geometric branch, a shared-MLP/max-pooling point-attribute branch, and an MLP global-statistics branch:

   z = LayerNorm(z_geo + W1 z_point + W2 z_global)
   

3. RuleFormer inserts a [RULE] token into the structured 3×3 context sequence (with [MASK] at the missing position) and induces an explicit, input-conditioned rule representation.

4. VerifyFormer inserts each candidate into the complete 3×3 sequence and re-induces the rule. Candidate costs combine target-embedding distance, observed-context reconstruction, and rule-representation consistency; the lowest-cost candidate is selected.

Architecture and optimization settings reported in the paper:

Setting	Value
RuleFormer	6 Transformer layers, 6 attention heads
VerifyFormer	3 Transformer layers, 6 attention heads
FFN expansion / dropout	4× / 0.1
Parameters	40.4M total; 18.6M trainable
Frozen weights	Point-MAE encoder
Optimizer	AdamW; learning rate 3e-4; weight decay 0.1
Schedule	5-epoch linear warmup; cosine annealing to 1e-6
Verification weights	α=1, β=0.5, γ=0.2
Loss weights / margin	λ=0.02, μ=0.05, τ=0.7
Batch	2 per GPU × 8 accumulation steps = effective 16
Precision / duration	Automatic mixed precision; 30 epochs; about 12.4 h on one RTX 4090

The training objective is

L = L_ce + λ L_margin + μ L_aux

where L_ce ranks the four candidates, L_margin separates the correct and incorrect verification costs, and L_aux supervises the six-way rule prediction from the induced rule representation. The coefficients above were tuned on the validation set.

For the paper's Qwen3-VL-8B fine-tuned comparison, LoRA is applied to the language-model attention projections with r=8, α=16, and dropout=0.05; all other parameters are frozen. The AVR baselines also sample each point cloud to 2,048 points and use the same Point-MAE encoder.

Evaluation protocol

The paper reports accuracy on a fixed test set. Native point clouds are used for 3D models. For 2D VLM comparisons, each puzzle is rendered from one of three shared single-view yaw angles (0°, +45°, or −45°) across all context and candidate panels. The full release contains the native PLY assets; rendered images are an evaluation modality described in the paper, not an additional file type in this release.

Loading the annotation index

from datasets import load_dataset

dataset = load_dataset("ShowRison/CloudAVR")
row = dataset["train"][0]
print(row["id"], row["rule_template"], row["gt_label"])

The index contains paths, labels, and compact rule parameters. Individual PLY paths refer to members of the rule archive listed by the archives configuration. For workflows that require direct per-file Hub URLs, the raw directory tree is retained for compatibility; the archives are the recommended bulk-download form.

To inspect all rule directories through the flat PLY view:

from collections import Counter
from pathlib import PurePosixPath
from datasets import load_dataset

meshes = load_dataset("ShowRison/CloudAVR", "meshes", split="train")
rules = Counter(PurePosixPath(p).parts[0] for p in meshes["mesh_path"])
print(meshes.num_rows)  # 1,296,000 after the full upload
print(rules)             # six rule directories

mesh_path in the meshes view is one concrete PLY path per row. In the annotation index it is retained as a compatibility alias for the puzzle directory; use mesh_paths, grid_paths, and candidate_paths when you need the individual assets. A viewer showing only Conservation is therefore reading a filtered directory/shard rather than the complete flat view.

Intended use and license

The dataset is intended for research on 3D/point-cloud matrix reasoning, candidate discrimination, controlled rule generalization, and robustness to geometric perturbations. No explicit open-source license has been assigned in this repository; please obtain permission from the authors before redistribution or commercial use.