EFFECTIVE REGULARIZATION THROUGH LOSS-FUNCTION METALEARNING
Year: 2020

Abstract:
Loss-function metalearning can be used to discover novel, customized loss functions for deep neural networks, resulting in improved performance, faster training, and improved data utilization. A likely explanation is that such functions discourage overfitting, leading to effective regularization. This paper demonstrates theoretically that this is indeed the case for the TaylorGLO method: Decomposition of learning rules makes it possible to characterize the training dynamics and show that the loss functions evolved by TaylorGLO balance the pull to zero error, and a push away from it to avoid overfitting. This observation leads to an invariant that can be utilized to make the metalearning process more efficient in practice, and result in networks that are robust against adversarial attacks. Loss-function optimization can thus be seen as a well-founded new aspect of metalearning in neural networks.

text: Loss-function metalearning can be used to discover novel, customized loss functions for deep neural networks, resulting in improved performance, faster training, and improved data utilization. A likely explanation is that such functions discourage overfitting, leading to effective regularization. This paper demonstrates theoretically that this is indeed the case for the TaylorGLO method: Decomposition of learning rules makes it possible to characterize the training dynamics and show that the loss functions evolved by TaylorGLO balance the pull to zero error, and a push away from it to avoid overfitting. This observation leads to an invariant that can be utilized to make the metalearning process more efficient in practice, and result in networks that are robust against adversarial attacks. Loss-function optimization can thus be seen as a well-founded new aspect of metalearning in neural networks.

heading: 1 INTRODUCTION
text: Regularization is a key concept in deep learning: it guides learning towards configurations that are likely to perform robustly on unseen data. Different regularization approaches originate from intuitive understanding of the learning process and have been shown to be effective empirically. However, the understanding of the underlying mechanisms, the different types of regularization, and their interactions, is limited.
Recently, loss function optimization has emerged as a new area of metalearning, and shown great potential in training better models. Experiments suggest that metalearned loss functions serve as regularizers in a surprising but transparent way: they prevent the network from learning too confident predictions (e.g. Baikal loss; Gonzalez & Miikkulainen, 2020a). While it may be too early to develop a comprehensive theory of regularization, given the relatively nascent state of this area, it may be possible to make progress in understanding regularization of this specific type. That is the goal of this paper.
Since metalearned loss functions are customized to a given architecture-task pair, there needs to be a shared framework under which loss functions can be analyzed and compared. The TaylorGLO (Gonzalez & Miikkulainen, 2020b) technique for loss function metalearning lends itself well to such analysis: It represents loss functions as multivariate Taylor polynomials, and leverages evolution to optimize a fixed number of parameters in this representation. In this framework, the SGD learning rule is decomposed to coefficient expressions that can be defined for a wide range of loss functions. These expressions provide an intuitive understanding of the training dynamics in specific contexts.
Using this framework, mean squared error (MSE), cross-entropy, Baikal, and TaylorGLO loss functions are analyzed at the null epoch, when network weights are similarly distributed (Appendix C), and in a zero training error regime, where the training samples’ labels have been perfectly memorized. For any intermediate point in the training process, the strength of the zero training error regime as an attractor is analyzed and a constraint on this property is derived on TaylorGLO parameters by characterizing how the output distribution’s entropy changes. In a concrete TaylorGLO loss function that has been metalearned, these attraction dynamics are calculated for individual samples at every epoch in a real training run, and contrasted with those for the cross-entropy loss. This comparison provides clarity on how TaylorGLO avoids becoming overly confident in its predictions. Further, the analysis shows (in Appendix D.2) how label smoothing (Szegedy et al., 2016), a traditional type
of regularization, can be implicitly encoded by TaylorGLO loss functions: Any representable loss function has label-smoothed variants that are also representable by the parameterization.
From these analyses, practical opportunities arise. First, at the null epoch, where the desired behavior can be characterized clearly, an invariant can be derived on a TaylorGLO loss function’s parameters that must hold true for networks to be trainable. This constraint is then applied within the TaylorGLO algorithm to guide the search process towards good loss functions more efficiently. Second, lossfunction-based regularization results in robustness that should e.g. make them more resilient to adversarial attacks. This property is demonstrated experimentally by incorporating adversarial robustness as an objective within the TaylorGLO search process. Thus, loss-function metalearning can be seen as a well-founded and practical approach to effective regularization in deep learning.

heading: 2 BACKGROUND
text: Regularization traditionally refers to methods for encouraging smoother mappings by adding a regularizing term to the objective function, i.e., to the loss function in neural networks. It can be defined more broadly, however, e.g. as “any modification we make to a learning algorithm that is intended to reduce its generalization error but not its training error” (Goodfellow et al., 2015). To that end, many regularization techniques have been developed that aim to improve the training process in neural networks. These techniques can be architectural in nature, such as Dropout (Srivastava et al., 2014) and Batch Normalization (Ioffe & Szegedy, 2015), or they can alter some aspect of the training process, such as label smoothing (Szegedy et al., 2016) or the minimization of a weight norm (Hanson & Pratt, 1989). These techniques are briefly reviewed in this section, providing context for loss-function metalearning.

heading: 2.1 IMPLICIT BIASES IN OPTIMIZERS
text: It may seem surprising that overparameterized neural networks are able to generalize at all, given that they have the capacity to memorize a training set perfectly, and in fact sometimes do (i.e., zero training error is reached). Different optimizers have different implicit biases that determine which solutions are ultimately found. These biases are helpful in providing implicit regularization to the optimization process (Neyshabur et al., 2015). Such implicit regularization is the result of a network norm—a measure of complexity—that is minimized as optimization progresses. This is why models continue to improve even after training set has been memorized (i.e., the training error global optima is reached) (Neyshabur et al., 2017).
For example, the process of stochastic gradient descent (SGD) itself has been found to provide regularization implicitly when learning on data with noisy labels (Blanc et al., 2020). In overparameterized networks, adaptive optimizers find very different solutions than basic SGD. These solutions tend to have worse generalization properties, even though they tend to have lower training errors (Wilson et al., 2017).

heading: 2.2 REGULARIZATION APPROACHES
text: While optimizers may minimize a network norm implicitly, regularization approaches supplement this process and make it explicit. For example, a common way to restrict the parameter norm explicitly is through weight decay. This approach discourages network complexity by placing a cost on weights (Hanson & Pratt, 1989).
Generalization and regularization are often characterized at the end of training, i.e. as a behavior that results from the optimization process. Various findings have influenced work in regularization. For example, flat landscapes have better generalization properties (Keskar et al., 2017; Li et al., 2018; Chaudhari et al., 2019). In overparameterized cases, the solutions at the center of these landscapes may have zero training error (i.e., perfect memorization), and under certain conditions, zero training error empirically leads to lower generalization error (Belkin et al., 2019; Nakkiran et al., 2019). However, when a training loss of zero is reached, generalization suffers (Ishida et al., 2020). This behavior can be thought of as overtraining, and techniques have been developed to reduce it at the end of the training process, such as early stopping (Morgan & Bourlard, 1990) and flooding (Ishida et al., 2020).
Both flooding and early stopping assume that overfitting happens at the end of training, which is not always true (Golatkar et al., 2019). In fact, the order in which easy-to-generalize and hard-togeneralize concepts are learned is important for the network’s ultimate generalization. For instance, larger learning rates early in the training process often lead to better generalization in the final model (Li et al., 2019). Similarly, low-error solutions found by SGD in a relatively quick manner—such as through high learning rates—often have good generalization properties (Yao et al., 2007).
Other techniques tackle overfitting by making it more difficult. Dropout (Srivastava et al., 2014) makes some connections disappear. Cutout (DeVries & Taylor, 2017), Mixup (Zhang et al., 2018), and their composition, CutMix (Yun et al., 2019), augment training data with a broader variation of examples.
Notably, regularization is not a one-dimensional continuum. Different techniques regularize in different ways that often interact. For example, flooding invalidates performance gains from early stopping (Ishida et al., 2020). However, ultimately all regularization techniques alter the gradients that result from the training loss. This observation suggests loss-function optimization might be an effective way to regularize the training process.

heading: 2.3 LOSS-FUNCTION METALEARNING
text: The idea of metalearning loss-functions has a deep history with many recent developments that have shown promise in practical settings.
Prior work in reinforcement learning showed that metalearning various types of objectives is useful. For instance, in evolving policy gradients (Houthooft et al., 2018), the policy loss is not represented symbolically, but rather as a neural network that convolves over a temporal sequence of context vectors. In reward function search (Niekum et al., 2010), the task is framed as a genetic programming problem, leveraging PushGP (Spector et al., 2001). Various actor-critic reinforcement learning approaches have tackled learning a meta-critic neural network that can generate losses (Sung et al., 2017; Zhou et al., 2020). Metalearned critic network techniques have also been applied outside of reinforcement learning to train better few-shot classifiers (Antoniou & Storkey, 2019).
In unsupervised representation learning, weight update rules for semi-supervised learning have themselves been metalearned successfully (Metz et al., 2018). The update rules were constrained to fit a biological neuron model and transferred well between tasks.
Concrete loss-function metalearning for deep networks was first introduced by Gonzalez & Miikkulainen (2020a) as an automatic way to find customized loss functions that aim to optimize a performance metric for a model. The technique, a genetic programming approach, named GLO, discovered one particular loss function, Baikal, that improves classification accuracy, training speed, and data utilization. Baikal appeared to achieve these properties through a form of regularization that ensured the model would not become overly confident in its predictions. That is, instead of monotonically decreasing the loss when the output gets closer to the correct value, Baikal loss increases rapidly when the output is almost correct, thus discouraging extreme accuracy. This paper shows how training dynamics are specifically impacted in this manner when training with the Baikal loss.
Overall, GLO demonstrated that while learned loss functions’ generalization effects transfer across datasets and models to some extent, they are most powerful when they are customized to individual tasks and architectures. Different loss functions can take advantage of the different characteristics of each such setting. Other techniques have advanced this new field further, for example by metalearning state-dependent loss functions for inverse dynamics models (Morse et al., 2020), and using a trained network that is itself a metalearned loss function (Bechtle et al., 2019).
One particular technique, TaylorGLO (Gonzalez & Miikkulainen, 2020b), lends itself well to analyzing what makes loss-function metalearning effective. TaylorGLO represents loss functions as parameterizations of multivariate Taylor polynomials. This parameterization allows it to scale to models with millions of trainable parameters, including a variety of deep learning architectures in image classification tasks. TaylorGLO loss functions have a tunable complexity based on the order of the polynomial; third-order functions were identified to work best in practical settings.
The third-order TaylorGLO loss function parameterization provides a fixed representation that can be used to analyze a large family of loss functions through a unified methodology. In prior work, TaylorGLO loss functions were shown to improve generalization empirically (Gonzalez & Miikkulainen, 2020b). This paper complements that work, aiming to explain why that is the case by analyzing the dynamics of training theoretically.

heading: 3 LEARNING RULE DECOMPOSITION
text: This section develops the framework for the analysis in this paper. By decomposing the learning rules under different loss functions, comparisons can be drawn at different stages of the training process. Consider the standard SGD update rule:
θ ← θ − η∇θ (L(xi,yi,θ)) . (1) where η is the learning rate, L(xi,yi,θ) is the loss function applied to the network h(xi,θ), xi is an input data sample, yi is the ith sample’s corresponding label, and θ is the set of trainable parameters in the model. The update for a single weight θj is
θj ← θj − ηDj (L(xi,yi,θ)) = θj − η ∂
∂s L(xi,yi,θ + sj) ∣∣∣∣ s→0 . (2)
where j is a basis vector for the jth weight. The following text illustrates decompositions of this general learning rule in a classification context for a variety of loss functions: mean squared error (MSE), the cross-entropy loss function, the general third-order TaylorGLO loss function, and the Baikal loss function. The TaylorGLO and Baikal loss functions are referenced in Section 2.3. Each decomposition results in a learning rule of the form
θj ← θj + η 1
n n∑ k=1 [γk(xi,yi,θ)Dj (hk(xi,θ))] , (3)
where γk(xi,yi,θ) is an expression that is specific to each loss function.
Substituting the Mean squared error (MSE) loss into Equation 2,
θj ← θj − η 1
n n∑ k=1 [ 2 (hk(xi,θ + sj)− yik) ∂ ∂s hk(xi,θ + sj) ] ∣∣∣∣ s→0
(4)
and breaking up the coefficient expressions into γk(xi,yi,θ) results in the weight update step γk(xi,yi,θ) = 2yik − 2hk(xi,θ). (5)
Substituting the Cross-entropy loss into Equation 2,
θj ← θj + η 1
n n∑ k=1 [ yik
1
hk(xi,θ + sj)
∂
∂s hk(xi,θ + sj) ] ∣∣∣∣ s→0
(6)
and breaking up the coefficient expressions into γk(xi,yi,θ) results in the weight update step γk(xi,yi,θ) =
yik hk(xi,θ) . (7)
Substituting the Baikal loss into Equation 2,
θj ← θj + η 1
n n∑ k=1 [( 1 hk(xi,θ + sj) + yik hk(xi,θ + sj)2 ) ∂ ∂s hk(xi,θ + sj) ] ∣∣∣∣ s→0
(8)
and breaking up the coefficient expressions into γk(xi,yi,θ) results in the weight update step
γk(xi,yi,θ) = 1
hk(xi,θ) + yik hk(xi,θ)2 . (9)
Substituting the Third-order TaylorGLO loss with parameters λ into Equation 2,
θj ← θj + η 1
n n∑ k=1 [ λ2 ∂ ∂s hk(xi,θ + sj) + λ32 (hk(xi,θ + sj)− λ1) ∂ ∂s hk(xi,θ + sj)
+λ43 (hk(xi,θ + sj)− λ1)2 ∂
∂s hk(xi,θ + sj) + λ5(yik − λ0)
∂
∂s hk(xi,θ + sj)
+ ( λ6(yik − λ0)2 (hk(xi,θ + sj)− λ1) + λ7(yik − λ0)2 ) ∂ ∂s hk(xi,θ + sj) ] ∣∣∣∣ s→0 (10)
and breaking up the coefficient expressions into γk(xi,yi,θ) results in the weight update step γk(xi,yi,θ) = 2λ3hk(xi,θ)− 2λ1λ3 + 2λ6hk(xi,θ)yik − 2λ6λ0hk(xi,θ)
−2λ1λ6yik + 2λ1λ6λ0 + λ2 + λ5yik − λ5λ0 + λ7y2ik − 2λ7λ0yik +λ7λ 2 0 + 3λ4hk(xi,θ) 2 − 6λ1λ4hk(xi,θ) + 3λ4λ21. (11)
To simplify analysis, γk(xi,yi,θ) can be decomposed into a linear combination of [1, hk(xi,θ), hk(xi,θ) 2, hk(xi,θ)yik, yik, y 2 ik] with respective coefficients [c1, ch, chh, chy, cy, cyy] whose values are implicitly functions of λ:
γk(xi,yi,θ) = c1 + chhk(xi,θ) + chhhk(xi,θ) 2 + chyhk(xi,θ)yik + cyyik + cyyy 2 ik. (12)

heading: 4 CHARACTERIZING TRAINING DYNAMICS
text: Using the decomposition framework above, it is possible to characterize and compare training dynamics under different loss functions. In this section, the decompositions are first analyzed under a zero training error regime to identify optimization biases that lead to implicit regularization. Second, generalizing to the entire training process, a theoretical constraint is derived on the entropy of a network’s outputs. Combined with experimental data, this constraint characterizes the data fitting and regularization processes that result from the TaylorGLO training process. This characterization shows how individual training samples are treated by different loss functions.

heading: 4.1 OPTIMIZATION BIASES IN THE ZERO TRAINING ERROR REGIME
text: Certain biases in optimization imposed by a loss function can be best observed in the case where there is nothing new to learn from the training data. Consider the case where there is zero training error, that is, hk(xi,θ)− yik = 0. In this case, all hk(xi,θ) can be substituted with yik in γk(xi,yi,θ), as is done below for the different loss functions.
Mean squared error (MSE): In this case,
γk(xi,yi,θ) = 2yik − 2hk(xi,θ) = 0. (13)
Thus, there are no changes to the weights of the model once error reaches zero. This observation contrasts with the findings in Blanc et al. (2020), who discovered an implicit regularization effect when training with MSE loss and label noise. Notably, this null behavior is representable in a non-degenerate TaylorGLO parameterization, since MSE is itself representable by TaylorGLO with λ = [0, 0, 0,−1, 0, 2, 0, 0]. Thus, this behavior can be leveraged in evolved loss functions. Cross-entropy loss: Since hk(xi,θ) = 0 for non-target logits in a zero training error regime, γk(xi,yi,θ) = 0 0 , i.e. an indeterminate form. Thus, an arbitrarily-close-to-zero training error regime is analyzed instead, such that hk(xi,θ) = for non-target logits for an arbitrarily small . Since all scaled logits sum to 1, hk(xi,θ) = 1− (n− 1) for the target logit. Let us analyze the learning rule as tends towards 0:
θj ← θj + lim →0
η 1
n n∑ k=1  yik Dj (hk(xi,θ)) yik = 0 yik 1− (n− 1) Dj (hk(xi,θ)) yik = 1 (14)
= θj + η 1
n n∑ k=1 { 0 yik = 0 Dj (hk(xi,θ)) yik = 1. (15)
Intuitively, this learning rule aims to increase the value of the target scaled logits. Since logits are scaled by a softmax function, increasing the value of one logit decreases the values of other logits. Thus, the fixed point of this bias will be to force non-target scaled logits to zero, and target scaled logits to one. In other words, this behavior aims to minimize the divergence between the predicted distribution and the training data’s distribution.
TaylorGLO can represent this behavior, and can thus be leveraged in evolved loss functions, through any case where a = 0 and b+ c > 0. Any λ where λ2 = 2λ1λ3 +λ5λ0− 2λ1λ6λ0−λ7λ20− 3λ4λ21 represents such a satisfying family of cases. Additionally, TaylorGLO allows for the strength of this bias to be tuned independently from η by adjusting the magnitude of b+ c.
Baikal loss: Notably, the Baikal loss function results in infinite gradients at zero training error, rendering it unstable, even if using it to fine-tune from a previously trained network that already reached zero training error. However, the zero-error regime is irrelevant with Baikal because it cannot be reached in practice:
Theorem 1: Zero training error regions of the weight space are not attractors for the Baikal loss function.
The reason is that if a network reaches reaches a training error that is arbitrarily close to zero, there is a repulsive effect that biases the model’s weights away from zero training error. Proof of this theorem is in Appendix D.1.
Third-order TaylorGLO loss: According to Equation 12, in the zero-error regime γk(xi,yi,θ) can be written as a linear combination of [1, yik, y2ik] and [a, b, c] (as defined in Appendix B), i.e. γk(xi,yi,θ) = a+ byik + cy 2 ik.
Notably, in the basic classification case, ∀w ∈ N1 : yik = ywik, since yik ∈ {0, 1}. This observation provides an intuition for why higher-order TaylorGLO loss functions are not able to provide fundamentally different behavior (beyond a more overparameterized search space), and thus no improvements in performance over third-order loss functions. The learning rule thus becomes
θj ← θj + η 1
n n∑ k=1 { aDj (hk(xi,θ)) yik = 0 (a+ b+ c)Dj (hk(xi,θ)) yik = 1, (16)
where a, b, c are functions of λ defined in Appendix B.
As a concrete example, consider the loss function TaylorGLO discovered for the AllCNN-C model on CIFAR-10 (Gonzalez & Miikkulainen, 2020b). It had a = −373.917, b = −129.928, c = −11.3145. Notably, all three coefficients are negative, i.e. all changes to θj are a negatively scaled values of Dj (hk(xi,θ)), as can be seen from Equation 16. Thus, there are two competing processes in this learning rule: one that aims to minimize all non-target scaled logits (increasing the scaled logit distribution’s entropy), and one that aims to minimize the target scaled logit (decreasing the scaled logit distribution’s entropy). The processes conflict with each other since logits are scaled through a softmax function. These processes can shift weights in a particular way while maintaining zero training error, which results in implicit regularization. If, however, such shifts in this zero training error regime do lead to misclassifications on the training data, hk(xi,θ) would no longer equal yik, and a non-zero error regime’s learning rule would come into effect. It would strive to get back to zero training error with a different θ.
Similarly to Baikal loss, a training error of exactly zero is not an attractor for some third-order TaylorGLO loss functions (this property can be seen through an analysis similar to that in Section D.1). The zero-error case would occur in practice only if this loss function were to be used to fine tune a network that truly has a zero training error. It is, however, a useful step in characterizing the behavior of TaylorGLO, as will be seen later.

heading: 4.2 DATA FITTING AND REGULARIZATION PROCESSES
text: Under what gradient conditions does a network’s softmax function transition from increasing the entropy in the output distribution to decreasing it? Characterizing this behavior can yield insights on how specific training samples affect a network’s trainable parameters. Let us analyze the case where all non-target logits have the same value, n−1 , and the target logit has the value 1− . That is, all non-target classes have equal probabilities.
Theorem 2. The strength of entropy reduction is proportional to ( − 1) ( e ( −1)(γ¬T−γT ) − e ( −1)γT (n−1)+ γ¬T ( (n−3)+n−1) (n−1)2 ) ( − 1) e ( −1)(γ¬T−γT ) − e ( −1)γT (n−1)+ γ¬T ( (n−3)+n−1) (n−1)2
(17)
where γ¬T is the value of γj for non-target logits, and γT for the target logit. Thus, values less than zero imply that entropy is increased, values greater than zero imply that it is decreased, and values equal to zero imply that there is no change. The proof is in Appendix D.3.
The strength of the entropy reduction in Theorem 2 can also be thought of as a measure of the strength of the attraction towards zero training error regions of the parameter space (i.e., shrinking non-target logits and growing target logits imply reduced training error). This strength can be calculated for individual training samples during any part of the training process, leading to the insight that the process results from competing “push” and “pull” forces. This theoretical insight, combined with empirical data from actual training sessions, explains how different loss functions balance data fitting and regularization.
Figure 1 provides one such example on AllCNN-C (Springenberg et al., 2015) models trained on CIFAR-10 (Krizhevsky & Hinton, 2009) with cross-entropy and custom TaylorGLO loss functions. Scaled target and non-target logit values were logged for every sample at every epoch and used to calculate respective γT and γ¬T values. These values were then substituted into Equation 17 to get the strength of bias towards zero training error. Specific instances of Equation 17 for four loss functions are plotted in Appendix E.
The cross-entropy loss exhibits a tendency towards zero training error for every single sample, as expected. The TaylorGLO loss, however, has a much different behavior: initially, there is a much stronger pull towards zero training error for all samples—which leads to better generalization (Yao et al., 2007; Li et al., 2019)—after which a stratification occurs, where the majority of samples are repelled, and thus biased towards a different region of the weight space that happens to have better performance characteristics empirically. A similar behavior is identified for the Baikal loss in Appendix E.

heading: 5 INVARIANT ON TAYLORGLO PARAMETERS
text: There are many different instances of λ for which models are untrainable. One such case, albeit a degenerate one, is λ = 0 (i.e., a function with zero gradients everywhere). Given the training dynamics at the null epoch (characterized in Appendix C), more general constraints on λ can be derived (in Appendix D.4), resulting in the following theorem:
Theorem 3. A third-order TaylorGLO loss function is not trainable if the following constraints on λ are satisfied: c1 + cy + cyy +
ch + chy n + chh n2
< (n− 1) ( c1 +
ch n + chh n2
) (18)
cy + cyy + chy n
< (n− 2) ( c1 +
ch n + chh n2
) . (19)
The inverse of these constraints may be used as an invariant during loss function evolution. That is, they can be used to identify entire families of loss function parameters that are not usable, rule
them out during search, and thereby make the search more effective. More specifically, before each candidate λ is evaluated, it is checked for conformance to the invariant. If the invariant is violated, the algorithm can skip that candidate’s validation training and simply assign a fitness of zero. However, due to the added complexity that the invariant imposes on the fitness landscape, a larger population size is needed for evolution within TaylorGLO to be more stable. Practically, a doubling of the population size from 20 to 40 works well.
Table 1 presents results from TaylorGLO runs with and without the invariant on the CIFAR-10 image classification benchmark dataset (Krizhevsky & Hinton, 2009) with various architectures. Networks with Cutout (DeVries & Taylor, 2017) were also evaluated to show that TaylorGLO provides a different approach to regularization. Standard training hyperparameters from the references were used for each architecture. Notably, the invariant allows TaylorGLO to discover loss functions that have statistically significantly better performance in many cases and never a detrimental effect. These result demonstrate that the theoretical invariant is useful in practice, and should become a standard in TaylorGLO applications.

heading: 6 ADVERSARIAL ROBUSTNESS
text: TaylorGLO loss functions discourage overconfidence, i.e. their activations are less extreme and vary more smoothly with input. Such encodings are likely to be more robust against noise, damage, and other imperfections in the data and in the network execution. In the extreme case, they may also be more robust against adversarial attacks. This hypothesis will be tested experimentally in this section.
Adversarial attacks elicit incorrect predictions from a trained model by changing input samples in small ways that can even be imperceptible. They are generally classified as “white-box” or “black-box” attacks, depending on whether the attacker has access to the underlying model or not, respectively. Naturally white-box attacks are more powerful at overwhelming a model. One such white-box attack is the Fixed Gradient Sign Method (FGSM; Goodfellow et al., 2015): following evaluation of a dataset, input gradients are taken from the network following a backward pass. Each individual gradient has its sign calculated and scaled by an scaling factor that determines the attack strength. These values are added to future network inputs with an scaling factor, causing misclassifications.
Figure 2 shows how robust networks with different loss functions are to FGSM attacks of various strengths. In this experiment, AllCNN-C and Wide ResNet 28-5 (Zagoruyko & Komodakis, 2016) networks were trained on CIFAR-10 with TaylorGLO and cross-entropy loss; indeed TaylorGLO outperforms the cross-entropy loss models significantly at all attack strengths. Note that in this case, loss functions were evolved simply to perform well, and adversarial robustness emerged as a side benefit. However, it is also possible to take adversarial attacks into account as an explicit objective in loss function evolution. Since TaylorGLO can uses non-differentiable metrics as objectives in its search process, the traditional validation accuracy objective can be replaced with validation accuracy at a particular FGSM attack strength. Remarkably, loss functions found with this objective outperform both the previous TaylorGLO loss functions and the cross-entropy loss. These results demonstrate that the TaylorGLO regularization leads to robust encoding (detailed in Appendix F), and such robustness can be further improved by making it an explicit goal in loss-function optimization.
Future work can naturally extend these analyses to black-box adversarial attacks and adversarial training. Moreover, just as custom loss functions can improve intrinsic robustness against adversarial attacks, custom loss function may make adversarial training more effective.

heading: 7 CONCLUSION
text: Regularization has long been a crucial aspect of training deep neural networks, and exists in many different flavors. This paper contributed an understanding of one recent and compelling family of regularization techniques: loss-function metalearning. A theoretical framework for representing different loss functions was first developed in order to analyze their training dynamics in various contexts. The results demonstrate that TaylorGLO loss functions implement a guard against overfitting, resulting in automatic regularization. Two practical opportunities emerged from this analysis: filtering based on an invariant was shown to improve the search process, and the robustness against overfitting to make the networks more robust against adversarial attacks. The results thus extend the scope of metalearning, focusing it not just on finding optimal model configurations, but also on improving regularization, learning efficiency, and robustness directly.

heading: A NOTATION OVERVIEW
text: Symbol Description h(xi,θ) The model, with a softmax hk(xi,θ) The model’s kth scaled logit Dj (f) The directional derivative of f along j Pdata Probability distribution of original data xi An input data sample, where xi ∼ Pdata yi A label that corresponds to the xi sample η Learning rate n Number of classes θ A model’s trainable parameters λ The loss function’s parameters
L(xi,yi,θ) The loss function

heading: B THIRD-ORDER TAYLORGLO LOSS FUNCTION IN THE ZERO TRAINING ERROR REGIME
text: γk(xi,yi,θ) = a+ byik + cy 2 ik, (20)
where
a = λ2 − 2λ1λ3 − λ5λ0 + 2λ1λ6λ0 + λ7λ20 + 3λ4λ21 (21) b = 2λ3 − 2λ6λ0 − 2λ1λ6 + λ5 − 2λ7λ0 − 6λ4λ1 (22) c = 2λ6 + λ7 + 3λ4. (23)

heading: C BEHAVIOR AT THE NULL EPOCH
text: Consider the first epoch of training. Assume all weights are randomly initialized:
∀k ∈ [1, n],where n ≥ 2 : E i
[hk(xi,θ)] = 1
n . (24)
That is, logits are distributed with high entropy. Behavior at the null epoch can then be defined piecewise for target vs. non-target logits for each loss function.
In the case of Mean squared error (MSE),
γk(xi,yi,θ) =
{ 2n−1 yik = 0
2n−1 − 2 yik = 1. (25)
Since n ≥ 2, the yik = 1 case will always be negative, while the yik = 0 case will always be positive. Thus, target scaled logits will be maximized and non-target scaled logits minimized.
In the case of Cross-entropy loss,
γk(xi,yi,θ) = { 0 yik = 0 n yik = 1.
(26)
Target scaled logits are maximized and, consequently, non-target scaled logits minimized as a result of the softmax function.
Similarly in the case of Baikal loss,
γk(xi,yi,θ) =
{ n yik = 0
n+ n2 yik = 1. (27)
Target scaled logits are minimized and, consequently, non-target scaled logits minimized as a result of the softmax function (since the yik = 1 case dominates).
In the case of Third-order TaylorGLO loss, since behavior is highly dependent on λ, consider the concrete loss function used above:
γk(xi,yi,θ) =
{ −373.917− 130.264 hk(xi,θ)− 11.2188 hk(xi,θ)2 yik = 0
−372.470735− 131.47 hk(xi,θ)− 11.2188 hk(xi,θ)2 yik = 1. (28)
Note that Equation 16 is a special case of this behavior where hk(xi,θ) = yik. Let us substitute hk(xi,θ) = 1 n (i.e., the expected value of a logit at the null epoch):
γk(xi,yi,θ) = { −373.917− 130.264 n−1 − 11.2188 n−2 yik = 0 −372.470735− 131.47 n−1 − 11.2188 n−2 yik = 1.
(29)
Since this loss function was found on CIFAR-10, a 10-class image classification task, n = 10:
γk(xi,yi,θ) = { −386.9546188 yik = 0 −385.729923 yik = 1. (30)
Since both cases of γk(xi,yi,θ) are negative, this behavior implies that all scaled logits will be minimized. However, since the scaled logits are the output of a softmax function, and the yik = 0 case is more strongly negative, the non-target scaled logits will be minimized more than the target scaled logits, resulting in a maximization of the target scaled logits.

heading: D PROOFS AND DERIVATIONS
text: Proofs and derivations for theorems in the paper are presented below:
D.1 ZERO TRAINING ERROR IS NOT AN ATTRACTOR OF BAIKAL
Given that Baikal does tend to minimize training error to a large degree—otherwise it would be useless as a loss function since we are effectively assuming that the training data is in-distribution— we can observe what happens as we approach a point in parameter space that is arbitrarily-close to zero training error. Assume, without loss of generality, that all non-target scaled logits have the same value.
θj ← θj + η 1
n n∑ k=1  lim hk(xi,θ)→ n−1 γk(xi,yi,θ)Dj (hk(xi,θ)) yik = 0 lim hk(xi,θ)→1− γk(xi,yi,θ)Dj (hk(xi,θ)) yik = 1 (31)
= θj+η 1
n n∑ k=1  lim hk(xi,θ)→ n−1 ( 1 hk(xi,θ) +
0
hk(xi,θ)2
) Dj (hk(xi,θ)) yik = 0
lim hk(xi,θ)→1−
( 1
hk(xi,θ) +
1
hk(xi,θ)2
) Dj (hk(xi,θ)) yik = 1 (32)
= θj + η 1
n n∑ k=1  n− 1 Dj (hk(xi,θ)) yik = 0( 1
1− +
1
(1− )2
) Dj (hk(xi,θ)) yik = 1
(33)
= θj + η 1
n n∑ k=1  n− 1 Dj (hk(xi,θ)) yik = 0
2− 2 − 2 + 1
Dj (hk(xi,θ)) yik = 1 (34)
The behavior in the yik = 0 case will dominate for small values of . Both cases have a positive range for small values of , ultimately resulting in non-target scaled logits becoming maximized, and subsequently the non-target logit becoming minimized. This is equivalent, in expectation, to saying that will become larger after applying the learning rule. A larger clearly implies a move away from a zero training error area of the parameter space. Thus, zero training error is not an attractor for the Baikal loss function.
D.2 LABEL SMOOTHING IN TAYLORGLO
Consider a basic setup with standard label smoothing, controlled by a hyperparameter α ∈ (0, 1), such that the target value in any yi is 1− αn−1n , rather than 1, and non-target values are α n , rather than 0. The learning rule changes in the general case as follows:
γk(xi,yi,θ) = 
c1 + chhk(xi,θ) + chhhk(xi,θ) 2
+chyhk(xi,θ) α
n + cy
α n + cyy
α2 n2 yik = 0
c1 + chhk(xi,θ) + chhhk(xi,θ) 2 + chyhk(xi,θ) ( 1− αn− 1
n ) +cy ( 1− αn− 1
n
) + cyy ( 1− αn− 1
n
)2 yik = 1
(35) Let ĉ1, ĉh, ĉhh, ĉhy, ĉy, ĉyy represent settings for c1, ch, chh, chy, cy, cyy in the non-label-smoothed case that implicitly apply label smoothing within the TaylorGLO parameterization. Given the two cases in the label-smoothed and non-label-smoothed definitions of γk(xi,yi,θ), there are two equations that must be satisfiable by settings of ĉ constants for any c constants, with shared terms highlighted in blue and red:
c1 + chhk(xi,θ) + chhhk(xi,θ) 2 + chyhk(xi,θ)
α n + cy α n + cyy
α2
n2
= ĉ1 + ĉhhk(xi,θ) + ĉhhhk(xi,θ) 2
(36)
c1 + chhk(xi,θ) + chhhk(xi,θ) 2 + chyhk(xi,θ) ( 1− αn− 1
n ) +cy ( 1− αn− 1
n
) + cyy ( 1− αn− 1
n )2 = ĉ1 + ĉhhk(xi,θ) + ĉhhhk(xi,θ) 2 + ĉhyhk(xi,θ) + ĉy + ĉyy
(37)
Let us then factor the left-hand side of Equation 36 in terms of different powers of hk(xi,θ):( c1 + cy α
n + cyy
α2
n2 ) ︸ ︷︷ ︸
ĉ1
+ ( ch + chy α
n ) ︸ ︷︷ ︸
ĉh
hk(xi,θ) + chh︸︷︷︸ ĉhh hk(xi,θ) 2
(38)
Resulting in definitions for ĉ1, ĉh, ĉhh. Let us then add the following form of zero to the left-hand side of Equation 37:(
chyhk(xi,θ) α
n + cy
α n + cyy
α2
n2
) − ( chyhk(xi,θ) α
n + cy
α n + cyy
α2
n2
) (39)
This allows us to substitute the definitions for ĉ1, ĉh, ĉhh from Equation 38 into Equation 37:
ĉ1 + ĉhhk(xi,θ) + ĉhhhk(xi,θ) 2 − ( chyhk(xi,θ) α
n + cy
α n + cyy
α2
n2 ) +chyhk(xi,θ) ( 1− αn− 1
n
) + cy ( 1− αn− 1
n
) + cyy ( 1− αn− 1
n )2 = ĉ1 + ĉhhk(xi,θ) + ĉhhhk(xi,θ) 2 + ĉhyhk(xi,θ) + ĉy + ĉyy
(40)
Simplifying into:
chyhk(xi,θ)
( 1− αn− 1
n
) + cy ( 1− αn− 1
n
) + cyy ( 1− αn− 1
n )2 − ( chyhk(xi,θ) α
n + cy
α n + cyy
α2
n2 ) = ĉhyhk(xi,θ) + ĉy + ĉyy
(41)
Finally, factor the left-hand side of Equation 41 in terms of, hk(xi,θ), 1, and 12:( chy ( 1− αn− 1
n
) − chy α
n ) ︸ ︷︷ ︸
ĉhy
hk(xi,θ)
+ ( cy ( 1− αn− 1
n
) − cy α
n ) ︸ ︷︷ ︸
ĉy
+ ( cyy ( 1− αn− 1
n
)2 − cyy α2
n2 ) ︸ ︷︷ ︸
ĉyy
(42)
Thus, the in-parameterization constants with implicit label smoothing can be defined for any desired, label-smoothed constants as follows:
ĉ1 = c1 + cy α
n + cyy
α2 n2 (43)
ĉh = ch + chy α
n (44)
ĉhh = chh (45)
ĉhy = chy
( 1− αn− 1
n
) − chy α
n (46)
ĉy = cy
( 1− αn− 1
n
) − cy α
n (47)
ĉyy = cyy
( 1− αn− 1
n
)2 − cyy α2
n2 (48)
So for any λ and any α ∈ (0, 1), there exists a λ̂ such that the behavior imposed by λ̂ without explicit label smoothing is identical to the behavior imposed by λ with explicit label smoothing. That is, any degree of label smoothing can be implicitly represented for any TaylorGLO loss function. Thus, TaylorGLO may discover and utilize label smoothing as part of discovering loss functions, increasing their ability to regularize further.
D.3 SOFTMAX ENTROPY CRITICALITY
Let us analyze the case where all non-target logits have the same value, n−1 , and the target logit has the value 1− . That is, all non-target classes have equal probabilities. A model’s scaled logit for an input xi can be represented as:
hk(xi,θ) = σk(f(xi,θ)) = efk(xi,θ)∑n j=1 e fj(xi,θ) (49)
where fk(xi,θ) is a raw output logit from the model.
The (k, j)th entry of the Jacobian matrix for h(xi,θ) can be easily derived through application of the chain rule:
Jkjh(xi,θ) = ∂hk(xi,θ)
∂fj(xi,θ) = { hj(xi,θ) (1− hk(xi,θ)) fk(xi,θ) k = j −hj(xi,θ) hk(xi,θ) fk(xi,θ) k 6= j (50)
Consider an SGD learning rule of the form:
θj ← θj + η 1
n n∑ k=1 [γk(xi,yi,θ)Dj (hk(xi,θ))] (51)
Let us freeze a network at any specific point during the training process for any specific sample. Now, treating all fj(xi,θ), j ∈ [1, n] as free parameters with unit derivatives, rather than as functions. That is, θj = fj(xi,θ). We observe that updates are as follows:
∆fj ∝ n∑ k=1 γj { hj(xi,θ) (1− hk(xi,θ)) k = j −hj(xi,θ) hk(xi,θ) k 6= j (52)
For downstream analysis, we can consider, as substitutions for γj above, γ¬T to be the value for non-target logits, and γT for the target logit.
This sum can be expanded and conceptually simplified by considering j indices and ¬j indices. ¬j indices, of which there are n− 1, are either all non-target logits, or one is the target logit in the case where j is not the target logit. Let us consider both cases, while substituting the scaled logit values defined above:
∆fj ∝ { γ¬T Jk=jh(xi,θ) + (n− 2)γ¬T Jk 6=jh(xi,θ) + γT Jk 6=jh(xi,θ) non-target j
γT Jk=jh(xi,θ) + (n− 1)γ¬T Jk 6=jh(xi,θ) target j (53)
∆fj ∝  γ¬Th¬T (xi,θ) (1− h¬T (xi,θ)) +(n− 2)γ¬T (−h¬T (xi,θ) h¬T (xi,θ)) +γT (−h¬T (xi,θ) hT (xi,θ)) non-target j
γThT (xi,θ) (1− hT (xi,θ)) +(n− 1)γ¬T (−h¬T (xi,θ) hT (xi,θ)) target j
(54)
where hT (xi,θ) = 1− , h¬T (xi,θ) = n− 1 (55)
∆fj ∝  γ¬T n− 1 ( 1− n−1 ) + γ¬T (n− 2)
2
n2 − 2n+ 1 + γT ( − 1) n− 1 non-target j
γT − γT 2 + γ¬T (n− 1)( − 1) n− 1 target j
(56) At this point, we have closed-form solutions for the changes to softmax inputs. To characterize entropy, we must now derive solutions for the changes to softmax outputs given such changes to the inputs. That is:
∆σj(f(xi,θ)) = efj(xi,θ)+∆fj∑n k=1 e fk(xi,θ)+∆fk (57)
Due to the two cases in ∆fj , ∆σj(f(xi,θ)) is thus also split into two cases for target and non-target logits:
∆σj(f(xi,θ)) =  ef¬T (xi,θ)+∆f¬T (n− 1)ef¬T (xi,θ)+∆f¬T + efT (xi,θ)+∆fT non-target j efT (xi,θ)+∆fT
(n− 1)ef¬T (xi,θ)+∆f¬T + efT (xi,θ)+∆fT target j
(58)
Now, we can see that scaled logits have a lower entropy distribution when ∆σT (f(xi,θ)) > 0 and ∆σ¬T (f(xi,θ)) < 0. Essentially, the target and non-target scaled logits are being repelled from each other. We can ignore either of these inequalities, if one is satisfied then both are satisfied, in part because |σ(f(xi,θ))|1 = 1. The target-case constraint (i.e., the target scaled logit must grow) can be represented as:
efT (xi,θ)+∆fT
(n− 1)ef¬T (xi,θ)+∆f¬T + efT (xi,θ)+∆fT > 1− (59)
Consider the target logit case prior to changes:
efT (xi,θ)
(n− 1)ef¬T (xi,θ) + efT (xi,θ) = 1− (60)
Let us solve for efT (xi,θ):
efT (xi,θ) = (n− 1)ef¬T (xi,θ) + efT (xi,θ) − (n− 1)ef¬T (xi,θ) − efT (xi,θ) (61)
= ( n− 1 − n+ 1 ) ef¬T (xi,θ) (62)
Substituting this definition into Equation 59: e∆fT ( n− 1 − n+ 1 ) ef¬T (xi,θ)
(n− 1)ef¬T (xi,θ)+∆f¬T + e∆fT ( n− 1 − n+ 1 ) ef¬T (xi,θ) > 1− (63)
Coalescing exponents: e∆fT+f¬T (xi,θ) ( n− 1 − n+ 1 ) (n− 1)ef¬T (xi,θ)+∆f¬T + e∆fT+f¬T (xi,θ) ( n− 1 − n+ 1
) + − 1 > 0 (64) Substituting in definitions for ∆fT and ∆f¬T and greatly simplifying in a CAS is able to remove instances of f¬T :
( − 1) e ( −1)(γ¬T−γT ) − e ( − 1)γT (n− 1) + γ¬T ( (n− 3) + n− 1)(n− 1)2 
( − 1)e ( −1)(γ¬T−γT ) − e
( − 1)γT (n− 1) + γ¬T ( (n− 3) + n− 1) (n− 1)2
> 0 (65)
D.4 TAYLORGLO PARAMETER INVARIANT AT THE NULL EPOCH
At the null epoch, a valid loss function aims to, in expectation, minimize non-target scaled logits while maximizing target scaled logits. Thus, we attempt to find cases of λ for which these behaviors occur. Considering the representation for γk(xi,yi,θ) in Equation 12:
θj ← θj + η 1
n n∑ k=1  ( c1 + chhk(xi,θ) + chhhk(xi,θ) 2 ) Dj (hk(xi,θ)) yik = 0( c1 + chhk(xi,θ) + chhhk(xi,θ) 2 +chyhk(xi,θ) + cy + cyy ) Dj (hk(xi,θ)) yik = 1
(66)
Let us substitute hk(xi,θ) = 1n (i.e., the expected value of a logit at the null epoch):
θj ← θj + η 1
n n∑ k=1  ( c1 + ch n + chh n2 ) Dj (hk(xi,θ)) yik = 0( c1 + cy + cyy + ch + chy
n + chh n2
) Dj (hk(xi,θ)) yik = 1
(67)
For the desired degenerate behavior to appear, the directional derivative’s coefficient in the yik = 1 case must be less than zero:
c1 + cy + cyy + ch + chy n + chh n2 < 0 (68)
This finding can be made more general, by asserting that the directional derivative’s coefficient in the yik = 1 case be less than (n− 1) times the coefficient in the yik = 0 case. Thus arriving at the following constraint on λ:
c1 + cy + cyy + ch + chy n + chh n2
< (n− 1) ( c1 +
ch n + chh n2
) (69)
cy + cyy + chy n
< (n− 2) ( c1 +
ch n + chh n2
) (70)
The inverse of these constraints may be used as invariants during loss function evolution.

heading: E EXAMPLES OF ZERO TRAINING ERROR ATTRACTOR DYNAMICS
text: The strength of the attraction towards zero training error regions of the parameter space (described in Theorem 2) can be plotted—for any given number of classes n—at different values using the
corresponding γT and γ¬T values from a particular loss function. These characteristic curves for four specific loss functions are plotted in Figure 3.
Both Baikal and TaylorGLO loss functions have significantly different attraction curves than the cross-entropy and mean squared error loss functions. Cross-entropy and mean squared error always exhibit positive attraction to zero training error. Conversely, TaylorGLO and Baikal only exhibit this positive attraction behavior for samples that are weakly memorized; well memorized samples produce a repulsive effect instead. This difference is what contributes to both metalearned loss functions’ regularizing effects, where overconfidence is avoided.

heading: F COMPARING MINIMA OF TRAINED NETWORKS
text: TaylorGLO loss functions are known to result in trained networks with flatter, lower minima (Gonzalez & Miikkulainen, 2020b). This result suggests that models trained with TaylorGLO loss function are more robust, i.e. their performance is less sensitive to small perturbations in the weight space, and that they also generalize better (Keskar et al., 2017). Since TaylorGLO loss functions that were discovered against an adversarial performance objective were even more robust (Section 6), what do their minima look like?
Model performance can be plotted along a random slice [−1, 1] of the weight space using a prior loss surface visualization technique (Li et al., 2018). The random slice vector is normalized in a filter-wise
manner to accommodate network weights’ scale invariance, thus ensuring that visualizations for two separate models can be compared. As a result of the randomness, this parameter space slice is unbiased and should take all parameters into account, to a degree. It can therefore be used to perturb trainable parameters systematically.
When AllCNN-C is trained with an adversarially robust versus a standard TaylorGLO loss function, its absolute accuracy is the same. However, the minimum is wider and flatter (Figure 4). This result suggests that it may be advantageous to evaluate TaylorGLO against an adversarial performance metric, even when the target application does not include adversarial attacks.

Review summaries:
This paper analyzes a learned loss function called TaylorGLO based on third-order Taylor expansion and its regularization properties. This approach is novel and interesting in that the loss function is also learned on data. The analysis of the TaylorGLO loss and another learned loss function Baikal loss near zero error reveals interesting properties of preventing overconfident predictions. 

Taylor polynomial based loss function metalearning acts as a regularizer that improves the networks adversarial attack robustness, performance, training time, and data utilization. The authors evolve weights, and so add arbitrary other factors to the loss, including adversarial robustness to learn a loss function parameterization which is more robust. They provide analysis of the attractor states under the optimization of a suite of loss functions.