To Ensemble or Not Ensemble: When does End-To-End Training Fail?

TL;DR

This paper investigates the conditions under which end-to-end training of network ensembles fails, revealing failure cases, optimal intermediate strategies, and connections to Dropout and ensemble diversity.

Contribution

It provides a detailed analysis of E2E training failures for ensembles, introducing a blending strategy and highlighting when partial or no E2E training is optimal.

Findings

E2E training can fail for over-parameterized ensembles.

Optimal training may lie between independent and fully E2E approaches.

Links between E2E training, Dropout, and ensemble diversity are uncovered.

Abstract

End-to-End training (E2E) is becoming more and more popular to train complex Deep Network architectures. An interesting question is whether this trend will continue-are there any clear failure cases for E2E training? We study this question in depth, for the specific case of E2E training an ensemble of networks. Our strategy is to blend the gradient smoothly in between two extremes: from independent training of the networks, up to to full E2E training. We find clear failure cases, where over-parameterized models cannot be trained E2E. A surprising result is that the optimum can sometimes lie in between the two, neither an ensemble or an E2E system. The work also uncovers links to Dropout, and raises questions around the nature of ensemble diversity and multi-branch networks.

Figures

Tables

Table 1. Table 1: DenseNet ensembles. A proxy measure of capacity is ( d , k ) 𝑑 𝑘 (d,k) , the depth d 𝑑 d and growth rate k 𝑘 k , which we decrease as the size M 𝑀 M of the ensemble increases. Each architecture occupies approximately 12GB RAM.

Name	Depth	$𝒌$	$𝑴$	Memory	Params.
DN-High	100	12	4	$\sim$12GB	$3.2$M
DN-Mid	82	8	8	$\sim$12GB	$2.1$M
DN-Low	64	6	16	$\sim$12GB	$1.7$M

Table 2. Table 2: Error rates (%) for DenseNet ensembles. Independent training is optimal (bold) for all but the smallest capacity networks.

	DN-Low	DN-Mid	DN-High
$\lambda =0.0$ (Independent)	$25.0$	$19.9$	$17.8$
$\lambda =0.5$	$23.5$	$20.0$	$18.8$
$\lambda =0.9$	$25.9$	$22.4$	$20.3$
$\lambda =1.0$ (End-to-End)	$29.6$	$25.7$	$22.1$
Bagging	$32.5$	$29.5$	$28.4$
Stacking	$28.3$	$23.4$	$21.4$

Table 3. Table 3: DenseNet architectures.

Name	Depth	$k$	Modules	Parameters
DN-High	100	12	4	3.2M
DN-Mid	82	8	8	2.1M
DN-Low	64	6	16	1.7M

Table 4. Table 4: ConvNet architectures. Each architecture is fully convolutional. Each convolution layer has a 3 × 3 3 3 3\times 3 kernel with no dilation. The ‘Filters’ column indicates the number of output features of each layer. Bold indicates a stride of 2 for a layer, otherwise a stride of 1 is used.

Parameters	Layers	Filters
0.07M	3	32,64,64
0.14M	4	32,64,64,128
0.29M	5	32,64,64,128,128
0.60M	6	32,64,64,128,128,256
1.20M	7	32,64,64,128,128,256,256

Equations

$$\bar{q}$$

$$\bar{q}(y\mid \mathbf{x})\stackrel{\text{def}}{=}{Z}^{-1}\prod _{j=1}^M{q}_i(y\mid \mathbf{x}{)}^{1/M}.$$

$$\bar{q}(y|{\bf x})=f^{-1}\Big{(}\frac{1}{M}\sum_{i}f(q_{i}(y|{\bf x}))\Big{)}$$

$$L_{\lambda }$$

$$\text{D}(p\Vert \bar{q})$$

$$L_{\lambda }$$

$$\displaystyle\frac{\partial L_{\lambda}}{\partial\hat{\eta}_{j}}=\frac{1}{M}\Big{(}(1-\lambda)\hat{y}_{j}+\lambda\bar{y}-y\Big{)}\,,$$

$$\displaystyle\frac{\partial^{2}L_{\lambda}}{\partial\hat{\eta}_{i}\partial\hat{\eta}_{j}}=\begin{cases*}\frac{1}{M}\left(1-\lambda(1-\frac{1}{M})\right)\cdot g^{\prime}(\hat{\eta}_{i})&if i = j\\ \frac{\lambda}{M^{2}}\cdot g^{\prime}(\bar{\eta})&otherwise\end{cases*}\,.$$

$$H=\left[\begin{array}{ccccc}q& r& r& \dots & r\\ r& q& r& \dots & r\\ r& r& q& \dots & r\\ ⋮& ⋮& & \ddots & ⋮\\ r& r& r& \dots & q\end{array}\right],$$

$$q=\frac{1}{M}\left(1-\lambda \left(1-\frac{1}{M}\right)\right)\cdot c$$

$$r=\frac{\lambda }{M^2}\cdot c.$$

$${\omega }_1$$

$${\omega }_2$$

$$\kappa (H)=\frac{{\omega }_1}{{\omega }_2}=\frac{1}{1-\lambda },$$

$$L^{(m)}=-\sum _k{y}_k\log q_k^{(m)}.$$

$$L_{LL}=\frac{1}{M}\sum _m{L}^{(m)}.$$

$$\frac{\partial L_{LL}}{\partial q_k^{(m)}}=\frac{1}{M}\frac{\partial L^{(m)}}{\partial q_k^{(m)}}.$$

$${\tilde{q}}_k$$

$$L_{SM}$$

$$=-\sum _k{y}_k\frac{1}{M}\sum _m\log q_k^{(m)}$$

$$=\frac{1}{M}\sum _m{L}^{(m)}=L_{LL}.$$

Full text

1 Introduction

Ensembles of neural networks are a common sight in the Deep Learning literature, often at the top of Kaggle leaderboards, and a key ingredient of now classic results, e.g. AlexNet (Krizhevsky et al.,, 2012). In recent literature, an equally common sight is End-to-End (E2E) training of a deep learning architecture, using a single loss to train all components simultaneously. An interesting scientific question is whether the E2E paradigm has limits, examined in some detail by Glasmachers, (2017), who concluded that E2E can be inefficient, and “does not make optimal use of the modular design of present neural networks”.

In line with this question, some have explored training an ensemble with E2E, as if it was a modular, multi-branch architecture. Dutt et al., (2020) explore E2E ensemble training and demonstrate it allows one to “significantly reduce the number of parameters” while maintaining accuracy. Anastasopoulos and Chiang, (2018) use the principle to improve accuracy in multi-source language translation. Furlanello et al., (2018) show good performance across a variety of standard benchmarks. This may seem promising, however, Lee et al., (2015) conclude the opposite, that such End-to-End training of an ensemble is harmful to generalization accuracy. The idea raises interesting scientific questions about learning in ensemble/modular architectures. Some authors have noted that some architectures (e.g. with multiple branches, or skip connections) may be viewed as an ensemble of jointly trained sub-networks, e.g. ResNets (Veit et al.,, 2016; Zhao et al.,, 2016). It is widely accepted that “diversity” of independently trained ensembles is beneficial (Dietterich,, 2000; Kuncheva and Whitaker,, 2003). and hard evidence lies in the success of the many published variants of Random Forests and Bagging (Breiman,, 1996). But if we train a set of networks End-to-End, they share a loss function—so their parameters are strongly correlated—seemingly the opposite of diversity. There is clearly a subtle relation here, raising hard questions, e.g., what is the meaning of ‘diversity’ in E2E ensembles?

Our aim is to understand when each scheme—Independent ensemble training, or End-to-End ensemble training—is appropriate, and to shed light on previously reported results.

Our strategy is to interpolate the gradient smoothly between the two—a convex combination of Independent and End-to-End training. This uncovers complex dynamics, highlighting a tension between individual model capacity and diversity, as well as generating interesting properties, including ensemble robustness with respect to faults.

**Organisation of the Paper:

**

In Section 2 we cover the necessary notation and probabilistic view we adopt for the paper. In Section 3 we ask and expand upon the reasoning behind the primary question of the paper: is it an ensemble of models, or one big model?. This leads us to define a hybrid training scheme, which turns out to generalise some previous work in ensemble diversity training schemes. In Sections 4 and 5 we thoroughly investigate the question, uncovering a rich source of unexpectedly complex dynamics. Finally in Sections 6 and 7 we outline how this connects to a wide range of work already published, and opens new doors for research.

2 Background and Design Choices

We assume a standard supervised learning scenario, with training set $S=\{(\boldsymbol{\mathbf{x}}_{i},y_{i})\}_{i=1}^{n}$ drawn i.i.d. from $P(\mathcal{X}\mathcal{Y})$. For each observation ${\bf x}$, we assume the corresponding $y$ is a class label drawn from a true distribution $p(y|{\bf x})$. We approximate this distribution with a model $q(y|{\bf x})$, corresponding to some deep network architecture. We will explore a variety of architectures: including simple MLPs, medium/large scale CNNs, and finally DenseNets (Huang et al.,, 2018).

To have an ensemble, there is a choice to make in how to combine the network outputs. In our work we choose to average the network logits, and re-normalise with softmax. This was used by Hinton et al., (2015), and Dutt et al., (2020)—we replicate one of their experiments later. There are of course alternatives, e.g. majority voting or averaging probability estimates. Majority voting rules out the possibility of E2E ensemble training by gradient methods, since the vote operation is inherently non-differentiable. Averaging probability estimates is common, but we present a result below that encouraged us to consider the averaging logits approach instead, beyond simply replicating Dutt et al., (2020).

We approach the classification problem from a probabilistic viewpoint: minimising the KL-divergence from a model $q$ to the target distribution $p$. Given a set of such probability models, we could ask, what is the optimal combiner rule that preserves the contribution from each, in the sense of minimising KL divergence? In a formal statement we refer to this as the ‘central’ model, denoted $\bar{q}$, that lies at the centre of the set of probability estimates:

[TABLE]

It can easily be proved that the minimizer here is the normalized geometric mean, corresponding to a Product of Experts model, though modeling only the means (i.e. a PoE of Generalized Linear Models):

[TABLE]

This can be written in terms of the distribution’s canonical link $f$ and its inverse $f^{-1}$. The inverse link for the Categorical distribution is the softmax $f^{-1}(\boldsymbol{\mathbf{\eta}})$, where $\boldsymbol{\mathbf{\eta}}$ is a vector of logits. Correspondingly, the logits are given by the link applied to class probabilities $\boldsymbol{\mathbf{\eta}}=f(q(y|{\bf x}))$.

[TABLE]

i.e. a softmax operation on the averaged logits — this provides additional motivation for the ensemble combination rule used by Hinton et al., (2015) and Dutt et al., (2020), since it is the rule that preserves the most information from the individual models, in the sense of KL divergence.

3 Is it an Ensemble, or one Big Model?

Ensemble methods are a well-established part of the ML landscape. A traditional explanation for the success of ensembles is the ‘diversity’ of their predictions, and particularly their errors. When we reach the limit of what a single model can do, we create an ensemble of such models that exhibit ‘diverse’ errors, and combine their outputs. This diversity can lead to the individual errors being averaged out, and overall lower ensemble error obtained.

A common heuristic is to have the individual models intentionally lower capacity than they might be, and compensate via diversity. Traditional ensemble methods, such as Bagging and Random Forests, generate diversity via randomization heuristics such as feeding different bootstraps of training data to each model (Brown et al., 2005a, ). Stacking (Wolpert,, 1992) is similar in spirit to E2E ensemble training, in that it trains the combiner function, although only after individual models are fixed, using them as meta-features.

However, if the ensemble combining procedure was fully differentiable, we could in theory train all networks End-to-End (E2E), as if they were branches or components of one “big model”. In this case, what role is there for diversity? Furthermore, with modern deep networks, it is easy to have extremely high capacity models, but regularised to avoid overfitting. With this in mind, is there much benefit to ensembling deep networks? Various empirical successes, e.g. Krizhevsky et al., (2012), suggest a tentative “yes”, but understanding the overfitting behaviour of deep network architectures is one of the most complex open challenges in the field today. It is now common to heavily over-parameterize and regularize deep networks. These observations raise interesting questions on the benefits of such architectures, and for ensemble diversity.

To study the question of failure cases for E2E ensembles, we could simply train a system E2E and report outcomes. However, to get a more detailed picture, we define a hybrid loss function, interpolating between the likelihood for an independent ensemble and the E2E ensemble likelihood. We refer to this as the Joint Training loss, since it treats the networks jointly as components of a single (larger) network, or as members of an ensemble. We stress that we are not advocating this as a means to achieve SOTA results, but merely as a forensic tool to understand the behaviour of the E2E paradigm.

Definition 1 (Joint Training Loss):

[TABLE]

where $D$ is the KL-divergence as defined before. The loss is a convex combination of two extremes: $\lambda=1$, where we train $\bar{q}$ as one system, and $\lambda=0$, where we train the ensemble independently (with a learning rate scaled by $1/M$). When $\lambda$ lies between the two, it could be seen as $\bar{q}$ being ‘regularized’ by the individual networks partially fitting the data themselves. Alternatively, we can view the same architecture as an ensemble, but trained interactively. This is made clear by rearranging Equation (4) as:

[TABLE]

A simple proof is available in supplementary material. This alternative view shows that $\lambda$ controls a balance between the average of the individual losses, and a term measuring the diversity between the ensemble members.

From this perspective, this is a diversity-forcing training scheme similar to previous work Liu and Yao, (1999). In fact for the special case of a Gaussian $p,q$, Eq (5) is exactly that presented by Liu and Yao, (1999). However, the probabilistic view allows us to generalise, and for the case of classification problems, this can be seen as managing the diversity in a classification ensemble. However, seen as a ‘hybrid’ loss, (4), explicitly varies the gradient in-between the two extremes of an ensemble and a single multi-branch architecture, thus including architectures studied previously (Lee et al.,, 2015; Dutt et al.,, 2020) as special cases. In the following section we use this to study the learning dynamics in terms of tensions between model capacity and diversity.

4 Experiments

End-to-End training of ensembles raises several interesting questions: How does End-to-End training behave when varying the capacity/size of networks? Should we have a large number of simple networks? Or the opposite—a small number of complex networks? What effect does varying $\lambda$ have in this setting, smoothly varying from Independent to End-to-End training? Suppose we have a high capacity, well-tuned single network, performing close to SOTA. In this situation, presumably, independent training of an ensemble of such models will still marginally improve over a single small model, due to variance reduction. However, it is much less clear in this case whether there will be further gains as $\lambda\rightarrow 1$, toward End-to-End training. We investigate this first with simple MLPs, exploring trade-offs while the number of learnt parameters is held constant, and then with higher capacity CNNs, including DenseNets (Huang et al.,, 2017).

Spending a Fixed Parameter Budget.

We first compare a single large network to an ensemble of very small networks: each with the same number of parameters. The study of such architectures may have implications for IoT/Edge compute scenarios, with memory/power constraints. We set a budget of memory or number of parameters, and ask how best to “spend” them in different architectures. This type of trade-off is well recognised as highly relevant in the current energy-conscious research climate, e.g. very recently Zhu et al., (2019). We stress again however that we are not chasing state of the art performance, and instead observe the dynamics of Independent vs E2E training in a controlled manner.

We use single layer MLPs in four configurations with ${\sim}$815$$K parameters: a single network with 1024 nodes ($1\times 1024$H), 16 networks each with 64 nodes ($16\times 64$H), 64 networks with 16 nodes ($64\times 16$H), and 256 networks with 4 nodes ($256\times 4$H). We evaluate these on the 10-class classification problem, Fashion-MNIST. Full experimental details are in the supplementary material.

Figure 2 summarizes results for the 1$\times$1024H network versus the 256$\times$4H ensemble. Again, these have the same number of configurable parameters, just deployed in a different manner. The ‘monolithic’ 1024 node network (horizontal dashed line, 10.2% error) significantly outperforms the ensemble trained independently (16.3%), as well as the ‘classic’ methods of Bagging and Stacking. However, End-to-End training of the small network ensemble almost matches performance, and Joint Training ($\lambda=0.95$) gets closer with 10.3% error.

Figure 3 shows detailed results, varying $\lambda$ on other configurations. The distinction between End-to-End training and independent training is most pronounced for the large ensemble of small networks, $256\times 4$H, where E2E training is sub-optimal.

However, as the capacity of the networks increases, the difference between End-to-End and independent training vanishes — illustrated by the almost uniform response to varying $\lambda$ with larger networks. This is investigated further in the next section with state-of-the-art DenseNet networks (Huang et al.,, 2017) with millions of parameters.

High Capacity Individual Models.

In deep learning, a recent effective strategy is to massively overparameterize a model and then rely on the implicit regularizing properties of stochastic gradient descent. We ask, is there anything to be gained from End-to-End training of such large models? What does the concept of diversity even mean when the models have almost zero training error? We address this by examining ensembles of DenseNets (Huang et al.,, 2017), which achieve close to SOTA at the time of writing. We train a variety of DenseNet ensembles on the CIFAR-100 dataset, with the size of the ensemble increasing as the complexity of each ensemble member decreases, such that each configuration occupies approximately 12GB of GPU RAM. These configurations are described in Table 1. Full experimental details can be found in the supplementary material.

Table 2 shows results for independent, End-to-End, and Joint training, vs. Bagging/Stacking. Each row contains results for a DenseNet ensemble, with minimum error rate in bold. Results for DN-High replicate the results of Dutt et al., (2020, Table 2).

In the previous section, we saw End-to-End training outperforming independent training for large ensembles of very small models. Here, we find the opposite is true for small ensembles of large, SOTA models. In every DenseNet configuration, End-to-End training (i.e. $\lambda=1$) is sub-optimal. In all but DN-Low, which is the configuration with the largest ensemble of smallest models, independent training ($\lambda=0$) achieves the lowest test error. These results indicate there is little to no benefit in test error when E2E ensemble training SOTA deep neural networks. However, the result for DN-Low suggests that there may be a relatively smooth transition, somewhere between E2E ensembles and independent training, as the complexity of the ensemble members increases.

Intermediate capacity.

In this section we further explore the relationship between ensemble member complexity and E2E ensemble training. We train ensembles of convolutional networks on CIFAR-100. Each ensemble has 16 members of varying complexity, from $70,000$ parameters up to $1.2$ million. Full details can be found in the supplementary material. Note that these experiments are not intended to be competitive with the SOTA, but to illustrate relative benefits of E2E ensembles as the complexity of individual members varies.

Figure 4 shows the test error rate and standard errors for each $\lambda$ value for each configuration. The ‘dip’ in each of the four lines in the figure is the optimal $\lambda$. We find that the optimal point smoothly decreases: E2E ensembles are the preferred option with simpler networks, but this changes as the networks become more complex. At 1.2M parameters, the optimal point lies clearly between the two extremes. This supports the trend observed in the previous sections, that the benefits of E2E training as a scheme depend critically on the complexity of individual networks.

When does End-to-End ensemble training fail?

These results suggest a trend: ensembles of low capacity models benefit from E2E training, and high capacity models perform better if trained independently. We suggest a possible explanation for this trend, and a diagnostic for determining during training whether E2E training will perform well. We find that ensembles of high capacity models, when trained E2E, exhibit a ‘model dominance’ effect, shown in Figure 6. There is a sharp transition in behaviour at $\lambda=1$ (E2E), whereby a single ensemble member individually performs well—in both training and test error—while all other members perform poorly. This effect is not observed in ensembles of low capacity models.

We suggest that this dominance effect can explain the poor performance of E2E training seen in Table 2. We also note that model dominance occurs in the E2E training experiments of Dutt et al., (2020, Table 2) (called ‘coupled training (FC)’ by the authors); the authors report the average and standard deviation (within a single trial) of the ensemble member error rates. In the case with 2 ensemble members, it can be inferred that one ensemble member achieves a much lower error rate than the other.

In our own experiments, the dominance effect manifests early in training (Figure 6). In each trial, the ensemble member with the lowest error rate by the end of epoch 3 dominates by the end of training; model dominance can be used as an early diagnosis during training that the ensemble members are overcapacity for E2E training. Note that model dominance can occur in classification because the ensemble prediction is a normalized geometric mean; a network closely fitting the data can arbitrarily reduce the ensemble error—the well-known ‘veto’ effect in Products of Experts (Welling,, 2007)—and the parameters of other networks can be prevented from moving far from their initial values. This ‘stagnation’ of other ensemble members can be seen in Figure 5, which shows some of the filters in the first layer of a ConvNet trained independently and E2E, showing a small number of strong filters in the latter case.

5 What happens between E2E and independent training?

The previous section has demonstrated clearly that E2E training of an ensemble can be sub-optimal. More interestingly perhaps, the complex behaviour seems to lie between independent and E2E. This section goes beyond just ensemble test error rate, and looks into properties of the networks inside the ensemble.

Robustness.

We find that Joint Training with $\lambda$ very slightly less than 1 can greatly increase the robustness of an ensemble, in the sense that dropping the response from a subset of the networks at test time does not significantly harm the accuracy. This partial evaluation, performing inference for only a subset of the networks, may be useful in resource-limited scenarios, e.g. limited power budgets in Edge/IoT devices.

Figure 7 analyses the $256\times 4$H ensemble, dropping a random subset of networks for each test example in Fashion-MNIST, averaged over 20 repeats. Independent training ($\lambda=0$) builds a highly robust ensemble, but which could also be seen to be redundant—adding more networks does not increase accuracy. End-to-End training ($\lambda=1$) achieves higher test accuracy, but the ensemble is not at all robust. Joint Training with $\lambda=0.99$ achieves the same accuracy as End-to-End with all members, but can maintain accuracy even if more than 50% of the networks are dropped. A similar behaviour is observed with the $64\times 16$H architecture, in Figure 8.

Robust ensembles: why does this occur? When training independently, the networks have no “idea” of each others’ existence—so solve the problem as individuals—and hence the ensemble is highly robust to removal of networks. When we End-to-End train the exact same architecture, all networks are effectively ”slave” components in a larger network. They cannot directly target their own losses, so individual errors would not be expected to be very low. However, as a system, they work together, and achieve low ensemble error. The problem is that the networks rely on the others too much—so when removing networks, the performance degrades rapidly. This is illustrated in Figure 9—we see individual network loss rapidly increasing as we approach End-to-End training (i.e. $\lambda=1$).

The “sweet spot” is a small amount of joint training with $\lambda=0.99$, which ensure the networks cannot rely on each other completely, but are still working together. This is highly reminiscent of Dropout, where one of Hinton’s stated motivations was to make each “hidden unit more robust and drive it towards creating useful features on its own without relying on other hidden units to correct its mistakes.” (Srivastava et al.,, 2014, Section 2). This similarity is not a coincidence, and is discussed in the next section.

6 Discussion & Future Work

The primary question for this paper was “when does E2E ensemble training fail?”, with the intention to explain conflicting results in the literature, e.g. Lee et al., (2015); Dutt et al., (2020). The answer turns out to be intimately tied with the over-parameterization (or not) of individual networks in the ensemble. Dutt et al., (2020); Lee et al., (2015) concluded that End-to-End training of ensembles leads to poor performance—however, only very large state-of-the-art models were studied. Our results agree with theirs exactly, in situations where ensemble members are over capacity—Table 2 reproduces the results of Dutt et al., (2020, Table 2)—but, the advantage of E2E emerges with lower capacity individuals, where there are also interesting and potentially useful dynamics in-between Independent/E2E training.

Relations to prior work. The investigation turned up links to literature going back over 20 years, in terms of ensemble diversity (Heskes,, 1998). As mentioned, we presented results primarily on classification problems—however, the framework presented in Section 2 applies generally for targets following any exponential family distribution. For the special case of a Gaussian, and when we re-arrange the loss as (5), the gradient is exactly equivalent to a previously proposed method, Negative Correlation Learning (NCL) (Liu and Yao,, 1999; Brown et al., 2005b, ). Thus, an alternative view of the loss is as a generalization of NCL to arbitrary exponential family distributions, where the Categorical distribution assumption here can be seen as managing diversity in classification ensembles, echoing the title of Brown et al., 2005b .

The Dropout connection? We observed a qualitative similarity between ensemble robustness, and the motivations behind Dropout (Srivastava et al.,, 2014). It is interesting to note that Negative Correlation Learning Liu and Yao, (1999) can be proven equivalent to a stochastic dropping of ensemble members during training (Reeve et al.,, 2018), i.e. Dropout at the network level. With some investigation we have determined that their result depends critically on the Gaussian assumption and hence holds only for NCL, not more generally for Joint Training loss with any exponential family. Despite this, the observations in Section 5 do suggest a connection, worthy of future work.

**Should we always E2E train Multi-Branch networks? ** The End-to-End training methodology treats the ensemble as if it were a single multi-branch architecture. A similar view could be taken of any multi-branch architecture, e.g. ResNeXt (Xie et al.,, 2017) that it is either an ensemble of branches, or a single system. We have found that if ensemble members are over capacity, then one network can ‘dominate’ an ensemble, leading to poor performance overall. This raises the obvious open question, of whether it is also true for sub-branches in general branched architectures like ResNeXt.

Ill-conditioning? As $\lambda\rightarrow 1$, the condition number of the Hessian for the JT Loss tends to infinity, as we show in the supplementary material. Therefore there may be cases where E2E training with first-order optimization methods (e.g. simple SGD) performs poorly, and where second-order methods behave markedly differently. We leave this question for future study.

7 Conclusions

We have presented a detailed analysis of the question “When does End-to-End Ensemble training fail?”. This is in response to the recent trend of end-to-end training being used more and more in deep learning, and specifically for an ensemble (Lee et al.,, 2015; Furlanello et al.,, 2018; Dutt et al.,, 2020). Our strategy for this was to study a convex combination of the likelihood-based losses for independent and E2E training, blending the gradient slowly from one to the other.

Our answer to the question is that End-to-End training tends to under-perform when member networks are significantly over-parameterized, though it is possible to diagnose whether this will happen by examining the relative network training errors in the first few epochs. In this case we suggest alternative classical methods such as Bagging, or Independent training. Further, we conjecture that this may have implications for general multi-branch architectures—should we always train them E2E, or perhaps individually?

The space between independent and E2E turned out to be a rich source of quite unexpectedly complex dynamics, generating robust ensembles, with links to Dropout, general multi-branch deep learning, and early literature on ensemble diversity. We suggest the book is not yet closed and perhaps there is much more to learn in this space.

Acknowledgements

The authors gratefully acknowledge the support of the EPSRC for the LAMBDA project (EP/N035127/1).

Appendix 0.A Re-writing the Joint Training Loss

Here we show that the convex combination form and the ‘ambiguity’ form of the loss are equivalent. Starting from the convex combination form:

[TABLE]

we use the ambiguity decomposition (Heskes,, 1998):

[TABLE]

Substituting the right-hand side for the $\text{D}(p\,\|\,\bar{q})$ term in (6), we obtain the ambiguity form of the loss:

[TABLE]

Appendix 0.B Experimental Details

Here we specify details such as dataset, model architecture, and training for the modular loss experiments.

0.B.1 Spending a Fixed Parameter Budget—MLPs / Fashion-MNIST

Dataset.

We use the Fashion-MNIST dataset (Xiao et al.,, 2017) with the predefined train/test split, holding out $10000$ training examples as a validation set for early stopping. We apply mean and standard deviation normalization, and no data augmentation.

Architectures.

We use single layer MLPs with ReLU activations, in four configurations each with ${\sim}$815$$K parameters: a single module with 1024 hidden nodes (1-M-1024-H), 16 modules with 64 hidden nodes each (16-M-64-H), 64 modules with 16 nodes (64-M-16-H), and 256 modules with 4 nodes (256-M-4-H).

Training.

We train for 200 epochs of SGD, batch size 100, momentum $0.9$, and tune the learning rate independently for each configuration and $\lambda$. Final reported test error is that at the epoch where validation error was minimized. Results are averaged over $5$ trials of random train/validation splits and initializations.

0.B.2 High Capacity Individual Models—DenseNets / CIFAR-100

Dataset.

We use the CIFAR-100 (Krizhevsky,, 2009) dataset with the predefined train/test split, per-channel mean and standard deviation normalization, and the standard data augmentation (see, e.g., He et al., (2016)).

Architectures.

We train ensembles of DenseNet-BC networks (Huang et al.,, 2017). We train 4 modules with a depth of 100 and growth rate 12 (DN-100-12-4)—a configuration used in Dutt et al., (2020). We also train ensembles of 8 and 16 smaller DenseNet modules. Our DenseNet implementation is based on Amos and Kolter, (2017).

Training.

We evaluate $\lambda$ values {0.0, 0.5, 0.9, 1.0} over 3 trials of parameter initialization. We use the training procedure described by Huang et al., (2017); Dutt et al., (2020). We use SGD with batch size $64$. The initial learning rate of $0.1$ is decreased by a factor of $10$ at epochs $150$ and $225$, with momentum $0.9$.

0.B.3 Intermediate Capacity—Small ConvNets / CIFAR-100

Dataset.

We use the CIFAR-100 dataset (Krizhevsky,, 2009) with the predefined train/test split, holding out $10000$ training examples for early stopping. We apply per-channel mean and standard deviation normalization, and apply the standard flip and crop data augmentation used for this dataset.

Architecture.

We train ensembles of 16 CNNs with ReLU activations. We apply global pooling before the final fully connected layer, in the style of MobileNets (Howard et al.,, 2017). The networks are fully convolutional, and we evaluate a variety of architectures of varying complexity. The architectures are described in Table 4.

Training.

We evaluate $\lambda$ values {0.0, 0.1, 0.2, …, 1.0} over $5$ trials of random training/validation splits and parameter initializations. We use SGD with batch size $128$, with learning rate 0.1, momentum $0.9$, and weight decay $10^{-}4$. We train for 400 epochs, decaying learning rate by a factor of 10 at epochs 200 and 300, before reporting test error at the epoch at which validation error is minimized.

Appendix 0.C Effect of $\lambda$ on the Condition Number of the Hessian

In this section we show that for $\lambda>0$, any stationary points—in the special case of scalar model outputs—has a Hessian with both positive and negative eigenvalues, and so all stationary points are saddle points. Further, we show that the condition number of the Hessian grows as $\lambda$ tends to $1$ from below.

For a given input pattern, let the target $y$ be distributed according to a single-parameter exponential family distribution with scalar parameter $\eta$. Let $\hat{\eta}_{j}$ be the parameter value prediction for the $j$th model of a collection of $M$ models, and let $\bar{\eta}=\frac{1}{M}\sum_{j=i}^{M}\hat{\eta}_{j}$ be the ensemble prediction. Let $\hat{y}_{j}=g(\hat{\eta}_{j})$ and $\bar{y}=g(\bar{\eta})$ be the conditional mean estimates of the $j$th model and ensemble model respectively, where $g$ is the canonical inverse link function of the distribution. We have

[TABLE]

where $L_{\lambda}$ is the modular loss, and the entries of the Hessian are given by

[TABLE]

From (9), for $\lambda\neq 0$ any stationary point of the loss must have $\hat{y}_{i}=\hat{y}_{j}=\bar{y}=y$, and therefore $c\overset{\text{def}}{=}g^{\prime}(\hat{\eta}_{i})=g^{\prime}(\hat{\eta}_{j})=g^{\prime}(\bar{\eta})=g^{\prime}(\eta)$ for all $i,j$, and the Hessian takes the form

[TABLE]

with diagonal entries

[TABLE]

and off-diagonal entries

[TABLE]

This matrix is $H=r\cdot J_{M}+(q-r)\cdot I_{M}$, where $J_{M}$ is the $M\times M$ matrix of ones and $I_{M}$ is the $M\times M$ identity matrix. The eigenvalues of $J_{M}$ are $M$ with multiplicity $1$ and [math] with multiplicity $M-1$. Therefore, the eigenvalues of $H$ are

[TABLE]

From this, we can see that for $\lambda>1$ the Hessian at the stationary point has both positive and negative eigenvalues, and therefore the stationary point is a saddle point, therefore the models will diverge. Moreover, for $1>\lambda>0$, the condition number is

[TABLE]

which tends to infinity as $\lambda$ tends to $1$ from below. This may suggest that optimization may be problematic for $\lambda$ close to $1$, and that we might see significantly different learning behaviour between first- and second-order methods in this regime.

Note that in the case of the Bernoulli distribution, the loss surface with respect to the parameter estimates $\hat{\eta}_{j}$ has no stationary points, but a similar argument can be made with limits.

Appendix 0.D Equivalence of ‘Coupled Ensembles’ Training Methods

We prove here that the ‘LL’ and ‘SM’ coupled training methods of Dutt et al., (2020) for ensembles of classifiers are actually equivalent to independent training, up to a scaling of learning rate. We demonstrate that here.

Suppose we have a collection of $M$ neural networks for a $K$ class classification problem. Let $q_{k}^{(m)}$ denote the $k$th post-softmax output of the $m$th neural network for a given example. Let $\mathbf{y}$ be the one hot-encoded true label. The cross entropy loss $L^{(m)}$ of the $m$th network is

[TABLE]

The ‘LL’ coupled training method of Dutt et al., (2020) has as its loss function $L_{LL}$ the arithmetic mean of the cross entropy loss functions for each network. I.e.,

[TABLE]

It follows from the fact that $\partial L^{(m)}/\partial q_{k}^{(n)}=0$ if $m\neq n$—i.e., that the cross entropy loss of one network does not depend on the output of another—that

[TABLE]

In words, the gradient of the ‘LL’ loss with respect to a given network output—and therefore the gradient with respect to the network parameters—is the same as when training independently, scaled by a factor $1/M$.

The ‘SM’ coupled training method of Dutt et al., (2020) works as follows. First, take the log of the probabilities $q_{k}^{(m)}$, and then take the arithmetic mean across networks. The key point here is that the result is not a vector of log probabilities; it is un-normalized. An inspection of the authors’ provided code (Dutt et al.,, 2018) shows that, in the ‘SM’ method, this un-normalized log probability vector is given as input to the NLLLoss loss function provided by PyTorch, which expects log probabilities. The result is that the cross entropy loss is applied to the un-normalized probabilities

[TABLE]

and that, if $\bf y$ is the one hot-encoded true label, the loss function that is effectively used is

[TABLE]

This suffices to demonstrate that the ‘LL’ and ‘SM’ methods are equivalent to independent training up to a scaling of learning rate.