Weight Space Representation Learning on Diverse NeRF Architectures
Authors: Francesco Ballerini
Pierluigi Zama Ramirez
Luigi Di Stefano
Samuele Salti
Venue: ICLR 2026 Poster (2026)
Keywords: weight space learning
representation learning
metanetworks
graph metanetworks
neural fields
neural radiance fields
NeRF
implicit neural representations
INR
Primary area: unsupervised, self-supervised, semi-supervised, and supervised representation learning
TL;DR: We present the first framework that performs tasks on NeRFs by processing their weights and is able to work on diverse architectures

Abstract: Neural Radiance Fields (NeRFs) have emerged as a groundbreaking paradigm for representing 3D objects and scenes by encoding shape and appearance information into the weights of a neural network. Recent studies have demonstrated that these weights can be used as input for frameworks designed to address deep learning tasks; however, such frameworks require NeRFs to adhere to a specific, predefined architecture. In this paper, we introduce the first framework capable of processing NeRFs with diverse architectures and performing inference on architectures unseen at training time. We achieve this by training a Graph Meta-Network within an unsupervised representation learning framework, and show that a contrastive objective is conducive to obtaining an architecture-agnostic latent space. In experiments conducted across 13 NeRF architectures belonging to three families (MLPs, tri-planes, and, for the first time, hash tables), our approach demonstrates robust performance in classification, retrieval, and language tasks involving multiple architectures, even unseen at training time, while also matching or exceeding the results of existing frameworks limited to single architectures. Our code and data are available at [this https URL](https://cvlab-unibo.github.io/gmnerf).

Published as a conference paper at ICLR 2026
WEIGHT SPACE REPRESENTATION LEARNING ON DIVERSE NERF ARCHITECTURES
Francesco Ballerini, Pierluigi Zama Ramirez, Luigi Di Stefano, Samuele Salti University of Bologna, Italy francesco ba lerini 4 4uun www..o..............o........... bo. it
ABSTRACT
Neural Radiance Fields (NeRFs) have emerged as groundbreaking paradigm for representing 3D objects and scenes by encoding shape and appearance information into the weights of a neural network. Recent studies have demonstrated that these weights can be used as input for frameworks designed to address deep learning tasks; however, such frameworks require NeRFs to adhere to a specific, predefined architecture. In this paper, we introduce the first framework capable of processing NeRFs with diverse architectures and performing inference on architectures unseen at training time. We achieve this by training Graph Meta-Network within an unsu- pervised representation learning framework, and show that a contrastive objective is conducive to obtaining an cethitecture-agnosiie latent space. experiments con- ducted across 13 NeRF architectures belonging to three families (MLPs, tri-planes, and, for the first time, hash tables). our approach demonstrates robust performance in classification, retrieval, and language tasks involving multiple architectures, even unseen at training time, while also matching or exceeding the results of cxisting frameworks limited to single architectures. Our code and data are available at this https URL.
INTRODUCTION
Neural Radiance Fields (NeRFs) (Mildenhall et al.. 2020) have emerged over the last few years as new paradigm for representing 3D objects and scenes (Xie et al., 2022). A NeRF is a neural network trained on a collection of images to map 3D coordinates to color and density values, which can then be used synthesize novel views of the underlying object or scene via volume rendering. Due to their continuous nature, NeRI' can encode an arbitrary number of images any resolution into finite number neural network weights, thus decoupling the number of observations and their spatial resolution from the memory required to store the 3D representation. As result, NeRFs hold the potential to become a standard tool for storing and communicating 3D information, as supported by the recent publication of several NeRF datasets (De Luigi et al., 2023; Hu et al., 2023; Zama Ramirez et al., 2024; Cardace et al., 2024; Amaduzzi et al., 2025).
With the rise of NeRFs deep learning tasks on them has become an increasingly relevant research question. The naive solution to this problem involves rendering views of the underlying object from its NeRF representation and leveraging existing neural architectures designed to process images. However, this procedure requires additional computation time and several decisions that are likely to impact its outcome, such as the number of views to render, their viewpoint, and their resolution. A more elegant and efficient approach, explored in recent works, relies on performing tasks on NeRFs by processing their weights as input, thereby requiring no rendering step. This strategy is adopted by 222v (Zama Ramirez et al., 2024), a representation learning framework that learns to map NeRF weights to latent vectors by minimizing rendering loss, where NeRFs are standard Multi-Layer Perceptrons (MLPs). These vectors are then used as input to deep learning pipelines for downstream tasks. A related approach is proposed by Cardace et al. (2024), who, instead of employing traditional MLPs, leverage tri tri-planar NeRFs (Chan et al., 2022), where input coordinates are projected onto three orthogonal planes of learnalle features compute the input for ML.P
new data format, whether and how it is possible perform traditional

---

Published as a conference paper at ICLR 2026
LATENT SPACE
CLASSIRER
CAR
HASH
MLP
TRI-PLANE
TRI-FLANE
GMN
AIRPLANE
GALLERY
HASH TARI
MLP
FASH TABLE
TRI PLANE
WHAT NORS THIS NEM REPRESENTT
LLM
A MSI 1OW PUCKUP TRUCK
HASH TABLE
Figure 1: Framework overview. Our representation learning framework leverages Graph Meta- Network (Lim et al., 2024) encoder to map weights of NeRFs with diverse architectures to a latent space where NeRFss representing similar objects are close to each other, regardless of their architecture. The embeddings are then used as input to downstream pipelines for classification, retrieval, and language tasks.
Both 2f2vec (Zama Ramirez et al., 2024) and the method by Cardace al. (2024), however, are designed to ingest specific type of NeRF architecture (i.e. MLPs with fixed hidden dimensions in nf2vec and tri-planes with fixed spatial resolution in Cardace et al.), and are thus unable to process diverse input architectures. In the context of research domain where constantly being explored (Xie et al., 2022), this assumption strongly limits their applicability. The issue of handling arbitrary architectures has recently been studied in the broader research field on meta-networks, i.c. neural networks that process other neural networks as input. Specifically, Graph Meta-Networks (GMNs) have been proposed (Lim al., 2024; Kofinas al., 2024), namely Graph Neural Networks (GNNs) that can ingest any neural architecture as long as it can be first converted into a graph. Yet, these works do not experiment with NeRFs as input to GMNs.
NeRF designs
Motivated by the potential of GMNs to process diverse NeRF architectures, we investigate whether a GMN encoder can learn a latent space where distances reflect the similarity between the actual content of the radiance fields rather than their specific neural parameterization. Our empirical study reveals that this latent space organization cannot be achieved by solely relying on a rendering loss (Zama Ramirez et al., 2024), such loss alone causes different NeRF architectures to aggregate into distinct clusters in the embedding space, even when they represent the same underlying object. To overcome this limitation, we draw inspiration from the contrastive learning literature and introduce SigLIP loss term (Zhai et al., 2023) that places pairs of NeRFs with different architectures representing the same object close each other in latent space while pushing other pairs further apart. Combined with a rendering loss, this approach enforces an architecture-agnosti embedding space organized by class and instance. Our experimental study features three families popular NeRF architectures, namely MLPs, tri-planes (Chan et al., 2022), and multiresolltion hash tables (Müller et al., 2022), for a total of 13 diverse architectures, and reveals that our encoder produces latent representations that serve as effective inputs for downstream tasks such as classification, retrieval, and language tasks. Notably, our framework is the first to perform tasks on NeRF parameterized as hash tables by processing their weights. Fig. 1 outlines the key components of our framework.
Our contributions can be summarized as follows:
We present the first framework that performs tasks on NeRFs parameterized by diverse architectures by processing their weights.
We propose to use contrastive learning objective to create latent space where NeRFs with similar content are close to each other, regardless of their architecture.
We tackle, for the first time, downstream tasks on NeRFs parameterized by hash tables.
We show that, within the families seen at training time, our framework can effectively process
unseen NeRF architectures and generalize NeRFs trained unseen data.
We achieve comparable or superior results to previous methods operating on single architectures.
RELATED WORK
Neural Radiance Fields. NeRFs were first introduced by Mildenhall et al. (2020) as a method for novel view synthesis, namely the task of generating previously unseen views of a scene from
2

---

Published as a conference paper at ICLR 2026
set of sparse imput images taken from different viewpoints. In the original formulation, a NeRF is an MLP that parameterizes a function (r, y, 2, 8, Φ) + (r, g. b, o)) that maps a 3D position (z, y, 2) and a 2D viewing direction (6, Φ) to an emitted color (r. g. b) and volume density o. Since then, several architectural variants have been proposed, many of which combine the MI.P with a trainable discrete data structure that quantizes the space of input coordinates and maps them dimensional vector, which then serves as the actual MLP input. These structures include voxel grids (Liu et al., 2020), tri-planes (Chan et al., 2022), and multi-resolution hash tables (Müller et al., 2022), and typically result in NeRF architectures that can be trained much faster to convergence without sacrificing rendering quality, In particular, hash tables are the most widely adopted NeRF architecture in recent works (Barron et al., 2023; Wang et al., 2024; Hu et al., 2024; Lee et al., 2025; Chen et al., 2024). This paper focuses on the NeRF architectures used Zama Ramirez et al. (2024) and Cardace et al. (2024), consisting of a single MLP and tri-plane followed by an MIP, respectively. and the one proposed by Muller et al. (2022), i.c. multi-resolution hash table followed by an MLP. In all three cases, the MLP adheres to the simplified formulation by Mildenhall et al. (2020) with no viewing direction, i.e. (I, y, 2) + (r, 9, b, o)
higher-
Meta-networks. Due to the high dimensionality of the weight space, its symmetries (Hecht-Nielsen, 1990), and the impact of randomness on the solution where training converges (Entezari et al., 2022; Ainsworth et al., 2023), processing neural network weights presents unique challenges that set them apart from more common input formats. The first works to address the design of neural networks that ingest the weights of other neural networks leverage group theory devise architectures that are equivariant to the permutation symmetries of the input networks (Navon et al., 2023; Zhou et al., 2023a;b). Yet, these neta-networks are tailored to specific input networks, such as MLPs and CNNs without normalization layers, and cannot generalize to arbitrary input architectures. To overcome this limitation, Graph Meta-Netwood
(GMNs) were introduced (Lim et al., 2024; Kofinas et al., 2024). Since GMNs are graph neural networks, they are, by design, equivariant to the node permutations of input graphs and can ingest any graph. Therefore, the challenge of processing neural network weights turns into the task of transforming the input network into a graph. In this paper, we use the GMN formulation by Lim et al. (2024) and devise our own conversion of hash tables into graphs.
Meta-networkk for NeRF processing. As the meta-network literature is still in its infancy, none of the aforementioned works include NeRFs as input in their experimental evaluation and instead choose to focus on simpler neural networks. The first methods to perform tasks on NeRFs by ingesting their weights are nf2vec (Zama Ramirez et al., 2024) and the framework by Cardace et al. (2024). n2evec is an encoder-decoder architecture trained end-to-end with a rendering loss; at inference time, the encoder takes the weights of a NeRF as input and produces an embedding, which in turn becomes the input to traditional deep learning pipelines for downstream tasks. More recent works (Ballerini et al., 2024; Amaduzzi et al., 2024) investigate the potential applications of this approach to language-related related tasks. While f2ve is designed to ingest MLPs, Cardace et al. processes tri-planar NeRFs (Chan et al., 2022) by discarding the MLP and giving the tri-planar component alone as input to a Transformer. Yet, both nfee and Cardace et al. suffer from the same drawback as the first meta-networks: they are designed to handle specific NeRF architectures. In this work, we instead present the first architecture-agnosiic framework for NeRF processing.
Contrastive learning. Contrastive learning is a representation learning approach that trains models to distinguish between similar (positive) and dissimilar (negative) data pairs by aiming to embed similar data points closer together while pushing dissimilar ones farther apart in latent space (Chen et al., 2020; He et al., 2020). Multimodal vision-language models extend this concept to align image and text modalities by maximizing the similarity between matching image-text pairs and minimizing it for mismatched ones, as demonstrated in CLIP (Radford et al., 2021), a model that learns shared embedding space supporting zero-shot transfer diverse vision tasks. Zhai al. (2023) build upon this foundation and propose to replace the dettmax-basedd loss used in CLIP with simple pairwise sigmoid loss, called SigLIP, which is shown to work better for relatively small (4k-32k) batch sizes. For this reason, in this paper, we use the SigLIP loss to align GMN embeddings of different NeRF architectures representing the same object.
3

---

Published as a conference paper at ICLR 2026
MLP
TRI-PUANE 634PH CONVERSION [Lim at
IISI TABLE GRAPH CONVERSION (Owrs)
GRAPH CONVERSION (Lim sL)
Le
LR
VOLUME RENDERING
LARR INER GaFt
N
GRAPI CONVERSION
94 bA A
VOLUME RENDERING
ESRU
GMN ENCODER
nI2ve: DECODER
IARUT LIVER
N D
CONVERSION
by
RENDERING
RENDERING
LR
Figure 2: Method overview. Left: parameter graph construction for MLP (left), tri tri-plane
(middle), and a renttiiresolution hash table (right). For better clarity, the graphs of a single x 2 x plane and of two 4 x hash tables shown. Right: our framework leverages a Graph Meta-Networ (Lim et al., 2024) encoder alongside the n f2ec decoder (Zama Ramirez et al., 2024) and is trained end-to-end on a dataset of NeRFs with different architectures .NAA.N7 with both a rendering (CR) and contrastive (Cc) loss.
3 METHOD
We tackle the challenging problem of embedding NeRFs parameterized by different neural archi- tectures with representation learning framework. Our method uses an encoder and a decoder trained end-to-end with a combination of rendering and contrastive objectives, where the encoder implemented as Graph Meta-Network (GMN). After training, the frozen encoder converts NeRF weights into an embedding that can serve as input to deep learning pipelines for downstream tasks. In the remainder of this section, we will describe each framework component; further details are provided in App. B.
From NeRFs to graphs. In order for a NeRF to be ingested by the encoder, it must be converted into a graph. The naive approach to perform this conversion would be to adopt the standard computation graph formulation, namely representing neural network as Directed Acyelic Graph (DAG), where nodes are activations and edges hold weight values. However, computation graphs scale poorly with the number of activations in networks with weight-sharing schemes, as single weight requires multiple edges, one for each activation it affects. This limitation has motivated Lim et al. (2024) to introduce the parameter graph representation, where each weight is associated with a single edge of the graph, rather than multiple edges. Lim et al. describe the parameter graph construction of several common neural layers, which can then be concatenated to form the overall parameter graph. Among these layers, they provide the parameter graph conversion of spatial parameter grids, such as those often used in NeRF architectures, specifically tri-planar ones (Chan al., 2022). However, they do not extend their parameter graph formulation to multi-resolution hash tables (Müller et al., 2022). In this paper, we leverage Lim et al.'s 's graph representations of linear layers and tri-planes, detailed in App. A, and propose conversion into parameter graphs for hash tables, described here. These three graph representations are shown in Fig. 2 (left). Specifically, hash tables map spatial locations of a dense 3D grid to feature vectors stored in a table via hashing function; in practice, multiple separate hash tables are used to index grids at different resolutions (hence the mulli-resolutionn terminology). To compute the output, the feature vectors of the grid vertices enclosing query point (xr, y, 2) are interpolated at each resolution, and the results are concatenated to serve as input to an MLP. The most direct way to convert hash table into a parameter graph would be to explicitly model the 3D grids of features encoded by the tables and adopt a graph representation analogous to the one used for tri-planes. Albeit simple, explicitly modeling the underlying voxel grid would require as many nodes as there are spatial locations, i.e. it would scale cubically with the resolution. Instead, we construct the parameter graph of a hash table with a node for each table entry and a node for each feature vector dimension. Then, we connect each entry node to each feature node via an edge that stores the corresponding feature value. This subgraph construction is repeated for each hash table, i.e. for each resolution level. Finally, the concatenation of all feature nodes becomes the first layer of the MLP parameter graph that follows. This graph representation preserves the memory efficiency of the hash table and is the one we adopt.
4

---

Published as a conference paper at ICLR 2026
Encoder. Our framework's encoder is the GMN proposed by Lim al. (2024), i.c. standard message-passing Graph Neural Network (GNN) (Battaglia et al., 2018) with node and edge features but no global graph-level feature. Node features updated by message-passingg along neighbors and contribute to updating the features of the edges connecting them. The final embedding is obtained via an average pooling of the edge features. Notably, as the encoder is GNN, it can process any input graph and, hence, any neural network that has undergone the previously described parameter-graph conversion, thereby allowing our framework handle any NeRF architecture for which a graph representation is known.
Decoder. Our framework leverages the decoder first introduced by nf2vec (Zama Ramirez et al., 2024), which takes as input the concatenation of the embedding produced by the encoder alongside a frequency encoding (Mildenhall et al., 2020) of 3D point (x,, y; =) and outputs learned approx- imation of the radiance field value (r. b, o at that point. Thus, the combination of decoder and embedding can itself be seen as conditioned neural radiance field. Inspired by Park et al. (2019), the decoder architecture consists of simple succession of linear layers, intertwined with ReLU activations, and a single skip connection from the input to halfway through the network.
The encoder and the decoder are trained end-to-end with a combination of two loss terms: rendering loss and a contrastive loss. The rendering loss is the one used by Zama Ramirez et al. (2024) to train the nee framework and can be described as follows. Consider NeRF ./: x + (c, o) with x = (xr, y. 2) and c = (r, b) and let 1 E I be one of the images W was trained on, with corresponding camera pose and intrinsic parameters. Let X' {x.} be the set of points sampled along ray cast from image / into the scene and passing through pixel p on the image plane, and let Cpr(p) be the color computed via volume rendering by accumulating the contributions of the (c),az) output values of A for all inputs x; E X. Analogously, let (p) be the color computed with the output values produced by the decoder when the encoder takes N as input. The rendering loss associated with NeRF N is defined as
Training.
CR(M)
Σ Σ TET PES(I)
(noothL
(1)
where ST) is a subset of pixels sampled from I and smoothL1 the smooth L1 loss (Girshick, 2015). More precisely, Zama Ramirez et al. compute one rendering loss term for foreground and one for background pixels, and express LR as a weighted sum of the two. Let L, T, H. be three NeRF architectures and consider dataset of NeRFs of 3D objects where each object j appears three times: as a NeRF M, parameterized by M, as a NeRF Ty parameterized by T, and as a NeRF Hi parameterized by H. Given a mmiii-batch B {(NVA,N))) (NV,,,22 ...))....>
...,. }. where each (Wf _N7)) randomly sampled from {(M,, Ty), (T,, Hly) (M,, H,)), the rendering loss computed over is the average rendering loss of each NeRF N in B, i.e.
[8] LR B
CR(N) J=1 NELN NP))
Σ
22)
where (NV is defined in Eq. 1. Our contrastive loss follows instead the definition by Zhai et al. (2023), namely
18|
B
Le
In
1+c e Pye(tu, +b+
where 2,x = i k and -1 otherwise. t and b are learnable scalar hyperparameters, and u, and Vù are the L2-normalized encoder embeddings of Ní and NE respectively. Finally, the combined loss used to train our framework is
CR+C= = CR + ACc
(4)
where À is a fixed hyperparameter. The rationale behind the choice of this loss is discussed in Sec. 4.1. Fig. 2 (right) shows an overview of our training procedure.
Inference. At inference time, single forward pass of the encoder converts the parameter graph of NeRF into a latent vector, which we then use as input to deep learning pipelines for classification, retrieval, and language tasks, as outlined in Fig. and detailed in Secs. 4.2 to 4.4.
5

---

Published as a conference paper at ICLR 2026
Table 1: Dataset architectures. Architectural hyperparameters of NeRF datasets featured in our experiments, including those used at inference time only (unseen).
Trainin
Unacen
N1P-21
MIP-32H
TRT-21.
TRT-32H
TRT-1
TRT-BC
HAGH-21.
RASH-12R
HAGR-3K
SASH-117
Layer
Trl Resebution
Trl plune Channels
Hosh Table Loock
4
Hash Tabee Sizz (lugg)
12
12
12
12
Class
Airplane
Car
Chair
Sofa
Watercraft
NeRF Architecture NLP
TRI
HASH
CR.
CR.C
Lc
Figure 3: t-SNE plots. 2D projections the latent space created by our framework when trained on dataset of NeRFs of ShapenetRender objects (Xu al., 2019), where each object is represented by three NeRFs parameterized by different architectures: MLPs, tri-planes, and multi-resolution hash tables.
EXPERIMENTS
Datasets. Our experimental evaluation is based on three families of NeRF architectures: MLP-based (i.e. a vanilla MLP), tri-planar (i.e. tri-plane (Chan et al., 2022) followed by MLP), and hash- based (i.e. a multi-resolltion hash table (Müller et al., 2022) followed by an MLP). These families are exemplified by the following datasets: (i) one consisting of Zama Ramirez al. (2024)'s MLP-based NeRFs only, which will be referred to as MLP; : (ii) one consisting of Cardace et al. (2024)*s 's tri tri-planar NeRFs only, which will be referred to TRI; (iii) one, created by us, consisting hash-based NeRFs only, which will be referred to as HASH; (iv) the union of MLPP, TRI, and HASH, i.e. a dataset where each object appears three times: once as an MI.P-based NeRF, then as tri-planar NeRF, and finally of our framework to perform tasks on arbitrary NeRF architectures, we create additional test sets of NeRFs featuring architectures belonging the same families of those seen training time but with different hyperparameters, which we will refer to as unseen architectures. The specifics of the architectures of all our datasets reported in Tab. 1. Overall, we consider total of 13 architectures across the three families. Following the protocol first introduced by Zama Ramirez et al. (2024), all the aforementioned NeRFs are trained on ShapenetRender (Xu al., 2019), dataset providing RGB images of synthetic 3D objects together with their class label.
mash-based NeRF; we will refer to this dataset as ALL. To further assess the ability
Models. To assess the impact of different losses training, we introduce distinction between three versions of our framework, depending on the learning objective: (i) LR. where the framework has been trained with the rendering loss of Eq. 2 alone; (ii) LR+C. where the framework has been trained with a combination of rendering and contrastive losses as in Eq. 4, with À = 2 x 10-2 2 (as it leads similar magnitudes in the two terms); (iii) Lc, where the framework has been trained with the contrastive loss of Eq. alone.
Single vs multi-architecture. Our method the first neural processing framework able to handle multiple NeRF architectures. Thus, the natural setting to test it is when it is trained on ALL; we will refer to this scenario as the multi-architecturee setting. Yet, our method can also be used when the input NeRF' all share the same architecture, e.g. when framework has been trained on MLP, TRI, or HASH only, by dropping the contrastive loss term. Therefore, to test its generality, we also perform experiments in such a scenario, which will refer to the tingl--rcciteetnn setting. In this setting, our approach can be compared to previous methods (Zama Ramirez al., 2024; Cardace al., 2024) that are limited to handling specific architectures.

---

Published as a conference paper at ICLR 2026
Table 2: NeRF classification (multi- architecture). The encoder is trained on ALL; the classifier is trained on the datasets in col- umn 2 and tested on those in columns 3-5.
Table 3: NeRF classification (single- architecture) The classifier is trained and tested on the same dataset on which the encoder is trained.
Accinc (8)/
Encoder Training
Method
Accuracy (98
Method
Classtter Traiting Set
3012
281
HABE
ni2vec
Ef2vec Cardace al. La (ours)
92.1
MLF
(ous)
ALC
9677
93.6
90,0
92.4
Et2vec
CR. (ouns)
HLP
93.8
91.5
25.3
58.6
56.6
19.5
Cardace et al. Eg (ours)
TRI
93.1
94,0
Cn. (ours)
11.4
93.8
Carre (oued)
77.8
66.5
r. v.f2ve
13.6
Cardace et al. Ca (ours)
HASH
(sMes)
92,5
4.1 LATENT SPACE ANALYSIS
To study the impact of different learning objectives the organization of the resulting NeRF latent space, we apply t-SNE dimensionality reduction (Van der Maaten & Hinton, 2008) to the embeddings computed by our framework on NeRFs belonging to the test set of the ALL dataset. Fig. 3 shows the resulting bi-dimensional plots. Some interesting patterns can be noted. When trained to minimize LR alone (Fig. 3, left), the encoder creates an embedding space that is clustered by class, even though class labels were not used at training time. This behavior is byproduct of the loss, which enforces NeRFs encoding similar shapes and colors to lie nearby in the latent space. Another outcome one may expect is that the same object represented by different NeRF architectures is projected into nearby embeddings; however, this turns out not to be the case. Instead, three distinct clusters emerge for each class, each corresponding to NeRF architecture, and these clusters are further away from each other than clusters sharing the same underlying architecture. This outcome shows that CR alone does not directly encourage the model to align NeRF embeddings regardless of the input architecture. Conversely, when trained to minimize Le alone (Fig. 3, right), the encoder significantly reduces the distance between different architectures representing the same class, but also provides a considerably less distinguishable clusterization by class compared to LR case (especially for some classes, like chairs, sofas, and tables). Finally, LR+C (Fig. 3, middle) strikes balance between these latent space properties. Compared to CR. one macro-cluster per class is present, although hash tables tend to form separate sub-cluster (which especially evident for airplanes and watercrafts). Compared to Lc, classes are more separated (although not as much as with LR), but the sub-clusterization of hash tables is more apparent. Thus, we expect Lg to be the best choice for tasks where the separation between classes is highly relevant; CR+C and Lc, on the other hand, are likely to be the most effective for tasks where strong invariance to the NeRF architecture is required, with LR+C being preferable, as it preserves more separation between classes. For these reasons, the remainder of this section shows experimental results obtained with Lg and LR-C; results for Le are reported in App. C.
4.2 NERF CLASSIFICATION
Once our framework has been trained, NeRF classification performed by learning a downstream classifier C to predict the labels of the embeddings produced by the encoder; an overview of this procedure is shown in Fig. 1. We report results for two cases: classification of NeRF architectures on which our framework was trained and classification of unseen architectures. In both cases, since the multi-architecture setting requires evaluating methods trained on ALL, neither one of the previous works, i.e. n f2ve (Zama Ramirez et al., 2024) and Cardace et al. (2024), can be applied to this scenario, as they can only be trained on MI.P and TRI, respectively.
Training architectures. Tab. 2 shows NeRF classification results in the multi-architecture setting on architectures used to train our framework. When C has been trained on ALL, LR performs the best: this result is consistent with the better separation between clusters corresponding to different classes provided by CR. as shown in Fig. (left) and discussed in Sec. 4.1. This trend can also be observed, as expected. when C is trained on either MLP, TRI, or HASH and then tested the same dataset, replicating the previous scenario with smaller datasets. On the other hand, the introduction of contrastive objective in CR is key to performance whenever C is trained on aicttttar
7

---

Published as a conference paper at ICLR 2026
Table 4: NeRF classification of unseen architectures (multi-architecture), The encoder trained on ALL; the classifier is trained the datasets in column 2 and tested on those in columns 3-12, containing NeRF architectures unseen at training time.
Method
Clossier Tnaring Set
XGP-23
3LP-3221
CRI-2L
TRI-22 II
TRI-1GM
TRI-EC
BASB-22
HACH--32
HASHI-1W 2W
Ge (oars)
913
874
98.2
$8.3
248
00.4
91.9
91.3
88.3
24.5
Seec (oun)
83.8
$7.0
$4.1
72.1
30.8
19.2
Aese (sur)
(oum)
NL.
91.3
15.6
86.1
81.3
68.3
22.6
25.2
434
59.2
79
21.0
15.1
51.5
190
90.8
55.8
21.3
248
76
467
S81
M6.9
113
639
50.
59.8
On louns
107
35.9
363
191
23.0
91.6
Caue
Table 5: NeRF classification of unseen architectures (single-acchitecture) The classifier is trained on the same dataset as the encoder and tested on the datasets in columns 32, containing NeRF architectures unseen training time.
Acceracy (R)
Methad
Facaderr Training Sai
NER-22
M2P-12H
-RT-22
TRE-12H
TRI-16M
TRT-60
RASH-21.
46S8--22
HA-F-11
RA3H-117
Candace et
ML2
(oams)
91.8
83.7
189
6.1
7.0
49
57
56
4.8
4.
Cinlace
TRC
91.
92.
Ea (ours)
161
10.0
92.6
825
22.9
72N
17.4
1M
10.1
121
(ours)
$3 39
154
213
21.3
213
90.6 91.8 81.2
388
dataset (e.g. MLP)) and tested on a dataset with a different architecture (e.g. TRI or HASH), as clusters of NcRFs belonging to the same class but parameterized by different architectures are closer in the embedding space than with LR alone. Overall, our method consistently achieves remarkable accuracies when tested on architectures included in the training set of C (i.e. red cells in Tab. 2). In the architetcce setting, instead, previous methods be trained and evaluated the datasets corresponding to the NeRF architecture they were designed to process, whereas C cannot be applied, as there single architecture and, therefore, positive pairs compute the contrastive loss. As shown Tab. 3, when both the encoder and the classifier are trained and tested on either MLP or TRI, our method outperforms both n n2ee and Cardace et al., while also achieving high accuracy on HASH. Hence, beyond its original aim, our approach can also provide a competitive alternative to single-architecture frameworks.
Unseen architectures. Multi aultietrchieecture classification results on unseen architectures are shown in Tab. 4. Remarkably, trend coherent with that of Tab. can be noticed, namely that Lg tends to perform best when the classifier C is trained either ALL or on an architecture belonging to the family of the unseen one presented test time (i.e. orange cells in Tab. 4), whereas L almost always prevails when training and test families differ, usually by significant margin. Notable exceptions are TRI-1 6W, where CR+C consistently yields the best results, and TRI TRI-8C. BCC, where CR outperforms CR+C (although less dramatically) even when changing the architecture family. Some other interesting patterns can be noted: in MLP and tri-plane families, reducing the number of hidden layers of an MLP has less impact on accuracy than reducing the hidden dimension, whereas it does not seem to have significant effect on hash table families; furthermore, changing hash table size is the most disruptive change, even when encoder and classifier have seen hash-based NeRFs training time. These patterns can serve as the basis for future investigations into this topic. Overall, it is worth highlighting that, in the most relevant scenario. i.c. when our framework has been trained on ALL, our method is able to reach remarkable accuracies on most of the unseen variations of known architecture families much better than f v in the only case in which the latter can be tested. Conversely, La performs worse than Cardace et al. (2024) in TRI-2I 2L and TRI 32H, i.e. TRI variations that change the MLP architecture. This is not surprising since, when performing classification, Cardace et al. processes the trine alone and discards the MLP, which makes their approach invariant to changes in the MLP architecture. Yet, since their method is tied to the tri- tri-plane quantization, it cannot process TRI-1 6W and is less robust than ours to the reduction in the number of channels. Finally, our method the only one that be tested on the hash table family, where it exhibits robust performance when trained on
tested on. In the single-are hrettectre setting, shown in Tab. 5, LR performs
8

---

Published as a conference paper at ICLR 2026
Table 6: NeRF retrieval (ShapenetRender), The encoder is trained ALL. Query/gallery combinations belong to their respective test sets.
Table NeRF retrieval (Objaverse generaliza- tion). The encoder is trained ALL. Query/gallery combinations belong to their respective test sets.
150
0.41
-104
1.67
1.05
D-16
2.40
1:48
3.71
0.11
0/71
0.33
14.77
15.27
13.17
13.45
9.82
6.18
1.79
2.2
BANDON
013
0135
0.33
0.13
01.3
XARDON
0.27
031
022
0.22
0127
0.2
feeciinnn (renn)
56.17
32.88
68.31
33,00
32.04
15.13
2367
17.8
26.00
033
19.00
8.80
0.24
0.5
0.24
0.53
0.5
24334
0.02
238
334
180
NL. MLP
MID TRI
QUERT
INN
NN
QUERY
1/N
J:VN
A/N
5/MN
OLBRY
2NNN
N/N
I
I
C
I
1
Figure 4: Across-datssets NeRF retrieval (CR+c), Query from the test set of MLP (Amaduzzi et al., 2025), gallery from the test set of MLP, TRI, or HASH.
HASH, except for HASH-11T, which already emerged as particularly challenging in the results of Tab. 4.
4.3 NERF RETRIEVAL
The embeddings produced by the trained encoder can also used to perform retrieval tasks via k-nearest neighbor search, as outlined in Fig. 1. In particular, as follows: given a NeRF embedding of a given object (a.k.a. the query) and a gallery of NeRF embeddings, the goal is find the embedding in the gallery that represents the same object as the query but encodes a different NeRF architecture. We evaluate the performance on this task with the recall @ metric (Wang al., 2017), defined the percentage queries whose l nearest neighbors contain the NeRF representing the same object as the query. Tab. 6 shows the retrieval results for various query/gallery test-set combinations; the recall @ obtained by randomly shuffling the gallery is shown for reference (RA (RANDOM rows). Although both Lg and LR+C significantly outperform the RANDOM baseline, the superior performance of CR+C confirms that the contrastive objective favors more architecture-agnostie latent space. Indeed, Figs. 6 and 7 display qualitatively that the latent space organization learned by CR+C captures the NeRF similarity in color and shape independently of the underlying architecture.
define instance-level retrieval
Generalization on Objaverse. To assess the generalization capabilities of our framework, we leverage three additional datasets: MLP TRI and HASH With MLP we denote dataset of MLP-based NeRFs trained on Objaverse (Deitke et al., 2023) recently released by Amaduzzi et al. (2025), whereas TB and HASH are datasets, created by us, of tri-planar and hash-based NeRFs trained on the test split of Objaverse defined by Amaduzzi et al. Specifically, NeRFs in MLP T and H2 have the same architecture as those in MLP, TRI, and HASH, respectively (see Tab. 1). Tab. 7 mirrors the experiment in Tab. 6, with the notable difference that the query and gallery contain NeRFs trained on different dataset (i.e. Objaverse) than the one the model has seen during training (i.c. ShapenetRender (Xu et al., 2019)). Although this leads, unsurprisingly. to an overall drop performance compared to Tab. 6, it is worth noting, once again, that both Lx and CR+C outperform the R RANDOM baseline, and the contrastive loss yields superior results. Fig. 4 shows instead qualitative retrieval experiment where the query is an MLP-based NeRF trained on Objaverse (i.e. MLP while the gallery contains NeRFs trained ShapenetRender, hence the query object not present in the gallery. Remarkably, for queries that resemble objects featured in ShapenetRender, our method retrieves NeRFs that belong to the same class the query (rows 1-2 of Fig. 4), with some failure cases occurring with more unusual queries (row 3). An extended version of these results is shown in Fig. 8.

---

Published as a conference paper at ICLR 2026
Table& 8: NeRF brief captioning Table 9: NeRF detailed cap-
Table 10: NeRF single-round Q&A (multi-architecture))
tioning -uultt-architecture)..
Method
Test Darzset
S BERT
SinCSE
Method
Test Danset
BERT
SInCSE
Methed
Test Danset
S BERT
SimCNET
LLINA
LLANA
LLINA
KLP 2RR
KLP
Cjuc (ouss)
56.4
Seec (ous))
73.5
Csuc (ours)
2RE
50.7
EASH
66.3
EASH
74.0
EASH
50.6
Table 11: NeRF brief caption- ing (single-architecture)
Table 12: NeRF detailed cap- Table 13: NeRF single-round Q&A (single-acchitectur))
tioning (single-architecture)
Method S-BERT1
SimCSE
Method
S-BERT
SimCSE
Method
S-BERT
SimCSE
ILANNA
68.6
70.5
LLaNA
77.4
79.8
LLaNA
81.0
81.6
CRIC (ours)
68.3
70.2
CRiC (ours)
74.1
76.0
CR.C (ours)
81.0
81.6
4.4 NERF CAPTIONING AND Q&A
Amaduzzi al. (2024; 2025) have previously shown that language tasks on NeRFs benefit from the holistic understanding of 3D objects captured by NeRF weights, leading their weight-processin framework (dubbed LLaNA) to outperform methods ingesting rendered views as input in NeRF captioning and NeRF Q&A tasks. To achieve these results, LLaNA uses the embeddings produced by the trained nf2vec encoder to condition an LLM belonging to the Llama 2 family (Touvron et al., 2023). To assess the effectiveness of our learned embeddings in downstream language tasks, we replaced the n f2vec encoder in LLANA's 's pipeline with our GMN encoder, trained the resulting framework on textual descriptions from the ShapeNeRF-Tex dataset (Amaduzzi et al., 2024), and evaluated it on brief captioning, detailed captioning, and single-round Q&A. In the multt-architecture setting, our framework is trained on ALL (as usual), and the ALL embeddings produced by our encoder are used to train the LLM. Since the nf2vec encoder can process only MLP-based NeRFs, the original LLaNA framework cannot be applied in the multi-architer architecture setting. In the single- architecture setting, instead, our framework is trained on MLP, and the MLP embeddings produced by our encoder are used to train the LLM. In this setting, our results are compared with the original LLaNA framework, which is also trained on MLP. Multi-architectune results are shown in Tabs. to 10, whereas single-architecture results are shown in Tabs. 11 to 13. As in Amaduzzi et al. (2024; 2025), the reported metrics are a measure of the similarity between the global embeddings of the generated and ground-truth texts, where such embeddings are produced by pre-trained Sentence- BERT (Reimers & Gurevych, 2019) and SimCSE (Gao et al., 2021) encoders, respectively. Extended results including traditional n-gram-basee garam- metrics are shown in App. F. Two main conclusions can be drawn from Tabs. 8 to 13: in the multi-architecture setting, our method is remarkably robust to the choice of test-time NeRF architecture; when instead restricted MLP-based NeRFs only. our method achieves results comparable to those of the original LLaNA framework. These results further confirm the architecture-agnose tasks, even as complex as those involving multimodal NeRF-language understanding.
nature of our embeddings and their effectiveness in downstream
5 CONCLUSIONS
In this paper, we presented the first framework that performs downstream tasks on NeRF weights with diverse architectures. Our method, based on Graph Meta-Network encoder ingesting the NeRF parameter graph, can (i) handle input NeRFs parameterized by MLPs, tri-planes, and, for the first time, multi-resolution hash tables; (ii) process, at inference time, variations of architectures seen during training: (iii) provide oftee-of-the-att performance in the
scenario.
Furthermore, we investigated the interplay between rendering and contrastive training objectives and showed that they serve complementary purposes, by favoring either class-level separability or invariance to the NeRF architecture. The main limitation of our study lies in its experimental evaluation, which primarily focuses on NeRFs that, although parameterized by 13 total architectures. are trained on a single dataset, i.e. ShapenetRender (Xu et al., 2019), with the notable exception of two generalization experiments on Objaverse (Deitke et al., 2023). Extending our training procedure on Objaverse itself or similar large-scale NeRF datasets would further validate the effectiveness of our approach, and we plan follow this research path in future work. Eventually, our methodology could be scaled up to become the first foundational model for NeRF weight space processing.
10

---

Published as a conference paper at ICLR 2026
REFERENCES
Samuel Ainsworth, Jonathan Hayase, and Siddhartha Srinivasa. Git re- basi::in: Merging models modulo permutation symmetries. In The Eleventh International Conference on Learning Representations. 2023. 3
Andrea Amaduzzi, Pierluigi Zama Ramirez, Giuseppe Lisanti, Samuele Salti, and Luigi Di Stefano. LLaNA: Large language and NeRF assistant. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. 3, 10, 20
Andrea Amaduzzi, Pierluigi Zama Ramirez, Giuseppe Lisanti, Samuele Salti, and Luigi Di Stefano. Scaling LLaNA: Advancing NeRF-language understanding through large-scale training. arXiv preprint (tti::2504.139993 2025. 1, 9, 10, 16, 19, 23, 24
Francesco Ballerini, Pierluigi Zama Ramirez, Roberto Mirabella, Samuele Salti, and Luigi Di Stefano. Connecting NeRFs, images, and text. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 866-876, 2024. 3
Satanjeev Banerjee and Alon Lavie. METEOR: An automatic metric for MT evaluation with improved correlation with human judgments. In Proceedings of the ACL Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization, pp. 65-72, 2005. 19
Jonathan Barron, Ben Mildenhall, Dor Verbin, Pratul Srinivasan, and Peter Hedman. Zip-NeRF: Anti-aliased grid- grid-based neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 19697-19705, 2023.
Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv: 1806.0/261 2018. 5
Adriano Cardace, Pierluigi Zama Ramirez, Francesco Ballerini, Allan Zhou, Samuele Salti, and Luigi Di Stefano. Neural processing of tri-plane hybrid neural fields. In The Twelfth International Conference on Learning Representations, 2024. 1, 2, 3, 6, 7, 8, 9, 16, 17, 18, 19
Eric R Chan, Connor Z. Lin, Matthew Chan, Koki Nagano, Boxiao Pan, Shalini De Mello, Orazio Gallo, Leonidas Guibas, Jonathan Tremblay, Sameh Khamis, al. Efficient geometry- 3D generative adversarial networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 16123-16133, 2022. 1, 2, 4,
Angel X. Chang, Thomas A. Funkhouser, Leonidas J. Guibas, Pat Hanrahan, Qi-Xing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song. Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. Shapenet: An information-rich 3D model repository. CORR, abs/1512.03012,, 2015. 16
Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pp- 1597-1607. PMLR, 2020. 3
Yihang Chen, Qianyi Wu, Mehrtash Harandi, and Jianfei Cai. How far we compress instant- NGP-based NeRF? In Proceedings of the IEEF/CVF Conference on Computer Vision and Pattern Recognition, pp. 20321-20330, 2024. 3
Lin Chin-Yew Rouge: A package for automatic evaluation of summaries. Proceedings of the Workshop Text Summarization Branches Out, 2004, 2004. 19
Luca De Luigi, Damiano Bolognini, Federico Domeniconi, Daniele De Gregorio, Matteo Poggi, and Luigi Di Stefano. ScanNeRF: scalable benchmark for neural radiance fields. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pp. 816-825, 2023.
Matt Deitke, Dustin Schwenk, Jordi Salvador, Luca Weihs, Oscar Michel, Eli VanderBilt, Ludwig Schmidt, Kiana Ehsani, Aniruddha Kembhavi, and Ali Farhadi. Objaverse: A universe of anno- tated 3D objects. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 131 13142-13153, 2023. 10, 16

---

Published as a conference paper at ICLR 2026
Rahim Entezari, Hanie Sedghi, Olga Saukh, and Behnam Neyshabur. The role of permutation invariance linear mode connectivity neural networks. In Internationna Conference on Learning Representations, 2022. 3
Tianyu Gao, Xingcheng Yao, and Danqi Chen. SimCSE:
Simple contrastive learning of sentence embeddings. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 6894-6910, 2021. 10, 20
Ross Girshick. Fast R-CNN. In 2015 IEEE International Conference on Computer Vision (ICCV), pp. 1440-1448, 2015. 5
Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF conference computer vision and pattrrn recognition, pp. 9729-9738, 2020. 3
Robert Hecht-Nielsen. On the algebraic structure of feedforward network weight spaces. In Advanced Neural Computers, pp. 129 135.. Elsevier, 1990. 3
Benran Hu, Junkai Huang, Yichen Liu, Yu- fu-Wing Tai, and Chi-Keung Tang. NeRF-RPN: A general framework for object detection in NeRFs. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp. 23528 -25388, 2023.
Yubin Hu, Xiaoyang Guo, Yang Xiao, Jingwei Huang, and Yong-Jin Liu. NGP-RT: Fusing multi- level hash features with lightweight attention for real-time novel view synthesis. In European Conference Computer Vision, pp. 148-165. Springer, 2024. 3
Miltiadis Kofinas, Boris Knyazev, Yan Zhang, Yunlu Chen, Gertjan Burghouts, Elstratios Gavves, Cees G. M. Snock, and David W. Zhang, Graph neural networks for learning equivariant represen- tations of neural networks. In The Twelfth International Conference on Learning Representations, 2024. 3,
Yongjae Lee, Li Yang. and Deliang Fan. MFNeRF: Memory efficient nerf with mixed-feature hash table. In 2025 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), pp. 2686-2695. IEEE, 2025.
Ruilong Li, Matthew Tancik, and Angjoo Kanazawa. NerfAce: A general NeRF acceleration toolbox. arXiv preprint arXiv:2210.04888 2022. 19
Derek Lim, Haggai Maron, Mare T. Law, Jonathan Lorraine, and James Lucas. Graph metanetworks for processing diverse neural architectures. In The Twelfth International Conference on Learning Representations, 2024. 2, 4, 5, 15, 17, 19
Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. Advances in Neural Information Processing Systems, 33:15651-15663, 2020. 3
Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Confer-
ence on Learning Representations, 2019. 17
Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. NeRF: Representing scenes as neural radiance fields for view synthesis. In European Conference Computer Vision, pp. 405-421, 2020. 2, 3, 5, 16, 17
Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller. Instant neural graphics primitives with a multiresolution hash encoding. ACM Transactions on Graphics (TOG), 41)) 1-15, 2022. 2, 3, 4, 6, 16
Aviv Navon, Aviv Shamsian, Idan Achituve, Ethan Fetaya, Gal Chechik, and Haggai Maron. Equiv- ariant architectures for learning deep weight spaces. In International Conference on Machine Learning, pp. 25790-25816 PMLR, 2023.
Kishore Papineni, Salim Roukos, Todd Ward. and Wei-Jing Zhu. Bleu: method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pp. 311-318, 2002. 19
12

---

Published as a conference paper at ICLR 2026
Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. DeepSDF: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE/CVF conference computer vision and pattern recognition, pp. 165-174, 2019.
Zhangyang Qi. Ye Fang, Zeyi Sun, Xiaoyang Wu, Tong Wu, Jiaqi Wang, Dahua Lin, and Hengshuang Zhao. GPT4Point: A unified framework for point-language understanding and generation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 26417- 26427, 2024. 16
Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pp.
8748 8763. PMLR, 2021. 3
Nils Reimers and Iryna Gurevych. Sentence-BERT: Sentence embeddings using siamese BERT- networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP- IJCNLP), pp. 3982-3992, 2019. 10, 20
Vincent Sitzmann, Julien Martel, Alexander Bergman, David Lindell, and Gordon Wetzstein. Im- plicit neural representations with periodic activation functions. Advances in neural information processing systems, 33:7462-7473, 2020. 16
Leslie N. Smith and Nicholay Topin. Super-convergence: very fast training of neural networks using large learning rates. In Tien Pham (ed.), Artificial Intelligence and Machine Learning for Multi-Domain Operations Applications, volume 11006, pp. 1100612. International Society for Optics and Photonics, SPIE, 2019. 17
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288 2023. 10
Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE. Journal of Machine Learning Research, 986):2577 2008.
Jian Wang, Feng Zhou, Shilei Wen, Xiao Liu, and Yuanqing Lin. Deep metric learning with angular loss. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2593-2601, 2017.
Yifan Wang, Yi Gong, and Yuan Zeng. Hyb-NeRF: multiresolution hybrid encoding for neural radiance fields. In 2024 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), pp. 3677-3686. IEEE, 2024.
Yiheng Xie, Towaki Takikawa, Shunsuke Saito, Or Litany, Shiqin Yan, Numair Khan, Federico Tombari, James Tompkin, Vincent Sitzmann, and Srinath Sridhar. Neural fields in visual computing and beyond. In Computer Graphics Forum, volume 41, pp. 641-676. Wiley Online Library, 2022. 1.2
Qiangeng Xu, Weiyue Wang. Duygu Ceylan, Radomir Mech, and Ulrich Neumann. DISN: Deep implicit surface network for high-quality single-view 3D reconstruction. Advances neural information processing systems, 32, 2019, 6, 9, 10, 16, 19
Runsen Xu, Xiaolong Wang, Tai Wang, Yilun Chen, Jiangmiao Pang, and Dahua Lin. PointLLM: Empowering large language models to understand point clouds. In European Conference Computer Vision, pp. 131-147. Springer, 2024. 16
Pierluigi Zama Ramirez, Luca De Luigi, Daniele Sirocchi, Adriano Cardace, Riccardo Spezialetti, Francesco Ballerini, Samuele Salti, and Luigi Di Stefano. Deep learning object-centric 3D) neural fields. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2024. 1, 2, 4, 5, 6. 7, 16, 17, 18, 19
Xiaohua Zhai, Basil Mustafa, Alexander Kolesnikov, and Lucas Beyer. Sigmoid loss for language image pre-training. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 11975-1 1986. 2023. 2, 3,
13

---

Published as a conference paper at ICLR 2026
Allan Zhou, Kaien Yang, Kaylee Burs, Adriano Cardace, Yiding Jiang, Samuel Sokota, J Zico Kolter, and Chelsea Finn, Permutation equivariant neural functionals. In Thirty-seventh Conference on Neural Information Processing Systems, 2023a. 3
Allan Zhou, Kaien Yang, Yiding Jiang, Kaylee Burns, Winnie Xu, Samuel Sokota, J Zico Kolter, and Chelsea Finn. Neural functional transformers. In Thirty-seventh Conference on Neural Information Processing Systems, 2023b. 3
14

---

Published as a conference paper at ICLR 2026
MLP
TRI-PLANE
W
SIAS MODES
MULTI-RES HASH TABLE
NT
MLP INPUT LAVER
parameter graph representation of an MLP, proposed by Lim et al. (2024). Right: parameter graph representation of tri-plane, proposed by Lim et al. (2024). Dotted edges should be connected to the C' channel nodes, but are not fully drawn for better visual clarity. Bottom left: our parameter graph representation of multi-resolution hash table.
Figure 5: Parameter graph conversion. Top left:
A ADDITIONAL PARAMETER GRAPH DETAILS
The parameter graph conversion of an MLP, a tri-plane, and a multi-resolution hash table is depicted in Fig. 5, with additional details compared to Fig. 2 (left).
MLP. The parameter graph of a linear layer (proposed by Lim et al. (2024)) coincides with its computation graph, except for biases, which are modeled by including an additional node for each (non-input) layer, connected to every other neuron in the layer with edge. As result, the parameter graph of an MLP is identical to its computation graph, with the addition of the aforementioned bias nodes. Each node stores three integer values: layer index, neuron index within the layer, and node type (neuron or bias). Each edge stores the corresponding weight or bias and two integers, i.e. layer index and edge type (linear layer weight or linear layer bias).
The parameter graph of tri- tri-plane (proposed by Lim et al. (2024)) contains one node for each spatial location and one node for each feature channel, where each spatial node is connected via an edge to every channel node; the channel nodes, together with one node for each input coordinate (more precisely, one node for each entry in their frequency encoding; see App. B) become the first layer of the MLP parameter graph that follows. Each node stores three integer values: layer index, neuron index within the layer, and node type (neuron for coordinate nodes or tri-planar for spatial and channel nodes). Each edge stores the corresponding learnable parameter (a.k.a. feature) and five additional values: layer index (integer), edge type (tri-planar, integer), and three (i, j. k) values (evenly spaced floats E [-1, 1) denoting the spatial position of the parameter within the tri-plane (with 0 on the yy plane, j = in the xz plane, and = 0 on the zy plane).
Tri-plane.
Hash table. As mentioned in Sec. 3, we are the first to propose parameter graph construction for multi-resolution hash tables. A single hash table is modeled with a node for each table entry and a node for each feature vector dimension, where each entry node is connected to each feature node via an edge. This subgraph construction is repeated for each hash table, i.e. for each resolution level. Finally, the concatenation of all feature nodes becomes the first layer of the MLP parameter graph that follows. Each node stores three integer values: layer index, neuron index within the layer, and node type (hash lable). Each edge stores the corresponding learnable parameter ka. feature) and four additional integers: layer index, edge type (hash lable), table index, and entry index within the table. Consider a multi-resolution hash table with N levels, max table size T, F features per entry, and max resolution R. Our parameter graph construction requires N F)) nodes and NTF edges. Conversely, if we drew an analogy with the tri tri-planar graph representation and explicitly modeled the underlying voxel grids with one node for each spatial location, it would result in graph with ON [t + F)) nodes and ON R F') edges. Since the purpose of hash grids is to reduce the memory footprint by mapping multiple voxel grid locations to the same table entry via hashing function, T should always be much smaller than R3 (e.g. NeRFs in HASH have = 2 vs R = 22!). ), hence N(T + F) < N (R + F) and NTF < N R F. Therefore, the motivation behind our choice of parameter graph representation for hash tables lies in its higher memory efficiency compared to its voxel-grid-based alternative.
15

---

Published as a conference paper at ICLR 2026
Table 14: Dataset architectures. Extended version of Tab. 1. Architectural hyperparameters of
NeRF datasets featured in our experiments, including those used at inference time only (unseen).
Trining
Unsees (ous)
RIP-21,
MIP-32H
TRI-2G,
TRI-32e
TRE-9C
HA-5--22
3Ade-3N
Froqueacy Enarding
V
/
X
MLP Activatin
Rell
Sine
ReL.
Rel.
ReLU
Sine
Sine
Site
Site
ReLU
RoLU
Rel.U
ReU
MLP Bislknn Layess
Dinersion
32
32
64
64
Th: plane
Chassels
16
Hash Tiol Leves
4
3
Hosh hewe Size (nig)
12
12
13
Hish Tuble Featares pe: Easy
2
2
B ADDITIONAL EXPERIMENTAL DETAILS
NeRF datasets. As outlined in Sec. 4, the datasets used throughout our experiments mostly consist of NeRFs trained ShapenetRender (Xu al., 2019). ShapenetRender is dataset featuring RGB images and class labels of synthetic objects belonging to 13 classes of the ShapeNetCore dataset (Chang et al., 2015): airplane, bench, cabinet, car, chair, display, lamp, speaker, rifle, sofa, table, phone, and watercraft. For each object, the dataset contains 36 224 x 224 images. We follow Zama Ramirez et al. (2024)'s train-val-test split without augmentations, consisting of 31744 NeRFs used for training, 3961 for validation, and 3961 for testing. Tab. 14 summarizes the NeRF architectures featured in our experiments. addition to the dataset descriptions provided in Sec. 4, we note here that:
MLP and TRI, input (2r, y, 2) coordinates go through a frequency encoding (Mildenhall et al., 2020) before being concatenated to the tri-plane or hash table output that gets fed to the MLP, as this choice was made by the original creators of the two datasets, i.c. Zama Ramirez et al. (2024) and Cardace et al. (2024), respectively. Conversely, the MLP in HASH takes input the output of the multi-resolution hash table by itself, without (encoded) input coordinates being concatenated to it; choose to do in order to be faithful to the original multi-resolution hash table architecture proposed by Müller et al. (2022). The presence or absence of concatenated encoded coordinates in a dataset used for training is then reflected in all the unseen variations of that architecture family (e.g. LL uses frequency encoding, whereas HASH 2L does not).
MLP layers are intertwined with ReLU activation functions MLP and HASH, whereas TRI uses sine activation functions (Sitzmann et al., 2020). The activation choices for MLP and TRI were made by their original creators (Zama Ramirez et al., 2024; Cardace et al., 2024), whereas we chose ReLU activations for HASH to remain faithful to the original hash table architecture (Müller al., 2022). The activation choice in a dataset used for training is then reflected in all the unseen variations of that architecture family (e.g. MLP-2L uses ReLU, whereas TRI- 2L uses sine).
All NeRFs approximate a function from input coordinates to predicted color and density values, i.c. (z, y, 2) + (r, r. b, or. This follows the simplified NeRF formulation proposed by Mildenhall et al. (2020), the alternative being adding a viewing direction (8, as input and letting the NeRF approximate function (x., y, 2, 0, (r,g, g, b, a). The formulation with viewing direction is usually modeled by two MI.Ps: a density MLP taking as input (z. y, 2) (or, more precisely, an encoding of (æ, y, z)) and producing as output o together with an additional vector h of features, and a color MLP taking as input the concatenation of h and (0, Φ) and predicting (r, g, b) as output. Both Zama Ramirez al. (2024) and Cardace et al. (2024) adopt the simplified (Ir, y, + (r, b, o) formulation modeled by single MLP when creating their NeRF datasets (i.e. MLP and TRI, respectively). We choose to follow the same formulation for HASH and the datasets of unseen architectures, both to keep the datasets consistent and to reduce the complexity of the parameter graph going into the encoder.
Furthermore, the experiments in Sec. 4.3 leverage three additional test sets, dubbed MLP TRI OB and HASH"* ML is dataset of MLP-based NeRFs trained on Objaverse (Deitke et al., 2023), a large-scale dataset of 3D objects. MLF was recently released by Amaduzzi et al. (2025), whereas we created TRI OR and HASHOR ourselves by training tri-planar and hash- NeRFs on the Objaverse test split used in Amaduzzi et al. (2025). More precisely, splits featured in Amaduzzi et al. (2025)'s benchmark, i.c. the one adopted by PointLLM (Xu et al., 2024) and the one adopted by GPT4Point (Qi et al., 2024). The resulting test set contains 1884
test split is the union of the two test
16

---

Published as a conference paper at ICLR 2026
Table 15: NeRF classification (multi-architecture), Extended version Tab. 2 with added Lc results. The encoder is trained on ALL; the classifier is trained on the datasets in column 2 and tested on those in columns 3-5.
Accuracy (%)
Method
Classifier Training Set
MLP
TRI
HASH
nf2vee (Zama Ramirez et al., 2024)
Cardace et al. (2024)
Ca (ours)
93.6
94,0
92.4
CR ic (ours)
ALT
90.7
90.6
90.0
Cp (ours)
82.5
77.8
64.0
Ln (ours)
93.8
25.3
19.3
CR.i (ours)
MLP
91.5
58.6
Ce (ours)
83.2
60.9
38.6
CR (ours)
11,4
93.8
9.3
CRiC (ours)
TRI
77.8
91.0
66.5
(ours)
70.4
79.0
47.6
La (ours)
13.8
35.7
92.7
CR.C (ours)
HASH
54.1
35.5
90.6
Le (ours)
65.4
63.7
64.6
NeRFs. NeRFss in MLP TRI and HASH have the same architecture as those in MLP, TRI, and HASH, respectively.
Encoder architecture. Our encoder is slight re-adaptation of the graph meta-network used in Lim al. (2024) in their experiment called predicting accuracy for varying architectures. It has the same network hyperparameters: hidden dimension 128, 4 layers, a pre-encoder, 2 readout layers, and uses directed edges. However, unlike Lim al. (2024), before wveraeepoooling the edge features, it maps them to vectors of size 1024 through single linear layer, resulting in a final embedding of size 1024 as in nf2vec (Zama Ramirez al., 2024).
Decoder architecture. We use the 2f2vec decoder in its original formulation (Zama Ramirez al., 2024). The input coordinates (ar, 2) mapped vector of size 144 through frequency encoding (Mildenhall et al., 2020) and concatenated with the (024-dimensional embedding produced by the encoder. The resulting vector of size 1168 becomes the input of the decoder, which consists of 4 hidden layers with dimension 1024 intertwined with ReLU activations, with a skip connection that maps the input vector to a vector of size 1024 via single linear layer + ReLU and sums it to the output of the second hidden layer. Finally, the decoder outputs the four (r, g. b, o) predicted radiance field values.
Training. Our encoder-decoder framework is trained end-to-end for 250 epochs with batch size 8, AdamW optimizer (Loshchilov & Hutter, 2019), one-cycle learning rate scheduler (Smith Topin, 2019), maximum learning rate 1 x 10 and weight decay 1 x 10 These training hyperparameters are the same for CR. LR+C. and Lc. In Eq. 1, foreground and background pixels are weighted by 0.8 and 0.2, respectively, as done in Zama Ramirez et al. (2024). In Eq. 3, t and b are initialized to 10 and - 10, respectively, as done in Zhai et al. (2023). In Eq. 4, À is set to x 10-2, as we experimentally observed that this choice leads to LR and Le values with the same order of magnitude.
Classification. In our classification experiments of Sec. 4.2, the classifier a concatenation of (linear -> batch-norm ReLU - dropout) blocks, where the hidden dimensions of the linear layers are 1024, 512, and 256, and a final linear layer at the end computes the class logits. The classifier is trained via cross-entropy loss for 150 epochs with batch size 256, AdamW optimizer (Loshchilov & Hutter, 2019), one-cycle learning rate scheduler (Smith & Topin, 2019), maximum learning rate 1 x 10-4, and weight decay 10-2, These same network and training hyperparameters are used in the classification experiments of Zama Ramirez et al. (2024).
C LC CLASSIFICATION AND RETRIEVAL RESULTS
NeRF classification. Tabs. 15 and 16 show classification results in the including those produced by Lc, which omitted in Tabs. and 4. Specifically, Tab. 15 shows
setting,
17

---

Published as a conference paper at ICLR 2026
Table 16: NeRF classification of unseen architectures (multt-archiecturr)) Extended version of Tab. 4 with added Le results. The encoder is trained on ALL; the classifier is trained on the datasets in column 2 and tested on those in columns 3-12, containing NeRF architectures unseen at training time.
Accuracy (8)
Training
Cheilter
XSP-21
7RI-21
TRI-1281
TRS-13M
TAI-2C
BASH-22
HASHI-22E
EASE-
HASH--11T
nffivec (Zama Hamieer Cardace (2024)
Ce (ours)
91.3
87.4
93.2
MS.3
6A.8
V1.3
91.2
58.3
24.5
Casc (iun))
27.8
07.3
27.7
Re (wee)
91.3
36.1
22.6
23.2
7.0
21,0
19.3
20.5
21.8
75
Cauc (murs)
ML2
96.6
11.3
63.3
43.4
59.3
13.1
51.5
58.5
55.0
2488
Ce (sura)
69.6
32.6
99.7
42.0
55.2
6.0
53.0
25.3
39.4
29.5
(ours)
Da (ver))
103
7.6
139
36.3
19.1
230
91.8
91.4
87.8
29.2
Sauc (oui)) 2e (wedd
BASS
47.0
48.4
40.6
34.0
43.4
19.3
89.5
87.9
56.4
25.7
Table 17: NeRF retrieval (ShapenetRender)) Extended version of Tab. with added Le results. The encoder is trained on ALL. Query/gallery combinations belong to their respective test sets.
Recall (8)
Method
ALI/ALI MLP/TRI
MLE/EASB
TRIMLP
TRIMEASH
HASHMLE
HASHTRRI
nf2vec (Zama Ramirez al., 2024)
Carlace et al. (2024)
RANDOM
0.03
0.03
0.03
Ca (ours)
0,00
1.80
0.43
4.48
1.67
1,06
0.38
Cusc (ours)
5,25
30.62
14.77
33.27
13:17
13.45
9,46
Cc (ours)
2,86
16.41
6.19
15.93
4.35
5.39
3.99
RANDOM
0.04
0.13
0.13
0.13
0.13
0.13
0.13
Ca (ours)
0.00
5.28
1.82
13,30
6.12
3.84
1.37
Cuzc (ours)
17.72
59.37
37.98
61.24
33,40
32,09
25.13
Le (ours)
10.91
40.61
18.03
38.89
14.11
16.84
14.21
RANDOM
0.08
0.25
0.25
0.25
0.25
0.25
0.25
Ca (ours)
0.00
8.19
3.08
19.24
9.23
6.09
2.68
CRyc (surs)
27.25
72.67
51.25
72.62
45.01
42.83
36.31
Ce (ours)
18.03
53.75
26.93
53.63
22.05
26.30
21.95
classification results when the classifier is tested on architectures seen during training, whereas Tab. 16 shows classification results when C is tested architectures belonging the families seen at training time but with different hyperparameters, which we refer to as unseen architectures in Sec. 4. In addition the observations discussed in Sec. 4.2, Tabs. 15 and 16 show that Le prevails over LR and CR+C in very few cases; this behavior is consistent with the less noticeable separation between class-level clusters produced by Le shown in Fig. 3 and discussed in Sec. 4.1. Notably, Le in the best performing method when C is trained on HASH and tested on TRI in Tab. 15, where CR+C struggles much more than in all other cases where is tested on architectures that are included in its training set (i.e. white cells).
NeRF retrieval. Tabs. and 18 show retrieval results including those produced by Lc, which are omitted in Tabs. 6 and 7. The recall@k of the RANDOM baseline is computed as
100- k
100
(5)
gallery|
Igallery|
Since retrieval is instance-level task, the contrastive loss enables Le to outperform LR for every query/gallery combination, albeit not effectively as LR+C, which consistently yields the best results. particular, when both the query and the gallery belong to ALL, LR is unable to perform the task: the latent space organization shown in Fig. 3 (left) and discussed in Sec. 4.1 prevents LR from being capable of recognizing the same object represented by NeRFs parameterized by different architectures. Furthermore, it is worth noting that the recall @ in the ALL/ALL case is lower than in the other query/gallery combinations because the gallery is larger and the probability missing the target instance is thus higher.
18

---

Published as a conference paper at ICLR 2026
Table 18: NeRF retrieval (Objaverse generalization). Extended version of Tab. 7 with added Le results.. The encoder trained on ALL. Query/gallery combinations belong to their respective test sets.
Recall (%)
Method
ALLALLL
XLP/RRI
XLP/HASH
TREMPP
TRIAHASH
BASHALE
HASHIIRI
n52vec (Zama Ramirez al., 2024)
Cardace et al. (2024)
RANDOM
0.02
0.05
0.05
0.05
0.05
0.05
0.05
Cu (ours)
0.00
2.60
0.48
2.71
0.48
0.74
0.32
Ca+c (ours)
0.64
9.82
6.10
8.33
1.75
6.74
2.92
C:: (ours)
0,18
3.66
2.23
3,66
0.96
3.13
1.80
RANDOM
0.09
0.27
0.27
0.27
0.27
0.27
0.27
Ca (ours)
0,00
6.37
1.11
7.27
1.91
2.92
0.69
CRiC (surs)
2.69
23,67
17.94
20.70
5,73
19.59
8.49
Cp (ours)
1.65
13.22
8,39
10.08
3.18
10.46
5.47
R RANDOM
0.18
0.53
0.53
0.53
0.53
0.53
0.53
Ca (ours)
0.00
9.66
2.39
10.99
3.24
4,88
1.80
CRIC (ours) Le (ours)
4.87
33.63
26.38
27.55
9.50
28.13
12.74
3.01
19.53
13.48
15,29
5.57
15.45
8.39
D IMPLEMENTATION AND HARDWARE
Our framework implementation built upon the codebases by Zama Ramirez al. (2024) (for the decoder and training) and Lim et al. (2024) (for the GMN architecture and graph conversion). NeRFs belonging to HASH, TRI 05, HASHOR and the unseen architectures framework (Li et al., 2022), as done in Zama Ramirez et al. (2024) and Cardace et al. (2024) for MLP and TRI. All experiments
trained with the NerfAcc
performed single NVIDIA RTX A6000. Training either LR or CR+C took ~22 weeks, whereas training Le took 4 days.
E ADDITIONAL QUALITATIVE RESULTS
Figs. and show NeRF retrieval qualitative results produced by LR+C c for varying query/gallery combinations belonging MLP, TRI, HASH. The similarity in color and/or appearance between the first 10 nearest neighbors and the query suggests that our framework encodes both relevant information about the appearance of the object represented by the NeRF and some invariance the architecture used to parameterize it.
Fig. 8 shows NeRF retrieval qualitative results produced by CR+C when the query belongs to MLP (Amaduzzi et al., 2025) and the gallery belongs to MLP, TRI, or HASH. As reminder, MLDOR's NeRFs are vanilla MLPs with the same architecture as those MLP (see Tab. 14). Since our framework was trained on ShapenetRender (Xu et al., 2019) NeRFs only. the purpose of this experiment to shed some light on its ability generalize to unseen datasets. The nearest neighbors of the MLP query reveal how remarkably well our method can retrieve NeRFs belonging to the same class as the query when the latter belongs to ShapenetRender classes (i.e. chair, lamp, and speaker), while mostly failing for the television query (whose closest ShapenetRender class would be display), although, interestingly, at least one object featuring a display with a pattern similar to that of the query is always found among the closest neighbors.
Fig. 9 compares retrieval qualitative results of LR and CR+C for one MLD (Amaduzzi et al., 2025) query. As may expect, the contrastive term in LR+C allows retrieving objects belonging the same class as the query even when the gallery NeRFs are parameterized by different architectures than the query (i.e. TRI and HASH), whereas LR produces reasonable results for all 10 nearest neighbors only when the gallery architecture is the same as the query (i.e. MLP), which, once again, demonstrates the importance of the contrastive objective when dealing with multiple architectures.
F ADDITIONAL NERF CAPTIONING AND Q&A RESULTS
Tabs. 19 to 24 show extended results for the language tasks described in See. 4.4 by adding BLEU- 1 (Papineni et al., 2002), ROUGE-L (Chin- Yew, 2004), and METEOR (Banerjee Lavie, 2005) metrics, which traditional handcrafted similarity measures based n-gram statistics. As discussed
19

---

Published as a conference paper at ICLR 2026
Table 19: NeRF brief captioning (multi-architecture)) Extended version of Tab.
Method
Test Dataset
S S-BERT' 1
SunCSE1 1 BLEU-1
ROUGE-L
METEOR f
aLaNA (Amaduzzi al., 2024)
67.1
Ca-c (ours)
TR2 HASH
66.4
67.8
32.5
34.4
35,9
66.3
67.9
32.4
34.5
35.6
Table 20: NeRF detailed captioning (multi-architecttree) Extended version of Tab. 9.
Method
Test Dataset
S-BERT
SimCSEt f BLEU-11
ROUGELI
METEOR
LLaNA (Amaduzzi al., 2024)
MLP
73.3
75.1
19.7
32.1
20.1
(ours)
72.2
73.8
19.5
31.4
19.7
HASH
72.4
74.0
19.6
31.7
19.9
Table 21: NeRF single-round Q&A (multi-architecturr)) Extended version of Tab. 10.
Method
Dataset
S-BERT
SimCSE
BLEU-1
ROUGE-L1
METEOR
LLaNA (Amaduzzi al, 2024)
MLF
80.9
81.4
45.6
52.6
49.5
Lxcc (ours)
TRI HASH
80.7
81.3
45.7
52.9
80.6
81.3
45.3
52.4
49.3
Table 22: NeRF brief captioning (single-architecture), Extended version of Tab. 11.
Method
S-BERT f
SimCSE f BLEU-1
ROUGE-L1 f
METEOR
LLaNA (Amaduzzi al., 2024) CR+C (ours)
68.6
70.5
20.6
28.3
31.8
68.3
70.2
33.1
35.3
36.6
Table 23: NeRF detailed captioning (single-architecture)) Extended version of Tab. 12.
Method
S S-BERT
SimCSE
BLEU-I
ROUGE-L
METEOR
LLaNA (Amaduzzi et al., 2024)
77.4
79.8
41.3
36.2
32.4
CR+C (ours)
74.1
76.0
20.1
32.5
20.6
Table 24: NeRF single-round Q&A (single-architecture)) Extended version of Tab. 13.
Method
S-BERT
SimCSE 1 BLEU-1 t ROUGE-L f METEOR
LLaNA (Amaduzzi al., 2024)
81.0
81.6
46.2
53.2
50.2
LRtc (ours)
81.0
81.6
45.4
52.5
49.4
in Sec. 4.4, S-BERT (Reimers & Gurevych, 2019) and SimCSE (Gao al., 2021) instead based on pre-trained networks, and generally considered more effective than n-gram- t-gram-based metrics at measuring the quality of the generated text (Amaduzzi al., 2024).
G LLM USAGE
LLMs were used in this paper tool aid and polish writing. No significant role in research ideation, experimentation, or writing was delegated to LLMs.
20

---

Published as a conference paper at ICLR 2026
MLP/TRA
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
MLP MLP/HASH
QUERY
1-NN
2-NN
3-NN
5-NN
6-NN
7-NN
8-NN
9-NN
TRI/MLP
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
Figure 6: NeRF retrieval qualitative results (CR+c). Query and gallery from the test set of MLP,
TRI, or HASH.
21

---

Published as a conference paper at ICLR 2026
QUERY
2-NN
3-NN
4-NN
5-NN
6-NN
8-NN
10-NN
HASH /MLP
QUERY
1-NN
2-NN
3-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
HASH/TH 'RRI
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
B-NN
9-NN
Figure 7: NeRF retrieval qualitative results (CR+c). Query and gallery from the test set of MLP, TRI, or HASH.
22

---

Published as a conference paper at ICLR 2026
MLP 0B /MLP
QUERY
T-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
MLP /TRI
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
MLP /HASH
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10 NN
Figure 8: Across-datasets NeRF retrieval (CR+c). Extended version of Fig. 4. Query from the test set of MSP (Amaduzzi et al., 2025), gallery from the test set of MLP, TRI, HASH.
23

---

Published as a conference paper at ICLR 2026
LR.
QUERY
1-NN
2-NN
3-NN
4-NN
5-NN
6-NN
7-NN
8-NN
9-NN
10-NN
MLP /MLP
MLP 'TRI
MLP /AAH
RRIC
QUERY
1-NN
2-NN
3-NN
4 4NNN
5-NN
6-NN
7-NN
8- NN
9-NN
10-NN
I
1
MLP /MLP
8
MLP OD /TRI
MLP HAAS
Figure Across-datasets NeRF retrieval (CR vs CR+C). Query from the test set of MLP (Amaduzzi al., 2025), gallery from the test set of MLP, TRI, HASH.
24


Reviews:
[{"review_id": "SnLkkSSGry", "reviewer": "Reviewer_bJuV", "summary": "This paper proposes an architecture-agnostic framework for weight-space representation learning on NeRFs. It encodes diverse NeRF architectures into a shared latent space using a Graph Meta-Network encoder plus an nf2vec-style decoder, trained with a rendering loss and a contrastive loss to align cross-architecture embeddings. Experiments over 13 architectures show strong performance on classification and instance-level retrieval, including unseen-architecture and cross-dataset scenarios.", "questions": "Under explicit weight permutations (e.g., permuting hidden units or hash entries), does the embedding remain stable? Any empirical test or theoretical discussion?\n\nWhat are typical graph sizes and embedding latencies for MLP/TRI/HASH, and how do they scale with resolution, channels, and table size?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The paper tackles an underexplored problem: processing NeRFs directly in weight space across heterogeneous architectures. Prior art (nf2vec; tri-plane-specific encoders) is bound to a single architecture; this work demonstrates a unified encoder that also handles hash-table NeRFs\n\n- The study spans 13 variants across three families, with both single- and multi-architecture training, and evaluates seen vs. unseen configurations. Results include detailed classification tables and retrieval\n\n- A unified weight-space interface for NeRFs could enable future foundation-style models for NeRF manipulation, indexing, and understanding without rendering, saving compute and simplifying pipelines.", "weaknesses": "- Most training/evaluation is on synthetic datasets (ShapeNetRender), with generalization probed only via limited Objaverse tests. It remains unclear how robust the encoder is to real-world NeRFs (capture noise, exposure variation, backgrounds) or to tasks where material/lighting realism matters. A larger cross-dataset study (e.g., forward-train on Objaverse; test on different captured NeRF sets) would strengthen claims. \n\n- The paper focuses on classification and retrieval. These are important, but practical NeRF workflows also require detection/segmentation in NeRF space, quality assessment, editability guidance, or content moderation. Demonstrating that the embeddings transfer to such tasks (even with light adapters) would better justify the \"general weight-space representation\" claim.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "2ntnxFtUEU", "reviewer": "Reviewer_X3pp", "summary": "This work proposes a new framework aiming at performing downstream tasks on NeRF weights with diverse architectures. The authors claim that the proposed model can handle multiple NeRF-related architectures, including multi-resolution hash tables, and validate the effectiveness of their proposed components.", "questions": "How many different categories can the proposed model handle?", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1.\tThis paper is well-written.\n2.\tIt focuses on a commonly overlooked problem regarding downstream tasks on trained NeRFs.\n3.\tThe proposed framework can handle various NeRF-related models, especially multi-resolution hash tables.", "weaknesses": "1.\tThe paper needs to provide a sufficient description of experimental details, such as training and testing datasets, as well as benchmarks.\n2.\tThe paper claims to be able to classify different NeRF architectures, but all experiments focus on object-centric NeRFs, lacking discussion of scene-based models.\n3.\tDue to incomplete experimental details, it is difficult to evaluate the effectiveness and generalizability of the proposed method.\n4.\tThe experimental section lacks discussion of some hyperparameters. Additionally, it lacks analysis of the experimental results, especially regarding the performance differences of the proposed method across different NeRF variants.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "EcYrU50KUG", "reviewer": "Reviewer_5Dgh", "summary": "The paper proposes a method for encoding different NeRF architectures to embeddings for the purpose of classification and retrieval.\n\nIn terms of architectures, MLP, triplane, and hash table-based NeRF architectures are being used as inputs for encoding.\nIn terms of loss, the rendering and the contrastive loss are being used.\n\nFor the encoding and decoding, a GMN-like and a nf2vec-like encoder and decoder are being used, respectively.\n\nShapenetRenderer and Objaverse datasets are being used for evaluation.\n\nThe authors noted the first time a hash table based spatial grid can be processed.", "questions": "1. Does the author have additional discussion or ideas in losses/encoder/decoder?\n2. hash table + GMN soundness: GMN is invariant/equivariant to standard neural network node permutation. Further, it respects the spatial content of a spatial grid (tri-plane like). Both these features are what the authors leveraged for the MLP and triplane-based NeRF in this current work. However, using a slightly different prime number for the hash function will lead to a completely different set of hash table features. I think this makes the hash table features inherently unsuitable for processing with the GMN. What's the authors' opinion on this? What features are stable, and what are unstable?\n3. hash table + GMN novelty: If I didn't miss a particular major point, this component is a major one in the pipeline that didn't directly reuse existing works' components. However, I think the hash table + GMN combination maybe inherently insufficient. Or at least warrant further analysis, improvement or modifications which the authors didn't mention. Does the authors have further points on why hash table can be combined with GMN this way, what components may require more careful analysis?", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The paper is well written, the explanations are thorough, and the figures are clear. The equations (for the loss) are clearly written. And the figures demonstrating the graph representation (of MLP, triplane and hashtable), though do require background reading, but is understandable once with the proper context.\n2. Supporting the MLP, triplane and hash table-based NeRFs cover most of the NeRF representation, if not all. This makes it a relatively general method for its own purpose.\n3. Both the quantitative and qualitative evaluations of the method itself are thorough. The retrieval does demonstrate similar content is being retrieved.", "weaknesses": "1. All of the losses and the encoder/decoder (GMN/nf2vec) used in this work are existing components. Making the novelty in those domains minimal (though the author didn't claim particular novelty in that domain and faithfully discussed the original works).\n2. The authors discussed its application to hash table. However, I have particular concern for this, both in terms of the novelty and soundness. Which I describe further in the question.\n3. The results are mostly compared within the works' own variants with different losses. With minimal comparison with existing works, even for the MLP or triplane-based solutions.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "ZyYjgjLDvA", "reviewer": "Reviewer_dPSz", "summary": "This work addresses the challenge of learning on Neural Radiance Fields (NeRF), treating NeRF as a data format. The key question is: how can we effectively conduct learning across various NeRF formats? Given the existence of multiple NeRF formats, the learning framework varies accordingly. To accommodate these different formats—such as MLP, Triplane, and Hashgrid—this approach first converts them into a graph representation. Then, a Graph Meta-Network, equipped with an unsupervised representation learning framework, is implemented. Results indicate that employing a contrastive objective significantly enhances generalization abilities for unseen NeRF formats, as demonstrated through classification and retrieval tasks.", "questions": "Q1. Can the learned embedding be used to reconstruct the NeRF? What is the Peak Signal-to-Noise Ratio (PSNR) for the learned embedding when using the decoder?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The research question is likely to attract interest from communities that utilize NeRF as a data format. The proposed technique enables direct retrieval and classification within this format.\n   \n2. The graph conversion method is novel, making it applicable to a wide range of NeRF data formats.\n\n3. Performance results are impressive. In single architecture tasks, the method surpasses previous techniques. In multiple architecture tasks, the addition of the contrastive loss notably boosts accuracy.", "weaknesses": "1. While the problem is intriguing, the paper does not adequately highlight the practical uses and advantages of learning directly on various NeRF formats. In many scenarios, a single NeRF format should be sufficient for each platform. Furthermore, when it comes to classification and retrieval, the question arises: why not simply store a few images (e.g., three orthogonal views) for each NeRF and perform learning on those images? The paper mentions that rendering takes time, but this argument feels weak. Although using the complete NeRF may benefit certain dense prediction tasks, the paper does not demonstrate such complex tasks.\n\n2. The experimental tasks performed undermines the claims made. Although the input NeRF formats are unified, the encoder architecture is limited to a Graph Network with global pooling to derive the embedding. It remains unclear how such an adaptation could extend to more complex tasks like 3D generation or 3D segmentation.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)