# Forward Only Learning for Orthogonal Neural Networks of Any Depth

Paul Caillon, Alex Colagrande, Erwan Fagnou, Blaise Delattre, Alexandre Allauzen

► To cite this version:

Paul Caillon, Alex Colagrande, Erwan Fagnou, Blaise Delattre, Alexandre Allauzen. Forward Only Learning for Orthogonal Neural Networks of Any Depth. 28th European Conference on Artificial Intelligence, Oct 2025, Bologne, Italy. 10.3233/FAIA251041. hal-05528951

HAL Id: hal-05528951

https://hal.science/hal-05528951v1

Submitted on 26 Feb 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
# Forward Only Learning for Orthogonal Neural Networks of any Depth

Paul Caillon<sup>a,*,1</sup>, Alex Colagrande<sup>a,1</sup>, Erwan Fagnou<sup>a</sup>, Blaise Delattre<sup>a</sup> and Alexandre Allauzen<sup>a,b</sup>

<sup>a</sup>Miles Team, LAMSADE, Université Paris-Dauphine - PSL, Paris, France

<sup>b</sup>ESPCI PSL, Paris, France

**Abstract.** Backpropagation is still the de facto algorithm used today to train neural networks. With the exponential growth of recent architectures, the computational cost of this algorithm also becomes a burden. The recent PEPITA and forward-only frameworks have proposed promising alternatives, but they failed to scale up to a handful of hidden layers, yet limiting their use. In this paper, we first analyze theoretically the main limitations of these approaches. It allows us the design of a forward-only algorithm, which is equivalent to backpropagation under the linear and orthogonal assumptions. By relaxing the linear assumption, we then introduce FOTON (Forward-Only Training of Orthogonal Networks) that bridges the gap with the backpropagation algorithm. Experimental results show that it outperforms PEPITA, enabling us to train neural networks of any depth, without the need for a backward pass. Moreover its performance on convolutional networks clearly opens up avenues for its application to more advanced architectures. The code is open-sourced on github.

## 1 Introduction and Related Work

Backpropagation (BP) [29] is still the cornerstone for training deep neural networks. With the exponential growth of architectures, its limitations have been highlighted, notably regarding its lack of efficiency, along with its biological implausibility [22]. More specifically, the sequentiality of the backward pass represents a computational bottleneck when training deep networks. The memory footprint and execution time represent a significant drawback and reducing this burden is a major challenge that could allow the use of state-of-the-art models on resource-limited devices [14, 13].

Alternatives have thus been proposed, most targeting the backward phase. Feedback Alignment (FA) replaces exact gradients with random feedback directions [21], while Direct FA (DFA) transmits feedback directly from the output to each layer in parallel [26]. These simplifications reduce test accuracy, though later works attempt to narrow the gap with BP by partially mimicking its behavior [1, 36, 17, 10, 16]. Nonetheless, clear limitations remain: poor scaling to deep convolutional networks [3, 18, 24, 7], and the need for an exact backward pass in certain modules, such as attention layers in transformers [19].

More recently, forward-only (FO) algorithms have been proposed as an alternative to the BP, replacing the backward pass by a modulated second forward pass. A first line of work relies on the estimation of the gradient, computed locally from a modified forward pass using

directional derivatives. These forward gradients provide a plausible update for the parameters [11, 31, 23, 9]. For efficient computation, the Jacobian-vector product is involved during the forward pass. However, while forward gradients are unbiased, they exhibit a large variance. This inhibits the convergence of the training as well as the scalability of this approach even in combination with local losses [27, 4, 9].

In this work, we focus on another family of forward-only algorithms, in which a second pass or *modulated forward pass* [33] computes network outputs on a perturbed input. The nature of this perturbation varies by method: for example, Hinton [12] use “negative” data samples, requiring designing or collecting a special dataset, whereas the PEPITA framework [8] derives its modulation directly from the error signal, allowing a more agnostic and data-efficient approach.

Srinivasan et al. [33] further analyzed the learning dynamics of these forward-only schemes and extended PEPITA to slightly deeper architectures but still found that, in practice, they fail to scale beyond five hidden layers and cannot adapt to convolutions. As a result, existing methods remain limited to shallow, fully connected networks.

To address these limitations, we identify the core bottleneck: forward-only passes cannot reliably transmit gradient information through many layers, and the absence of a true backward path demands special data or ad-hoc fixes. We show that under linear orthogonality, a purely forward strategy exactly recovers BP updates. Leveraging this, we introduce *FOTON*, which matches BP in the orthogonal linear regime and scales robustly to deep non-linear networks. Crucially, FOTON dispenses with any backward pass or storage of the automatic differentiation graph: all updates are computed via forward evaluations alone, dramatically reducing memory overhead by eliminating the need to retain activations or gradient buffers. Our contributions are:

* We show theoretically that, for orthogonal linear networks, PEPITA’s update rules can be modified to exactly reproduce BP’s gradients.

* We relax the linearity constraint to derive FOTON, a forward-only algorithm that continues to deliver effective learning signals in deep non-linear models without ever invoking a backward pass.

* We provide an in-depth empirical study of FOTON’s training dynamics, illustrating its stability and scalability compared to PEPITA.

* We adapt FOTON to convolutional architectures—orthogonalizing conv kernels via BCOP—and demonstrate, for the first time, successful forward-only training of multi-layer convnets.

<footnote>* Corresponding Author. Email: paul.caillon@dauphine.psl.eu</footnote>

<footnote n="1">¹ Equal contribution</footnote>
<figure><img src="image_2.png" /><figcaption>Figure 1: Overview of different error transportation configurations, inspired by [8]. a) Backpropagation (BP). b) Feedback Alignment (FA). c) Forward Only propositions (PEPITA and Forward-Forward). d) Adapted PEPITA (PEPITA+Weight Mirroring), from [33]. e) Forward-Only Training of Orthogonal Networks (FOTON). Green arrows indicate forward paths, orange ones error paths. Weights are denoted $W_\ell$, feedback matrices are $B_\ell$ if specific to a layer (FA). Matrix used to project the error on the input layer are denoted as $F_\ell$ if specific to a layer (PEPITA+WM from [33]) or $F$ if global (standard PEPITA). In the case of FOTON the $F_\ell$ are replaced by $W_\ell^\top := W_\ell^{-1}$ as the layers are orthogonal.</figcaption></figure>

## 2 Background and Notations

Let $f(x; \theta)$ be a neural network with $L$ layers, where $x \equiv h_0$ is the input and $\theta$ denotes its parameters. The network computes the prediction $\hat{y} = a_L$, where $a_\ell = W_\ell h_{\ell-1}$ and $h_\ell = \sigma_\ell(a_\ell)$ are respectively pre-activation and activation of the layer $l$ (for $1 \le l \le L$), and $\sigma_\ell$ denotes the element-wise non-linear activation function. Given a loss function $\mathcal{L}$, $\nabla_\ell \mathcal{L} \equiv \frac{\partial \mathcal{L}}{\partial h_\ell}$ represents the gradient of the loss with respect to the activation at layer $\ell$.

The BP algorithm computes this term sequentially after a forward pass, starting from the output layer. The term $e \equiv \nabla_L \mathcal{L}$ corresponds to the error made by the network for the input $x$. For the Mean Squared Error (MSE) loss, it can be written as $e = \hat{y} - y$. Given a learning rate $\eta$ and denoting the Hadamard product by $\odot$, the weight updates are written as follows:

$$ \delta W_\ell = -\eta (\delta h_\ell^{\text{BP}} \odot \sigma'_\ell(a_\ell)) h_{\ell-1}^\top, \forall \ell < L, \quad (1) $$

$$ \delta W_L = -\eta e h_{L-1}^\top, \quad (2) $$

$$ \delta h_{\ell}^{\text{BP}} = \nabla_{\ell} \mathcal{L} = W_{\ell+1}^{\top} (\delta h_{\ell+1}^{\text{BP}} \odot \sigma'_{\ell+1}(a_{\ell+1})), \forall \ell. \quad (3) $$

Hence, the update of a layer $\ell$ depends on the error back-propagated through the $\{L, L-1, ..., \ell+1\}$ subsequent layers, as illustrated in Figure 1. It also requires the storage of the computation graph to estimate the gradients in reverse order. This overhead may becomes prohibitive for deep networks. It is also worth noting that the weight updates are “backward-locked”, meaning that it is not possible to update the weights of a layer before the gradients of the subsequent layers have been computed.

In the PEPITA framework introduced by Dellaferrera and Kreiman [8], the error signal is projected in the input space to compute a second modulated forward pass. In the following, we adopt the formalism of Srinivasan et al. [33]. While the first forward pass is applied to the input $x$, the second forward pass uses $x - Fe$ as the input:

$$ \begin{aligned} h_1^{\text{err}} &= \sigma_1(a_1^{\text{err}}) = \sigma_1(W_1(x - Fe)), \\ h_\ell^{\text{err}} &= \sigma_\ell(a_\ell^{\text{err}}) = \sigma_\ell(W_\ell h_{\ell-1}^{\text{err}}) \quad \text{for } 2 \le \ell \le L, \end{aligned} \quad (4) $$

where $F$ is a fixed random matrix. After two forward passes, the weights are updated using the PEPITA learning rule:

$$ \delta W_1 = -\eta (h_1 - h_1^{\text{err}})(x - Fe)^{\top}; \quad (5) $$

$$ \delta W_\ell = -\eta (h_\ell - h_\ell^{\text{err}})(h_{\ell-1}^{\text{err}})^\top \quad \text{for } 2 \le \ell < L; \quad (6) $$

$$ \delta W_L = -\eta e (h_{L-1}^{\text{err}})^{\top}. \quad (7) $$

## 3 Forward-Only Training of Orthogonal Networks (FOTON)

Our contribution relies on the key insight that, in orthogonal linear networks, the PEPITA update rules (Eqs. 5–7) can be made to reproduce exactly the gradients of standard backpropagation (Eqs. 1,2). By relaxing the linearity assumption, we derive FOTON, a forward-only training algorithm that preserves this equivalence in the linear regime while still delivering strong learning signals in deep non-linear networks, as demonstrated by our experiments on MNIST, CIFAR-10 and CIFAR-100 (see Section 4).

Although naively recomputing the error-projection matrix $F$ at every iteration might add a pseudo extra forward pass—so FOTON is not inherently faster per step than backpropagation—its real benefit is the elimination of the backward pass and the entire computation graph. This pure forward execution makes FOTON especially attractive in memory-constrained settings, where removing the backward lock and all intermediate activation storage brings substantial practical gains. Moreover, as shown in Section 4.4, one can further reduce this overhead by relaxing the exact weight-alignment requirement by updating $F$ less frequently or via weight-mirroring schemes, aligning forward and feedback weights, as in [1].

### 3.1 Limitations of the PEPITA learning rule

Introduced by Dellaferrera and Kreiman [8], the PEPITA learning rule illustrated in Figure 1c is a promising alternative to BP. Initially tested on only two-layer networks, it has been extended to networks
<table><caption>**Table 1:** Test accuracy [%] achieved by BP, BP with orthogonalized weights as each step (denoted BP ⊥), FA, DFA, PEPITA, PEPITA + WM and FOTON on the MNIST dataset on fully connected networks of different depths. Used hyperparameters are reported in the Appendix [6]. Bold fonts refer to the best results for alternatives to BP. × represents algorithms that failed to scale to the corresponding depth.</caption><thead><tr><th>Learning rule</th><th>Forward-only</th><th>1 HL</th><th>2 HL</th><th>3 HL</th><th>5 HL</th><th>10 HL</th><th>50 HL</th></tr></thead><tbody><tr><td>BP via SGD</td><td>●</td><td>98.91</td><td>98.85</td><td>98.89</td><td>98.49</td><td>97.44</td><td>97.49</td></tr><tr><td>BP ⊥</td><td>●</td><td>94.33</td><td>95.19</td><td>96.18</td><td>96.91</td><td>96.5</td><td>97.85</td></tr><tr><td>FA</td><td>●</td><td>98.42</td><td>98.25</td><td>98.08</td><td>97.96</td><td>95.43</td><td>×</td></tr><tr><td>DFA</td><td>●</td><td>98.32</td><td>98.26</td><td>98.30</td><td>98.10</td><td>94.50</td><td>×</td></tr><tr><td>PEPITA (original)</td><td>●</td><td>98.01</td><td>×</td><td>×</td><td>×</td><td>×</td><td>×</td></tr><tr><td>PEPITA + WM</td><td>●</td><td>98.42</td><td>98.19</td><td>96.33</td><td>×</td><td>×</td><td>×</td></tr><tr><td>FOTON (ours)</td><td>●</td><td><b>98.49</b></td><td><b>98.61</b></td><td><b>98.36</b></td><td><b>98.32</b></td><td><b>97.27</b></td><td><b>88.42</b></td></tr></tbody></table>

with 3 hidden layers and even 5 hidden layers in very specific settings by Srinivasan et al. [33] as illustrated in Figure 1d. However, the empirical results show a trend of decreasing (and even collapsing) performance with the depth of the network, contrary to what is observed with BP. Furthermore, the theoretical analysis provided in [33] is only valid for two-layer networks. For deeper networks, commonly used in practice, a theoretical analysis of the convergence and learning dynamics is made near impossible due to the progressive degradation of the signal during the modulated forward. The results and analysis provided in Section 4 support the observation that the modulated forward pass is unable to transmit a meaningful error signal.

## 3.2 FOTON learning rule

First, instead of writing $e = \hat{y} - y$ as in the previous works on PEPITA, we use the more general form $e = \nabla_L \mathcal{L}$. This formulation allows us to consider any differentiable loss, hence generalizing the work of Dellaferrera and Kreiman [8], Srinivasan et al. [33]. We then use the following changes in the PEPITA update rules 5–7, as in [33]:

$$ \delta W_{\ell} = -\eta (h_{\ell} - h_{\ell}^{\text{err}}) (h_{\ell-1})^{\top} \quad \text{for } 1 \le \ell < L; \qquad (8) $$

$$ \delta W_L = -\eta e h_{L-1}^{\top}. \qquad (9) $$

With these modifications, the update rule closely relates to the one calculated by BP, and in particular matches BP for the last layer (equations 9 and 2). Furthermore, if $h_{\ell} - h_{\ell}^{\text{err}} = \nabla_{\ell} \mathcal{L}$ for $1 \le \ell < L$, the update given by equation 8 resolves exactly to the one given by equation 1. Therefore to reduce the gap with BP, the quantity $\delta h_{\ell}^{\text{FO}} := h_{\ell} - h_{\ell}^{\text{err}}$ becomes pivotal. Let us detail its computation:

$$ \delta h_{\ell}^{\text{FO}} = \sigma_{l}(W_{\ell}\sigma_{\ell-1}(W_{\ell-1}\sigma_{\ell-2}(\cdots\sigma_{1}(W_{1}x)))) - \sigma_{l}(W_{\ell}\sigma_{\ell-1}(W_{\ell-1}\sigma_{\ell-2}(\cdots\sigma_{1}(W_{1}(x-Fe)))))) \quad (10) $$

In the next section, we will consider different assumptions to improve PEPITA.

### 3.2.1 Orthogonal linear networks

In the case of linear networks, equation 10 reads:

$$ \delta h_{\ell}^{\text{FO}} = W_{\ell} W_{\ell-1} \cdots W_{1} Fe \qquad (11) $$

Assuming a perfect weight alignment in the sense proposed by Srinivasan et al. [33] following the idea of Akrout et al. [1] (i.e. $F = W_1^\top W_2^\top \cdots W_L^\top$), and orthogonal weights (i.e. $W_\ell^\top W_\ell = I$), equation 11 simplifies to:

$$ \delta h_{\ell}^{\text{FO}} = W_{\ell+1}^{\top} \cdots W_{L}^{\top} e = \delta h_{\ell}^{\text{BP}}. \qquad (12) $$

This means that in the case of orthogonal linear networks of any depth, assuming a perfect weight alignment of F with the forward weights, FOTON is strictly equivalent to BP.

### 3.2.2 Non-linear networks

In the case of non-linear networks, we show empirically in section 4 that the FOTON learning rule remains very effective. While there is no theoretical guarantee of convergence in this general case, we can still get some intuition as to why these results are observed.

By approximating the activation functions linearly ($\sigma'_\ell(x) \approx \lambda$), we can see how FOTON approaches backpropagation up to a rescaling:

$$ \delta h_{\ell}^{\text{FO}} \approx \lambda^{\ell} W_{\ell+1}^{\top} W_{\ell+2}^{\top} \cdots W_{L}^{\top} e \approx \lambda^{2\ell-L+1} \cdot \delta h_{\ell}^{\text{BP}} \quad (13) $$

This shows the direction provided by FOTON is still a descent direction, as showed in Figure 3, where the signal given by FOTON has a positive cosine similarity with the true gradient. The constant factor can be absorbed by the learning rate or an adaptive optimizer like Adam. See the Appendix [6] for more details.

### 3.2.3 Convolutional networks

In the case of convolutional layers, the update rule must be adapted since the outer product of equation 8 gives a valid update for a dense layer but not for the convolutional kernel. To the best of our knowledge, the only method proposed in the literature that handle convolution layers in the forward-only framework is introduced in [8], where they average the products between the output components and the respective convolutional receptive fields. However, this method fails to scale to deep networks. In this work we propose a different approach that leverages the strong analogy between BP and FOTON, with the rule to update a convolutional kernel:

$$ \delta k_{\ell} = -\eta \text{conv}_{k}(h_{\ell-1}^{\top} (h_{\ell} - h_{\ell}^{\text{err}})) $$

where $\text{conv}_k(x) = k * x$ is the left-convolution by a kernel $k$ and $\star$ indicates the adjoint operator (i.e. the transposed convolution). We highlight that our proposition drastically differs from the previously cited method, since it allows us to still match backpropagation in the linear case, and to remain first order approximation in the general case. To ensure the orthogonality of the convolutional layers, we use Block Convolution Orthogonal Parametrization (BCOP) as introduced by Li et al. [20]. Lastly, we only consider average pooling layers as the max pooling operation is not adapted to the forward-only framework. More details are provided in the Appendix [6].

## 3.3 Layer orthogonalization

FOTON ensures left-orthogonality of the **weight matrices** throughout training via the Björck algorithm [5] as done by Li et al. [20]. However, our method does *not* depend on this peculiar choice and any orthogonalization scheme—e.g. Cayley transforms [34] or skew-symmetric exponentials [32]—could be substituted. This orthogonalization is carried out at each iteration, ensuring near-perfect orthogonality throughout training. While it introduces a non-trivial runtime overhead, substantial benefits arise from enforcing orthogonality.
<table><caption>**Table 2:** Test accuracy [%] achieved by BP, PEPITA and FOTON on the CIFAR-10/100 datasets on fully connected networks of different depths, over 5 independent runs. The results reported for PEPITA are the best results obtained following the improvements of PEPITA done by Srinivasan et al. [33]. × represents algorithms that failed to scale to the corresponding depth.</caption><thead><tr><th rowspan="2">Learning rule</th><th colspan="6">CIFAR-10</th><th colspan="6">CIFAR-100</th></tr><tr><th>1 HL</th><th>2 HL</th><th>3 HL</th><th>5 HL</th><th>10 HL</th><th>50 HL</th><th>1 HL</th><th>2 HL</th><th>3 HL</th><th>5 HL</th><th>10 HL</th><th>50 HL</th></tr></thead><tbody><tr><td>BP via SGD</td><td>56.23</td><td>57.42</td><td>57.51</td><td>52.55</td><td>52.96</td><td>45.62</td><td>29.36</td><td>29.80</td><td>29.01</td><td>28.32</td><td>25.15</td><td>13.53</td></tr><tr><td>BP ⊥</td><td>55.78</td><td>54.90</td><td>54.68</td><td>52.97</td><td>52.53</td><td>52.05</td><td>28.15</td><td>28.30</td><td>28.02</td><td>28.20</td><td>25.49</td><td>20.88</td></tr><tr><td>PEPITA (best results)</td><td>53.80</td><td>53.44</td><td>53.80</td><td>×</td><td>×</td><td>×</td><td>27.07</td><td>26.95</td><td>23.13</td><td>×</td><td>×</td><td>×</td></tr><tr><td>FOTON (ours)</td><td><strong>55.61</strong></td><td><strong>55.14</strong></td><td><strong>55.70</strong></td><td><strong>53.09</strong></td><td><strong>52.22</strong></td><td><strong>40.86</strong></td><td>25.23</td><td>25.02</td><td><strong>23.84</strong></td><td><strong>22.60</strong></td><td><strong>21.00</strong></td><td><strong>15.65</strong></td></tr></tbody></table>

First, orthogonal layers preserve the norm of backpropagated gradients, preventing both vanishing and exploding gradients and stabilizing activation distributions [2, 28]. Second, maintaining unit singular values yields well-conditioned optimization landscapes that can accelerate convergence and improve generalization [30].

Third, enforcing orthogonality provides provable robustness guarantees: by bounding the Lipschitz constant, networks become more resistant to adversarial perturbations and admit deterministic certificates of robustness [35]. Finally, orthogonal transformations preserve pairwise distances in feature space, promoting stable feature reuse and mitigating representation collapse in very deep architectures as empirically verified in the deepest models used in Tables 1,2.

We emphasize that the left-orthogonality constraint applies to rectangular matrices, ensuring that column vectors remain orthogonal throughout training. Despite the added cost, this structural regularization allows deeper or more compact models to train reliably. We investigate a potential reduction of this overhead by updating the orthogonalization less frequently in our ablation study Section 4.4.

# 4 Empirical Evaluation

## 4.1 Experimental Setup

In this section, we detail our empirical evaluation of FOTON and present its results. All experiments were run on a single NVIDIA A100 GPU, and all results report the mean (with negligible standard deviation) over five independent runs. We evaluate on MNIST, CIFAR-10/100 using standard train/test splits without any data augmentation.

For our multilayer perceptrons, we consider three regimes: shallow networks with 1–3 hidden layers of 1024 units and ReLU activations (following Srinivasan et al. [33]); mid-depth models with 5 or 10 layers of 256 units and ReLU; and very deep stacks of 50 layers with 256 units and Tanh activations (to avoid the “dying ReLU” issue in extreme depth).

In convolutional settings, we use two successive 3×3 conv layers (32 then 64 filters), each followed by average pooling, capped by a single fully-connected classification layer; all convolutional kernels are orthogonalized via BCOP. Across all architectures, we compare FOTON to PEPITA (and its variants) and to standard BP (with or without per-step orthogonalization). The complete set of optimization hyperparameters is provided in the Appendix [6]. Finally, we supplement these results with the analysis of the training dynamics of FOTON when compared to PEPITA and ablation studies on the frequency of layer orthogonalization and on how often the *F* matrix is recomputed.

## 4.2 Results

We begin by evaluating FOTON on non-linear networks of varying depth—both fully connected and convolutional—across the MNIST, CIFAR-10, and CIFAR-100 benchmarks, and compare its accuracy

to that of PEPITA and standard backpropagation. Our experimental protocol closely follows [33], using the same tasks, hyperparameters, and shallow-network configurations as slight deviations in those parameters caused PEPITA’s training to collapse. Crucially, despite extensive tuning and the enhancements from Srinivasan et al. [33], we were unable to train PEPITA beyond five hidden layers, whereas FOTON scales reliably to much deeper architectures.

### 4.2.1 Results on Fully Connected Networks

The results regarding fully connected networks are summarized in Table 1 for MNIST and Table 2 for CIFAR-10 and CIFAR-100. First, we observe and experimentally confirm that FOTON provides learning to deep non-linear networks, answering to a major limitation of PEPITA. This confirms the theoretical analysis made in Section 3. Our results demonstrate that FOTON scales reliably to depths of up to 50 layers, whereas PEPITA fails beyond five layers despite exhaustive hyperparameter tuning. On MNIST (Table 1), FOTON achieves 98.32% at 5 hidden layers, 97.27% at 10 layers and still 88.42% at 50 layers, compared with PEPITA’s collapse after 3 layers (96.33% at 3 HL, no result beyond).

Similarly, on CIFAR-10 (Table 2), FOTON reaches 55.70% at 3 layers, 53.09% at 5 layers and 52.22% at 10 layers, while PEPITA cannot be trained past 3 layers. In convolutional settings (Table 3), FOTON attains 90.69% on a 2×conv MNIST network and 28.48% on a 1×conv CIFAR-100 network, outperforming PEPITA in every configuration. Moreover, on fully-connected models up to 10 layers, FOTON matches or exceeds standard backpropagation (and even approaches orthogonal-BP performance) without ever executing a backward pass and even more crucially **without needing to store any computation graph**.

Finally, these experiments omit data augmentation, batch normalization and advanced learning-rate schedules or optimizers as Adam [15]—techniques that typically improve backpropagation—so integrating them represents a clear path to further boost FOTON’s accuracy.

### 4.2.2 Results on Convolutional Networks

Extending FOTON to convolutional architectures requires reconciling the orthogonality constraint—which is naturally formulated on the large Toeplitz matrix of the convolution with the small, spatial structure of the kernel itself. To enforce orthogonality on each convolutional layer we employ Block Convolution Orthogonal Parametrization (BCOP) [20]. Unlike the original PEPITA update, which correlates post and pre-synaptic activations patch-by-patch and does not align with the true gradient of the linearized conv layer, FOTON’s convolutional update is derived by mimicking backpropagation: in the linear (or piecewise-linear) regime, the exact weight gradient is given by applying the adjoint convolution (i.e. the transposed convolution) of the error to the input feature map.
<figure><img src="image_3.png" /><figcaption>**Figure 2:** Cosine similarity between the true gradient computed by BP and the estimates computed using FOTON (blue), PEPITA (green), and PEPITA with orthogonal initialization (orange), on a 50 hidden layers linear network on MNIST during training. The cosine similarity is averaged over the training set, and is reported for 5 layers across the network. Two cases are reported depending on the stability of PEPITA training (stable in (a) and unstable in (b)). Stable training was obtained for a very small learning rate $lr = 1e^{-5}$.</figcaption></figure>

In practice, we implement this via PyTorch's `torch.nn.grad(conv2d_input)` operator. This approach recovers the true backprop gradients under the orthogonality assumption and enables training multi-layer convolutional networks entirely in a forward-only fashion. Further implementation details are provided in the supplementary material.

<table><caption>**Table 3:** Test accuracy [%] achieved by BP, PEPITA and FOTON on the MNIST and CIFAR-100 datasets, on convolutional networks with one or two convolutional layers, and a linear classifier. $\times$ represents algorithms that failed to scale to the corresponding depth.</caption><thead><tr><th rowspan="2">Learning rule</th><th colspan="2">Conv ×1</th><th colspan="2">Conv ×2</th></tr><tr><th>MNIST</th><th>CIFAR-100</th><th>MNIST</th><th>CIFAR-100</th></tr></thead><tbody><tr><td>BP via SGD</td><td>98.86</td><td>34.20</td><td>98.93</td><td>34.45</td></tr><tr><td>PEPITA (best results)</td><td><strong>98.29</strong></td><td>27.56</td><td><strong>×</strong></td><td><strong>×</strong></td></tr><tr><td>FOTON (ours)</td><td><strong>98.29</strong></td><td><strong>28.48</strong></td><td><strong>90.69</strong></td><td><strong>21.98</strong></td></tr></tbody></table>

Table 3 summarizes FOTON's performance on convolutional architectures with one or two convolutional layers for MNIST and CIFAR-100. To our knowledge, this is the first demonstration of a forward-only method successfully training networks with more than a single convolutional layer. Although FOTON does not yet match standard backpropagation's accuracy, it clearly outperforms PEPITA and scales to deeper conv nets, a trend consistent with its superior behavior in fully connected settings, even for shallow models, showcasing the potential of the algorithm for more advanced architectures.

## 4.3 Analysis of the training dynamics

In this section we conduct an analysis of the difference of the training dynamics between FOTON and PEPITA, in terms of the updates computed. We begin with deep linear networks—where FOTON is theoretically equivalent to backpropagation—to validate our analysis, and then extend the study to non-linear models to shed light on the behaviors underlying the results reported in Section 4.2.

### 4.3.1 Linear case

As shown in Figure 2, in the linear case the cosine similarity between the gradients computed by FOTON and BP is exactly 1 for all layers, meaning that FOTON computes the same gradients as BP. This is coherent with the theoretical analysis made in Section 3, as in this case, the update rules of BP and FOTON are exactly the same. When comparing the cosine similarity between the gradients computed by BP, and PEPITA initialized following the scheme developed in [33], we observe that it is very close to 0, meaning that PEPITA gives directions that are close to orthogonal to the true gradient. This suggests that PEPITA does not transmit the error signal correctly, to the point that the direction given by the PEPITA update rule is orthogonal to the one given by BP. In high dimensions, this can be interpreted as a random direction, meaning that PEPITA actually does not produce any meaningful weight update.
<figure><img src="image_4.png" /><figcaption>**Figure 3:** Cosine similarity between the true gradient computed by BP and the estimates computed using FOTON (blue) and PEPITA (green), on a 10 hidden layers network with ReLU nonlinearity on MNIST during training. The cosine similarity is averaged over the training set, and is reported for 5 layers across the network.</figcaption></figure>

However, this has to be nuanced by the fact that under a right initialization (e.g. orthogonal initialization), PEPITA can actually transmit the error signal coherently, as shown in Figure 2 for the orange curve. However it is extremely sensitive to the hyperparameters, and training was not stable for most of the hyperparameters tested (as illustrated in Figure 2). This is coherent with the findings of [33] that PEPITA can actually work on 4 to 5 hidden layers networks for some specific hyperparameters. Even in this case, the cosine similarity of PEPITA still decreases in the deeper layers, indicating a progressive perturbation of the error signal during the modulated forward pass.

### 4.3.2 Non-linear case

We extend our non-linear training-dynamics analysis in Figure 3, which plots the layer-wise cosine similarity between FOTON's update directions and the true backprop gradients on a 10-layer ReLU network. We find that:

* Across all ten layers, FOTON's cosine similarity remains strictly above 0.1, even in the deepest layers—indicating that it consistently transmits a meaningful descent direction through the non-linear activations. This is in striking contrast to PEPITA, whose cosine similarity stays near zero (and eventually becomes negative), effectively pointing its updates in random or adversarial directions.

* After the third hidden layer, FOTON's cosine similarity curve flattens out rather than decaying further with depth. We conjecture that ReLU's piecewise-linear structure, combined with our orthogonalization, prevents additional signal erosion once the error has traversed a few layers.

* Because FOTON's cosine similarity stays strictly positive and our learning rates are kept sufficiently small, Zoutendijk's theorem [25] guarantees that the algorithm will converge to a (local) minimum, which we indeed observe experimentally.

* To further increase this alignment, one could incorporate local Jacobian or activation-aware corrections into the construction of $F$, as well as explore lightweight regularizers that preserve orthogonality without full Björck projections. These directions could raise the cosine similarity even closer to 1 in the non-linear regime.

Overall, this analysis confirms that FOTON's forward-only updates remain a valid descent direction in deep non-linear networks—whereas PEPITA's updates not only lose coherence but can actively reverse the gradient—thus explaining FOTON's ability to scale to arbitrary depths.

## 4.4 Ablation Studies

We further explore the possibility of relaxing FOTON's theoretical constraints that we introduced in Section 3, namely the perfect weight alignment and the exact left orthogonality of the weight matrices. To do so, we conduct ablation studies on the orthogonalization rate and its effect on network performance, and on the role of computing the exact $F$ matrix at each step. Experiments on feedforward networks of varying depth on CIFAR-100 are presented in Figure 4.

### 4.4.1 Impact of the Orthogonalization Rate

The results presented in Figure 2 show that the orthogonality constraint is necessary but its enforcement might not be needed at each update step as in the linear case PEPITA can converge even in very deep networks, provided an orthogonal initialization.

The appropriate rate depends on the depth and complexity of the network, with different rates potentially enabling better convergence or hampering performance. A looser orthogonality condition can be found through careful tuning, as excessively loose enforcement of orthogonality can lead to network divergence.

The data in Figure 4a reveal a clear depth-dependent tolerance to infrequent orthogonalization. In the very shallow 2-layer model, pushing the orthogonalization interval out to 2000 steps actually yields the highest accuracy (≈ 25.8%), indicating that once weights are well-initialized, repeated re-orthogonalization can even slightly hamper learning in simple architectures. This is likely because strictly orthogonal constraints reduce the expressivity of shallow networks. This also shed light on why PEPITA might perform slightly better in the very shallow regime as seen on CIFAR-100 in Table 2.

By contrast, at depths 5, 10 and 50 the picture is very different: allowing an epoch to occur between re-orthogonalizations causes catastrophic collapse (accuracy drops to 1% on CIFAR-100 for intervals of 200 or 2000). This shows the paramount importance of the orthogonality constraint we propose to add to the standard PEPITA framework, without which relatively shallow networks cannot be trained.

Thus, while very shallow MLPs can “get by” on a single initial orthogonalization, deeper networks require fairly frequent enforcement (every 50 steps or less) to preserve the gradient-norm-preserving properties that underpin FOTON's stability. This suggests a simple rule of thumb: increase the orthogonalization frequency with network depth. While shallow nets tolerate (and may even benefit from) sparse updates, deep nets demand regular correction to avoid divergence.
<figure><img src="image_5.png" /><figcaption>(a) Test accuracy vs. orthogonalization rate frequency. A rate of 200 represents roughly an orthogonalization every epoch.</figcaption></figure>

<figure><img src="image_6.png" /><figcaption>(b) Test accuracy vs. *F*-update frequency. Tick “∞” means *F* was never updated after initialization.</figcaption></figure>

<caption>**Figure 4:** Performance on CIFAR-100 of feedforward networks with varying depth as a function of (a) the frequency of orthogonalization and (b) the frequency of *F*-matrix updates.</caption>

### 4.4.2 Impact of the Exact Weight Alignment

We next investigate how the sparsity of feedback-matrix updates impacts final test accuracy across different depths. Figure 4b shows, for each depth $d \in \{2, 5, 10, 50\}$, the accuracy when we recompute the error-projection matrix *F* every *k* steps ($k \in \{1, 10, 50, \infty\}$, where $\infty$ denotes “no update”).

At all depths, recomputing *F* on every forward pass ($k = 1$) yields the highest accuracy, and performance drops monotonically as updates become sparser ($k = 10$, then 50, then never). Surprisingly, even without any *F* refresh ($k = \infty$), the network still achieves non-trivial accuracy (e.g. 22.5% at depth 2 and 12.6% at depth 50). This suggests that a single, well-initialized orthogonal feedback matrix already provides enough signal to bootstrap learning—contrasting sharply with standard PEPITA, which fails to scale beyond 5 layers.

We find no “sweet spot” at which infrequent updates match the performance of dense updates: every configuration benefits from more frequent *F* refreshes. That said, these results motivate exploring approximate or smoothed update schemes—such as weight-mirroring [1]—to strike a better trade-off between computational cost and alignment quality, which we leave for future work.

## 5 Limitations and Discussion

Our experiments demonstrate that FOTON overcomes PEPITA's depth barrier and is a promising step towards the training of deep networks with forward-only algorithms. Under our orthogonality constraint, FOTON transmits far more faithful learning signals than PEPITA, matching exact backprop in the linear regime and maintaining strictly positive gradient alignment even through tens of non-linear layers.

We also show that despite the orthogonal constraint, FOTON is able to learn better than PEPITA, even for shallow networks, and manages to be competitive with BP on the tasks tested, without ever needing to backpropagate the error signal or to build and store an automatic-differentiation graph, dramatically cutting memory usage.

Crucially, our ablation on the *F*-matrix refresh rate shows that while recomputing *F* every step yields the highest accuracy, infrequent updates still produce nontrivial performance. This suggests avenues for smoother or occasional updates, removing computation overhead without collapsing training.

We also show that enforcing perfect orthogonality does restrict expressivity especially in shallow models. However, we find that deeper networks benefit from the norm-preserving and stability properties it provides. We also show that these ideas readily extend to convolutional layers via BCOP-orthogonalization, opening the door

to forward-only training of modern architectures, with a clear avenue being scaling to ResNets and Transformers. While our empirical results support stable gradient transmission, a formal non-linear theory of gradient alignment also remains a clear direction for future work.

Finally, there is ample room to reduce overhead and further close the gap with BP, for instance by integrating adaptive optimizers, lightweight orthogonality regularizers, or approximations of *F* updates (e.g., weight mirroring), as well as incorporating batch normalization and data augmentation. At the same time, certain standard operations such as max-pooling will require specific forward-only adaptations to fit within the FOTON framework.

These directions promise to further close the gap with BP while retaining FOTON's minimal-memory, purely-forward advantage. However, standard techniques like max-pooling would require a specific adaptation as a forward-only version is not straightforward to define.

## 6 Conclusion

The FOTON algorithm proposed in this work emerges as a promising forward-only alternative to conventional BP. It successfully solves the main limitation of PEPITA, which is the scalability to deep networks, resorting to the orthogonal constraint to provide a meaningful error signal to the network. We showed the ability of FOTON not only to learn better than PEPITA in most shallow settings, but also to scale to deeper networks and to be competitive with BP on the tasks tested. We further show that FOTON can be adapted to convolutional networks, opening up the possibility of applying it to more diverse architectures.

We provide a theoretical framework for FOTON, showing that it is equivalent to BP in the case of orthogonal linear networks and can approximate it well in the non-linear case. Our theoretical results and empirical findings are also analyzed through a thorough study of the training dynamics, underlying the key differences between FOTON and PEPITA in terms of the error signal transmitted to the network.

We also discuss the limitations of FOTON, notably the orthogonality constraint that could be a bottleneck for the expressiveness of the network and the possibility of relaxing it in future research. FOTON's performance on deep non-linear networks opens up avenues for its application in a broader range of settings. The adaptation and use of standard techniques for BP to improve its performance is a promising direction for future research.
## Acknowledgments

This work was performed using HPC resources from GENCI-IDRIS (grants AD011015154 and A0151014627), and received funding from the French Government via the program France 2030 ANR-23-PEIA-0008, SHARP.

## References

[1] M. Akrout, C. Wilson, P. Humphreys, T. Lillicrap, and D. B. Tweed. Deep learning without weight transport. *Advances in neural information processing systems*, 32, 2019.

[2] C. Anil, J. Lucas, and R. Grosse. Sorting out Lipschitz function approximation. In *K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning*, volume 97 of *Proceedings of Machine Learning Research*, pages 291–301. PMLR, 09–15 Jun 2019.

[3] S. Bartunov, A. Santoro, B. Richards, L. Marris, G. E. Hinton, and T. Lillicrap. Assessing the scalability of biologically-motivated deep learning algorithms and architectures. *Advances in neural information processing systems*, 31, 2018.

[4] G. Belouze. Optimization without backpropagation. *arXiv preprint arXiv:2209.06302*, 2022.

[5] A. Bjorck and C. Bowie. An iterative algorithm for computing the best estimate of an orthogonal matrix. *SIAM Journal on Numerical Analysis*, 8(2):358–364, 1971. ISSN 00361429. URL http://www.jstor.org/stable/2949484.

[6] P. Caillon, A. Colagrande, E. Fagnou, B. Delattre, and A. Allauzen. Supplementary material for "forward only learning for orthogonal neural networks of any depth", Aug. 2025. URL https://doi.org/10.5281/zenodo.16950205.

[7] B. A. Crafton, A. Parihar, E. Gebhardt, and A. Raychowdhury. Direct feedback alignment with sparse connections for local learning. *Frontiers in Neuroscience*, 13:525, 2019.

[8] G. Dellaferrera and G. Kreiman. Error-driven input modulation: solving the credit assignment problem without a backward pass. In *International Conference on Machine Learning*, pages 4937–4955. PMLR, 2022.

[9] L. Fournier, S. Rivaud, E. Belilovsky, M. Eickenberg, and E. Oyallon. Can forward gradient match backpropagation? In *International Conference on Machine Learning*, pages 10249–10264. PMLR, 2023.

[10] J. Guerguiev, K. Kording, and B. Richards. Spike-based causal inference for weight alignment. In *International Conference on Learning Representations*, 2020.

[11] A. Güneş Baydin, B. A. Pearlmutter, D. Syme, F. Wood, and P. Torr. Gradients without Backpropagation. *arXiv e-prints*, art. arXiv:2202.08587, Feb. 2022. doi: 10.48550/arXiv.2202.08587.

[12] G. Hinton. The forward-forward algorithm: Some preliminary investigations. *arXiv preprint arXiv:2212.13345*, 2022.

[13] J. Kendall, R. Pantone, K. Manickavasagam, Y. Bengio, and B. Scellier. Training end-to-end analog neural networks with equilibrium propagation. *arXiv preprint arXiv:2006.01981*, 2020.

[14] L. Khacef, P. Klein, M. Cartiglia, A. Rubino, G. Indiveri, and E. Chicca. Spike-based local synaptic plasticity: A survey of computational models and neuromorphic circuits. *Neuromorphic Computing and Engineering*, 3(4):042001, 2023.

[15] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. *arXiv preprint arXiv:1412.6980*, 2014.

[16] D. Kunin, A. Nayebi, J. Sagastuy-Brena, S. Ganguli, J. Bloom, and D. L. Yamins. Two routes to scalable credit assignment without weight symmetry. *arXiv preprint arXiv:2003.01513*, 2020.

[17] B. J. Lansdell, P. Prakash, and K. P. Kording. Learning to solve the credit assignment problem. In *International Conference on Learning Representations*, 2020.

[18] J. Launay, I. Poli, and F. Krzakala. Principled training of neural networks with direct feedback alignment. *arXiv preprint arXiv:1906.04554*, 2019.

[19] J. Launay, I. Poli, F. Boniface, and F. Krzakala. Direct feedback alignment scales to modern deep learning tasks and architectures. *Advances in neural information processing systems*, 33:9346–9360, 2020.

[20] Q. Li, S. Haque, C. Anil, J. Lucas, R. B. Grosse, and J.-H. Jacobsen. Preventing gradient attenuation in lipschitz constrained convolutional networks. *Advances in neural information processing systems*, 32, 2019.

[21] T. P. Lillicrap, D. Cownden, D. B. Tweed, and C. J. Akerman. Random synaptic feedback weights support error backpropagation for deep learning. *Nature communications*, 7(1):13276, 2016.

[22] T. P. Lillicrap, A. Santoro, L. Marris, C. J. Akerman, and G. Hinton.

Backpropagation and the brain. *Nature Reviews Neuroscience*, 21(6): 335–346, 2020.

[23] C. C. Margossian. A review of automatic differentiation and its efficient implementation. *Wiley interdisciplinary reviews: data mining and knowledge discovery*, 9(4):e1305, 2019.

[24] T. H. Moskovitz, N. A. Roy, and J. W. Pillow. A comparison of deep learning and linear-nonlinear cascade approaches to neural encoding. *BioRxiv*, page 463422, 2018.

[25] J. Nocedal and S. Wright. Numerical optimization springer-verlag. *New York*, 1999.

[26] A. Nøkland. Direct feedback alignment provides learning in deep neural networks. *Advances in neural information processing systems*, 29, 2016.

[27] M. Ren, S. Kornblith, R. Liao, and G. Hinton. Scaling forward gradient with local losses. *arXiv preprint arXiv:2210.03310*, 2022.

[28] P. Rodríguez, J. González, G. Cucurull, J. M. Gonfaus, and X. Roca. Regularizing CNNs with Locally Constrained Decorrelations. *arXiv e-prints*, art. arXiv:1611.01967, Nov. 2016. doi: 10.48550/arXiv.1611.01967.

[29] D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Learning representations by back-propagating errors. *Nature*, 323:533–536, 1986. URL https://api.semanticscholar.org/CorpusID:205001834.

[30] A. M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. *arXiv preprint arXiv:1312.6120*, 2013.

[31] D. Silver, A. Goyal, I. Danihelka, M. Hessel, and H. van Hasselt. Learning by directional gradient descent. In *International Conference on Learning Representations*, 2021.

[32] S. Singla and S. Feizi. Skew orthogonal convolutions. In *Proceedings of the International Conference on Machine Learning (ICML)*, 2021.

[33] R. F. Srinivasan, F. Mignacco, M. Sorbaro, M. Refinetti, A. Cooper, G. Kreiman, and G. Dellaferrera. Forward learning with top-down feedback: Empirical and analytical characterization. *arXiv preprint arXiv:2302.05440*, 2023.

[34] A. Trockman and J. Z. Kolter. Orthogonalizing convolutional layers with the cayley transform. In *International Conference on Learning Representations*, 2021.

[35] Y. Tsuzuku, I. Sato, and M. Sugiyama. Lipschitz-margin training: Scalable certification of perturbation invariance for deep neural networks. *Advances in neural information processing systems*, 31, 2018.

[36] W. Xiao, H. Chen, Q. Liao, and T. Poggio. Biologically-plausible learning algorithms can scale to large datasets. Technical report, Center for Brains, Minds and Machines (CBMM), 2018.

[37] X. Yi. Asymptotic Singular Value Distribution of Linear Convolutional Layers. *arXiv e-prints*, art. arXiv:2006.07117, June 2020. doi: 10.48550/arXiv.2006.07117.
## A Detailed Experimental Setup and Hyperparameters

In this section, we provide a comprehensive overview of the experimental setup and hyperparameters used in our study, detailing the conditions under which FOTON is evaluated. This includes the architectures, datasets, and training protocols chosen to highlight its practical performance compared to standard backpropagation and other forward-only baselines.

Unless otherwise specified, the orthogonalization rate is set to 1 and the number of Björck iterations used to orthogonalize the weights is fixed to 5. In the same way, unless otherwise specified, *F* is updated once per epoch to keep the weight mirroring assumption valid. The experiments were run on a single A100 GPU.

Table 4 shows the hyperparameters used for the 1, 2, and 3 hidden layers networks, Table 5 shows the hyperparameters used for the 5, 10 and 50 hidden layers networks and Table 6 shows the hyperparameters used for the convolutional networks.

<table><caption>Table 4: 1, 2, and 3 hidden layers network architectures and settings used in the experiments.</caption><thead><tr><th rowspan="2">Hyperparameters</th><th colspan="3">1 Hidden layer</th><th colspan="3">2 Hidden layers</th><th colspan="3">3 Hidden layers</th></tr><tr><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th></tr></thead><tbody><tr><td>Dataset</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Input size</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td></tr><tr><td>Hidden units</td><td>1 × 1024</td><td>1 × 1024</td><td>1 × 1024</td><td>2 × 1024</td><td>2 × 1024</td><td>2 × 1024</td><td>3 × 1024</td><td>3 × 1024</td><td>3 × 1024</td></tr><tr><td>Output units</td><td>10</td><td>10</td><td>100</td><td>10</td><td>10</td><td>100</td><td>10</td><td>10</td><td>100</td></tr><tr><td>Learning rate BP</td><td>0.1</td><td>0.01</td><td>0.1</td><td>0.1</td><td>0.01</td><td>0.1</td><td>0.1</td><td>0.01</td><td>0.1</td></tr><tr><td>Learning rate PEPITA</td><td>0.1</td><td>0.2</td><td>0.01</td><td>0.1</td><td>0.01</td><td>0.01</td><td>0.001</td><td>0.01</td><td>0.01</td></tr><tr><td>Learning rate FOTON</td><td>0.2</td><td>0.05</td><td>0.05</td><td>0.2</td><td>0.05</td><td>0.05</td><td>0.1</td><td>0.05</td><td>0.05</td></tr><tr><td>Weight decay BP</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Weight decay PEPITA</td><td>10<sup>-5</sup></td><td>10<sup>-4</sup></td><td>10<sup>-5</sup></td><td>10<sup>-5</sup></td><td>10<sup>-4</sup></td><td>10<sup>-5</sup></td><td>10<sup>-5</sup></td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td></tr><tr><td>Weight decay FOTON</td><td>0</td><td>0</td><td>0</td><td>10<sup>-2</sup></td><td>10<sup>-1</sup></td><td>0</td><td>0</td><td>0</td><td>10<sup>-3</sup></td></tr><tr><td>Batch size BP</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td></tr><tr><td>Batch size PEPITA</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td></tr><tr><td>Batch size FOTON</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td></tr><tr><td>Number of Epochs</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>Dropout BP</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Dropout PEPITA</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td><td>0.1</td></tr><tr><td>Dropout FOTON</td><td>0</td><td>0.1</td><td>0.2</td><td>0</td><td>0.2</td><td>0.2</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Error PEPITA</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td><td>MSE</td></tr><tr><td>Error FOTON</td><td>MSE</td><td>CE</td><td>CE</td><td>MSE</td><td>CE</td><td>CE</td><td>MSE</td><td>CE</td><td>CE</td></tr><tr><td>CE temperature</td><td></td><td>4</td><td>1</td><td></td><td>4</td><td>1</td><td></td><td>1</td><td>2</td></tr><tr><td>Decay epochs BP</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td></tr><tr><td>Decay epochs PEPITA</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td><td>60, 90</td></tr><tr><td>Decay epochs FOTON</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td><td>None</td></tr></tbody></table>

<table><caption>Table 5: 5, 10 and 50 hidden layers network architectures and settings used in the experiments.</caption><thead><tr><th rowspan="2">Hyperparameters</th><th colspan="3">5 Hidden layers</th><th colspan="3">10 Hidden layers</th><th colspan="3">50 Hidden layers</th></tr><tr><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th><th>MNIST</th><th>CIFAR10</th><th>CIFAR100</th></tr></thead><tbody><tr><td>Dataset</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Input size</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>32 × 32 × 3</td></tr><tr><td>Output units</td><td>10</td><td>10</td><td>100</td><td>10</td><td>10</td><td>100</td><td>10</td><td>10</td><td>100</td></tr><tr><td>Learning rate BP</td><td>0.1</td><td>0.01</td><td>0.1</td><td>0.1</td><td>0.01</td><td>0.1</td><td>0.01</td><td>0.01</td><td>0.01</td></tr><tr><td>Learning rate FOTON</td><td>0.2</td><td>0.01</td><td>0.01</td><td>0.01</td><td>0.01</td><td>0.01</td><td>0.1</td><td>0.005</td><td>0.005</td></tr><tr><td>Weight decay BP</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td></tr><tr><td>Weight decay FOTON</td><td>0</td><td>0</td><td>10<sup>-4</sup></td><td>0</td><td>0</td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td><td>10<sup>-4</sup></td></tr><tr><td>Batch size BP</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td></tr><tr><td>Batch size FOTON</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td><td>256</td></tr><tr><td>Number of Epochs</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>Dropout BP</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Dropout FOTON</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Error FOTON</td><td>MSE</td><td>CE</td><td>CE</td><td>MSE</td><td>CE</td><td>CE</td><td>MSE</td><td>CE</td><td>CE</td></tr><tr><td>CE temperature</td><td></td><td>1</td><td>2</td><td></td><td>2</td><td>2</td><td></td><td>2</td><td>2</td></tr><tr><td>Decay epochs BP</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td></tr><tr><td>Decay epochs FOTON</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td><td>30,60</td></tr></tbody></table>

In the first case reported Table 4, we used a hidden size of 1024 hidden units, either for 1, 2, or 3 hidden layers, and the output size was 10 for MNIST and CIFAR10, and 100 for CIFAR100. In the second case reported in Table 5, we used a hidden size of 256 units, and the output size was 10 for MNIST and CIFAR10, and 100 for CIFAR100. In the third case reported in Table 6, we used one or two convolutional layer with 32 filters of size 3 × 3 followed by a linear layer, after each convolution we applied a rescaled average pooling and the output size was 10 for MNIST and 100 for CIFAR100. The BP baseline was trained using standard SGD optimizer. The ReLU non linearity was used between every layer in every setting. However, for the deeper architecture with 50 layers we replaced ReLU with TanH, since preliminary trials showed that TanH helped mitigate the dying ReLU effect and consistently provided better results in terms of both convergence and final accuracy.

## B Theoretical comparison between FOTON and Backpropagation

In this section we prove in details that FOTON gives a first order approximation of the exact gradient computed by Backpropagation.
<table><caption>**Table 6:** 1 and 2 convolutional layers followed by a 1 linear layer classifier head architectures and settings used in the experiments.</caption><thead><tr><th>Hyperparameters</th><th colspan="2">1 convolutional layer</th><th colspan="2">2 convolutional layers</th></tr><tr><th>Dataset</th><th>MNIST</th><th>CIFAR100</th><th>MNIST</th><th>CIFAR100</th></tr></thead><tbody><tr><td>Input size</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td><td>28 × 28 × 1</td><td>32 × 32 × 3</td></tr><tr><td>Output units</td><td>10</td><td>100</td><td>10</td><td>100</td></tr><tr><td>Learning rate BP</td><td></td><td></td><td></td><td></td></tr><tr><td>Learning rate FOTON</td><td>0.08</td><td>0.08</td><td>0.06</td><td>0.01</td></tr><tr><td>Weight decay BP</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Weight decay FOTON</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Batch size BP</td><td>64</td><td>64</td><td>64</td><td>64</td></tr><tr><td>Batch size FOTON</td><td>256</td><td>256</td><td>256</td><td>256</td></tr><tr><td>Number of Epochs</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>Dropout BP</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Dropout FOTON</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Error FOTON</td><td>CE</td><td>CE</td><td>CE</td><td>CE</td></tr><tr><td>CE temperature</td><td>1</td><td>1</td><td>2</td><td>1</td></tr><tr><td>Decay epochs BP</td><td>None</td><td>None</td><td>None</td><td>None</td></tr><tr><td>Decay epochs FOTON</td><td>None</td><td>None</td><td>None</td><td>None</td></tr></tbody></table>

## B.1 Equivalence in deep linear regime

We start showing the simplified result in the case of deep linear networks that are neural networks without activation functions. These models are just a composition of linear functions and therefore they do not have any approximation advantage over a linear regression, however they differ in the optimization dynamics and while PEPITA, and its variants, match backpropagation in the linear regression case they differ from exact gradient computation on linear deep neural networks. We show that FOTON computes exactly the gradients in this case and experiments support our theoretical findings. We believe that the simplified case will make more clear the role of orthogonality and of FOTON's learning rule.

**Theorem B.1 (Equivalence in deep linear regime).** In the case of deep linear neural networks, FOTON perfectly matches backpropagation, i.e.

$$ \delta W_{\ell}^{FO} = \delta W_{\ell}^{BP} = \frac{\partial \mathcal{L}}{\partial W_{\ell}} \quad \forall \ell = 1, \dots, L $$

*Proof.* We start recalling the update of backpropagation:

$$ \delta W_{\ell}^{BP} = -\eta \delta a_{\ell}^{BP} (h_{\ell-1})^{\top} \quad \text{for } 1 \le \ell < L; \qquad (14) $$

$$ \delta W_{L}^{BP} = -\eta e h_{L-1}^{\top}. \qquad (15) $$

It follows that FOTON is equivalent to backpropagation if and only if $\delta a_{\ell}^{FO} = \delta a_{\ell}^{BP}$ for all $\ell$. The two recursive formulas can be expanded as follows:

$$ \delta a_{\ell}^{FO} = W_{\ell} \sigma_{\ell-1}(W_{\ell-1} \sigma_{\ell-2}(\cdots \sigma_{1}(W_{1}x))) - W_{\ell} \sigma_{\ell-1}(W_{\ell-1} \sigma_{\ell-2}(\cdots \sigma_{1}(W_{1}(x-Fe))) $$

$$ \delta a_{\ell}^{BP} = \sigma'_{\ell} W_{\ell+1}^{\top} \sigma'_{\ell+1} \cdots W_{L}^{\top} e $$

In the linear case, that is when the activation function are the identity, the two become:

$$ \delta a_{\ell}^{FO} = W_{\ell}(W_{\ell-1}(\cdots W_{1}x)) - W_{\ell}(W_{\ell-1}(\cdots W_{1}(x-Fe))) $$

$$ \delta a_{\ell}^{BP} = W_{\ell+1}^{\top} W_{\ell+2}^{\top} \cdots W_{L}^{\top} e $$

When the weight matrices are row-orthogonal, the first update of FOTON is the following:

$$ \delta a_{\ell}^{FO} = W_{\ell}(W_{\ell-1}(\cdots W_{1}Fe)) $$

and admitting a perfect weight alignment, as implemented in FOTON, since $F = W_{1}^{\top} W_{2}^{\top} \cdots W_{L}^{\top}$, we have:

$$ \delta a_{\ell}^{FO} = W_{\ell}(W_{\ell-1}(\cdots W_{1}W_{1}^{\top} W_{2}^{\top} \cdots W_{L}^{\top})e) = W_{\ell+1}^{\top} W_{\ell+2}^{\top} \cdots W_{L}^{\top} e = \delta a_{\ell}^{BP} $$

and the proof is complete. □

## B.2 Equivalence in deep norm-preserving regime

FOTON may perfectly match backpropagation in a more general and interesting case than the previously discussed linear one but at the cost of a bigger memory consumption. This will not make FOTON a valuable alternative to the better performing backpropagation but it shows a closer gap to exact gradient computation with respect to PEPITA.
**Theorem B.2.** Let $f$ be an orthogonal neural network with piecewise orthogonal (and linear) activation functions, such as GroupSort. We assume that the non-linear activations are incorporated in the matrix $F$ as

$$F = W_1^\top \sigma'_1 W_2^\top \sigma'_2 \cdots W_L^\top$$

where the gradient of the activation functions are taken in the respective activation $h_\ell$ obtained from the standard forward pass of $x$. In this case FOTON is exactly equivalent to backpropagation, i.e.

$$\delta W_{\ell}^{FO} = \delta W_{\ell}^{BP} \quad \forall \ell$$

*Proof.* The proof is similar to the one given in B.1 with some additional details to take care of. First of all, the error $e$ can be considered small compared to $x$, i.e. $||Fe|| \ll ||x||$. We can thus assume that the activation patterns by $x$ do not change from those by $x - Fe$ and so we have that

$$\begin{aligned} \delta a_{\ell}^{FO} &= W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 (W_1 x))) - W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 (W_1 (x - Fe)))) \\ &= W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 (W_1 (Fe)))) \end{aligned}$$

and thus we have

$$\begin{aligned} \delta a_{\ell}^{FO} &= W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 W_1 W_1^{\top} \sigma'_1 W_2^{\top} \sigma'_2 \cdots \sigma'_{L-1} W_L^{\top}) e) \\ &= \sigma'_{\ell} W_{\ell+1}^{\top} \sigma'_{\ell+1} \cdots \sigma'_{L-1} W_L^{\top} e \\ &= \delta a_{\ell}^{BP} \end{aligned}$$

since the activation $\sigma_\ell$ are piecewise orthogonal $\forall \ell$.

□

*Remark B.3.* The main issue with the previous theorem is that the gradients w.r.t the activations depend on the single data points. Therefore in order to implement this version, we need to store a matrix $F$ for any data point (or equivalently a tensor of size the dimension of $F$ times the batch size) obtaining an algorithm with a memory cost comparable to backpropagation. A main advantage of FOTON is to have a memory cost independent of the batch size in the error projection, which is a major advantage in the case of large batch sizes.

## B.3 Linear approximation in deep non-linear regime

In the case of non-linear networks, there is no guarantee for FOTON to match backpropagation. However some approximations allow us to see how it can still approach backpropagation and make the model learn.

Let $f$ be an orthogonal neural network with any non-linear activation functions $\sigma_\ell$. If we approximate the activation functions linearly ($\sigma_\ell(x) \approx \lambda x$), we get:

$$\begin{aligned} \delta h_{\ell}^{FO} &= \sigma_{\ell} (W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 (W_1 x)))) - \sigma_{\ell} (W_{\ell} \sigma_{\ell-1} (W_{\ell-1} \sigma_{\ell-2} (\cdots \sigma_1 (W_1 (x - Fe)))) \\ &\approx \lambda W_{\ell} \lambda W_{\ell-1} \lambda \cdots \lambda W_1 Fe \\ &= \lambda^{\ell} \cdot W_{\ell+1}^{T} W_{\ell+2}^{T} \cdots W_{L}^{T} \nabla_{L} \mathcal{L} \end{aligned}$$

$\text{and}$
$$\delta h_{\ell}^{BP} = W_{\ell+1}^{\top} \sigma'_{\ell+1} \cdots W_{L}^{\top} e \approx \lambda^{L-\ell+1} \cdot W_{\ell+1}^{\top} W_{\ell+2}^{\top} \cdots W_{L}^{\top} \nabla_{L} \mathcal{L}$$
This leads to:
$$\delta h_{\ell}^{FO} \approx \lambda^{2\ell-L+1} \cdot \delta h_{\ell}^{BP}$$

This indicates that the FOTON learning rule can still provide a descent direction in the non-linear case. This is further confirmed in our experiments, where FOTON performs close to backpropagation in many different settings.

## C Extension of FOTON to Convolutional Networks

As mentioned in the main text, the application of FOTON to convolutional networks is non-trivial, as the orthogonality constraint is applied to the Toeplitz matrix and not to the convolutional kernel. In the original PEPITA paper [8], a seminal proposition to update convolutional layers relying on forward-only algorithm was made. The kernels are learned based on post and pre-synaptic related terms and the update is computed for each filter. When writing the convolutional layer as a linear operation (the corresponding matrix is a concatenation of doubly Toeplitz matrices as shown by Yi [37]), this update does not match the original PEPITA update, as the update is not computed on the kernel indices but on the kernel patches. In FOTON, we propose to apply the same update as in the fully connected layers. We designed the convolutional update of FOTON to match backpropagation in the linear (or piecewise linear) case as in section B.1. In this section, we first recall the update rule for backpropagation and derive the update rule for FOTON, using the analogy built in section B.1.
For an MLP, BP updates the parameters as: $\delta W_{\ell} = \frac{\partial \mathcal{L}}{\partial W_{\ell}} = \frac{\partial \mathcal{L}(W_{\ell}h_{\ell-1})}{\partial W_{\ell}} = \delta a_{\ell}h_{\ell-1}^T$, where $\mathcal{L}$ is the loss function. This follows from the fact that

$$ \begin{aligned} \partial \mathcal{L}((W_{\ell} + \mathcal{E})h_{\ell-1}) &= \partial \mathcal{L}(W_{\ell}h_{\ell-1}) + \left\langle \frac{\partial \mathcal{L}}{\partial W_{\ell}h_{\ell-1}}, \mathcal{E}h_{\ell-1} \right\rangle + o(\|\mathcal{E}\|) \\ &= \partial \mathcal{L}(W_{\ell}h_{\ell-1}) + \left\langle \frac{\partial \mathcal{L}}{\partial W_{\ell}h_{\ell-1}}h_{\ell-1}^{\top}, \mathcal{E} \right\rangle + o(\|\mathcal{E}\|) \end{aligned} $$

and the result follows from the definition of differential.

In the case of convolutional layers, the $W_{\ell}h_{\ell-1}$ is replaced by the convolution $k_{\ell} * h_{\ell-1}$ where $k_{\ell}$ is the kernel. It follows that:

$$ \begin{aligned} \mathcal{L}((k_{\ell} + \mathcal{E}) * h_{\ell-1}) &= \mathcal{L}(k_{\ell} * h_{\ell-1}) + \left\langle \frac{\partial \mathcal{L}}{\partial k_{\ell} * h_{\ell-1}}, \mathcal{E} * h_{\ell-1} \right\rangle + o(\|\mathcal{E}\|) \\ &= \mathcal{L}(W_{\ell} * h_{\ell-1}) + \left\langle \frac{\partial \mathcal{L}}{\partial W_{\ell} * h_{\ell-1}}, h_{\ell-1} * \mathcal{E} \right\rangle + o(\|\mathcal{E}\|) \\ &= \mathcal{L}(W_{\ell} * h_{\ell-1}) + \left\langle \frac{\partial \mathcal{L}}{\partial W_{\ell} * h_{\ell-1}}, \text{conv}_{h_{\ell-1}}(\mathcal{E}) \right\rangle + o(\|\mathcal{E}\|) \\ &= \mathcal{L}(W_{\ell} * h_{\ell-1}) + \left\langle \text{conv}_{h_{\ell-1}}^{*} \left( \frac{\partial \mathcal{L}}{\partial W_{\ell} * h_{\ell-1}} \right), \mathcal{E} \right\rangle + o(\|\mathcal{E}\|) \end{aligned} $$

where $\text{conv}_k(x) = k * x$ is the left-convolution by a fixed kernel $k$. Since it's a linear operator, it admits an adjoint, the *transposed convolution*, that we denote by $\star$. It follows that the update rule for the kernel in backpropagation is:

$$ \delta k_{\ell} = \text{conv}_{h_{\ell-1}}^{*}(\delta a_{\ell}) $$

To match BP in the linear and piecewise linear case, FOTON updates the kernel as follows:

$$ \begin{aligned} \delta k_{\ell} &= \text{conv}_{h_{\ell-1}}^{*}(\delta a_{\ell}^{\text{FO}}) \\ &= \text{conv}_{h_{\ell-1}}^{*}(a_{\ell} - a_{\ell}^{\text{err}}) \end{aligned} $$

In practice, the $\text{conv}_{h_{\ell}}^{*}$ operator corresponds to the `torch nn grad conv2d input` function in PyTorch.

# D Choice of Pooling Module

Pooling modules are important parts of convolutional neural networks and they are often considered as non linear activations so the theory developed in B.3 applies identically. Max pooling and average pooling are among the most used pooling modules. Adapting max pooling to any forward-only learning system, is however not straightforward. The nature of max pooling itself, which selects the maximum value from a set of inputs and discards the rest is inherently non-differentiable. Handling its selective nature and data-dependency cannot be done only by keeping track of the maximum value as is done in backpropagation.

The alternative we used is average pooling, which is differentiable more compatible with FOTON's forward-only error-driven modulation. Average pooling is linear and row orthogonal if scaled by $\sqrt{2}$, which we implemented to keep the FOTON's orthogonality constraint.

However, it is important to note that in practice, max pooling tends to outperform average pooling in terms of performance in most computer vision tasks, particularly in image classification tasks with datasets such as CIFAR10 and CIFAR100. Adapting max-pooling to FOTON could be a potential future research direction, as it would align better with the standard practice in the field.