---
license: mit
task_categories:
- feature-extraction
viewer: false
tags:
- weight-space-learning
- nerf
- graph-metanetwork
---

# Weight Space Representation Learning on Diverse NeRF Architectures (ICLR 2026)

[![paper](https://img.shields.io/badge/arxiv-paper-darkred?logo=arxiv)](https://arxiv.org/abs/2502.09623)
[![code](https://img.shields.io/badge/github-code-blue?logo=github)](https://github.com/CVLAB-Unibo/gmnerf)
[![project](https://img.shields.io/badge/project-page-green)](https://cvlab-unibo.github.io/gmnerf)
[![models](https://img.shields.io/badge/huggingface-models-plum?logo=huggingface)](https://huggingface.co/frallebini/gmnerf)

![teaser](https://cvlab-unibo.github.io/gmnerf/static/images/teaser.svg)

This repository contains the dataset for the paper [Weight Space Representation Learning on Diverse NeRF Architectures](https://huggingface.co/papers/2502.09623). The framework is capable of processing NeRFs with diverse architectures (MLPs, tri-planes, and hash tables) by training a Graph Meta-Network to obtain architecture-agnostic latent spaces.

## Usage

You can use the official scripts provided in the [GitHub repository](https://github.com/CVLAB-Unibo/gmnerf) to interact with the data.

### Graph computation
To compute the graphs of NeRFs (e.g., test set of the MLP architecture):
```bash
python export_graphs.py --data-root ./data --dataset shapenet --arch mlp --split test
```

### Embedding computation
To compute embeddings produced by the trained $\mathcal{L}_{\text{R+C}}$ encoder:
```bash
python export_embs.py --ckpt_name l_rec_con --data.root ./data --dataset shapenet --arch mlp --split test
```

## NeRF weights

Main dataset structure:
```
.
└── nerf
    └── shapenet
        ├── hash
        │   └── class_id
        │       └── nerf_id
        │           ├── train
        │           │   └── *.png              # object views used to train the NeRF
        │           ├── grid.pth               # nerfacc-like occupancy grid parameters
        │           ├── nerf_weights.pth       # nerfacc-like NeRF parameters
        │           └── transforms_train.json  # camera poses
        ├── mlp
        │   └── class_id
        │       └── nerf_id
        │           ├── train
        │           │   └── *.png                 
        │           ├── grid.pth                
        │           ├── nerf_weights.pth        
        │           └── transforms_train.json
        ├── triplane
        │   └── class_id
        │       └── nerf_id
        │           ├── train
        │           │   └── *.png                 
        │           ├── grid.pth                
        │           ├── nerf_weights.pth        
        │           └── transforms_train.json
        ├── test.txt                           # test split
        ├── train.txt                          # training split
        └── val.txt                            # validation split
```
Unseen architectures (`nerf/shapenet/hash_unseen`, `nerf/shapenet/mlp_unseen`, and `nerf/shapenet/triplane_unseen`) and Objaverse NeRFs (`nerf/objaverse`) have analogous directory structures.

# NeRF graphs

Main dataset structure:
```
.
└── graph
    └── shapenet
        ├── hash
        │   ├── test
        │   │   └── *.pt  # torch_geometric-like graph data
        │   ├── train
        │   │   └── *.pt
        │   └── val
        │       └── *.pt
        ├── mlp
        │   ├── test
        │   │   └── *.pt
        │   ├── train
        │   │   └── *.pt
        │   └── val
        │       └── *.pt
        └── triplane
            ├── test
            │   └── *.pt
            ├── train
            │   └── *.pt
            └── val
                └── *.pt
```
Unseen architectures (`graph/shapenet/hash_unseen`, `graph/shapenet/mlp_unseen`, and `graph/shapenet/triplane_unseen`) and Objaverse NeRFs (`graph/objaverse`) have analogous directory structures.

## NeRF embeddings

Main dataset structure:
```
.
└── emb
    └── model
        └── shapenet
            ├── hash
            │   ├── test
            │   │   └── *.h5
            │   ├── train
            │   │   └── *.h5
            │   └── val
            │       └── *.h5
            ├── mlp
            │   ├── test
            │   │   └── *.h5
            │   ├── train
            │   │   └── *.h5
            │   └── val
            │       └── *.h5
            └── triplane
                ├── test/
                │   └── *.h5
                ├── train
                │   └── *.h5
                └── val
                    └── *.h5
```
where `model`s are:
- `l_con`, aka $\mathcal{L}_\text{C}$
- `l_rec`, aka $\mathcal{L}_\text{R}$
- `l_rec_con`, aka $\mathcal{L}_\text{R+C}$

Unseen architectures (`emb/model/shapenet/hash_unseen`, `emb/model/shapenet/mlp_unseen`, and `emb/model/shapenet/triplane_unseen`) and Objaverse NeRFs (`emb/model/objaverse`) have analogous directory structures.

## Language data

The `language` directory contains $\mathcal{L}_\text{R+C}$ embeddings (i.e. those found in `emb/l_rec_con/shapenet`) paired with textual annotations from the [ShapeNeRF-Text dataset](https://huggingface.co/datasets/andreamaduzzi/ShapeNeRF-Text/tree/main). This directory structure allows running the [official LLaNA code](https://github.com/CVLAB-Unibo/LLaNA) without any additional preprocessing.

## Cite us

If you find our work useful, please cite us:

```bibtex
@inproceedings{ballerini2026weight,
  title = {Weight Space Representation Learning on Diverse {NeRF} Architectures},
  author = {Ballerini, Francesco and Zama Ramirez, Pierluigi and Di Stefano, Luigi and Salti, Samuele},
  booktitle = {The Fourteenth International Conference on Learning Representations},
  year = {2026}
}
```