Title: Module-wise Training of Neural Networks via the Minimizing Movement Scheme
Venue: NeurIPS 2023
Accepted: yes
Keywords: Deep learning

greedy layerwise training

memory

optimal transport
Abstract: Greedy layer-wise or module-wise training of neural networks is compelling in constrained and on-device settings where memory is limited, as it circumvents a number of problems of end-to-end back-propagation. However, it suffers from a stagnation problem, whereby early layers overfit and deeper layers stop increasing the test accuracy after a certain depth. We propose to solve this issue by introducing a simple module-wise regularization inspired by the minimizing movement scheme for gradient flows in distribution space. We call the method TRGL for Transport Regularized Greedy Learning and study it theoretically, proving that it leads to greedy modules that are regular and that progressively solve the task. Experimentally, we show improved accuracy of module-wise training of various architectures such as ResNets, Transformers and VGG, when our regularization is added, superior to that of other module-wise training methods and often to end-to-end training, with as much as 60% less memory usage.

Module-wise Training of Neural Networks via the Minimizing Movement Scheme

Abstract

Greedy layer-wise or module-wise training of neural networks is compelling in constrained and on-device settings where memory is limited, as it circumvents a number of problems of end-to-end back-propagation. However, it suffers from a stagnation problem, whereby early layers overfit and deeper layers stop increasing the test accuracy after a certain depth. We propose to solve this issue by introducing a module-wise regularization inspired by the minimizing movement scheme for gradient flows in distribution space. We call the method TRGL for Transport Regularized Greedy Learning and study it theoretically, proving that it leads to greedy modules that are regular and that progressively solve the task. Experimentally, we show improved accuracy of module-wise training of various architectures such as ResNets, Transformers and VGG, when our regularization is added, superior to that of other module-wise training methods and often to end-to-end training, with as much as 60% less memory usage.

1 Introduction

End-to-end backpropagation is the standard training method of neural networks. However, it requires storing the whole model and computational graph during training, which requires large memory consumption. It also prohibits training the layers in parallel. Dividing the network into modules, a module being made up of one or more layers, accompanied by auxiliary classifiers, and greedily solving module-wise optimization problems sequentially (i.e. one after the other fully) or in parallel (i.e. at the same time batch-wise), consumes much less memory than end-to-end training as it does not need to store as many activations, and when done sequentially, only requires loading and training one module (so possibly one layer) at a time. Module-wise training has therefore been used in constrained settings in which end-to-end training can be impossible such as training on mobile devices [58, 57] and dealing with very large whole slide images [65]. When combined with batch buffers, parallel module-wise training also allows for parallel training of the modules [8]. Despite its simplicity, module-wise training has been recently shown to scale well [8, 47, 60, 45], outperforming more complicated alternatives to end-to-end training such as synthetic [33, 14] and delayed [32, 31] gradients, while having superior memory savings.

In a classification task, module-wise training splits the network into successive modules, a module being made up of one or more layers. Each module takes as input the output of the previous module, and each module has an auxiliary classifier so that a local loss can be computed, with backpropagation happening only inside the modules and not between them (see Figure 1 below).

The main drawback of module-wise training is the well-documented stagnation problem observed in [43, 7, 60, 47], whereby early modules overfit and learn more discriminative features than end-to-end

training, destroying task-relevant information, and deeper modules don't improve the test accuracy significantly, or even degrade it, which limits the deployment of module-wise training. We further highlight this phenomenon in Figures 2 and 3 in Section 4.4. To tackle this issue, InfoPro [60] propose to maximize the mutual information that each module keeps with the input, in addition to minimizing the loss. [7] make the auxiliary classifier deeper and Sedona [47] make the first module deeper. These last two methods lack a theoretical grounding, while InfoPro requires a second auxiliary network for each module besides the classifier. We propose a different perspective, leveraging the analogy between residual connections and the Euler scheme for ODEs [61]. To preserve input information, we minimize the kinetic energy of the modules along with the training loss. Intuitively, this forces the modules to change their input as little as possible. We leverage connections with the theories of gradient flows in distribution space and optimal transport to analyze our method theoretically.

:input

y : label

l : loss

k : output of Tk

Zk : prediction of Fk

Forward-prop

Back-prop

1(21,y)

1(22, y)

1(23, y)

:input

21

22

23

y : label

l : loss

Classifier

Classifier

Classifier

F1

F2

F3

k : output of Tk

Zk : prediction of Fk

C1

C2

Forward-prop

Module

C1

Module

C2

Module

Back-prop

T1

T2

T3

Our approach is particularly well-adapted to networks that use residual connections such as ResNets [27, 28], their variants (e.g. ResNeXt [62], Wide ResNet [63], EfficientNet [56] and MobileNetV2 [48]) and vision transformers that are made up essentially of residual connections [39, 17], but is immediately usable on any network where many layers have the same input and output dimension such as VGG [52]. Our contributions are the following:

We propose a new method for module-wise training. Being a regularization, it is lighter than many recent state-of-the-art methods (PredSim [45], InfoPro [60]) that train another auxiliary network besides the auxiliary classifier for each module.

We theoretically justify our method, proving that it is a transport regularization that forces the module to be an optimal transport map making it more regular and stable. We also show that it amounts to a discretization of the gradient flow of the loss in probability space, which means that the modules progressively minimize the loss and explains why the method avoids the accuracy collapse observed in module-wise training.

Experimentally, we consistently improve the test accuracy of module-wise trained networks (ResNets, VGG and Swin-Transformer) beating 8 other methods, in sequential and parallel module-wise training, and also in multi-lap sequential training, a variant of sequential module-wise training that we introduce and that performs better in many cases. In particular, our regularization makes parallel module-wise training superior or comparable in accuracy to end-to-end training, while consuming 10% to 60% less memory.

2 Transport-regularized module-wise training

The typical setting of (sequential) module-wise training for minimizing a loss L , is, given a dataset D , to solve one after the other, for 1 ≤ k ≤ K , Problems

where G k = T k ◦ ... ◦ T 1 for 1 ≤ k ≤ K , G 0 = id , T k is the module (one or many layers) and F k is an auxiliary classifier. Module T k receives the output of module T k -1 , and auxiliary classifier F k computes the prediction from the output of T k so the loss can be computed. The inputs are x and L has access to their labels y to calculate the loss. i.e. L ( F, T ◦ G k -1 ( x )) = l ( F ◦ T ◦ G k -1 ( x ) , y ) where l is a machine learning loss such as cross-entropy. See Figure 1. The final network trained this way is F K ◦ G K . But, at inference, we can stop at any depth k and use F k ◦ G k if it performs better. Indeed, an intermediate module often performs as well or better than the last module because of the early overfitting and subsequent stagnation or collapse problem of module-wise training [43, 7, 60, 47].

We propose below in (2) a regularization that avoids the destruction of task-relevant information by the early modules by forcing them to minimally modify their input. Proposition 2.2 proves that by using our regularization (2), we are indeed making the modules build upon each other to solve the task, which is the property we desire in module-wise training, as the modules now act as successive proximal optimization steps in the minimizing movement scheme optimization algorithm for maximizing the separability of the data representation. The background on optimal transport (OT), gradient flows and the minimizing movement scheme is in Appendices A and B.

2.1 Method statement

To keep greedily-trained modules from overfitting and destroying information needed later, we penalize their kinetic energy to force them to preserve the geometry of the problem as much as possible. If each module is a single residual block (that is a function T = id + r , which includes many transformer architectures [39, 17]), its kinetic energy is simply the squared norm of its residue r = T -id , which we add to the loss L in the target of the greedy problems (1). All layers that have the same input and output dimension can be rewritten as residual blocks and the analysis applies to a large variety of architectures such as VGG [52]. Given τ> 0 , we now solve, for 1 ≤ k ≤ K , Problems

where G τ k = T τ k ◦ .. ◦ T τ 1 for 1 ≤ k ≤ K and G τ 0 = id . The final network is F τ K ◦ G τ K . Intuitively, this biases the modules towards moving the points as little as possible, thus at least keeping the performance of the previous module. Residual connections are already biased towards small displacements and this bias is desirable and should be encouraged [35, 64, 26, 15, 36]. But the method can be applied to any module where T ( x ) and x have the same dimension so that T ( x ) -x can be computed.

To facilitate the theoretical analysis, we rewrite the method in a more general formulation using data distribution ρ , which can be discrete or continuous, and the distribution-wide loss L that arises from the point-wise loss L . Then Problem (2) is equivalent to Problem

with ρ τ k +1 =( T τ k ) glyph[sharp] ρ τ k , ρ τ 1 = ρ and L ( F, T glyph[sharp] ρ τ k ) = ∫ L ( F, T ( x )) d ρ τ k ( x ) = ∫ L ( F, z ) d T glyph[sharp] ρ τ k ( x ) .

2.2 Link with the minimizing movement scheme

We now formulate our main result: solving Problems (3) is equivalent to following a minimizing movement scheme (MMS) [50] in distribution space for minimizing Z ( µ ) := min F L ( F, µ ) , which is the loss of the best classifier. If we are limited to linear classifiers, Z ( ρ τ k ) is the linear separability of the representation ρ τ k at module k of the data distribution ρ . The MMS, introduced in [24, 23], is a metric counterpart to Euclidean gradient descent for minimizing functionals over distributions. In our case, Z is the functional we want to minimize. We define the MMS below in Definition 2.1

The distribution space we work in is the metric Wasserstein space W 2 (Ω) = ( P (Ω) , W 2 ) , where Ω ⊂ R d is a convex compact set, P (Ω) is the set of probability distributions over Ω and W 2 is the Wasserstein distance over P (Ω) derived from the optimal transport problem with Euclidean cost:

where we assume that ∂ Ω is negligible and that the distributions are absolutely continous.

Definition 2.1. Given Z : W 2 (Ω) → R , and starting from ρ τ 1 ∈ P (Ω) , the Minimizing Movement Scheme (MMS) takes proximal steps for minimizing Z . It is s given by

The MMS (5) can be seen as a non-Euclidean implicit Euler step for following the gradient flow of Z , and ρ τ k converges to a minimizer of Z under some conditions (see the end of this section).

So under the mentioned assumptions on Ω and absolute continuity of the distributions, we have that Problems (3) are equivalent to the minimizing movement scheme (5):

Proposition 2.2. The distributions ρ τ k +1 = ( T τ k ) glyph[sharp] ρ τ k , where the functions T τ k are found by solving (3) and ρ τ 1 = ρ is the data distribution, coincide with the MMS (5) for Z = min F L ( F, . ) .

Proof. The minimizing movement scheme (5) is equivalent to taking ρ τ k +1 = ( T τ k ) glyph[sharp] ρ τ k where

under conditions that guarantee the existence of a transport map between ρ τ k and any other measure, and absolute continuity of ρ τ k suffices, and the loss can ensure that ρ τ k +1 is also absolutely continuous. Among the functions T τ k that solve problem (6), is the optimal transport map from ρ τ k to ρ τ k +1 . To solve specifically for this optimal transport map, we have to solve the equivalent Problem

Problems (6) and (7) have the same minimum value, but the minimizer of (7) is now an optimal transport map between ρ τ k and ρ τ k +1 . This is immediate from the definition (4) of the W 2 distance. Equivalently minimizing first over F and then over T in (3), it follows from the definition of Z that Problems (3) and (7) are equivalent, which concludes.

Since we solve Problems (3) over neural networks, their representation power shown by universal approximation theorems [13, 29] is important to get close to equivalence between (5) and (3), as we need to approximate an optimal transport map. We also know that the training of each module, if it is shallow, converges [5, 6, 34, 22, 18].

If Z is lower-semi continuous then Problems (5) always admit a solution because P (Ω) is compact. If Z is also λ -geodesically convex for λ> 0 , we have convergence of ρ τ k as k →∞ and τ → 0 to a minimizer of Z , potentially under more technical conditions (see Appendix B). Even though a machine learning loss will usually not satisfy these conditions, this analysis offers hints as to why our method avoids in practice the problem of stagnation or collapse in performance of module-wise training as k increases, as we are making proximal local steps in Wasserstein space to minimize the loss. This convergence discussion also suggests taking τ as small as possible and many modules.

2.3 Regularity result

As a secondary result, we show that Problem (3) has a solution and that the solution module T τ k is an optimal transport map between its input and output distributions, which means that it comes with some regularity. [36] show that these networks generalize better and overfit less in practice. We assume that the minimization in F is over a compact set F , that ρ τ k is absolutely continuous, that L is continuous and non-negative, that Ω is convex and compact and that ∂ Ω is negligible.

Proposition 2.3. Problem (3) has a minimizer ( T τ k , F τ k ) such that T τ k is an optimal transport map. And for any minimizer ( T τ k , F τ k ) , T τ k is an optimal transport map.

The proof is in Appendix C. OT maps have regularity properties under some boundedness assumptions. Given Theorem A.1 in Appendix A taken from [20], T τ k is η -Hölder continuous almost everywhere and if the optimization algorithm we use to solve the discretized problem (2) returns an approximate solution pair ( ˜ F τ k , ˜ T τ k ) such that ˜ T τ k is an glyph[epsilon1] -optimal transport map, i.e. ‖ ˜ T τ k -T τ k ‖ ∞ ≤ glyph[epsilon1] , then we have (using the triangle inequality) the following stability property of the module ˜ T τ k :

for almost every x, y ∈ supp ( ρ τ k ) and C> 0 . Composing these stability bounds on T τ k and ˜ T τ k allows to get bounds for the composition networks G τ k and ˜ G τ k = ˜ T τ k ◦ .. ◦ ˜ T τ 1 .

To summarize Section 2, the transport regularization makes each module more regular and it allows the modules to build on each other as k increases to solve the task, which is the property we desire.

3 Practical implementation

3.1 Multi-block modules

For simplicity, we presented in (2) the case where each module is a single residual block. However, in practice, we often split the network into modules that are made-up of many residual blocks each. We show here that regularizing the kinetic energy of such modules still amounts to a transport regularization, which means that the theoretical results in Propositions 2.2 and 2.3 still apply.

If each module T k is made up of M residual blocks, i.e. applies x m +1 = x m + r m ( x m ) for 0 ≤ m<M , then its total discrete kinetic energy for a single data point x 0 is the sum of its squared residue norms ∑ ‖ r m ( x m ) ‖ 2 , since a residual network can be seen as a discrete Euler scheme for an ordinary differential equation [61] with velocity field r :

and ∑ ‖ r m ( x m ) ‖ 2 is then the discretization of the total kinetic energy ∫ 1 0 ‖ r t ( x ) ‖ 2 d t of the ODE. If ψ x m denotes the position of a point x after m residual blocks, then regularizing the kinetic energy of multi-block modules now means solving

where G τ k = T τ k ◦ .. ◦ T τ 1 for 1 ≤ k ≤ K and G τ 0 = id . We also minimize this sum of squared residue norms instead of ‖ T ( x ) -x ‖ 2 (the two no longer coincide) as it works better in practice, which we assume is because it offers a more localized control of the transport. As expressed in (9), a residual network can be seen as an Euler scheme of an ODE and Problem (10) is then the discretization of

where ρ τ k +1 = ( T τ k ) glyph[sharp] ρ τ k and r m is the discretization of vector field v t at time t = m/M . Here, distributions ρ τ k are pushed forward through the maps T τ k which correspond to the flow φ at time t = 1 of the kinetically-regularized velocity field v t . We recognize in the second term in the target of (11) the optimal transport problem in its dynamic formulation (15) from [9], and given the equivalence between the Monge OT problem (4) and the dynamic OT problem (15) in Appendix A, Problem (11) is in fact equivalent to the original continuous formulation (3), and the theoretical results in Section 2 follow immediately (see also the proof of Proposition 2.3 in Appendix C).

3.2 Solving the module-wise problems

The module-wise problems can be solved in two ways. One can completely train each module with its auxiliary classifier for N epochs before training the next module, which receives as input the output of the previous trained module. We call this sequential module-wise training. But we can also do this batch-wise, i.e. do a complete forward pass on each batch but without a full backward pass, rather a backward pass that only updates the current module T τ k and its auxiliary classifier F τ k , meaning that T τ k forwards its output to T τ k +1 immediately after it computes it. We call this parallel module-wise training. It is called decoupled greedy training in [8], which shows that combining it with batch buffers solves all three locking problems and allows a linear training parallelization in the depth of the network. We propose a variant of sequential module-wise training that we call multi-lap sequential module-wise training, in which instead of training each module for N epochs, we train each module from the first to the last sequentially for N/R epochs, then go back and train from the first module to

the last for N/R epochs again, and we do this for R laps. For the same total number of epochs and training time, and the same advantages (loading and training one module at a time) this provides a non-negligible improvement in accuracy over normal sequential module-wise training in most cases, as shown in Section 4. Despite our theoretical framework being that of sequential module-wise training, our method improves the test accuracy of all three module-wise training regimes.

3.3 Varying the regularization weight

The discussion in Section 2.2 suggests taking a fixed weight τ for the transport cost that is as small as possible. However, instead of using a fixed τ , we might want to vary it along the depth k to further constrain with a smaller τ k the earlier modules to avoid that they overfit or the later modules to maintain the accuracy of earlier modules. We might also want to regularize the network further in earlier epochs when the data is more entangled. We propose in Appendix D to formalize this varying weight τ k,i across modules k and SGD iterations i by using a scheme inspired by the method of multipliers to solve Problems (2) and (10). However, it works best in only one experiment in practice. The observed dynamics of τ k,i suggest simply finding a fixed value of τ that is multiplied by 2 for the second half of the network, which works best in all the other experiments (see Appendix E).

4 Experiments

We call our method TRGL for Transport-Regularized Greedy Learning. For the auxiliary classifiers, we use the architecture from DGL [7, 8], that is a convolution followed by an average pooling and a fully connected layer, which is very similar to that used by InfoPro [60], except for the Swin Transformer where we use a linear layer. We call vanilla greedy module-wise training with the same architecture but without our regularization VanGL, and we include its results in all tables for ablation study purposes. The code is available at github.com/block-wise/module-wise and implementation details are in Appendix E.

4.1 Parallel module-wise training

To compare with other methods, we focus first on parallel training, as it performs better than sequential training and has been more explored recently. The first experiment is training in parallel 3 residual architectures and a VGG-19 [52] divided into 4 modules of equal depth on TinyImageNet. We compare in Table 1 our results in this setup to three of the best recent parallel module-wise training methods: DGL [8], PredSim [45] and Sedona [47], from Table 2 in [47]. We find that our TRGL has a much better test accuracy than the three other methods, especially on the smaller architectures. It also performs better than end-to-end training on the three ResNets. Parallel TRGL in this case with 4 modules consumes 10 to 21% less memory than end-to-end training (with a batch size of 256).

The second experiment is training in parallel two ResNets divided into 2 modules on CIFAR100 [37]. We compare in Table 2 our results in this setup to the two delayed gradient methods DDG [32] and FR [31] from Table 2 in [31]. Here again, parallel TRGL has a better accuracy than the other two methods and than end-to-end training. With only two modules, the memory gains from less backpropagation are neutralized by the weight of the extra classifier and there are negligible memory savings compared to end-to-end training. However, parallel TRGL has a better test accuracy by up to almost 2 percentage points.

The third experiment is training in parallel a ResNet-110 divided into two, four, eight and sixteen modules on STL10 [12]. We compare in Table 3 our results in this setup to the recent methods InfoPro [60] and DGL [8] from Table 2 in [60]. TRGL largely outperforms the other methods. It also outperforms end-to-end training in all but one case (that with 16 modules). With a batch size of 64, memory savings of parallel TRGL compared to end-to-end training reach 48% and 58 . 5% with 8 and 16 modules respectively, with comparable test accuracy. With 4 modules, TRGL training weighs 24% less than end-to-end-training, and has a test accuracy that is better by 2 percentage points (see Section 4.2 and Table 6 for a detailed memory usage comparison with InfoPro).

The fourth experiment is training (from scratch) in parallel a Swin-Tiny Transformer [39] divided into 4 modules on three datasets. We compare in Table 4 our results with those of InfoPro [60] and InfoProL, a variant of InfoPro proposed in [46]. TRGL outperforms the other module-wise training methods. It does not outperform end-to-end training in this case, but consumes 29% less memory on CIFAR10 and CIFAR100 and 50 % less on STL10, compared to 38% for InfoPro and 45% for InfoProL in [46].

Finally, we compare our method to InfoPro, DGL and Sedona in Table 5 below on a large scale experiment on ImageNet.

4.2 Memory savings and training time

As seen above, parallel TRGL is lighter than end-to-end training by up to almost 60% . The extra memory consumed by our regularization compared to parallel VanGL is between 2 and 13% of

end-to-end memory. Memory savings depend then mainly on the size of the auxiliary classifier, which can easily be adjusted. Note that delayed gradients method DDG and FR increase memory usage [31], and Sedona does not claim to save memory, but rather to speed up training [47]. DGL is architecture-wise essentially identical to VanGL and consumes the same memory.

We compare in Table 6 the memory consumption of our method to that of InfoPro [60] on a ResNet110 on STL10 with a batch size of 64 (so the same setting as in Table 3). InfoPro [60] also propose to split the network into modules that have the same weight but not necessarily the same number of layers. They only implement this for K ≤ 4 modules. When the modules are even in weight and not in depth, we call the training methods VanGL*, TRGL* and InfoPro*. In practice, this leads to shallower early modules which slightly hurts performance according to [47], and as seen below. However, TRGL* still outperforms InfoPro and end-to-end training, and it leads to even bigger memory savings than InfoPro*. We see in Table 6 below that TRGL saves more memory than InfoPro in two out of three cases (4 and 8 modules), and about the same in the third case (16 modules), with much better test accuracy in all cases. Likewise, TRGL* is lighter than InfoPro*, with better accuracy.

However, parallel module-wise training does slightly slow down training. Epoch time increases by 6% with 2 modules and by 16% with 16 modules. TRGL is only slower than VanGL by 2% for all number of modules due to the additional regularization term. This is comparable to InfoPro which reports a time overhead between 1 and 27% compared to end-to-end training. See Appendix F for details.

4.3 Sequential full block-wise training

Block-wise sequential training, meaning that each module is a single residual block and that the blocks are trained sequentially, therefore requiring only enough memory to train one block and its classifier. Even though it has been less explored in recent module-wise training methods, it has been used in practice in very constrained settings such as on-device training [58, 57]. We therefore test our regularization in this section in this setting, with more details in Appendix G.

We propose here to use shallower ResNets that are initially wider. These architectures are welladapted to layer-wise training as seen in [7]. We check first in Table 10 in Appendix G that this architecture works well with parallel module-wise training with 2 modules by comparing it favorably on CIFAR10 [37] with methods DGL [8], InfoPro [60] and DDG [32] that use a ResNet-110 with the same number of parameters.

We then train a 10-block ResNet block-wise on CIFAR100. In Tables 11 and 12 in Appendix G, we see that MLS training improves the accuracy of sequential training by 0 . 8 percentage points when the trainset is full, but works less well on small train sets. Of the two, the regularization mainly improves the test accuracy of MLS training. The improvement increases as the training set gets smaller and reaches 1 percentage point. While parallel module-wise training performs quite close to end-to-end training in the full data regime and much better in the small data regime, sequential and multi-lap sequential training are competitive with end-to-end training in the small data regime. Combining the multi-lap trick and the regularization improves the accuracy of sequential training by 1.2 percentage points when using the entire trainset. We report further results for full block-wise training on MNIST [38] and CIFAR10 [37] in Tables 13 and 14 in Appendix G.

The 88% accuracy of sequential training on CIFAR10 in Table 13 is the same as in Table 2 of [7], which is the best method for layer-wise sequential training available, with VGG networks of comparable depth and width.

4.4 Accuracy after each module

Finally, we verify that our method avoids the stagnation or collapse in accuracy with depth. In Figure 2 below, we show the accuracy of each module with and without the regularization.

On the left, from parallel module-wise training experiments from Table 3, TRGL performs worse than vanilla greedy learning early, but surpasses it in later modules, indicating that it does avoid early overfitting. On the right, from sequential block-wise training experiments from Table 13, we see a large decline in performance that the regularization avoids. We see similar patterns in Figure 3 in Appendix G with parallel and MLS block-wise training.

9

51

74

50

Test accuracy in %

R

H

70

47

46

Vanilla parallel module-wise training

Vanilla sequential block-wise training

Regularized parallel module-wise training

45

Regularized sequential block-wise training

10

11

12

13

14

15

1

2

3

4

5

8

6

Module

Block

5 Limitations

The results in Appendix G show a few limitations of our method, as the improvements from the regularization are sometimes minimal on sequential training. However, the results show that our approach works in all settings (parallel and sequential with many or few modules), whereas other papers don't test their methods in all settings, and some show problems in other settings than the original one in subsequent papers (e.g. delayed gradients methods when the number of modules increases [31] and PredSim in [47]). Also, for parallel training in Section 4.1, the improvement from the regularization compared to VanGL is larger and increases with the number of modules (so with the memory savings) and reaches almost 5 percentage points. We show in Appendix H that our method is not very sensitive to the choice of hyperparameter τ over a large scale.

6 Related work

Layer-wise training was initially considered as a pre-training and initialization method [10, 43] and was recently shown to be competitive with end-to-end training [7, 45]. Many papers consider using a different auxiliary loss, instead of or in addition to the classification loss: kernel similarity [42], information-theory-inspired losses [53, 44, 41, 60] and biologically plausible losses [53, 45, 25, 11]. Methods [7], PredSim [45], DGL [8], Sedona [47] and InfoPro [60] report the best module-wise training results. [7, 8] do it simply through the architecture choice of the auxiliary networks. Sedona applies architecture search to decide on where to split the network into modules and what auxiliary classifier to use before module-wise training. Only BoostResNet [30] also proposes a block-wise training idea geared for ResNets. However, their results only show better early performance and end-to-end fine-tuning is required to be competitive. A method called ResIST [19] that is similar to block-wise training of ResNets randomly assigns ResBlocks to one of up to 16 modules that

10

are trained independently and reassembled before another random partition. More of a distributed training method, it is only compared to local SGD [54]. These methods can all be combined with our regularization, and we do use the auxiliary classifier from [7, 8].

Besides module-wise training, methods such as DNI [33, 14], DDG [32] and FR [31], solve the update and backward locking problems with an eye towards parallelization by using delayed or predicted gradients, or even predicted inputs to address forward locking, which is what [55] do. But they observe training issues with more than 5 modules [31]. This makes them compare unfavorably to module-wise training [8]. The high dimension of the predicted gradient, which scales with the size of the network, makes [33, 14] challenging in practice. Therefore, despite its simplicity, greedy module-wise training is more appealing when working in a constrained setting.

Viewing ResNets as dynamic transport systems [16, 36] followed from their view as a discretization of ODEs [61]. Transport regularization of ResNets in particular is motivated by the observation that they are naturally biased towards minimally modifying their input [35, 26]. We further linked this transport viewpoint with gradient flows in the Wasserstein space to apply it in a principled way to module-wise training. Gradient flows on the data distribution appeared recently in deep learning. In [1], the focus is on functionals of measures whose first variations are known in closed form and used, through their gradients, in the algorithm. This limits the scope of their applications to transfer learning and similar tasks. Likewise, [21, 40, 4, 3] use the explicit gradient flow of f -divergences and other distances between measures for generation and generator refinement. In contrast, we use the discrete minimizing movement scheme which does not require computation of the first variation and allows to consider classification.

7 Conclusion

We introduced a transport regularization for module-wise training that theoretically links module-wise training to gradient flows of the loss in probability space. Our method provably leads to more regular modules and experimentally improves the test accuracy of module-wise parallel, sequential and multi-lap sequential (a variant of sequential training that we introduce) training. Through this simple method that does not complexify the architecture, we make module-wise training competitive with end-to-end training while benefiting from its lower memory usage. Being a regularization, the method can easily be combined with other layer-wise training methods. Future work can experiment with working in Wasserstein space W p for p =2 , i.e. regularizing with a norm ‖ . ‖ p with p =2 .

References

ALVAREZ-MELIS, D., AND FUSI, N. Dataset dynamics via gradient flows in probability space. ICML (2021).

AMBROSIO, L., GIGLI, N., AND SAVARE, G. Gradient Flows in Metric Spaces and in the Space of Probability Measures . Birkhäuser Basel, 2005.

ANSARI, A. F., ANG, M. L., AND SOH, H. Refining deep generative models via discriminator gradient flow. In ICLR (2021).

ARBEL, M., KORBA, A., SALIM, A., AND GRETTON, A. Maximum mean discrepancy gradient flow. In NeurIPS (2019).

ARORA, R., BASU, A., MIANJY, P., AND MUKHERJEE, A. Understanding deep neural networks with rectified linear units. In International Conference on Learning Representations (2018).

BACH, F. Breaking the curse of dimensionality with convex neural networks. Journal of Machine Learning Research 18 , 19 (2017), 1-53.

BELILOVSKY, E., EICKENBERG, M., AND OYALLON, E. Greedy layerwise learning can scale to imagenet. In ICML (2019).

BELILOVSKY, E., EICKENBERG, M., AND OYALLON, E. Decoupled greedy learning of cnns. In ICML (2020).

BENAMOU, J., AND BRENIER, Y. A computational fluid mechanics solution to the mongekantorovich mass transfer problem. Numerische Mathematik (2000).

glyph[negationslash]

glyph[negationslash]

BENGIO, Y., LAMBLIN, P., POPOVICI, D., AND LAROCHELLE, H. Greedy layer-wise training of deep networks. In NeurIPS (2006).

BERND ILLING, WULFRAM GERSTNER, G. B. Towards truly local gradients with clapp: Contrastive, local and predictive plasticity. arXiv (2020).

COATE, A., LEE, H., AND NG, A. Y. An analysis of single layer networks in unsupervised feature learning. In AISTATS (2011).

CYBENKO, G. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems 2 (1989), 303-314.

CZARNECKI, W. M., ´ SWIRSZCZ, G., JADERBERG, M., OSINDERO, S., VINYALS, O., AND KAVUKCUOGLU, K. Understanding synthetic gradients and decoupled neural interfaces. In ICML (2017).

DE, S., AND SMITH, S. L. Batch normalization biases residual blocks towards the identity function in deep networks. In NeurIPS (2020).

DE BÉZENAC, E., AYED, I., AND GALLINARI, P. Optimal unsupervised domain translation. arXiv (2019).

DOSOVITSKIY, A., BEYER, L., KOLESNIKOV, A., WEISSENBORN, D., ZHAI, X., UNTERTHINER, T., DEHGHANI, M., MINDERER, M., HEIGOLD, G., GELLY, S., USZKOREIT, J., AND HOULSBY, N. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations (2021).

DU, S. S., AND GOEL, S. Improved learning of one-hidden-layer convolutional neural networks with overlaps. arXiv (2018).

DUN, C., WOLFE, C. R., JERMAINE, C. M., AND KYRILLIDIS, A. Resist: Layer-wise decomposition of resnets for distributed training. arXiv (2021).

FIGALLI, A. The Monge-Ampere Equation and Its Applications . Zurich lectures in advanced mathematics. European Mathematical Society, 2017.

GAO, Y., JIAO, Y., WANG, Y., WANG, Y., YANG, C., AND ZHANG, S. Deep generative learning via variational gradient flow. In ICML (2019).

GE, R., LEE, J. D., AND MA, T. Learning one-hidden-layer neural networks with landscape design. In International Conference on Learning Representations (2018).

GIANAZZA, U., GOBBINO, M., AND SAVARÈ, G. Evolution problems and minimizing movements. Atti della Accademia Nazionale dei Lincei. Classe di Scienze Fisiche, Matematiche e Naturali. Rendiconti Lincei. Matematica e Applicazioni 5 (1994), 289-296.

GIORGI, E. D., MARINO, A., AND TOSQUES, M. Problemi di evoluzione in spazi metrici e curve di massima pendenza. Atti della Accademia Nazionale dei Lincei. Classe di Scienze Fisiche, Matematiche e Naturali. Rendiconti 68 , 3 (3 1980), 180-187.

GUPTA, S. K. A more biologically plausible local learning rule for anns. arXiv (2020).

HAUSER, M. On residual networks learning a perturbation from identity. arXiv (2019).

HE, K., ZHAN, X., REN, S., AND SUN, J. Identity mappings in deep residual networks. In ECCV (2016).

HE, K., ZHANG, X., REN, S., AND SUN, J. Deep residual learning for image recognition. In CVPR (2016).

HORNIK, K., STINCHCOMBE, M., AND WHITE, H. Multilayer feedforward networks are universal approximators. Neural Networks 2 , 5 (1989), 359-366.

HUANG, F., ASH, J., LANGFORD, J., AND SCHAPIRE, R. Learning deep resnet blocks sequentially using boosting theory. In ICML (2018).

HUO, Z., GU, B., AND HUANG, H. Training neural networks using features replay. In NeurIPS (2018).

HUO, Z., GU, B., YANG, Q., AND HUANG, H. Decoupled parallel backpropagation with convergence guarantee. In ICML (2018).

JADERBERG, M., CZARNECKI, W. M., OSINDERO, S., VINYALS, O., GRAVES, A., SILVER, D., AND KAVUKCUOGLU, K. Decoupled neural interfaces using synthetic gradients. In ICML (2017).

JANZAMIN, M., SEDGHI, H., AND ANANDKUMAR, A. Beating the perils of non-convexity: Guaranteed training of neural networks using tensor methods. arXiv (2016).

JASTRZEBSKI, S., ET AL. Residual connections encourage iterative inference. In ICLR (2018).

KARKAR, S., AYED, I., DE BÉZENAC, E., AND GALLINARI, P. A principle of least action for the training of neural networks. In ECML-PKDD (2020).

KRIZHEVSKY, A. Learning multiple layers of features from tiny images. University of Toronto Technical Report (2009).

LECUN, Y., CORTES, C., AND BURGES, C. J. MNIST handwritten digit database. yann.lecun.com/exdb/mnist (2010).

LIU, Z., LIN, Y., CAO, Y., HU, H., WEI, Y., ZHANG, Z., LIN, S., AND GUO, B. Swin transformer: Hierarchical vision transformer using shifted windows. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV) (2021).

LIUTKUS, A., IM¸ SEKLI, U., MAJEWSKI, S., DURMUS, A., AND STOTER, F.-R. Slicedwasserstein flows: Nonparametric generative modeling via optimal transport and diffusions. In ICML (2019).

MA, W.-D. K., LEWIS, J., AND KLEIJN, W. B. The hsic bottleneck: Deep learning without back-propagation. In AAAI (2020).

MANDAR KULKARNI, S. K. Layer-wise training of deep networks using kernel similarity. In DLPR workshop, ICPR (2016).

MARQUEZ, E. S., HARE, J. S., AND NIRANJAN, M. Deep cascade learning. IEEE Transactions on Neural Networks and Learning Systems (2018).

NGUYEN, T. T., AND CHOI, J. Layer-wise learning of stochastic neural networks with information bottleneck. Entropy 21 (2019).

NØKLAND, A., AND EIDNES, L. H. Training neural networks with local error signals. In ICML (2019).

PATHAK, P., ZHANG, J., AND SAMARAS, D. Local learning on transformers via feature reconstruction, 2022.

PYEON, M., MOON, J., HAHN, T., AND KIM, G. Sedona: Search for decoupled neural networks toward greedy block-wise learning. In ICLR (2021).

SANDLER, M., HOWARD, A. G., ZHU, M., ZHMOGINOV, A., AND CHEN, L. Mobilenetv2: Inverted residuals and linear bottlenecks. In 2018 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2018, Salt Lake City, UT, USA, June 18-22, 2018 (2018), Computer Vision Foundation / IEEE Computer Society, pp. 4510-4520.

SANTAMBROGIO, F. Optimal Transport for Applied Mathematicians . Birkhäuser, 2015.

SANTAMBROGIO, F. Euclidean, metric, and wasserstein gradient flows: an overview. arXiv (2016).

SAXE, A. M., MCCLELLAND, J. L., AND GANGULI, S. Exact solutions to the nonlinear dynamics of learning in deep linear neural network. In ICLR (2014).

SIMONYAN, K., AND ZISSERMAN, A. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR 2014) (2014).

SINDY LÖWE, PETER O'CONNOR, B. V. Putting an end to end-to-end: Gradient-isolated learning of representations. In NeurIPS (2019).

STICH, S. U. Local sgd converges fast and communicates little. In ICLR (2019).

SUN, Q., DONG, H., CHEN, Z., SUN, J., LI, Z., AND DONG, B. Layer-parallel training of residual networks with auxiliary-variable networks. arXiv (2021).

TAN, M., AND LE, Q. EfficientNet: Rethinking model scaling for convolutional neural networks. In Proceedings of the 36th International Conference on Machine Learning (0915 Jun 2019), K. Chaudhuri and R. Salakhutdinov, Eds., vol. 97 of Proceedings of Machine Learning Research , PMLR, pp. 6105-6114.

TANG, Y., TENG, Q., ZHANG, L., MIN, F., AND HE, J. Layer-wise training convolutional neural networks with smaller filters for human activity recognition using wearable sensors. IEEE Sensors Journal (2021).

TENG, Q., WANG, K., ZHANG, L., AND HE, J. The layer-wise training convolutional neural networks using local loss for sensor-based human activity recognition. IEEE Sensors Journal (2020).

VILLANI, C. Optimal Transport: Old and New . Springer-Verlag, 2008.

WANG, Y., NI, Z., SONG, S., AND LE YANG, G. H. Revisiting locally supervised learning: an alternative to end-to-end training. In ICLR (2021).

WEINAN, E. A proposal on machine learning via dynamical systems. Commun. Math. Stat (2017).

XIE, S., ET AL. Aggregated residual transformations for deep neural networks. In CVPR (2017).

ZAGORUYKO, S., AND KOMODAKIS, N. Wide residual networks. In BMVC (2016).

ZHANG, J., ET AL. Towards robust resnet: A small step but a giant leap. In IJCAI (2019).

ZHANG, J., ZHANG, X., MA, K., GUPTA, R., SALTZ, J., VAKALOPOULOU, M., AND SAMARAS, D. Gigapixel whole-slide images classification using locally supervised learning. In Medical Image Computing and Computer Assisted Intervention - MICCAI 2022 (Cham, 2022), Springer Nature Switzerland, pp. 192-201.

A Background on optimal transport

The Wasserstein space W 2 (Ω) with Ω a convex and compact subset of R d is the space P (Ω) of probability measures over Ω , equipped with the distance W 2 given by the solution to the optimal transport problem

where Π( α, β ) is the set of probability distribution over Ω × Ω with first marginal α and second marginal β , i.e. Π( α, β ) = { γ ∈ P (Ω × Ω) | π 1 glyph[sharp] γ = α, π 2 glyph[sharp] γ = β } where π 1 ( x, y ) = x and π 2 ( x, y ) = y . The optimal transport problem can be seen as looking for a transportation plan minimizing the cost of displacing some distribution of mass from one configuration to another. This problem indeed has a solution in our setting and W 2 can be shown to be a geodesic distance (see for example [49, 59]). If α is absolutely continuous and ∂ Ω is α -negligible then the problem in (12) (called the Kantorovich problem) has a unique solution and is equivalent to the Monge problem, i.e.

and this problem has a unique solution T glyph[star] linked to the solution γ glyph[star] of (12) through γ glyph[star] = ( id , T glyph[star] ) glyph[sharp] α . Another equivalent formulation of the optimal transport problem in this setting is the dynamical formulation [9]. Here, instead of directly pushing samples of α to β using T , we can equivalently displace mass, according to a continuous flow with velocity v t : R d → R d . This implies that the density α t at time t satisfies the continuity equation ∂ t α t + ∇· ( α t v t ) = 0 , assuming that initial and final conditions are given by α 0 = α and α 1 = β respectively. In this case, the optimal displacement is the one that minimizes the total action caused by v :

Instead of describing the density's evolution through the continuity equation, we can describe the paths φ x t taken by particles at position x from α when displaced along the flow v . Here φ x t is the position at time t of the particle that was at x ∼ α at time 0. The continuity equation is then equivalent to ∂ t φ x t = v t ( φ x t ) . See chapters 4 and 5 of [49] for details. Rewriting the conditions as necessary, Problem (14) becomes

and the optimal transport map T glyph[star] that solves (13) is in fact T glyph[star] ( x ) = φ x 1 for φ that solves the continuity equation together with the optimal v glyph[star] from (15). We refer to [49, 59] for these results on optimal transport.

Optimal transport maps have some regularity properties under some boundedness assumptions. We mention the following result from [20]:

Theorem A.1. Let α and β be absolutely continuous measures on R d and T the optimal transport map between α and β for the Euclidean cost. Suppose there are bounded open sets X and Y , such that the density of α (respectively of β ) is null on X c (respectively Y c ) and bounded away from zero and infinity on X (respectively Y ).

Then there exists two relatively closed sets of null measure A ⊂ X and B ⊂ Y , such that T is η -Hölder continuous from X \ A to Y \ B , i.e. ∀ x, y ∈ X \ A we have

B Background on gradient flows

We follow [50, 2] for this background on gradient flows. Given a function L : R d → R and an initial point x 0 ∈ R d , a gradient flow is a curve x : [0 , ∞ [ → R d that solves the Cauchy problem

A solution exists and is unique if ∇L is Lipschitz or L is convex. Given τ > 0 and x τ 0 = x 0 define a sequence ( x τ k ) k through the minimizing movement scheme :

L lower semi-continous and L ( x ) ≥ C 1 -C 2 ‖ x ‖ 2 guarantees existence of a solution of (17) for τ small enough. L λ -convex meets these conditions and also provides uniqueness of the solution because of strict convexity of the target. See [49, 50, 2].

We interpret the point x τ k as the value of a curve x at time kτ . We can then construct a curve x τ as the piecewise constant interpolation of the points x τ k . We can also construct a curve ˜ x τ as the affine interpolation of the points x τ k .

If L ( x 0 ) < ∞ and inf L > -∞ then ( x τ ) and (˜ x τ ) converge uniformly to the same curve x as τ goes to zero (up to extracting a subsequence). If L is C 1 , then the limit curve x is a solution of (16) (i.e. a gradient flow of L ). If L is not differentiable then x is solution of the problem defined using the subdifferential of L , i.e. x satisfies x ′ ( t ) ∈ -∂ L ( x ( t )) for almost every t .

If L is λ -convex with λ > 0 , then the solution to (16) converges exponentially to the unique minimizer of L (which exists by coercivity). So taking τ → 0 and k →∞ , we tend towards the minimizer of L .

The advantage of the minimizing movement scheme (17) is that it can be adapted to metric spaces by replacing the Euclidean distance by the metric space's distance. In the (geodesic) metric space W 2 (Ω) with Ω convex and compact, for L : W 2 (Ω) → R ∪{∞} lower semi-continuous for the weak convergence of measures in duality with C (Ω) (equivalent to lower semi-continuous with respect to the distance W 2 ) and ρ τ 0 = ρ 0 ∈ P (Ω) , the minimizing movement scheme (17) becomes

This problem has a solution because the objective is lower semi-continuous and the minimization is over P (Ω) which is compact by Banach-Alaoglu.

We can construct a piecewise constant interpolation between the measures ρ τ k , or a geodesic interpolation where we travel along a geodesic between ρ τ k and ρ τ k +1 in W 2 (Ω) , constructed using the optimal transport map between these measures. Again, if L ( x 0 ) < ∞ and inf L > -∞ then both interpolations converge uniformly to a limit curve ˜ ρ as τ goes to zero. Under further conditions on L , mainly λ -geodesic convexity (i.e. λ -convexity along geodesics) for λ > 0 , we can prove stability and convergence of ˜ ρ ( t ) to a minimizer of L as t →∞ , see [49, 50, 2].

C Proof of Proposition 2.3

Proof. Take a minimizing sequence ( ˜ F i , ˜ T i ) , i.e. such that C ( ˜ F i , ˜ T i ) → min C , where C ≥ 0 is the target function in (3) and denote β i = ˜ T iglyph[sharp] ρ τ k . Then by compacity ˜ F i → F glyph[star] and β i ⇀β glyph[star] in duality with C b (Ω) by Banach-Alaoglu. There exists T glyph[star] an optimal transport map between ρ τ k and β glyph[star] . Then C ( F glyph[star] , T glyph[star] ) ≤ lim C ( ˜ F i , ˜ T i ) = min C by continuity of L and because

as W 2 metrizes weak convergence of measures. We take ( F τ k , T τ k ) = ( F glyph[star] , T glyph[star] ) . It is also immediate that for any minimizing pair, the transport map has to be optimal. Taking a minimizing sequence ( ˜ F i , ˜ v i ) and the corresponding induced maps ˜ T i we get the same result for Problem (11). Problems (3) and (11) are equivalent by the equivalence between Problems (13) and (15).

D Varying the regularization weight

The discussion in Section 2.2 suggests taking a fixed weight τ for the transport cost that is as small as possible. However, instead of using a fixed τ , we might want to vary it along the depth k to further

constrain with a smaller τ k the earlier modules to avoid that they overfit or the later modules to maintain the accuracy of earlier modules. We might also want to regularize the network further in earlier epochs when the data is more entangled. To unify and formalize this varying weight τ k,i across modules k and SGD iterations i , we use a scheme inspired by the method of multipliers to solve Problems (2) and (10). To simplify the notations, we will instead consider the weight λ k,i :=2 τ k,i given to the loss. We denote θ k,i the parameters of both T k and F k at SGD iteration i . We also denote L ( θ, x ) and W ( θ, x ) respectively the loss and the transport regularization as functions of parameters θ and data x . We now increase the weight λ k,i of the loss every s iterations of SGD by a value that is proportional to the current loss. Given increase factor h> 0 , initial parameters θ k, 1 , initial weights λ k, 1 ≥ 0 , learning rates ( η i ) and batches ( x i ) , we apply for module k and i ≥ 1 :

The weights λ k,i will vary along modules k because they will evolve differently with iterations i for each k . They will increase more slowly with i for larger k because deeper modules will have smaller loss. This method can be seen as a method of multipliers for the problem of minimizing the transport under the constraint of zero loss. Therefore it is immediate by slightly adapting the proof of Proposition 2.3 or from [36] that we are still solving a problem that admits a solution whose non-auxiliary part is an optimal transport map with the same regularity as stated above. We use the same initial value λ 1 = λ k, 1 for all modules so that this method requires choosing three hyper-parameters ( h , s and λ 1 ). In practice (see Section 4.1 and Appendix E), it works best in only one experiment. Simply manually finding a value of τ that is multiplied by 2 for the second half of the network works best in all the other experiments.

E Implementation details

We use standard data augmentation and standard implementations for VGG-19, ResNet-50, ResNet101, ResNet-110, ResNet-152 and Swin-Tiny Transformer (the same as for the other methods in Section 4.1). We use NVIDIA Tesla V100 16GB GPUs for the experiments. Training a Resnet-152 on TinyImageNet in Table 1 takes about 36 hours. Training a Resnet-152 on CIFAR100 in Table 1 takes about 11 hours. Training a ResNet-110 on STL10 in Table 3 takes about 3 hours. Training a Swin-Tiny Transformer in Table 4 take between 40 minutes and 1 hour.

For sequential and multi-lap sequential training, we use SGD with a learning rate of 0 . 007 . With the exception of the Swin Transformer in Table 4, we use SGD for parallel training with learning rate of 0 . 003 in all Tables but Table 3 where the learning rate is 0 . 002 . For the Swin Transformer in Table 4, we use the AdamW optimizer with a learning rate of 0 . 007 and a CosineLR scheduler.

For end-to-end training we use a learning rate of 0.1 that is divided by five at epochs 120, 160 and 200. Momentum is always 0.9. For parallel and end-to-end training, we train for 300 epochs. For sequential and multi-lap sequential training, the number of epochs varies per module (see Section G).

For experiments in Section 4.1, we use a batch size of 256, orthogonal initialization [51] with a gain of 0.1, label smoothing of 0.1 and weight decay of 0.0002. The batch size changes to 64 for Table 3 and to 1024 for Table 4.

For experiments in Section 4.3, we use a batch size of 128, orthogonal initialization with a gain of 0.05, no label smoothing and weight decay of 0.0001.

In Table 1, we use τ = 500000 for the first two modules and then double it for the last two modules for TRGL. In Table 2, we use λ k, 1 = 1 , h = 1 and s = 50 for TRGL. In Table 3, we use τ = 0 . 5 and double it at the midpoint, expect for the first line where τ = 50 .

F Memory savings and training time

We compare in Table 7 the memory consumption of our method to that of InfoPro [60] on a ResNet110 split into K modules trained in parallel on STL10 with a batch size of 64 (so the same setting as in Table 3 in Section 4.1). We report in Table 7 the memory saved as a percentage of the 6230 MiB memory required by end-to-end training with the same batch size. VanGL refers to our architecture trained without the regularization. InfoPro [60] also propose to split the network into K modules that

have the same weight but not necessarily the same number of layers. They only implement this for K ≤ 4 modules. When the modules are even in weight and not in depth, we call the training methods VanGL*, TRGL* and InfoPro*. In practice, this leads to shallower early modules which slightly hurts performance according to [47]. We verify this in Table 8 (to be compared with Table 3 in Section 4.1). However, TRGL* still outperforms InfoPro and end-to-end training, and it leads to even bigger memory savings. We see in Table 7 that TRGL saves more memory than InfoPro in two out of three cases (4 and 8 modules), and about the same in the third case (16 modules), with much better test accuracy in all cases. Likewise, TRGL* is lighter than InfoPro*, with better accuracy. We also see that the added memory cost of the regularization compared to vanilla greedy learning is small. However, parallel module-wise training does slightly slow down training. Epoch time increases by 6% with 2 modules and by 16% with 16 modules. TRGL is only slower than VanGL by 2% for for all number of modules due to the additional regularization term. This is comparable to InfoPro which report a time overhead between 1 and 27% compared to end-to-end training.

Note that methods DDG [32] and FR [31], being delayed gradient methods and not module-wise training methods, do no save memory (they actually increase memory usage, see FR [31]). Sedona [47] also does not claim to save memory, as their first module (the heaviest) is deeper than the others, but rather to speed up computation. Finally, DGL [8] is architecture-wise essentially identical to VanGL and consumes the same memory.

G Sequential full block-wise training

To show that our method works well with all types of module-wise training when using few modules, we train a ResNet-101 split in 2 modules on CIFAR100, sequentially and multi-lap sequentially. Results are in Table 9. We see that our idea of multi-lap sequential training adds one percentage point of accuracy to sequential training, and that the regularization further improves the accuracy by about half a percentage point. As only one module has to be trained at a time, these two training methods require only around half the memory end-to-end training requires (the size of the heaviest module and its classifier more exactly).

We now focus on full block-wise training, meaning that each module is a single ResBlock, mostly sequentially. We propose here to use shallower and initially wider ResNets with a downsampling and 256 filters initially and a further downsampling and doubling of the number of filters at the midpoint, no matter the depth. In these ResNets, we use the ResBlock from [27] with two convolutional layers. If such a network is divided in K modules of M ResBlocks each, we call the network a K -M ResNet. These wider shallower architectures are well-adapted to layer-wise training as seen in [7]. We check in Table 10 that this architecture works well with parallel module-wise training by comparing favorably on CIFAR10 ([37]) a 2-7 ResNet with DGL, InfoPro ([60]) and DDG [32]. The 2-7 ResNet has 45 millions parameters, which is about the same as the ResNet-110 divided in two used by the other methods, and performs better when trained in parallel.

We now train a 10-block ResNet block-wise on CIFAR100 (a 10-1 ResNet in our notations). We report even the small improvements in accuracy to show that our method works in all settings (parallel or sequential with many or few splits), which other methods don't do. For sequential training, block k is trained for 50+10 k epochs where 0 ≤ k ≤ 10 , block 0 being the encoder. This idea of increasing the number of epochs along with the depth is found in [43]. For MLS training, block k is trained for 10+2 k epochs, and this is repeated for 5 laps. In block-wise training, the last block does not always perform the best and we report the accuracy of the best block. In Table 11, we see that MLS training improves the test accuracy of sequential training by around 0 . 8 percentage points when the training dataset is full, but works less well on small training sets. Of the two, the regularization mainly improves the test accuracy of MLS training. The improvement increases as the training set gets smaller and reaches 1 percentage point. That is also the case for parallel module-wise training in Table 12, which already performs quite close to end-to-end training in the full data regime and much better in the small data regime. Combining the multi-lap trick and the regularization improves the performance of sequential training by 1.2 percentage points.

We report further results of block-wise training on CIFAR10 in Table 13 and on MNIST [38] in Table 14, but now we report the accuracy of the last block. We see again greater improvement due to the regularization as the training set gets smaller, gaining up to 6 percentage points.

35

40

34

39 -

%

33

.=

Testaccuracyi

32

38

31

37

30

6

Vanilla multi-lap sequential block-wise training

36

-

Vanilla parallel block-wise training

Regularized multi-lap sequential block-wise training

Regularized parallel block-wise training

0

1

2

3

4

5

6

7

8

9

10

0

1

2

3

4

5

6

7

8

9

10

Block

Block

H Sensitivity to hyper-parameters

We show in Figure 4 below that TRGL still performs better than VanGL (in the same setting as in Table 3 in Section 4.1) for values of τ from 0.03 to 100 and is still roughly equivalent to it for values up to 5000.

TRGL

VanGL

77

Test accuracy in %

76

74

10

10°

102

I Broader impact

Less memory usage has a positive environmental impact and allows organizations with less resources to use deep learning.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes a new training method for greedy layer-wise or module-wise training of neural networks, which is compelling in constrained and on-device settings where memory is limited and suffers from a stagnation problem. Experimental results show that their method improves the accuracy of module-wise training of various architectures.\n\n-------After Rebuttal-------\n\nI thank the authors for the answers to my comments and questions. Most of my concerns are properly addressed. Therefore I raise my score.\n\nWhile I still think the word \"early overfitting\" in the paper should be carefully used. I agree with the phenomenon that vanilla module-wise training performs very well in the early layers but stagnates and gets overtaken later. While it can be due to the insufficient mutual information between the learned features and the inputs, instead of the early layer overfitting. Generally, I think the early modules containing fewer learnable parameters are difficult to overfit the large-scale dataset, such as ImageNet.\n\nSTRENGTHS:\n1. Overall, the idea is new and the proposed method is theoretically sound.\n2. The paper is well-written and easy to follow.\n\nWEAKNESSES:\nOn Line 34, the authors claim that the early modules can overfit and learn more discriminative features than end-to-end training, destroying task-relevant information, and deeper modules don’t improve the test accuracy significantly, or even degrade it. However, the experimental results in this paper are not sufficient enough to support this assumption, especially for the overfitting problem.\n\nAs the listed experiments are all conducted on small or medium-scale datasets, the overfitting problem might happen for the early layers. While, for the large-scale dataset, such as ImageNet, the early layers are more likely to be under-fitting due to the insufficient model \ncapacity of the first few layers.\n\nQUESTIONS:\n1. The wall-time training cost is also an important evaluation metric for training algorithms. I suggest the authors provide a comparison of the training time between their proposed TRGL and other related methods.\n\nLIMITATIONS:\nSee weaknesses and questions.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-06-27"}

comments: SUMMARY:
The paper explores the module-wise training of neural networks via the Minimizing Movement Scheme. This approach aims to overcome the stagnation problem often encountered in layer-wise training, leading to improved accuracy and reduced memory usage. The authors compare their results with those of other methods and demonstrate the effectiveness of their approach on various architectures, including ResNets, Transformers, and VGG.

STRENGTHS:
1. The introduced methodology effectively addresses the frequently observed stagnation issue associated with layer-wise training. As a result, there is a noteworthy enhancement in model accuracy along with a commendable reduction in memory usage.

2. Establishing a connection between neural network training and optimal transport theory is not only intellectually stimulating, but it also presents intriguing theoretical insights.

3. Generally, the manuscript is well-structured and clearly articulated. However, some convoluted notations used in Section 2.2 could potentially be simplified for improved reader comprehension.

WEAKNESSES:
1. The paper is currently missing a detailed convergence analysis. It's vital to elucidate whether the overall training process will indeed converge in order to reinforce the reliability and robustness of the proposed approach.

2. The study could benefit from a more comprehensive ablation analysis, specifically, an exploration on the impact of variations in the regularization penalty. This would further validate the robustness of the model and provide additional insights into its behavior under different conditions.

QUESTIONS:
N/A

LIMITATIONS:
Yes
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-06-29

comments: SUMMARY:
The paper proposed a new regularization for module-wise training via the distance of the input and output of the module.

STRENGTHS:
1. The proposed regularization is quite straightforward and easy to apply.
2. The paper connects the proposed regularization with optimal transport via theoretical analysis.
3. Some experimental results are good, like adding more modules on STL-10.

WEAKNESSES:
1. Although the author shows the connection between the proposed regularization and optimal transport, it does not provide insights regarding convergence. Whether the proposed regularization helps the convergence of the multi-module training might be more interesting for larger audiences.
2. Authors argue that 'residual connections are already biased towards small displacements.' However, residual connections are not toward small values for early layers, as shown in [28]. As a result, how does the proposed method control each module's regularization strength? If they are set to the same value, then the regularization may be harmful to early layers. In addition, the selection of the regularization strength becomes more complex when increasing the number of modules K.
3. The improvements over the previous method are only obvious on STL-10, and STL-10 is not a large dataset. In addition, larger datasets and models are omitted. I think memory saving will be more meaningful for larger datasets and models. As a result, the scalability of the proposed method is not examined.

QUESTIONS:
1. Why is the memory saving of the proposed method often less than other methods? Where this overhead comes from?
2. Some notations are not introduced properly. For example, the `#' notation, and what is the difference of $T_k$ and $T_k^{\tau}$.

LIMITATIONS:
Limitations are provided.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-06

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nTRGL offers a promising approach to module-wise training that addresses the stagnation problem, improves accuracy, and reduces memory usage in constrained and on-device settings. The method introduces a module-wise regularization inspired by the minimizing movement scheme for gradient flows in distribution space. By minimizing the kinetic energy of modules along with the training loss, TRGL encourages modules to change their inputs as little as possible, preserving task-relevant information.\n\nSTRENGTHS:\n(1) TRGL significantly reduces memory usage compared to end-to-end training, ranging from 10% to 60% less memory. This makes it particularly suitable for constrained settings and on-device training where memory resources are limited.\n\n(2) The authors provide theoretical analysis, proving that TRGL leads to more regular and stable greedy modules that progressively minimize the loss.\n\n(3) TRGL can be applied to various network architectures, especially those using residual connections such as ResNets and vision transformers.\n\nWEAKNESSES:\n(1) TRGL introduces an additional regularization term to the training objective, which increases the computational complexity of the training process. The calculation of the kinetic energy and its incorporation into the loss function may require additional computational resources, leading to longer training times. How about the actual training time compared to other methods?\n\n(2) what is VanGL? is it just a module-wise training without the regularization terms?\n\n(3) In my opinion, the performance gain is marginal compared  to vanilla VanGL.\n\n(4) The principle of finding Tau is vague.\n\nQUESTIONS:\nSee weakness\n\nLIMITATIONS:\nThis increased complexity may result in longer training times and higher computational requirements, which could be a limitation in resource-constrained environments or when training large-scale models.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-06"}