---
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

```text
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:

   ```text
   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

```text
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

```python
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:

```python
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.