Magnituder Layers for Implicit Neural Representations in 3D

## Abstract

Abstract Improving the efficiency and performance of implicit neural representations in 3D, particularly Neural Radiance Fields (NeRF) and Signed Distance Fields (SDF) is crucial for enabling their use in real-time applications. These models, while capable of generating photo-realistic novel views and detailed 3D reconstructions, often suffer from high computational costs and slow inference times. To address this, we introduce a novel neural network layer called the “magnituder”, designed to reduce the number of training parameters in these models without sacrificing their expressive power. By integrating magnituders into standard feed-forward layer stacks, we achieve improved inference speed and adaptability. Furthermore, our approach enables a zero-shot performance boost in trained implicit neural representation models through layer-wise knowledge transfer without backpropagation, leading to more efficient scene reconstruction in dynamic environments.

## 1 Introduction

In recent years, the integration of advanced machine learning techniques into robotics has transformed the field of robotic manipulation and trajectory planning. As robots increasingly operate in unstructured environments, the ability to perceive and interact with complex scenes becomes essential. Traditional robotic perception methods often rely on explicit geometric models, which can limit flexibility and adaptability. In contrast, implicit neural representations such as Neural Radiance Fields (NeRF) (Mildenhall et al., ) and incremental Signed Distance Fields (iSDF) (Ortiz et al., ) have emerged as powerful tools that offer robust ways to model 3D scenes with high fidelity.

NeRF, initially developed for novel view synthesis, uses multiple feed-forward layers (FFLs) to encode 3D scenes into a continuous volumetric representation. This allows for photo-realistic rendering from arbitrary viewpoints. Its ability to learn intricate scene details from sparse data makes NeRF particularly appealing for robotics applications, especially in dynamic or poorly structured environments. On the other hand, iSDF provides a versatile framework for capturing the geometric properties of objects, facilitating real-time collision detection and path planning. By representing surfaces as implicit functions, iSDF seamlessly integrates shape information into robotic control systems.

Despite the exciting opportunities that NeRF and iSDF offer for enhancing robotic manipulation and trajectory planning, their practical deployment in real-world scenarios still requires improvements in training and inference speed. While iSDF provides real-time mapping, it relies on known camera poses, which adds computational overhead in real-world applications. Accelerating both training and inference can make the entire system faster, expanding the potential for real-time applications.

In real-world applications, robots often encounter novel objects and unpredictable conditions. Rapid adaptation to new scenarios is crucial for maintaining operational efficiency and safety. The ability to quickly retrain models or adapt them on-the-fly can significantly improve a robot’s performance in tasks such as grasping or navigating cluttered spaces. Slow training cycles may result in outdated models that fail to accurately represent the current environment, leading to decreased reliability and effectiveness.

Moreover, inference speed is vital for real-time decision-making in robotic systems. Delays in processing visual and spatial data can negatively impact a robot’s ability to perform timely actions, which is particularly important in fast-paced environments. For instance, in collaborative settings where robots work alongside humans, latency can create safety risks and hinder task efficiency. Thus, optimizing inference times while maintaining high accuracy is essential for deploying these advanced representations in practical applications.

The main computational block for NeRF and iSDF are feed-forward layers (FFLs).
To reduce the computational complexity, various methods have been proposed that reduce the burden of FFLs by exploiting explicit representations (Chen et al., ; Sun et al., ; Müller et al., ; Yu et al., ; Fridovich-Keil et al., ; Liu et al., ; Barron et al., ), reducing the number of network inferences through sample pruning with additional occupancy flags (Sun et al., ; Müller et al., ; Li et al., ), or introducing a novel volume rendering procedure (Han et al., ).

In this work, we address this challenge by introducing a novel neural network layer, called magnituder that can be combined with standard FFLs in an implicit neural representation.
The magnituders disentangle the processing of weights and inputs to the layer, only connecting them at the end through simple linear operations. The magnituders use structured transformations of the input to the layer that depend solely on the magnitude of the input (hence their name). This design allows for a reduction in the training parameters of the FFL blocks while maintaining the same level of expressivity as a standard FFL.

To summarize, our contributions in this work are the following :

- •
We introduce a novel random feature mechanism called magnituders that optimizes the computation of FFLs in implicit neural representations (Section 3).
- •
We demonstrate how this mechanism can approximate FFL with commonly used activation functions like ReLU and Softplus (Section 4.1).
- •
We showcase the versatility of our method across a wide range of scenes and a variety of implicit neural representations (Section 4.2).
- •
We distill existing MLP layers in an implicit neural representation with our magnituders which are trained analytically without backpropagation. Our method allows for zero-shot integration of our novel layer with pretrained models, improving inference speed without costly retraining. To the best of our knowledge, this is the first successful application of knowledge distillation without backpropagation for implicit neural representations, demonstrating its effectiveness in downstream tasks (Section 4.3).

Note that our method is orthogonal to the sparse sampling and the partitioning techniques and can be combined in such to further reduce the computational footprint.

## 2 Related Work

Neural Radiance Fields (NeRF) (Mildenhall et al., ) have transformed the synthesis of novel views from posed 2D images, offering impressive quality in rendering complex 3D scenes.
However, both training and rendering processes remain time-consuming, prompting extensive research aimed at accelerating these tasks, by integrating explicit representations (Liu et al., ; Yu et al., ; Hu et al., ; Tancik et al., ; Takikawa et al., ; Chen et al., ; Sun et al., ; Müller et al., ; Fridovich-Keil et al., ; Xu et al., ; Barron et al., ; Takikawa et al., ; Hu et al., ), dividing a scene into smaller blocks (Reiser et al., ; Tancik et al., ; Turki et al., ; Xiangli et al., ; Turki et al., ), caching (baking) the implicit functions (Garbin et al., ; Hedman et al., ; Chen et al., ; Reiser et al., ), and devising some novel tweaks (Lindell et al., ; Han et al., ).
Given their effectiveness, there has also been significant work extending NeRF to accommodate dynamic (Pumarola et al., ; Park et al., ; ; Li et al., ; Weng et al., ; Fang et al., ; Park et al., ; Cao & Johnson, ; Fridovich-Keil et al., ; Li et al., ; Wang et al., ; Shao et al., ; Attal et al., ; Wang et al., ; Lin et al., ; Xu et al., ), unbounded (Wang et al., ; Barron et al., ; Choi et al., ; Barron et al., ; Wang et al., ), and challenging appearances scenarios (Martin-Brualla et al., ; Ichnowski et al., ; Mildenhall et al., ; Bemana et al., ; Verbin et al., ; Guo et al., ; Fujitomi et al., ; Zhan et al., ; Warburg et al., ; Lee et al., ; Kim et al., ; Goli et al., ; Verbin et al., ; Ren et al., ).

Signed Distance Fields (SDF) are scalar fields that represent the distance to the nearest surface point, crucial in robotics for tasks such as environment mapping, collision avoidance, and trajectory optimization (Zucker et al., ; Toussaint, ; Schulman et al., ; Mukadam et al., ; Dong et al., ; ; Chaplot et al., ; Das & Yip, ; Verghese et al., ; Zhang et al., ; Johari et al., ; Deng et al., ; Yan et al., ; Zhu et al., ).
In computer vision, Truncated Signed Distance Fields (TSDF) are employed in SLAM systems, as traditional SDF computations can be prohibitively expensive in real time (Newcombe et al., ; ). Several approaches have emerged to facilitate real-time SDF construction due to its importance in robotics (Ortiz et al., ; Han et al., ; Oleynikova et al., ), while others have addressed challenges in constructing SDF for complex environments (Finean et al., ; Reijgwart et al., ; Geng et al., ; Qiu et al., ).
To get a photo-realistic quality of scene reconstruction, recent works replace the volume density in NeRF formulations with SDF, using well-designed SDF-to-volume density conversion formulas (Yariv et al., ; Wang et al., ; Yariv et al., ).
Further acceleration is achieved by combining explicit grid structures with implicit SDF (Yu et al., ; Wang et al., ; Li et al., ; Wang et al., ; Rosu & Behnke, ), populating thin shells near the zero level set (Wang et al., ), or baking SDF into a high-quality triangle mesh (Yariv et al., ).

A common challenge in training neural networks is that their space and time complexity scale quadratically with the size of their hidden layers. This challenge is also inherited by implicit neural representations.
One of the ways to tackle this issue is via dimensionality reduction à la Johnson-Lindenstrauss
Transform (or JLT) (Dasgupta & Gupta, ; Dasgupta et al., ; Ailon & Liberty, ) or kernel methods (Rahimi & Recht, ). Kernel methods have a rich history, spanning the linearization of 2-layer neural networks (Cho & Saul, ; ), Neural Tangent Kernels (NTK)(Jacot et al., ), and the linearization of attention mechanisms in Transformers (Choromanski et al., ). Kernel methods using random feature mechanisms have shown promise in reducing the computational complexity of neural networks (Choromanski et al., ; Rahimi & Recht, ). However, these approaches are not directly applicable to the MLP layers that are the backbone of NeRF and iSDF systems. To address the computational complexity of FFLs, Sehanobish et al. () introduced the Universal Random Feature (URF), which disentangles weights and inputs in specific MLP layers. Their method relies on Fourier transforms of activation functions, limiting its applicability to commonly used activation functions in machine learning.

## 3 Magnituders

In this section we define our magnituder-layers (MAG-layers in short). Consider a layer $\mathcal{M}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{l}$ taking as input a $d$-dimensional vector, outputting an $l$-dimensional vector and given as follows:

$$ $\mathcal{M}_{\mathbf{W},\theta}(\mathbf{x})=\mathbb{E}\left[\mathbf{W}\mathbf{ v}_{\theta}(\|\mathbf{x}\|_{2})\right],$ (1) $$

where $\mathbf{W}\in\mathbb{R}^{l\times d}$ is a learnable matrix and $\mathbf{v}_{\theta}:\mathbb{R}\rightarrow\mathbb{R}^{d}$ is a map operating on the magnitude (length) of the input $\mathbf{x}$. This transformation is potentially learnable (with a set of learnable parameters $\theta$) or probabilistic (in the latter setting, $\theta$ encode the parameters of the distribution $\mathcal{D}_{\theta}$ used to sample the values of $\mathbf{v}_{\theta}(\mathbf{x})$). The expectation is with respect to $\mathcal{D}_{\theta}$. In practice, in the probabilistic setting, $\mathcal{M}_{\mathbf{W},\theta}(\mathbf{x})$ is not computed exactly, but unbiasedly approximated by sampling.

Magnituders disentangle the processing of the input $\mathbf{x}$ and weights $\mathbf{W}$, only to connect them via simple linear matrix-vector multiplication at the end. In magnituders, randomness is introduced via multiplications of $\mathbf{x}$ with a Gaussian matrix $\mathbf{G}\in\mathbb{R}^{m\times d}$ where the entries are drawn iid from $\mathcal{N}(0,1)$, for some $m>0$ which are subsequently followed by purely deterministic transformations. The parameter $m$ is called the number of random features in a MAG-layer. Under this randomization strategy, taking a kernel perspective, magnituders can be interpreted as outputting a vector of approximate kernel values $\mathrm{K}(\mathbf{w}_{i},\mathbf{x})$ for $i=1,...,l$, where kernel $\mathrm{K}:\mathbb{R}^{d}\times\mathbb{R}^{d}\rightarrow\mathbb{R}$ is defined as:

$$ $\mathrm{K}_{\mathrm{MAG}}(\mathbf{u},\mathbf{v})\overset{\mathrm{def}}{=}\sum_ {i=1}^{d}u_{i}\mathbb{E}[f_{\theta_{i}}(\|\mathbf{v}\|_{2}g)],$ (2) $$

where $g\overset{\mathrm{iid}}{\sim}\mathcal{N}(0,1)$ and functions $f_{\theta_{1}},...,f_{\theta_{d}}:\mathbb{R}\rightarrow\mathbb{R}$ are deterministic. This comes directly from the fact that for $\mathbf{g}\sim\mathcal{N}(0,\mathbf{I}_{d})$, we have: $\mathbf{v}^{\top}\mathbf{g}\sim\|\mathbf{v}\|_{2}\times\mathcal{N}(0,1)$.

The above kernel can be efficiently and accurately approximated by quasi Monte Carlo methods (QMCs).

### 3.1 Magnituders and QMCs

A straightforward approach to estimating kernels from Equation 2 is through Monte Carlo methods, which is effectively implemented in versions of the magnituder layers that leverage Gaussian matrices
$\mathbf{G}$.

To be more specific, the kernel from Eq. 2 is approximated as follows : For $\mathbf{g}_{1},...,\mathbf{g}_{m}\overset{\mathrm{iid}}{\sim}\mathcal{N}(0,
\mathbf{I}_{d})$:

$$ $\mathrm{K}_{\mathrm{MAG}}(\mathbf{u},\mathbf{v})\approx\sum_{i=1}^{d}u_{i}f_{ \theta_{i}}(\mathbf{v}^{\top}\mathbf{g}_{i}),$ (3) $$

A standard technique to reduce the variance for approximators based on ensembles of Gaussian vectors is via the so-called orthogonal random features or ORFs (Yu et al., ). The ensembles of iid vectors are replaced by block-orthogonal ensembles, where within each $d$-element block vectors have marginal Gaussian distributions $\mathcal{N}(0,\mathbf{I}_{d})$, yet different vectors in each block are exactly orthogonal. Blocks are constructed independently. ORFs are popular since they can be easily constructed. For magnituders we have the following variance reduction lemma:

###### Lemma 3.1 .

Denote by $\widehat{\mathrm{K}}^{\mathrm{iid}}_{\mathrm{MAG}}(\mathbf{u},\mathbf{v})$ and estimator from the RHS of Eq. 3 appying iid ensemble: $\mathbf{g}_{1}^{\mathrm{iid}},...,\mathbf{g}_{m}^{\mathrm{iid}}$ and by $\widehat{\mathrm{K}}^{\mathrm{ort}}_{\mathrm{MAG}}(\mathbf{u},\mathbf{v})$ its variant leveraging block-orthogonal ensemble (ORFs): $\mathbf{g}^{\mathrm{ort}}_{1},...,\mathbf{g}^{\mathrm{ort}}_{m}$. If functions $f_{\theta_{i}}$ are analytic with non-negative Taylor coefficients and $u_{i}\geq 0$ for $i=1,...,m$ then:

$$ $\mathrm{Var}(\widehat{\mathrm{K}}^{\mathrm{ort}}_{\mathrm{MAG}}(\mathbf{u}, \mathbf{v}))\leq\mathrm{Var}(\widehat{\mathrm{K}}^{\mathrm{iid}}_{\mathrm{MAG} }(\mathbf{u},\mathbf{v}))$ (4) $$

###### Proof.

The proof follows directly from Lemma 4 and Theorem 6 in Choromanski et al. ().
∎

We observe that, empirically, even in cases where the conditions of Lemma 3.1 are not satisfied, the ORFs still provide quality gains (see Figure 16).

Finally, we would like to posit our magnituder layers in the broader context of linearizing neural networks via kernel methods. If $f_{{\theta}_{i}}$’s are deterministic functions, the right hand side of Equation 2 represents a 2-layer NN where the input layer is fixed and only $u_{i}$ is trainable. The linearization of such 2-layer NN is widely considered under various conditions (Cho & Saul, ; ; Ghorbani et al., ; Neal, ). The notable difference between the previous works and our work is that $\mathrm{K}_{\mathrm{MAG}}$
cannot be modeled as a standard neural network i.e. matrix-vector multiplications followed by point-wise nonlinear transformations, so such techniques can not be readily applied here.

###### Lemma 3.1 .

###### Proof.

### 3.2 Connections with SNNK

We now discuss our magnituder layer with another similar mechanism SNNK introduced by Sehanobish et al. (). Like magnituders, SNNKs also disentangle the weights and the inputs by leveraging the so-called Universal Random Features (URFs). However there are some key differences, which we detail below:

The SNNK-layers are defined as follows:

$$ $\mathrm{SNNK}_{\mathbf{W}}(\mathbf{x})=\mathbb{E}[\Phi(\mathbf{W})\Psi(\mathbf {x})],$ (5) $$

where: (1) probabilistic map $\Phi:\mathbb{R}^{l\times d}$ is obtained by applying probabilistic maps $\Phi^{i}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}$ for $i=1,...,l$, independently on the verticalized rows $\mathbf{w}_{1},...,\mathbf{w}_{l}$ of $\mathbf{W}$ respectively and furthermore, (2) $\Psi:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}$ is another probabilistic map.

Thus the randomness is introduced in both the weight and the input tower. And the kernel that is associated to SNNK can be defined as :

$$ $\mathrm{K}_{\mathrm{SNNK}}(\mathbf{u},\mathbf{v})\overset{\mathrm{def}}{=} \mathbb{E}_{\mathbf{g}\in\mathcal{N}(0,\mathbf{I}_{d})}[\Phi(\mathbf{u}^{\top} \mathbf{g})\Psi(\mathbf{v}^{\top}\mathbf{g})]$ (6) $$

which can be estimated using QMC methods via the following approximation :

$$ $\mathrm{K}_{\mathrm{SNNK}}(\mathbf{u},\mathbf{v})\approx\frac{1}{m}\sum_{i=1}^ {m}\Phi(\mathbf{u}^{\top}\mathbf{g}_{i})\Psi(\mathbf{v}^{\top}\mathbf{g}_{i})$ (7) $$

However, rigorous theoretical results regarding variance reduction from ORFs for the estimators defined in the RHS of Eq. 7 are known only for very specific nontrivial functions $\Phi$ and $\Psi$, i.e. the exponential map: $z\rightarrow\exp(c\times z)$ (Choromanski et al., ) and sgn-function $z\rightarrow\mathrm{sgn}(z)$ (Choromanski et al., ). Moreover, we believe that the explicit dependence on $\|\mathbf{x}\|_{2}$ in magnituders, enables them to outperform SNNKs in applications leveraging implicit neural-network-based representations, as we show in Sec. 4.1 (Figure 1).

## 4 Experiments

In this section, we present a comprehensive empirical evaluation of our MAG-layers. Specifically, we design experiments to answer the following research questions:

- •
(Q1) How accurate are MAGs in approximating some commonly used FFLs?
- •
(Q2) How can MAGs be used to speed up various existing implicit neural representation methods?
- •
(Q3) How can MAGs be used to improve inference speeds of an already trained NeRF or an iSDF model?

In all our experiments, we use the MAG-layer of the form
$\mathbf{M}_{\mathbf{W}}(\mathbf{x})=\mathbf{W}f(\mathbf{Gx})$, where $\mathbf{W}\in\mathbb{R}^{d^{\prime}\times m}$ is a trainable matrix, $\mathbf{G}\in\mathbb{R}^{m\times d}$ is a random matrix, $d$ (resp. $d^{\prime}$) is the dimension of the input (resp. output), $m$ is the number of random features, and $f=\text{ReLU}$ applied point-wise. By choosing
$m<<d$, we can achieve a reduction in training parameters while maintaining comparable performance, as we will demonstrate in these experiments.
Additional experiments including detailed ablation studies can be found in Appendix D.

### 4.1 Synthetic Experiments

First, we justify our choice of $f$ by demonstrating the superiority of our magnituder (MAG) layers in approximating both ReLU-linear and SoftPlus-linear layers. These activations are selected because they are commonly used in downstream applications. Additionally, we show the performance boost over the existing random feature mechanism (SNNK) (Sehanobish et al., ). We replicate this experiment over 10 random seeds and present the average of these runs in Figure 1. More details can be found in Appendix C.1. Furthermore, we support our choice of using ORFs (i.e. $\mathbf{G}$ is an orthogonal random matrix) with the results presented in Figure 16.

Figure: Figure 1: Approximation capability of our MAG layer. Here we compare with the SNNK layer as our baseline. The size of the dots represents the number of training parameters and for fairness, we made sure that the MAG layer and the SNNK has the same number of training parameters. (Left) : Approximating a ReLU-Linear layer. (Right) : Approximating a Softplus-Linear layer.
Refer to caption: extracted/5922742/time_vs_loss_relu.png

Thus in the subsequent sections, we will only use ORFs in our MAG-layers.

### 4.2 MAG-Layers for Implicit Neural Representations

In this section, we show how MAG layers can be seamlessly injected into various implicit neural representation methods including NeRF (Mildenhall et al., ), Zip-NeRF Barron et al. (), D-NeRF (Pumarola et al., ) and iSDF (Ortiz et al., ), to accelerate existing methods. Additionally, we introduce novel design choices for these models to further enhance inference speeds.

#### 4.2.1 NeRF Experiments

In this section, we focus on integrating MAG-layers into NeRF models (Mildenhall et al., ). While NeRF has demonstrated impressive capabilities in generating photo-realistic scenes, it suffers from long training and inference times. Thus, to accelerate inference times and reduce model sizes, we replace three MLP layers in the baseline NeRF architecture with our random feature mechanism, which we refer to as MAG-NeRF (see Figure 3).
Our design choice enables the “bundling process”, allowing subsets of layers to be grouped together to create a lean, efficient model without sacrificing accuracy (see Appendix A).

We evaluate both the baseline NeRF and MAG-NeRF using the PyTorch implementation of NeRF (Yen-Chen, ) on the Synthetic NeRF dataset (Mildenhall et al., ).
We train MAG-NeRF in the same manner as the baseline NeRF by running 200k iterations and rendering the test images at half resolution.
During inference, we apply a bundling process to the MAG-NeRF network by collapsing the MAG layer with any subsequent Linear layers before nonlinear activation.
When concatenation is involved, we decompose the weight matrix into two parts and bundle them together.
For instance, in Figure 3 (b), we bundle three consecutive layers (4${}^{\text{th}}$-6${}^{\text{th}}$ arrows: Red, Orange, and Black) by decomposing the Linear-ReLU layer (black arrow) into two parts: 60 by 256 and 256 by 256.

In Table 1 and Figure 2, we present the quantitative and qualitative results of our MAG-NeRF.
We report the rendering quality metrics with PSNR, SSIM (Wang et al., ), and LPIPS (Zhang et al., ), along with the network inference time required to render an image.
MAG-NeRF significantly reduces both inference time and model size by approximately 24% and 30%, respectively, with virtually no loss in reconstruction quality.
Detailed results on each scene is presented in Tables 5, 6 and 7.
Other rendered images are in Figures 8 and detailed ablation studies can be found in Figure 14 as well as in Table 8.

Figure: Figure 2: Results of rendering through NeRF versus MAG-NeRF. The Ground Truth column shows the reference image, followed by the rendered results. The images compare the visual outputs for two scenes: drums (left) and ficus (right).
Refer to caption: x1.png

**Table 1: Comparison between NeRF and our MAG-NeRF on the Synthetic NeRF dataset (Mildenhall et al., ). We report the mean results for all 8 scenes. The inference time refers to the approximate time for forward passes of each model to render a single 400x400 image.**
| Metric | PSNR ($\uparrow$) | SSIM ($\uparrow$) | LPIPS ($\downarrow$) | Inference time ($\downarrow$) (s) | Model Size ($\downarrow$) (MB) |
| --- | --- | --- | --- | --- | --- |
| NeRF | 30.45 | 0.950 | 0.032 | 2.36 | 3.27 |
| MAG-NeRF (ours) | 30.10 | 0.945 | 0.035 | 1.79 | 2.27 |

Figure: (a) Baseline NeRF architecture
Refer to caption: extracted/5922742/network_nerf_baseline.png

#### 4.2.2 Zip-NeRF experiments

Prior works have accelerated NeRF by integrating explicit grid structures with MLPs (Chen et al., ; Sun et al., ; Müller et al., ; Barron et al., ).
By incorporating these explicit structures, networks can encode spatial information more efficiently, reducing the computational burden on MLPs.
Despite these improvements, there remains room for further acceleration within the MLP architectures themselves.
We address this shortcoming using our MAG layers.

We specifically focus on Zip-NeRF (Barron et al., ), which has demonstrated exceptional performance in unbounded scenes and relies on shallow MLPs to decode grid-based features.
We use the Pytorch implementation of Zip-NeRF (Gu, ) for both the baseline and our modification.
Similar to our approach with the baseline NeRF architecture, we identify two consecutive linear layers with ReLU activations within Zip-NeRF and replace the first of these with our MAG layer, resulting in a variant we refer to as MAG-Zip-NeRF.
Since this replacement occurs in only a single place, this experiment serves as an extreme case study for the effectiveness of our method.

Figure 4 and Table 2 present the qualitative and quantitative results.
Despite this minimal modification, we maintain similar rendering quality while improving the rendering speed by 6%.
Figure 9 shows the rendered images for other scenes.

Figure: Figure 4: Rendered images from the Mip-NeRF 360 dataset (Barron et al., ). For each scene, the images from left to right show the Ground Truth, Zip-NeRF, and MAG-Zip-NeRF.
Refer to caption: x2.png

**Table 2: Comparison between Zip-NeRF (Barron et al., ) and MAG-Zip-NeRF on the 360_v2 dataset (Barron et al., ). We report the mean results for all 7 scenes.**
| Metric | PSNR ($\uparrow$) | SSIM ($\uparrow$) | LPIPS ($\downarrow$) | Inference time ($\downarrow$) (s) |
| --- | --- | --- | --- | --- |
| Zip-NeRF | 28.18 | 0.823 | 0.193 | 4.03 |
| MAG-Zip-NeRF (ours) | 27.81 | 0.815 | 0.198 | 3.78 |

#### 4.2.3 Dynamic NeRF experiments

For our final NeRF experiment, we focus on D-NeRF (Pumarola et al., ), which can synthesize novel views of dynamic scenes with complex non-rigid geometries. It represents a dynamic scene using an implicit neural network by modeling the dynamic movement, named deformation network.
We choose Pytorch implementation of D-NeRF (Tang, ) which further integrates the hash-grid (Müller et al., ) to accelerate the training and rendering.
We inject our MAG layer in the deformation network, thereby accelerating the rendering of dynamic NeRF (see Appendix C.4 and Figure 10 for more details).

We present the quantitative results in Table 3 with the rendered images in Figure 11. We achieve a $\mathbf{7\%}$ speedup in inference while maintaining a similar reconstruction quality.

**Table 3: Comparison between D-NeRF and our MAG-D-NeRF on the Dynamic NeRF dataset (Pumarola et al., ). We report the mean results for all 8 scenes.**
| Metric | PSNR ($\uparrow$) | SSIM ($\uparrow$) | LPIPS ($\downarrow$) | Inference time ($\downarrow$) (s) |
| --- | --- | --- | --- | --- |
| D-NeRF | 30.70 | 0.954 | 0.033 | 1.269 |
| MAG-D-NeRF (ours) | 30.26 | 0.948 | 0.038 | 1.177 |

#### 4.2.4 iSDF experiments

In our final application of MAG layers, we explore iSDF (Ortiz et al., ), a real-time module designed to reconstruct SDF from depth sequences. This application highlights the versatility of our method, showcasing its effectiveness in real-time scenarios.
The network architecture consists of a 7-layer MLP (See Figure 12).
We replace Softplus with ReLU for initial speedup and then evaluate whether further acceleration can be achieved with MAG layers (See Appendix D and Figure 13 for justification).

We modify the original iSDF network using a similar strategy as in our NeRF experiments, resulting in our new variant, MAG-iSDF (details are provided in Appendix C.5).
We evaluate the accuracy of our MAG-iSDF in ReplicaCAD (Szot et al., ) sequences using three metrics:
average SDF error ($\text{L1}_{\text{avg}}$) over the entire scene,
surface SDF error ($\text{L1}_{\text{surf}}$) on GT mesh surface,
and the one-way Chamfer Distance (CD) from the reconstructed to the GT mesh.
We also report the training time per step ($t_{\text{train}}$) including sample generation and forward-backward passes,
and inference time ($t_{\text{infer}}$) by measuring 1000 random rays’ forward pass.

In Table 4, we compare the original iSDF with three variants of MAG-iSDF that employ different numbers of random features: 32, 64, and 128.
The results reveal a trade-off between computational speed and reconstruction quality.
However, as shown in Figure 5, when we visualize slices of the reconstructed SDFs on the xy-plane at $z=70\text{ cm}$, the reconstruction quality remains quite similar.

Table: Table 4: Quantitative results of MAG-iSDF. RF is the number of random features, $\text{L1}_{\text{avg}}$ is calculated across all SDF levels, and $\text{L1}_{\text{surf}}$ is for ground truth surface points. $t_{\text{train}}$ refers to iteration time (including backward pass), and $t_{\text{infer}}$ measures forward pass inference time. Results are averaged across 6 ReplicaCAD (Szot et al., ) sequences with 3 random seeds.

Figure: Figure 5: Visualization of reconstructed SDFs in iSDF with a varying number of random features. Each figure shows the reconstructed SDF, following the colormap at the bottom.
Refer to caption: x3.png

Reducing hidden dimensions is a straightforward method to accelerate training.
For fair comparison, we reduce the number of hidden channels in the last layer to 32 and replace the last hidden layer with a MAG layer containing 32 random features.
We evaluate this on the longest sequence, apt_2_nav, from the Replica dataset in iSDF.
In Figure 6, we plot the inference time and Chamfer Distance.
While hidden dimension reduction (DR) reduces inference time at the expense of quality, our MAG layer achieves a similar speed-up while maintaining reconstruction quality.
The bundling process combines the last two layers into a single operation, leading to additional speed-up without compromising quality (Figure 6).

Figure: Figure 6: Comparison of two acceleration methods: hidden dimension reductions (DR) and our magnituder layer (MAG). The left figure shows network inference time and the right figure shows the Chamfer distance of the reconstructed mesh. MAG accelerates the network more efficiently than DR while preserving the reconstruction quality.
Refer to caption: extracted/5922742/isdf_dr_mag.png

### 4.3 Knowledge Distillation with magnituder

In previous sections, we demonstrate that our MAG layer can significantly accelerate the inference time of implicit neural representations.
However, this acceleration requires retraining the model from scratch, a process that is both computationally intensive and time-consuming, especially for complex models like NeRF and Zip-NeRF.

To address this limitation, we introduce a layer distillation mechanism that eliminates the need for retraining on a per-scene basis.
This method allows us to accelerate existing, pretrained models without having to rebuild them from the ground up.
By storing the inputs and outputs of the target hidden layer in trained implicit neural representations, and then optimizing the MAG layer using a mean squared error objective, we can efficiently replicate the behavior of the original model. This optimization can be performed without the need for backpropagation due to the existence of a closed-form solution (Additional details in Section B).

First, we distill a pretrained Zip-NeRF model with a MAG layer and test the distillation in bicycle dataset (additional details are provided in Appendix C.3).
We set the number of random features to 64, with additional ablations provided in Appendix D.3 (Figure 15 and Table 9).
The qualitative results of the distillation are shown in Figure 7.
Notably, this distillation process is lightning fast, taking only $\mathbf{0.12}$ seconds on a single RTX 4090, thanks to the closed-form solution for the input-output pairs.
Since we use the same number of random features as in Section 4.2.2, we achieve the same $\mathbf{6\%}$ rendering acceleration without needing to train from scratch.

We also test the distillation in the last hidden layer of iSDF (Ortiz et al., ).
In Figure 7, we visualize the reconstructed SDF and the extracted zero level-set mesh from apt_2_nav dataset. Our results indicate that the reconstruction quality of the distilled MAG-iSDF is comparable to that of the baseline iSDF, with a $\mathbf{9\%}$ improvement in inference speed.

Figure: (a) Zip-NeRF
Refer to caption: x4.png

## 5 Conclusion

We introduce a novel type of neural network layer, termed ‘magnituders’, which can efficiently approximate the computations of ReLU and Softplus linear layers. By integrating magnituders into Neural Radiance Fields (NeRF) and Signed Distance Fields (SDF) models, we achieve a reduction in training parameters while preserving expressivity. Our approach enhances inference speed and adaptability for real-time robotic applications. Additionally, the straightforward design of magnituders facilitates layer-wise knowledge distillation without requiring backpropagation. We demonstrate that this distillation process leads to efficient inference.

## Author Contributions

SMK ran all the iSDF experiments along with all the ablations and most of NERF experiments. BK ran several NeRF and Zip-NeRF experiments. AS and KC led the project. AS implemented the MAG layers and ran small scale experiments. KC provided theoretical analysis for the MAG layers. DS ran several D-NeRF experiments. AD and MO were senior advisors for the project. All authors contributed to the writing of the manuscript.

## Ethics Statement

This paper focuses mostly on developing novel neural network layers that can lower the computation footprint of certain feedforward layers. The experiments with
NeRF and iSDF illustrate how this method can lower the inference speed while remaining competitive with the baselines. It should be
noted though that even though these models are widely used, these models have considerable computational
footprint and thus the corresponding carbon footprint.

## Reproducibility Statement

Details and the code pointers to reproduce each experiment are provided in Appendix C.

## Appendix A Compressing Networks by Combining Layers

For training NERF, we use a RF layer followed by a linear layer. In this section, we explain how this choice of architecture allows for more efficient inference. In this section, we use the PyTorch convention of describing a linear layer.

Recall the RF layer be given by the following equation :

$$ $~{}\mathbf{Y}_{1}=\phi_{2}(\mathbf{X_{1}})\mathbf{W_{1}}^{\top}$ (8) $$

If the RF layer is followed by the linear layer with weight $\mathbf{W}_{2}$ and bias $\mathbf{b}_{2}$, then

$$ $\displaystyle\mathbf{Y}_{2}$ $\displaystyle=\mathbf{Y_{1}W_{2}}^{\top}+\mathbf{b_{2}}$ $\displaystyle=\phi_{2}(\mathbf{X_{1}})\mathbf{W_{1}}^{\top}\mathbf{W_{2}}^{ \top}+\mathbf{b_{2}}$ $\displaystyle=\phi_{2}(\mathbf{X_{1}})\mathbf{\hat{W}}_{2}^{\top}+\mathbf{b_{2}}$ $$

where $\mathbf{\hat{W}}_{2}:=\mathbf{W_{2}}\mathbf{W_{1}}$.

Note that the above compression works when a non-linearity is applied on the weights (as in the case of (Sehanobish et al., )) or an optional bias in Equation 8.

This simple compression technique allows us to collapse the final 2 layers in our iSDF experiments allowing for more efficient inference.

## Appendix B Knowledge Distillation Made Easy

The simple form of the RF layer makes knowledge distillation particularly simple.

To be precise, we want to train a MAG layer $\mathcal{M}$ to match the outputs of a trained FFL using MSE as the metric. If $\mathbf{x}$ (resp. $\mathbf{y}$) is the input (resp. output of a trained FFL, we want to find the weights $\mathbf{\hat{W}}$, which minimizes the following error :

$$ $||\mathcal{M}_{\mathbf{W}}(\mathbf{x})-\mathbf{y}||_{2}$ $$

The optimal $\mathbf{\hat{W}}$ has a closed form :

$$ $\mathbf{\hat{W}}=(\mathbf{x^{\prime}}^{\top}\mathbf{x}^{\prime})^{-1}\mathbf{x }^{\prime\top}\mathbf{y}$ (9) $$

where $\mathbf{x^{\prime}}:=\text{ReLU}(\mathbf{Gx})$, $\mathbf{G}$ is an (orthogonal) random matrix.

The above solution is clearly unique iff $\mathbf{x}^{\prime\top}\mathbf{x}^{\prime}$ is invertible. In the case where $\mathbf{x}^{\prime\top}\mathbf{x}^{\prime}$ is not invertible, one can replace the inverse by the Moore-Penrose pseudoinverse.

Thus the problem of distilling specific input-output pairs in the MAG layer can be solved without backpropagation.

## Appendix C Experimental Details

In this section, we provide additional details for the experiments in our main paper.
We will release the code for the MAG layer shortly.

### C.1 Synthetic Experiments

In this subsection, we provide additional experimental details for the synthetic experiments.
For these experiments, 10,000 samples are drawn randomly from the range $(0,1)$ with a dimension of $512$, and are then passed through a Linear layer of shape $(512,512)$.
Non-linearity of ReLU (resp. Softplus) is applied on the outputs of the linear layer.
Our aim is to show that our MAG-layer can accurately approximate these outputs.

We use the SNNK layers (Sehanobish et al., ) as a baseline. We train MAG and SNNK layers for 1k epochs with $8,16,32,64,128,256,512$ random features using the Adam optimizer (Kingma, ). We repeat this experiment 10 times and report the average time vs the MSE loss across the replicates. This experiment is run on free Google Colab equipped with a T4 GPU with 12Gb of RAM.

We show that our new MAG layers can accurately approximate the outputs of these linear layers while SNNKs struggle to fit the data.

### C.2 NeRF Experiments

**Table 5: PSNR of rendered images for NeRF reconstruction in Synthetic NeRF Mildenhall et al. () dataset. Higher is better.**
| Scene | chair | drums | ficus | hotdog | lego | materials | mic | ship |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NeRF | 33.70 | 25.46 | 26.40 | 35.81 | 31.31 | 29.00 | 33.11 | 28.79 |
| MAG-NeRF | 32.76 | 24.92 | 28.11 | 35.22 | 30.14 | 28.62 | 32.42 | 28.61 |

**Table 6: SSIM of rendered images for NeRF reconstruction in Synthetic NeRF Mildenhall et al. () dataset. Higher is better.**
| Scene | chair | drums | ficus | hotdog | lego | materials | mic | ship |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NeRF | 0.978 | 0.930 | 0.939 | 0.979 | 0.965 | 0.956 | 0.979 | 0.870 |
| MAG-NeRF | 0.972 | 0.922 | 0.958 | 0.975 | 0.952 | 0.951 | 0.975 | 0.857 |

**Table 7: LPIPS of rendered images for NeRF reconstruction in Synthetic NeRF Mildenhall et al. () dataset. Lower is better.**
| Scene | chair | drums | ficus | hotdog | lego | materials | mic | ship |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NeRF | 0.013 | 0.049 | 0.048 | 0.012 | 0.017 | 0.021 | 0.020 | 0.074 |
| MAG-NeRF | 0.019 | 0.056 | 0.025 | 0.017 | 0.025 | 0.025 | 0.026 | 0.084 |

Figure: Figure 8: Rendered images from the Synthetic NeRF dataset (Mildenhall et al., ). For each scene, the images from left to right show the Ground Truth, NeRF (Mildenhall et al., ), and MAG-NeRF.
Refer to caption: x6.png

In NeRF experiments, we use the default configuration of the Pytorch implementation of NeRF (Yen-Chen, ).
The inference time is computed using a single NVIDIA RTX 4090 and an AMD Ryzen 7 7700 8-Core Processor.
All tests are conducted on the Synthetic NeRF dataset (Mildenhall et al., ), and the details of our architecture choices are illustrated in Figure 3.
In our experiments, we set the number of random features to 256, with additional results for the different number of random features provided in Section D.2.

We report the detailed results for each scene in Tables 5, 6 and 7 and the rendering results are in Figure 8.

### C.3 Zip-NeRF Experiments

Figure: Figure 9: Rendered images from the Mip-NeRF 360 dataset (Barron et al., ). For each scene, the images from left to right show the Ground Truth, Zip-NeRF (Barron et al., ), and MAG-Zip-NeRF.
Refer to caption: x7.png

Zip-NeRF is an extension of Mip-NeRF 360 (Barron et al., ), integrating explicit hash-grid for acceleration (Müller et al., ).
The architecture consists of two shallow proposal MLPs, which help determine where samples should be placed, and a NeRF MLP, responsible for generating the final color output.
We find that accelerating the proposal MLPs was challenging due to their shallow architecture and low-dimensional mapping (6 $\rightarrow$ 64 $\rightarrow$ 1).
So we choose NeRF MLP as our acceleration target, and we select the view-dependent part of MLP, which consists of two consecutive linear ReLU layers.

In all experiments, we use the default configuration of the PyTorch implementation of Zip-NeRF (Gu, ) on Mip-NeRF 360 dataset (Barron et al., ).
The computational resources used for calculating rendering time are consistent with those in the NeRF experiments.
However, due to hardware limitations, we reduce the ray batch size from 65,536 to 4,096, preventing out-of-memory issues.
We set the number of random features to 64 for the MAG layer.
All rendered images from Mip-NeRF 360 dataset can be shown in Figure 9.

For the distillation process, we need to get the input-output pairs from the pre-trained models.
However, rendering a single image through the volume rendering process (Kajiya & Von Herzen, ) requires a large number of samples, which causes some memory issues if we use all of the samples for distillation.
To address this, we reduce the sample size by selecting 1/16 of the images from the dataset and rendering them at 1/8 of the original training resolution.
Additionally, we minimize the sample size by randomly subsampling 10% of the input-output pairs, ensuring the distillation process fits within our hardware limits and works efficiently.

### C.4 D-NeRF Experiments

Figure: (a) D-NeRF architecture
Refer to caption: extracted/5922742/network_dnerf_baseline.png

D-NeRF (Pumarola et al., ) extends NeRF to represent dynamic scenes using a deformation network.
When rendering an image, the deformation network takes the position and time as inputs, producing a 3-dimensional offset that captures the current positional shift.
This offset allows the ray to bend, simulating how the scene moves over time.

We use Pytorch implementation (Tang, ) for D-NeRF, which integrates the hash-grid (Müller et al., ) for further acceleration.
Since it exploits the explicit grid structure, the network is shallower than the original D-NeRF.
To accelerate this model, we target the deformation network, by replacing two of its layers with our MAG layers (See Figure 10 for more details).

For a fair apple-to-apple comparison between the baseline and our MAG variants, we minimize randomness by disabling certain acceleration methods in the implementation.
Specifically, we use the preload configuration and remove other acceleration options to ensure consistency across experiments.

Figure: Figure 11: Rendered images from the D-NeRF dataset (Pumarola et al., ). For each scene, the images from left to right show the Ground Truth, D-NeRF (Pumarola et al., ; Tang, ), and MAG-D-NeRF.
Refer to caption: x8.png

### C.5 iSDF Experiments

Figure: (a) Baseline iSDF architecture
Refer to caption: extracted/5922742/network_isdf_baseline.png

Figure 12 shows the baseline iSDF (Ortiz et al., ) and the modified MAG-iSDF architectures.
We use six ReplicaCAD (Szot et al., ) scenes, following original iSDF (Ortiz et al., ) paper.
In all experiments, we use the default configuration of public available iSDF code while replacing only the SDF network with our MAG-iSDF.

To evaluate efficiency, we report two time-related metrics: training time and inference time.
However, it’s important to note that, as iSDF is an incrementtal mapping module, the number of keyframes can vary between different experiment runs.
Because the sample size is proportional to the number of keyframes, training time may not serve as a perfect measure of the network’s efficiency.
To account for this, we also report inference time, which is measured by sampling 1000 random rays and recording the time taken for a single forward pass through the network.

## Appendix D Additional experiments

In this section, we present additional experiments on (a) justifying the use of ReLU over Softplus (Section D.1), (b) ablation studies (Section D.2, D.3), and (c) justify the choice of using ORF in our MAG layers.

### D.1 ReLU over Softplus in iSDF

Figure: Figure 13: Error visualization comparing ground truth and reconstructed SDF using various activation functions. The first column displays the average error. The subsequent rows illustrate errors across different ranges of ground truth SDF values. In robotics scenarios such as grasping or manipulation, achieving more precise reconstruction, particularly for lower SDF values as shown in the first row, is crucial.
Refer to caption: x9.png

As our goal is to explore how far we can accelerate using MAG layers, we first investigate potential speed improvements in the baseline model before making modifications.
We found that replacing Softplus with ReLU results in faster inference with minimal quality degradation.
Specifically, this change causes a slight performance decrease for distances $s\geq 100\,\text{cm}$ (see Figure 13).
However, since surface information is critical for robotics tasks such as manipulation or navigation, we exploit ReLU activation in our iSDF experiments both in baseline (iSDF) and MAG-iSDF to prioritize network speed.

### D.2 Effect of Number of Random Features in MAG-NeRF

In this experiment, we investigate how the number of random features affects the quality of MAG-NeRF. We evaluate three scenes: hotdog, materials, and drums, which represent easy, medium, and hard cases, respectively, based on rendering quality in Table 1. We test models with 16, 32, 64, 128, and 256 random features.

We present the qualitative and quantitative results of the number of random features in MAG-NeRF in Figure 14 and Table 8.
Using a small number of random features, like 16, results in approximately a twofold acceleration compared to the baseline model.

Figure: Figure 14: Comparison of rendering results with varying numbers of random features in MAG-NeRF. The numbers at the top indicate the number of random features used for each specific MAG-NeRF model. The ground truth image is on the left, while the right shows zoomed-in views of each reconstruction.
Refer to caption: x10.png

Table: Table 8: Comparison between NeRF and our random feature mechanism on the drums dataset. The inference time refers to the approximate time for forward passes of each model to render a single 400x400 image.

### D.3 Effect of Number of Random Features in Zip-NeRF Distillation

When distilling a linear ReLU layer into our MAG layer, the number of random features must to be set.
This choice impacts the quality and acceleration trade-off.
In Figure 15 and Table 9, we present an ablation study to illustrate how the number of random features affects the distillation process.

Figure: Figure 15: Comparison of rendering results with varying numbers of random features in Zip-NeRF distillation. The numbers at the top indicate the number of random features. Rendering from the target pretrained model is on the left, with zoomed-in views of each reconstruction on the right.
Refer to caption: x11.png

**Table 9: PSNR of rendered images and inference time for pretrained Zip-NeRF and MAG layer distillation using various number of random features on the bicycle dataset (Barron et al., ).**
|  | Pretrained | 32 | 64 | 128 | 256 | 512 |
| --- | --- | --- | --- | --- | --- | --- |
| PSNR ($\uparrow$) | 23.66 | 20.72 | 21.06 | 21.55 | 21.72 | 22.06 |
| Inference time ($\downarrow$) (s) | 4.03 | 3.76 | 3.78 | 3.86 | 4.06 | 4.43 |

### D.4 Orthogonal Random Features in MAG

In this subsection, we show that ORFs in MAG produce better approximation quality than random projections.

Figure: Figure 16: Comparing the approximation capability of our MAG layer with orthogonal random features vs random features. (Left) : Approximating a ReLU-Linear layer. (Right) : Approximating a Softplus-Linear layer.
Refer to caption: extracted/5922742/mag_vs_orf_relu.png

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: Please see weaknesses.
soundness: 2
strengths: 1. This paper performs extensive experiments to thoroughly demonstrate the capability of the proposed method.
2. The proposed method improves inference speed and reduces the model size of implicit 3D representations.
summary: This paper proposes a novel neural network layer called the "Magnituder," designed to reduce the number of training parameters in implicit 3D representation models like NeRF and SDF. The proposed method can also be integrated into pretrained NeRF models without additional optimization. Extensive experiments on multiple datasets and tasks demonstrate that this approach achieves faster inference speed and reduced model size.
weaknesses: 1. While the proposed neural network achieves speedup and compression, it does so at the cost of rendering quality. This seems more like a trade-off than a true improvement, as there are other methods in 3D representation, such as 3D Gaussian Splatting, Instant-NGP, and Neus2, that significantly increase inference speed (up to 10x) without compromising rendering quality. This limitation diminishes the significance of the contribution.
2. A simple baseline may achieve similar effects to the proposed method by reducing the number of layers in the original MLP. This approach could also reduce parameters and increase inference speed, potentially affecting rendering quality. The authors are encouraged to include this comparison.
3. The proposed Magnituder layer lacks any designs specifically for 3D tasks. As a general layer that can be integrated into MLPs, it could also be applied to other tasks like classification, or in models with MLP components like ResNet or Transformer. To fully demonstrate the benefits of this layer, it would be valuable to test it on other tasks as well.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. As MAG is a lossy acceleration method, you can also reduce the number of parameters used in baseline NeRF MLP to make it faster but with a slightly lower quality. For example in Fig 3., you can reduce the hidden feature size in the baseline NeRF to match the random feature size in the corresponding red block in the MAG-NeRF. In this case, does MAG-NeRF still perform better in quality and speed?
2. How about the speedup on the training time?
soundness: 2
strengths: * The proposed method is well-analyzed through kernel estimation methods and the theoretical comparison with the prior approach SNNK. This makes the proposed method technically sound.
* The authors apply MAG-layers in multiple applications, which is appreciated.
summary: This work presents a new neural network layer, magnituder (MAG), to improve the efficiency of MLP models used on implicit neural representations (NeRF, SDF, etc.). Magnituder disentangles the weights and inputs of MLP layers by injecting a mapping function operating on the magnitude of the input. The design of magnituder is supported by the analysis of the approximation of kernel methods. Magnituder does provide improvements in inference speed and model size but not significant.
weaknesses: Although the paper introduces an interesting new layer with some random features to speed up MLP models used in implicit neural representations, the improvements from their results are not that exciting (compared to other NeRF acceleration works in recent years). Other than the original NeRF, the proposed MAG layers can only provide less than 10% inference speed improvements. Besides, this marginal inference speedup is also at the cost of a quality drop.

Given the current trend towards neural 3D representations that use very few and tiny MLP layers or even no MLP layers (e.g., InstantNGP, 3DGS), the benefits of applying MAG-layers to such architectures would likely be very insignificant.

It would be better to see if the MAG-layers could be beneficial for other applications that use a lot of MLP layers, not just on implicit neural representations.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: Considering the aforementioned strengths and weaknesses, I tend to give a reject as the initial rating. The authors are also encouraged to refer to the weaknesses for rebuttal.
- I personally consider the effectiveness of MAG can be explained intuitively by dictionary learning. The $W$ can be seem as a learnable dictionary to model a sparse mapping from $x$ to the next layer. Can the authors provide more insights towards the mechanism of MAG? Also, is there any potential connection between MAG and separable convolution which decouples channels from tensors.
- Zip-NeRF is known for its large memory consumption (referring to NeRF-baselines). Is it possible to reduce the massive overheads by applying MAG layers or the improvement can only be time-wise?
- How does the proposed method perform compared to common acceleration techniques? The aim of this question is to confirm the contribution of MAG is not trivial and not easily achieved by other simple operations.
- How does the MAG-inserted MLP converge? Will there be a different tendency compared to vanilla MLP?
soundness: 3
strengths: - The paper attempts to solve the problem of computational costs in the filed of Implicit Neural Representation, which is clearly motivated and significant for making INRs more scalable.
- The proposed MAG layers follow a plug-and-play fashion, making the integration into most of MLP-based INRs easy and fast, which would be greatly valued by the users. The core idea of simplifying the computation of FC layer is interesting.
- The experiments do showcase certain effectiveness of the MAG layers in terms of reducing the inference time at a cost of some performance.
summary: This paper proposes a novel neural network layer, named MAG (magnituder), that is able to decouple the computation of inputting and weights parameters, thus accelerating the computation. The authors validate the effectiveness of MAG layers by inverse graphics (static, dynamic, and geometry) by reforming NeRF, Zip-NeRF, D-NeRF, and iSDF. The results show that the proposed MAG layers manage to accelerate the computation with small performance drop.
weaknesses: - The elaboration of the adopted methods (Sec.3) is somehow not sufficient to me. The authors are encouraged to include another illustration or pseudo code to better describe their method.
- Though the connection between MAG and SNNK is covered, such strategy for simplification still requires comparison between other well-known alternatives, e.g., distillation, pruning, and also separable convolution.
- The overall writing of this manuscript is not informative. For example, Sec.2 is a comprehensive but meaningless review of the applications of INRs, which is not closely related to the scope of the manuscript. Instead, the authors are supposed to include more strategies for simplifying or accelerating INRs.
- The quantitative results are not satisfactory enough to match the claimed contribution. A universal decline of performance can be witnessed across basically all use cases under all evaluation metrics while the acceleration is just marginal. Besides, the measure of computational costs should cover more aspects in addition to just time, which can be easily affected by complicated factors.

Meta-review: This submission proposes a new network layer, towards enabling efficiency improvements for implicit neural representation (INR) tasks. The paper draws on inspiration from kernel method approximations, where input magnitudes are considered in order to disentangle them from MLP layer weights. Experimental work evidences improvements in inference speed and model size, across various tasks.

The paper received reviews from three reviewers that collectively note core idea technical-soundness and thorough experimental investigation. The crux of the shared common concerns relate to the limited significance of the work, within the context of 3D reconstruction, and the potential low impact. Multiple reviewers suggest to generalise and better position the contributions, as applicable beyond INR.

AC believes that additions and narrative refinements resuting from the rebuttal can likely benefit from a further round of review and therefore recommends rejection. Authors are encouraged to use the collective feedback to strengthen the work towards submission at an alternative venue.

Decision: Reject