Study on the applicability of Direct Feedback Alignment to neural view synthesis, recommender systems, geometric learning, and natural language processing.
Despite being the workhorse of deep learning, the backpropagation algorithm is no panacea. It enforces sequential layer updates, thus preventing efficient parallelization of the training process. Furthermore, its biological plausibility is being challenged. Alternative schemes have been devised; yet, under the constraint of synaptic asymmetry, none have scaled to modern deep learning tasks and architectures. Here, we challenge this perspective, and study the applicability of Direct Feedback Alignment to neural view synthesis, recommender systems, geometric learning, and natural language processing. In contrast with previous studies limited to computer vision tasks, our findings show that it successfully trains a large range of state-of-the-art deep learning architectures, with performance close to fine-tuned backpropagation. At variance with common beliefs, our work supports that challenging tasks can be tackled in the absence of weight transport.READ FULL TEXT VIEW PDF
Current algorithms for deep learning probably cannot run in the brain be...
This work shows that a differentiable activation function is not necessa...
Current algorithms for deep learning probably cannot run in the brain be...
While the backpropagation of error algorithm allowed for a rapid rise in...
The scaling hypothesis motivates the expansion of models past trillions ...
Language evolves over time in many ways relevant to natural language
The last decade has witnessed an experimental revolution in data science...
Study on the applicability of Direct Feedback Alignment to neural view synthesis, recommender systems, geometric learning, and natural language processing.
While the backpropagation algorithm (BP) Werbos:74; Rumelhart:86 is at the heart of modern deep learning achievements, it is not without pitfalls. For one, its weight updates are non-local and rely on upstream layers. Thus, they cannot be easily parallelized jaderberg2017decoupled, incurring important memory and compute costs. Moreover, its biological implementation is problematic crick1989recent; marblestone2016toward. For instance, BP relies on the transpose of the weights to evaluate updates. Hence, synaptic symmetry is required between the forward and backward path: this is implausible in biological brains, and known as the weight transport problem grossberg1987competitive.
Consequently, alternative training algorithms have been developed. Some of these algorithms are explicitly biologically inspired movellan1991contrastive; o1996biologically; salakhutdinov2009deep; le1986learning; bengio2014auto; lee2015difference; lillicrap2016random, while others focus on making better use of available compute resources belilovsky2019greedy; jaderberg2017decoupled; czarnecki2017sobolev; nokland2019training; hjelm2018learning; lowe2019putting; nokland2016direct. Despite these enticing characteristics, none has been widely adopted, as they are often demonstrated on a limited set of tasks. Moreover, as assessed in bartunov2018assessing, their performance on challenging datasets under the constraint of synaptic asymmetry is disappointing.
We seek to broaden this perspective, and demonstrate the applicability of Direct Feedback Alignment (DFA) nokland2016direct in state-of-the-art settings: from applications of fully connected networks such as neural view synthesis and recommender systems, to geometric learning with graph convolutions, and natural language processing with Transformers. Our results define new standards for learning without weight transport and show that challenging tasks can indeed be tackled under synaptic asymmetry.
All code needed to reproduce our experiments is available at https://github.com/lightonai/dfa-scales-to-modern-deep-learning.
Training a neural network is a credit assignment problem: an update is derived for each parameter from its contribution to a cost function. To solve this problem, a spectrum of algorithms existslillicrap2020backpropagation.
Finding a training method applicable under the constraints of biological brains remains an open problem. End-to-end propagation of gradients is unlikely to occur caporale2008spike, implying local learning is required. Furthermore, the weight transport problem enforces synaptic asymmetry grossberg1987competitive. Inspired by auto-encoders, target propagation methods (TP) le1986learning; bengio2014auto; lee2015difference train distinct feedback connections to invert the feedforward ones. Feedback alignment (FA) lillicrap2016random
replaces the transpose of the forward weights used in the backward pass by a random matrix. Throughout training, the forward weights learn toalign with the arbitrary backward weights, eventually approximating BP.
As deep learning models grow bigger, large-scale distributed training is increasingly desirable. Greedy layer-wise training belilovsky2019greedy
allows networks to be built layer by layer, limiting the depth of backpropagation. To enable parallelization of the backward pass, updates must only depend on local quantities. Unsupervised learning is naturally suited for this, as it relies on local losses such as Deep InfoMaxhjelm2018learning and Greedy InfoMax lowe2019putting. More broadly, synthetic gradient methods, like decoupled neural interfaces jaderberg2017decoupled; czarnecki2017sobolev and local error signals (LES) nokland2019training, approximate gradients using layer-wise trainable feedback networks. DFA nokland2016direct expands on FA and directly projects a global error to each layer. A shared feedback path is still needed, but it only depends on a simple random projection operation.
Local training methods are successful in unsupervised learning lowe2019putting
. Even in a supervised setting, they scale to challenging datasets like CIFAR-100 or ImageNetnokland2019training; belilovsky2019greedy. Thus, locality is not too penalizing. However, TP, FA, and DFA are unable to scale to these tasks bartunov2018assessing. In fact, DFA is unable to train convolutional layers launay2019principled. To enable feedback alignment techniques to perform well on challenging datasets, some form of weight transport is necessary: either by explicitly sharing sign information liao2016important; moskovitz2018feedback; xiao2018biologicallyplausible, or by introducing dedicated phases of alignment for the forward and backward weights where some information is shared akrout2019using. To the best of our knowledge, no method compatible with the weight transport problem has ever been demonstrated on challenging tasks.
We focus on DFA, a compromise between biological and computational considerations. Notably, DFA is compatible with synaptic asymmetry: this asymmetry raises important challenges, seemingly preventing learning in demanding settings. Moreover, it allows for asynchronous weight updates, and puts a single operation at the center of the training stage. This enables new classes of training co-processors launay2020lightintheloop; frenkel2020bottom, leveraging dedicated hardware to perform the random projection.
We apply DFA in a large variety of settings matching current trends in machine learning. Previous works have found that DFA is unsuitable for computer vision tasksbartunov2018assessing; launay2019principled; but computer vision alone cannot be the litmus test of a training method. Instead, we consider four vastly different domains, across eight tasks, and with eleven different architectures. This constitutes a survey of unprecedented scale for an alternative training method, and makes a strong case for the possibility of learning without weight transport in demanding scenarios.
We demonstrate the ability of DFA to tackle challenging tasks. We successfully learn and render real-world 3D scenes (section 3.1.1); we perform recommendation at scale (section 3.1.2); we explore graph-based citation networks (section 3.2); and we consider language modelling with a Transformer (section 3.3). We study tasks at the state-of-the-art level, that have only been recently successfully tackled with deep learning.
We prove that the previously established failure of DFA to train convolutions does not generalize. By evaluating performance metrics, comparing against a shallow baseline, measuring alignment, and visualizing t-SNE embeddings, we show that learning indeed occurs in layers involving graph convolutions and attention. This significantly broadens the applicability of DFA–previously thought to be limited to simple problems like MNIST and CIFAR-10.
In a fully connected network, at layer out of , neglecting its biases, with its weight matrix, its non-linearity, and its activations, the forward pass is:
is the input data, and are the predictions. A task-specific cost function is computed to quantify the quality of the predictions with respect to the targets .
The gradient signal of the (i+1)-th layer violates synaptic asymmetry. DFA replaces it with a random projection of the topmost derivative of the loss, . For common classification and regression losses such as the mean squared error or the negative log likelihood, this corresponds to a random projection of the global error . With , a fixed random matrix of appropriate shape drawn at initialization for each layers:
We study the applicability of DFA to a diverse set of applications requiring state-of-the-art architectures. We start with fully connected networks, where DFA has already been demonstrated, and address new challenging settings. We then investigate geometric learning: we apply DFA to graph neural networks in classification tasks on citation networks, as well as graph autoencoders. These architectures feature graph convolutions and attention layers. Finally, we use DFA to train a transformer-based Natural Language Processing (NLP) model on a dataset of more than 100 million tokens.
DFA has been successful at training fully connected architectures, with performance on-par with backpropagation nokland2016direct; bartunov2018assessing. However, only computer vision tasks have been considered, where fully connected networks considerably underperform their convolutional counterpart. Here, we focus on tasks where fully connected architectures are state-of-the-art. Moreover, the architectures considered are deeper and more complex than those necessary to solve a simple task like MNIST.
The most recent state-of-the-art neural view synthesis methods are based on large fully connected networks: this is an ideal setting for a first evaluation of DFA on a challenging task.
There has been growing interest in methods capable of synthesising novel renders of a 3D scene using a dataset of past renders. The network is trained to learn an inner representation of the scene, and a classical rendering system can then query the model to generate novel views. With robust enough methods, real-world scenes can also be learned from a set of pictures.
Until recently, most successful neural view synthesis methods were based on sampled volumetric representations penner2017soft; flynn2019deepview; mildenhall2019local
. In this context, Convolutional Neural Networks (CNNs) can be used to smooth out the discrete sampling of 3D spacesitzmann2019deepvoxels; lombardi2019neural. However, these methods scale poorly to higher resolutions, as they still require finer and finer sampling. Conversely, alternative schemes based on a continuous volume representation have succeeded in generating high-quality renders sitzmann2019scene, even featuring complex phenomenons such as view-dependant scattering mildenhall2020nerf. These schemes make point-wise predictions, and use fully connected neural networks to encode the scene.
We employ Neural Radiance Fields (NeRF) mildenhall2020nerf, the state-of-the-art for neural view synthesis. NeRF represents scenes as a continuous 5D function of space–three spatial coordinates, two viewing angles–and outputs a point-wise RGB radiance and opacity. A ray-casting renderer can then query the network to generate arbitrary views of the scene. The network modeling the continuous function is 10 layers deep. Two identical networks are trained: the coarse network predictions inform the renderer about the spatial coordinates that the fine network should preferentially evaluate to avoid empty space and occluded regions.
Peak Signal to Noise Ratio (PSNR, higher is better) of neural view synthesis methods trained with backpropagation against NeRF trained with DFA. Even when trained with DFA, NeRF outperforms two state-of-the-art methods on a synthetic dataset (NeRF-Synthetic), and achieves fair performance on a challenging real world views datasets (LLFF-Real). BP results frommildenhall2020nerf.
On a dataset of renders featuring complex scenes with non-Lambertian materials (NeRF-Synthetic mildenhall2020nerf
), NeRF-DFA outperforms two previous fine-tuned state-of-the-art methods–Scene Representation Networks (SRN)sitzmann2019scene and Local Light Field Fusion (LLFF) mildenhall2019local–and nearly matches the performance of Neural Volumes (NV) lombardi2019neural. While DFA underperforms alternative methods trained with BP on the real world view dataset (LLFF-Real mildenhall2019local), its performance remains significant: real world view synthesis is a challenging tasks, and this level of PSNR indicates that learning is indeed happening.
In particular, we find that NeRF-DFA retains the key characteristics of NeRF-BP: it can render view-dependant effects, and is multi-view consistent. The last point is an especially important achievement, and most visible in videos, as it is a challenge for most algorithms penner2017soft; flynn2019deepview; mildenhall2019local; sitzmann2019scene. The main drawback of NeRF-DFA appears to be a seemingly lower render definition. The NeRF architecture has not been fine-tuned to achieve these results: DFA works out-of-the-box on this advanced method. Future research focusing on architectural changes to NeRF could improve performance with DFA; some preliminary results are included in the supplementary material.
We have demonstrated that DFA can train large fully connected networks on the difficult task of neural view synthesis. We now seek to use DFA in more complex heterogeneous architectures, combining the use of fully connected networks with other machine learning methods. Recommender systems are an ideal application for such considerations.
Recommender systems are used to model the behavior of users and predict future interactions. In particular, in the context of click-through rate (CTR) prediction, these systems model the probability of a user clicking on a given item. Building recommender systems is hardmcmahan2013ad: their input is high-dimensional and sparse, and the model must learn to extract high-order combinatorial features from the data. Moreover, they need to do so efficiently, as they are used to make millions of predictions and the training data may contain billions of examples.
Factorization Machines (FM) rendle2010factorization use inner-products of latent vectors between features to extract pairwise feature interactions. They constitute an excellent baseline for shallow recommender systems, but fail to efficiently transcribe higher-level features. To avoid extensive feature engineering, it has been suggested that deep learning can be used in conjunction with wide shallow models to extract these higher-level features cheng2016wide. In production, these systems are regularly retrained on massive datasets: the speedup allowed by backward unlocking in DFA is thus of particular interest.
Deep Factorization Machines (DeepFM) guo2017deepfm combine FM and a deep fully connected neural network, which we train with DFA. The input embedding is still trained directly via gradient descent, as weight transport is not necessary to backpropagate through the FM. Deep & Cross Networks (DCN) wang2017deep replace the FM with a Cross Network, a deep architecture without non-linearities capable of extracting high-degree interactions across features. We train the fully connected network, the deep cross network, and the embeddings with DFA. Finally, Adaptative Factorization Network (AFN) cheng2019adaptive uses Logarithmic Neural Networks hines1996logarithmic to enhance the representational power of its deep component. We evaluate these methods on the Criteo dataset criteo, which features nearly 46 million samples of one million sparse features. This is a difficult task, where performance improvements of the AUC on the 0.001-level can enhance CTR significantly cheng2016wide.
Performance metrics are reported in Table 2
. To obtain these results, a simple hyperparameter grid search over optimization and regularization parameters was performed for BP and DFA independently. DFA successfully trains all methods above the FM baseline, and in fact matches BP performance in both DeepFM and AFN. Because of their complexity, recommender systems require intensive tuning and feature engineering to perform at the state-of-the-art level–and reproducing existing results can be challengingdacrema2019we. Hence, it is not surprising that a performance gap exists with Deep&Cross–further fine-tuning may be necessary for DFA to reach BP performance.
Alignment measurements corroborate that learning is indeed occurring in the special layers of Deep&Cross and AFN–see supplementary for details. Our results on recommender systems support that DFA can learn in a large variety of settings, and that weight transport is not necessary to solve a difficult recommendation task.
The use of sophisticated architectures beyond fully connected layers is necessary for certain tasks, such as geometric learning bronstein2017geometric, where information lies in a complex structured domain. To address geometric learning tasks, methods capable of handling graph-based data are commonly needed. Graph convolutional neural networks (GCNNs) bruna2014spectral; henaff2015deep; defferrard2016convolutional; kipf2017semi have demonstrated the ability to process large-scale graph data efficiently. We study the applicability of DFA to these methods, including recent architectures based on an attention mechanism. Overall, this is an especially interesting setting, as DFA fails to train more classic 2D image convolutional layers launay2019principled.
Complex data like social networks or brain connectomes lie on irregular or non-Euclidean domains. They can be represented as graphs, and efficient processing in the spectral domain is possible. Non-spectral techniques to apply neural networks to graphs have also been developed gori2005new; scarselli2008graph; li2015gated
, but they exhibit unfavorable scaling properties. The success of CNNs in deep learning can be attributed to their ability to efficiently process structured high-dimensional data by sharing local filters. Thus, a generalization of the convolution operator to the graph domain is desirable:bruna2014spectral first proposed a spectral convolution operation for graphs, and henaff2015deep
introduced a form of regularization to enforce spatial locality of the filters. We use DFA to train different such GCNNs implementations. We study both spectral and non-spectral convolutions, as well as methods inspired by the attention mechanism. We consider the task of semi-supervised node classification: nodes from a graph are classified using their relationship to other nodes as well as node-wise features.
Fast Localized Convolutions (ChebConv) defferrard2016convolutional approximate the graph convolution kernel with Chebyshev polynomials, and are one of the first scalable convolution methods on graph. Graph Convolutions (GraphConv) kipf2017semi remove the need for an explicit parametrization of the kernel by enforcing linearity of the convolution operation on the graph Laplacian spectrum. It is often considered as the canonical graph convolution. More recent methods do not operate in the spectral domain. Spline Convolutions (SplineConv) fey2018splinecnn use a spline-based kernel, enabling the inclusion of information about the relative positioning of nodes, enhancing their representational power–for instance in the context of 3D meshes. Graph Attention Networks (GATConv) veli2018graph use self-attention bahdanau2015neural layers to enable predictions at a given node to attend more specifically to certain parts of its neighborhood. Finally, building upon Jumping Knowledge Network xu2018powerful, Just Jump (DNAConv) feyDNAConv uses multi-head attention vaswani2017attention
to enhance the aggregation process in graph convolutions and enable deeper architectures. We use PyTorch GeometricFey/Lenssen/2019 for reference implementation of all of these methods. We evaluate performance on three citation network datasets: Cora, CiteSeer, and PubMed sen2008collective.
We report classification accuracy in Table 3. BP and DFA regularization and optimization hyperparameters are fine-tuned separately on the Cora dataset. In general, we find that less regularization and lower learning rates are needed with DFA. DFA successfully trains all graph methods, independent of whether they use the spectral domain or not, and even if they use attention. Furthermore, for GraphConv, SplineConv, and GATConv DFA performance nearly matches BP.
As GCNNs struggle with learning meaningful representations when stacking many layers xu2018how, all architectures but DNAConv are quite shallow (two layers). However, DFA performance is still significantly higher than that of a shallow training method–see supplementary for details. The lower performance on DNAConv is not a failure to learn: alignment measurements show that learning is indeed occurring. It may be explained instead by a need for more in-depth fine-tuning, as this is a deep architecture with 5 successive attention layers.
We further demonstrate that DFA helps graph convolutions learn meaningful representations by aplying t-SNE maaten2008visualizing; chan2019gpu to the hidden layer activations in GraphConv (Figure 3). Cluster of classes are well-separated, indicating that a useful intermediary representation is derived by the first layer.
We consider one last application of graph convolutions, in the context of graph autoencoders (GAE). We train a non-probabilistic GAE kipf2016variational based on GraphConv with DFA, and report results in Table 3. DFA performance is always in line with BP.
We complete our study by training a Transformer vaswani2017attention on a language modelling task. Transformers have proved successful in text, image, music generation, machine translation, and many supervised NLP tasks vaswani2017attention; radford2018improving; parmar2018imaget; dhariwal2020jukebox; devlin2019bert. Here, we demonstrate that DFA can train them, and we show the influence of tuning the optimizer hyperparameters in narrowing the gap with BP.
NLP has largely benefited from advances in deep learning. Recurrent Neural Networks were responsible for early breakthroughs, but their sequential nature prevented efficient parallelization of data processing. Transformers are attention-based models that do not rely on recurrence or convolution. Their ability to scale massively has allowed the training of models with several billion parametersShoeybi2019MegatronLMTM; brown2020language, obtaining state-of-the-art results on all NLP tasks: Transformers now top the prominent SQuAD 2.0 rajpurkar2016squad; rajpurkar2018squad2 and SuperGLUE wang2019superglue
benchmarks. In parallel, transfer learning in NLP has leaped forward thanks to language modelling, the unsupervised task of predicting the next word. It can leverage virtually unlimited data from web scrapingcommoncrawl. This enabled the training of universal language models howard2018universal on extremely large and diversified text corpora. These models are useful across a wide range of domains, and can solve most NLP tasks after fine-tuning.
The prominence of both language modelling and Transformers gives us the ideal candidate for our NLP experiments: we train a Transformer to predict the next word on the WikiText-103 dataset merity2017pointer, a large collection of good and featured Wikipedia articles. We use byte-pair-encoding sennrich2016bpe with 32,000 tokens. Our setup is similar to GPT radford2018improving: we adapt the Transformer, originally an encoder-decoder model designed for machine translation, to language modelling. We keep only the encoder and mask the tokens to predict. Our architecture consists in 6 layers, 8 attention heads, a model dimension of 512, and a hidden size of 2048 in the feed-forward blocks. The text is sliced in chunks of 128 tokens and batches of 64 such chunks, resulting in 8192 tokens per batch. Our baseline is trained with BP using the optimization setup of vaswani2017attention
. We found perplexity after 20 epochs to be an excellent indicator of perplexity at convergence; to maximize the number of experiments we could perform, we report the best validation perplexity after 20 epochs. We study two ways of implementing DFA: applying the feedback after every encoder block (macro) or after every layer in those blocks (micro). The input embedding layer receives gradients from the next feedback point through BP. This leaves some amount of weight transport even in the micro case.
Our results are summarized in Table 4. Hyper-parameters fine-tuned for BP did not fare well with DFA, but changes in the optimizer narrowed the gap between BP and DFA considerably. The learning rate schedule used on top of Adam kingma2014adam in vaswani2017attention proved detrimental. Using Adam alone required reducing the learning rate between BP and DFA. Increasing from 0.98 vaswani2017attention to 0.999 improved performance significantly. Finally, a simple scheduler that reduces the learning rate when the validation perplexity plateaus helped reducing it further. Considering that the perplexity of the shallow baseline is over 400, DFA is clearly able to train Transformers. However, our results are not on par with BP, especially in the micro setting. A substantial amount of work remains to make DFA competitive with BP, even more so in a minimal weight transport scenario. The large performance improvements brought by small changes in the optimizer indicate that intensive fine-tuning, common in publications introducing state-of-the-art results, could close the gap between BP and DFA.
|Baseline||+ Adam||+||+ LR schedule||Baseline||+|
We conducted an extensive study demonstrating the ability of DFA to train modern architectures. We considered a broad selection of domains and tasks, with complex models featuring graph convolutions and attention. Our results on large networks like NeRF and Transformers are encouraging, suggesting that with further tuning, such leading architectures can be effectively trained with DFA. Future work on principled training with DFA–in particular regarding the influence of common practices and whether new procedures are required–will help close the gap with BP.
More broadly, we verified for the first time that learning under synaptic asymmetry is possible beyond fully-connected layers, and in tasks significantly more difficult than previously considered. This addresses a notable concern in biologically-plausible architectures. DFA still requires an implausible global feedback pathway; however, local training has already been demonstrated at scale. The next step towards biologically-compatible learning is a local method without weight transport.
While the tasks and architectures we have considered are not biologically inspired, they constitute a good benchmark for behavioural realism bartunov2018assessing. Any learning algorithm claiming to approximate the brain should reproduce its ability to solve complex and unseen task. Furthermore, even though the current implementation of mechanisms like attention is devoid of biological considerations, they represent broader concepts applicable to human brains lindsay2020attention. Understanding how our brain learns is a gradual process, and future research could incorporate further realistic elements, like spiking neurons.
Finally, unlocking the backward pass in large architectures like Transformers is promising. More optimized implementation of DFA–built at a lower-level of existing ML libraries–could unlock significant speed-up. Leveraging the use of a single random projection as the cornerstone of training, dedicated accelerators may employ more exotic hardware architectures. This will open new possibilities in the asynchronous training of massive models.
This study is the first experimental validation of DFA as an effective training method in a wide range of challenging tasks and neural networks architectures. This significantly broadens the applications of DFA, and more generally brings new insight on training techniques alternative to back-propagation. From neural rendering and recommender systems, to natural language processing or geometric learning, each of these applications has its own potential impact. Our task selection process was motivated by current trends in deep learning, as well as by technically appealing mechanisms (graph convolutions, attention). A limit of our survey is that our–arguably biased–selection of tasks cannot be exhaustive. Our experiments required substantial cloud compute resources, with state-of-the-art GPU hardware. Nevertheless, as this study provides new perspectives for hardware accelerator technologies, it may favor the application of neural networks in fields previously inaccessible because of computational limits. Future research on DFA should continue to demonstrate its use in novel contexts of interest as they are discovered.
Each of the applications considered in our study has a wide potential impact, consider for example the impact of textual bias in pretrained word embeddings bolukbasi2016man. We refer to luccioni2019morality and references therein for a discussion of ethical concerns of AI applications.
DFA enables parallelization of the backward pass and places a single operation at the center of the training process, opening the prospect of reducing the power consumption of training chips by an order of magnitude launay2020lightintheloop. Not only is more efficient training a path to more environmentally responsible machine learning strubell2019energy
, but it may lower the barrier of entry, supporting equality and sustainable development goals. A significant downside of moving from BP to DFA is a far more limited understanding of how to train models and how the trained models behave. There is a clear empirical understanding of the impact of techniques such as batch normalization or skip connections on the performance of BP; new insights need to be obtained for DFA. BP also enjoys decades of works on topics like adversarial attacks, interpretability, and fairness. Much of this work has to be cross-checked for alternative training methods, something we encourage further research to consider as the next step towards safely and responsively scaling up DFA.
Finally, a key motivation for this study was to demonstrate that learning challenging tasks was possible without weight transport. Biologically motivated methods are a more foundational research direction, and as such the possible long-term impact of our findings is harder to estimate under this light. However, fundamental research of this kind is important to open new pathways for ML and neuroscience.
We thank Igor Carron and Laurent Daudet for the general guidance on the subject of this investigation and the insightful comments, as well as the larger LightOn team for their support.
In feedback alignment methods, the forward weights learn to align
with the random backward weights, making the delivered updates useful. This alignment can be quantified by measuring the cosine similarity between the gradient signal delivered by DFAand the gradient signal BP would have delivered . For learning to occur and DFA to work as a training method, there must be alignment. This can be measured numerically [launay2019principled]. Measuring alignments allows to check whether or not the layers are effectively being trained by DFA, regardless of performance metrics. We note that any alignment value superior to 0 signifies that learning is occuring. Values closer to 1 indicate a better match with BP, but small alignment values are sufficient to enable learning. We report values measured at the deepest DFA layer.
We measure alignment on the Criteo dataset, in the two architectures featuring non-conventional fully-connected layers: Deep & Cross and AFN. Alignment is measured after 15 epochs of training, and averaged over a random batch of 512 samples. Results are reported in table A.1. These alignment measurements indicate that learning is indeed occurring in the cross and logarithmic layers. High-variance of alignment in the cross layers is unique: it may be explained by the absence of non-linearity, and account for the difference in performance between BP and DFA on this architecture–which is higher than on the others.
|Deep & Cross||AFN|
|Alignment||0.40 (0.91)||0.49 (0.08)|
Alignment cosine similarity (higher is better, standard deviation in parenthesis) of recommender systems as measured on the Criteo dataset. Learning occurs in both architectures, and high variance may explain the larger performance gap on Deep & Cross compared to other methods.
We measure alignment on the Cora dataset, after 250 epochs of training, averaging values over every sample available–train, validation, and test split included. Results are reported in Table A.2
. We observe high alignment values in all architectures, indicative that learning is indeed occuring. Slightly lower values in SplineConv and GATConv may be explained by the use of the Exponential Linear Unit (ELU) instead of the Rectified Linear Unit (ReLU) used as activation in other architectures.
|Alignment||0.87 (0.12)||0.77 (0.25)||0.56 (0.22)||0.63 (0.18)||0.92 (0.30)|
We compare DFA to BP, but also to shallow learning–where only the topmost layer is trained. While DFA may not reach the performance level of BP, it should still vastly outperform shallow learning: failure to do so would mean that the weight updates delivered by DFA are useless. On a simple task like MNIST, a shallow baseline may be as high as 90%. However, given the difficulty of the tasks we consider, the shallow baseline is here usually much lower.
Because NeRF models are expensive to train–up to 15 hours on a V100–we consider a simplified setup for the shallow baseline, NeRF-Tiny. This setup operates at half the full resolution of the training images available, runs for 5000 iterations only, and does away with view-dependant characteristics. Furthermore, the network is cut down to 3 layers of half the width of NeRF, and no coarse network is used to inform the sampling. We train this network on the Lego scene of the NeRF-Synthetic dataset, and compare results.
Figure A.1 presents renders generated by NeRF-Tiny trained with BP, DFA, and a shallow approach. While BP and DFA delivers similar renders, shallow training fails to reproduce even basic scene geometry, instead outputting a diffuse cloud of colors. This highlights that while DFA may not reach a level of performance on-par with BP on NeRF, it nonetheless delivers meaningful updates enabling the learning of complex features.
Because recommender systems require fine-tuning, we perform the same hyperparameter search for shallow learning than for DFA and BP. Results are detailed in Table A.3. Performance of shallow training is always well under BP and DFA–remember that 0.001-level matter in recommender systems. In particular, in Deep & Cross, where there was the biggest gap between BP and DFA, the performance of the shallow method is extremely poor, well below the FM baseline. Finally, it is expected to see that DeepFM recovers more or less the performance of FM even with a shallow baseline.
We use the same hyperparameters as for DFA to produce the shallow baseline on graph datasets. Results are reported in Table A.4. Performance is always much worse than BP and DFA. GATConv recovers the best performance: random attention layers may still deliver useful features [tay2020synthesizer], as do random convolutions.
In the baseline setting (optimizer and hyper-parameters of [vaswani2017attention]), a Transformer trained in the shallow regime yields a perplexity of 428 on WikiText-103. We do not consider other settings, as the cost of training a Transformer is high and we do not expect any meaningful improvements–as with NeRF above.
We use an architecture identical to the one used in [mildenhall2020nerf], but based on the effective code implementation rather than the description in the paper111https://github.com/bmild/nerf/issues/11. During our tests, we have found that lowering the learning rate to rather than works best with DFA.
For all training methods (BP, DFA, and shallow), we have conducted independent hyperparameter searches. We performed a grid search over the learning rate, from to in steps, as well as over the dropout probability, from to in steps (where applicable). On DeepFM, this search leads to reduce the learning rate from with BP to with DFA, but to keep the 0.5 dropout rate. On Deep & Cross, we reduce learning rate from to , with no dropout in both cases. In AFN, we reduce dropout from to and dropout from 0.3 to 0.
We manually test for a few hyperparameters configuration on the Cora dataset, focusing on learning rate, weight decay, and dropout. We do not consider architectural changes, such as changing the number of filters or of attention heads. For ChebConv and GraphConv, we reduce weight decay to instead of , and set the dropout rate to and respectively, instead of with BP. For SplineConv, we find that no change in the hyperparameters are necessary. For GATConv, we reduce weight decay to instead of and reduce dedicated dropout layer to instead of but keep the dropout rate within the GAT layer. Finally, on DNAConv we disable weight decay entirely, instead of an original value of , double the learning rate from to , and disable dropout entirely. In all cases, we share the backward random matrix across all nodes in a graph.
The model hyper-parameters were fixed across all of our experiments, except for the number of attention heads in one case, that we will precise below, and dropout. We tested several values of dropout probability between 0 and 0.5, but found the original value of 0.1 to perform best. We manually tested a number of optimizers, optimizer parameters and attention mechanisms. We tested four combinations of optimizers and schedulers : Adam with the scheduler used in [vaswani2017attention], Adam alone, RAdam [liu2019variance] alone, and Adam with a scheduler that reduces the learning rate when the validation perplexity plateaus. We found it necessary to reduce the initial learning rate of Adam from to , although it could be set back to with a scheduler. We tried two values of : 0.98 and 0.999. We also tried to change and observed some small differences that were not significant enough for the main text. Finally, we tried three attention mechanisms in addition to the standard multihead scaled dot-product attention: the dense and random (learnable) Synthesizers of [tay2020synthesizer], as well as the fixed attention patterns of [raganato2020fixed]. The latter needed to be adapted to language modelling to prevent attending to future tokens, which led us to reduced the number of attention heads to 4. The backward random matrix is always shared across all tokens and batches.
We consider an attention layer operating on input . The queries, keys, and values are respectively , and is the dimension of the queries and keys. The layer performs:
When using DFA on attention, we deliver the random feedback to the top of the layer. Accordingly, to obtain updates to we still to have to backpropagate through the attention mechanism itself. This involves weight transport on , sacrificing some biological realism for simplicity. Overall weight transport between layers still does not occur, and updating the layers in parallel remains possible.
Beside using FA or DFA within the attention layer, alternative mechanisms like the synthesizer [tay2020synthesizer]–which uses random attention in place of the query and key system–or fixed attention [raganato2020fixed] can remove the need for weight transport. Implementing these mechanisms in DFA-trained Transformers, or other attention-powered architectures, will require further research.
We report per-scene scores for each dataset in Table A.5. BP values are taken from [mildenhall2020nerf]. On three scenes of the synthetic datasets, NeRF-DFA even outperforms past state-of-the-art methods trained with BP. Note that Neural Volumes (NV) is not applicable to forward-facing view synthesis–as is required in LLFF-Real–and thus no results are reported.
We report sample renders from the NeRF-Synthetic dataset (Figure A.2) and the LLFF-Real dataset (Figure A.2), for every scene available. However, we recommend readers to consult the supplementary video to make better sense of characteristics like multi-view consistency and view-dependent effects (most visible on the LLFF-Real Room scene).
Despite retranscribing scene geometry in a multi-view consistent way, NeRF produces renders of a lower quality when trained with DFA instead of BP. In particular, it struggles to transcribe small-scale details, resulting in "blurry" renders. Moreover, it displays high-frequency artefacts: not in the scene geometry, but in individual pixels taking values very distant from their neighborhood. Interestingly, this noise phenomenon is unique to NeRF-DFA: it is not observed on NeRF-BP with similar PSNR values (achieved during training) or on other methods with similar or lower PSNR. This leads us to hypothesize this is an aspect unique to DFA, possibly due to the alignment process. Indeed, DFA creates a bias on the weights, by encouraging them to be "aligned" with an arbitrary values dependant on the random matrix used. It is possible this could introduce random noise in the final renders–though we leave a more principled experiment to future research.
To attempt to alleviate this issue, we first consider NeRF-Dual. In NeRF-Dual, we average the pixel-wise prediction between the fine and coarse network, to attempt to remove some of the noise. To do so, we first still use the coarse network to create a probability distribution for the hierarchical sampling. Then, we evaluate again both the coarse and fine networks at the locations informed by this probability distribution. Compared to vanilla NeRF, this requires an extra batch of evaluation of the coarse network for all rays–rougly speaking, this increases inference time by 30-50% depending on the coarse network architecture considered. We note that this is not applied during training, so that training times remain identical.
Figure A.2 and Figure A.3 showcase comparisons between NeRF and NeRF-Dual trained with DFA on all scenes. When viewed at high resolution–such as in our supplementary video–the NeRF-Dual renders are more pleasing, especially for the full scenes. They remove most of the high-frequency noise, leading to smoother renders. However, this averaging process further blurs small-scale details in the render. This is especially visible in the NeRF-Synthetic dataset, on scenes like Ficus. Furthermore, NeRF-Dual introduces novel artefacts in the Mic and Ship scenes, with areas improperly colored with a violet tint. The cause for these artefacts is unknown, but they show that NeRF-Dual is far from a silver bullet. The PSNR is also minimally increased, by less than 0.5 per scene. Nevertheless, this shows some promise in possibilities to allievate the shortcomings of NeRF-DFA. It is possible that changes to the overall rendering process, or the use of classic image processing techniques, may help enhance the NeRF-DFA images.
Finally, we also experimented with increasing the capacity of the fine network, by widening its layers to 512 neurons. We call this architecture NeRF-XL. However, we have not succeeded in getting PSNR values higher than with vanilla NeRF on DFA. In particular, the training process becomes much more cumbersome, as multi-GPU parallelism is needed to fit the model. It is possible that higher network capacity may help learning both the task at hand and to align simultaneously, but further work is required.
All main experiments require at most a single NVIDIA V100 GPU with 16GB of memory to reproduce. Alignment measurement on large architectures (NeRF and Transformers) require a second identical GPU to keep a copy of the network to evaluate BP gradients.
We estimate that a total of around 10,000 GPU-hours on V100s were necessary for this paper. Accordingly, we estimate the cloud-computing carbon impact of this paper to be of 1700 kgCOeq222https://mlco2.github.io/impact#compute.
However, without hyperparameter searches, our results can be reproduced with less than 500 GPU-hours on V100s, with most of that budget going to NeRF and Transformers.
We use the shared random matrix trick from [launay2019principled] to reduce memory use in DFA and enable its scaling to large networks. We use PyTorch [NEURIPS2019_9015] for all experiments. For reference implementation of the methods considered, we relied on various sources. Our NeRF implementation is based on the PyTorch implementation by Krishna Murthy333https://github.com/krrish94/nerf-pytorch, with modifications to allow for proper test and validation, as well as DFA and multi-GPU support. For recommender systems, we use the torchfm package444https://github.com/rixwew/pytorch-fm. Finally, we use PyTorch Geometric [Fey/Lenssen/2019] for all graph operations. Our Transformer implementation is our own. Our code is available as supplementary material.
We provide training, testing, and rendering code along with the configurations used to obtain our results. An example to reproduce our results is given in the supplementary code repository. Given the computing cost associated with training a NeRF, we also provide our trained models.
We provide the code to reproduce all of our results. Note that the t-SNE results are not exactly reproducible, as the CUDA implementation used is non-deterministic.
We provide bash scripts to reproduce Table 4 and the shallow results.