AANG: A UTOMATING A UXILIARY LEARNI NG
Anonymous authors
Paper under double-blind review
A BSTRACT
Auxiliary objectives, supplementary learning signals that are introduced to help aid learning on data-starved or highly complex end-tasks, are commonplace in machine learning.
Whilst much work has been done to formulate useful auxiliary objectives, their construction is still an art which proceeds by slow and tedious handdesign.
Intuition for how and when these objectives improve end-task performance has also had limited theoretical backing.
In this work, we present an approach for automatically generating a suite of auxiliary objectives.
We achieve this by deconstructing existing objectives within a novel unified taxonomy, identifying connections between them, and generating new ones based on the uncovered structure.
Next, we theoretically formalize widely-held intuitions about how auxiliary learning improves generalization on the end-task.
This leads us to a principled and efficient algorithm for searching the space of generated objectives to find those most useful to a specified end-task.
With natural language processing (NLP) as our domain of study, we demonstrate that our automated auxiliary learning pipeline leads to strong improvements over competitive baselines across continued training experiments on a pre-trained model on 5 NLP 1 .
I NTRODUCTION
ICML Experiments derylucio November
[Figure]
No
[Figure]
No
[Figure]
Replace Bidirectional Real / Synthetic ...
[Figure]
In NLP, many auxiliary objectives have been proposed to boost transfer learning on a variety of end-task.
Here, we present the decomposition of some named objectives in NLP within our framework.
The auxiliary learning paradigm, where we augment a primary objective with extra learning signals to boost end-task performance, is a staple of many machine learning (ML) domains.
In natural language processing (NLP), well known models like
SpanBERT (Joshi et al., 2020) and RoBERTa (Liu et al., 2019b) are trained on masked language modelling (MLM) auxiliary objectives (Devlin et al., 2018) before fine-tuning on the end-task.
And for speech processing and reinforcement learning (RL), Oord et al.
(2018) introduced the popular contrastive predictive coding objective which achieved state of the art performance in many settings when multi-tasked with the end-task.
Despite these successes and many more, research into devising such objectives has progressed in a very local, objective-by-objective manner (Raffel et al., 2019;
Clark et al., 2020; Grill et al., 2020; Chen et al., 2020).
Auxiliary objectives are constructed by handdesign and without much overarching structure, relying on the experience and intuition of a select group of researchers versed at making appropriate design choices.
Unfortunately, this status-quo not only creates a technical barrier of entry for exploring auxiliary objectives in new domains but also, by virtue of its incremental nature, limits the rate at which new objectives are discovered and investigated.
To address the above challenges, this paper presents a framework for automatically generating and utilizing a large set of candidate auxiliary objectives.
Our framework is seeded by the following key observation: leading auxiliary objectives across multiple domains can be viewed as making different design decisions within a 4 stage pipeline: Input Data ( D ) → Input Transformation ( T ) → Model
Representation ( R ) → Output ( O ) .
For instance, in RL, a common auxiliary objective is to predict the environment’s forward dynamics (Agrawal et al., 2016; Hafner et al., 2019).
To construct this objective, the current task state-action pair ( D ) is corrupted ( T ) and then passed through the model to produce a latent representation ( R ) which is finally used to predict the next state ( O ) .
Similarly, in NLP, the XLNet (Yang et al., 2019) objective—which performs language modelling on a randomly factorized permutation of the input—can be written within our taxonomy as {D = Out-of-Domain , T = No-op ,
R = Random-Factorized , O =
Next Token } .
These two examples (along with others listed in Figure 1) fall within a class we term named objectives : objectives that have been previously proposed in the auxiliary learning literature.
[Figure]
Decomposing named objectives within our taxonomy provides a unified view of the auxiliary learning landscape.
From this vantage point, it becomes clear that there are many unexplored combinations of the various primitives used across named objectives.
This presents a simple formula for automatically generating a large set of candidate objectives: take the cartesian product of the design decisions across given stages (Figure 2).
Using this compositional process, not only can we reconstruct existing named objectives, we can also generate new combinations.
This overcomes the tedium of implementing each objective independently since we can just reuse a small set of simple stage-wise primitives.
Generating a large set of objectives raises the natural question of how to efficiently select the most helpful ones for a given end task.
Instead of leaving this to practitioner intuition, we develop principled guidelines to address this question by theoretically studying the impact of auxiliary learning on a particular end-task.
Specifically, using arguments based on algorithmic stability (Hardt et al., 2016;
Bousquet & Elisseeff, 2002), we derive end-task generalization error bounds that are dependent on the choice of auxiliary task.
This contributes to existing theory (Saunshi et al., 2020; Xie et al., 2021) on how auxiliary learning impacts the end-task by suggesting a new candidate mechanism: auxiliary learning results in more stable optimization end-points in the sense of Bousquet & Elisseeff (2002), which in theory improves generalization of the final model.
Guided by our theory, we introduce AANG ( A utomating A uxiliary Learni NG ), an efficient, structureaware algorithm for adaptively combining a set of related objectives to improve generalization on a specific end-task.
AANG incorporates the following prescriptions from our theory: (i) auxiliary tasks that are more similar to the end-task are desirable.
Given a set of objectives, AANG learns adaptive weights to bring the composite objective closer to the end-task; (ii) in general, more auxiliary data is better.
AANG maximizes the effective amount of data used in training by using all the generated objectives instead of taking task-specific subsets.
To empirically validate our method for automatically generating and utilizing auxiliary objectives, we experiment on five NLP tasks.
We do so in the widely-used setting of continued pretraining (Gururangan et al., 2020; Aghajanyan et al., 2021;
Dery et al., 2021b; Zhang et al., 2022), where a model trained with a single auxiliary objective on large-scale data is further trained on end-task related data.
Without introducing any external data or architectural modifications, variants of AANG outperform strong and widely used baselines in 4 out of 5 tasks.
AANG achieves an average improvement of 4 . 2 % over standard fine-tuning of RoBERTa across our chosen tasks.
We believe our results will spur further research into exploring automating auxiliary learning across a variety of settings.
Notably, while we focus on NLP when discussing the space of auxiliary objectives (Section 3) and in our empirical evaluation (Section 6), our theoretical results (Section 4) and AANG itself are domain-agnostic 2 .
R ELATED W ORK
To properly scope this work, we define auxiliary learning as training a model on alternative objectives with the goal of improving performance on some primary end-task.
Auxiliary learning is an instantiation of transfer learning (Caruana, 1997; Baxter, 2000; Ruder et al., 2019).
It covers the pretrain-then-finetune paradigm (Huh et al., 2016;
Devlin et al., 2018; Schneider et al., 2019;
Gururangan et al., 2020) as well as end-task aware multitasking approaches (Lin et al., 2019; Dery et al., 2021a;b).
Whilst auxiliary objectives may be meta-learned (Liu et al., 2019a; Navon et al., 2020), for simplicity – since incorporating these would require further expansion of our design space – such objectives are out of the scope of this paper.
This work bears many parallels to the area of neural architecture search (NAS) (Stanley &
Miikkulainen, 2002; Zoph & Le, 2016; Roberts et al., 2021).
Whilst we seek to automate auxiliary learning, the objective of NAS is to automate the discovery of the right neural architecture given a specific end-task.
Search spaces of candidate architectures are created by taking the cartesian product of architecture design choices across the depth of the network.
The design of suitable architectural search spaces for a variety of settings has been an active area of research (Tan & Le, 2019; Howard et al., 2019;
Dao et al., 2020; Roberts et al., 2021).
To develop AANG , we borrow ideas from the
NAS literature on efficient algorithms for sifting through spaces of architectures.
Mirroring the popular differentiable NAS method DARTS Liu et al.
(2018), we perform a continuous relaxation over the search space of objectives, allowing for efficient search by gradient descent.
We also use a factored approach to model relationships between objectives that share primitives.
This is inspired by recent work on stochastic-relaxation weight sharing (Dong & Yang, 2019; Li et al., 2020).
As a theoretical contribution, this work derives an end-task aware generalization error bound for auxiliary learning.
Our bound is built on that of Hardt et al.
(2016), who derive generalization bounds for parametric models trained with stochastic gradient descent (SGD).
To derive their bounds, they leverage the concept of algorithmic stability introduced by Bousquet & Elisseeff (2002).
Informally, a randomized algorithm is uniformly stable if changing a single training data point in the given samples does not change its end-point too much .
Said change is characterized as the average difference in predictions between the two learned models.
Stability implies generalization in expectation (Hardt et al., 2016; Kuzborskij & Lampert, 2018).
A UTOMATICALLY G ENERATING A UXILIARY O BJECTIVES
To begin, we take a high-level view of the landscape of named objectives.
Using running examples from NLP, we propose the following coarse structure for the sequence of choices made in the hand-design of auxiliary objectives:
Data , D : Auxiliary objective pipelines begin with a choice of input data.
Here, options can range from heterogeneous out-of-domain data (Radford et al., 2019), in-domain data with respect to the final end-task (Beltagy et al., 2019) or the task data itself (Gururangan et al., 2020).
It may even include data outside the modality of the end-task.
Input-Transformation , T :
Many auxiliary objectives are self-supervised with respect to their input data.
They corrupt or transform the input and then reconstruct it in whole or part.
For example, input text tokens can be masked , replaced or deleted .
Operations can also be aggregated as in BERT-Op : mask 80% of selected tokens and randomly replace 50% of the remaining Devlin et al.
; Liu et al. (2019b).
Representation , R : After transformation, representations of the input data can be computed from a given model in different ways.
A chosen token’s representation can depend on only its left context ( Left-to-Right )
(Radford et al., 2018) or its right context ( Right-to-Left ) (Peters et al., 2018).
It could also depend on the representations of a randomly selected permutation of other tokens ( Random Factorized )
Yang et al.
Output , O : Finally, representations obtained from the previous stage are fed into a loss function producing a final output.
The choice of output loss is usually coupled with the choice of transformation made in stage 2.
Choices include but are not restricted to denoising tokens , predicting the next token or predicting the TF-IDF (Term Frequency-Inverse Document Frequency) of a token.
The above taxonomy {D → T → R → O} is expansive enough to cover a range of named auxiliary objectives of interest in NLP (Figure 1) 3 .
For example, we can write any member of the GPT series (Radford et al., 2018; 2019; Brown et al., 2020) which perform left-to-right language modelling on out-of-domain data as {D = Out-of-Domain , T = No-op , R = Left-To-Right , O =
Next Token } .
We can summarize the pre-existing choices within each design stage to obtain a unique set of options.
For example, we can reduce the set of model representation types used by the objectives enumerated in
Figure 1 to the unique set R = { Bi-directional, Left-To-Right, Right-To-Left, Random-Factorized } .
Having summarized the list of primitives within each stage, a simple formula for generating a space of auxiliary objectives becomes apparent: take the cartesian product of the design choices at each stage (see Figure 2).
In general, given an instance of our taxonomy, we can construct a space of objectives
A = D ×T ×R×O of size |A| ≤ |D|×|T |×|R|×|O| .
Consider New Obj 1 from Figure 2.
This previously unexplored objective can be obtained by combining the special masking operation from
BERT ( BERT-Op ) with computing model representations based on left-to-right causal masking as in
GPT.
In fact, this objective proved one of the most useful ones in our experiments below (see Figure 5).
Our framework also allows us to reason about whole families of objectives, F , by thinking in terms of design stages and choices.
For example, given a particular end-task E with input text E D , we can create a family of objectives based solely on task data by fixing to that option in our input data stage; we call this family F D = E D .
F D = E D not only includes pre-existing TAPT Gururangan et al.
but also unexplored objectives like task-data dependent variants of XLNET, ELMO etc.
Auxiliary learning with F D = E D can be seen as a relaxed form of data augmentation which we dub task augmentation .
Whilst data augmentation requires applying transformations that preserve the data-point’s label, task augmentation has no such restriction and thus offers greater flexibility in terms of specifying {T , R , O} .
We can also reason about expanding particular stages to include new primitives.
Any supervised loss can be added to the output stage,
O , allowing us to potentially explore auxiliary objectives based on supervised signals like NER or POS tagging (Carreras et al., 2003; Charniak, 1997).
A special example is setting O to the end-task supervised output E O .
This leads to F O = E O D = E D
which is a subset of F D = E D .
F O = E O D =
E D includes many objectives like predicting the end-task signal from corrupted input data.
In Section 6, we will introduce a search space of objectives that leverages task augmentation.
T HE I MPACT OF A UXILIARY L EARNING ON E ND - TASK G ENERALIZATION
In this section, we relieve reliance on practitioner intuition by deriving a set of guiding principles on how to effectively utilize the automatically generated objectives from Section 3.
Auxiliary learning influences the end-task through both training and generalization error.
Previous theory has largely focused on characterizing the impact on end-task training error.
Liu et al.
(2021), for example, show that end-task agnostic pre-training can create a performance gap in training error compared to training with the end-task alone.
The size of this gap depends on how dissimilar the pre-training auxiliary objective is from the end-task.
They introduce the following assumption (which we will borrow) to formalize their notion of task similarity:
Assumption A.1: Let f e represent the end-task objective and f a be the auxiliary objective.
There exists ∆ ≥
such that ∥∇ f a ( θ ) − ∇ f e ( θ ) ∥
≤ ∆ ∀ θ .
Note that θ represents all the parameters of the model.
Smaller ∆ implies f a is more similar to the primary task f e .
Liu et al.
(2021) bound the end-task agnostic training error gap to be logarithmic in ∆ .
Unlike training error, end-task generalization error has gone unstudied in the auxiliary learning setting.
Bounding the generalization error not only adds to our theoretical understanding of the impact of auxiliary learning but also provides insights to guide algorithm design.
To arrive at a bound, we adapt the technique of Hardt et al.
(2016) who derive a generalization bound on training with only the end-task via stochastic gradient descent.
We consider the end-task aware setting where the end-task is multi-tasked with the auxiliary objective.
This setting has recently been shown to improve end-task performance over the pretrain-then-finetune paradigm (Dery et al., 2021a;b; Yao et al., 2021).
Auxiliary learning with Dynamic Sampling: We are given an auxiliary objective f a ( · ; z ) ∈ [0 , 1] with N a samples S
a
=
( z 1 , . . .
, z N a ) from the distribution D a .
f a can either be a single objective or a weighted linear combination of objectives : f a = (cid:80) k w k f ka .
At any iteration of SGD, we sample a choice of the end-task function f e or the auxiliary objective f a according to the probabilities λ e , λ a ∈ [0 , 1] | λ e + λ a = 1 .
Given the chosen objective, we sample a data-point and perform stochastic gradient descent based on the sampled data-point.
We now present our bound in the setting described.
Theorem 4.1 (Auxiliary learning with Dynamic Sampling) .
Assume that f e (; z e ) , f a (; z a ) ∈ [0 , 1] are both L -Lipschitz with β e and β a -smooth loss functions respectively.
Consider that we have
N ′ =
N e + N a total samples where f e and f a have N e and N a samples respectively.
r e = N e N ′ is the fraction of the available data represented by the end-task.
Suppose that we run stochastic gradient descent for T steps with monotonically non-increasing step sizes α t ≤ ct by dynamically sampling the tasks according to λ e and λ a .
Then, with respect to f e , the generalization error is bounded by:
[Equation]
γ [Equation] λ [Equation]
Here β ∗ =
min { β e , β a } and λ ∗ is the weighting of the function with smaller smoothness.
Proof.
See Appendix E for full proof and Appendix F for more discussion
As a detailed inspection of the proof will show, we derive Equation 1 by appealing to algorithmic stability (Bousquet & Elisseeff, 2002;
Hardt et al., 2016; Kuzborskij & Lampert, 2018) (See Section 2).
To our knowledge, ours is the first work to present an algorithmic stability view to formally explain how auxiliary learning influences end-task performance.
Equation 1 surfaces the following prescriptions about learning with auxiliary tasks :
P1 Smaller ∆ improves ϵ gen .
This implies that the more similar the auxiliary objective is to the end-task (under Assumption A.1), the lower the generalization error.
P2 Larger N ′ leads to smaller ϵ gen 4 .
Since we usually have a fixed amount of task data N e , we can increase N ′ by adding more auxiliary data N a .
E ND - TASK A WARE S EARCH OF S TRUCTURED O BJECTIVE S PACES Algorithm
AANG
Input: Search Space - A
Factor vectors - { W All , W I , W T , W R , W O }
End-task - E ,
End-task weight - λ e Initial Model Params - θ
∈
R D repeat Sample a batch of n objectives
K n ∼ A
Weighting of objectives in K n
Construct w n for k = 1 to n do ( d, t, r, o ) =
[ K nk ] .
stages w k ∝ exp (cid:0)
W
All( d, t, r, o )
+ W I d + W T t + W R r + W
O
o
cid:1)
w nk ← w k end for Get losses from batches of data ˆ L A ( K n , w n )
=
(cid:80) nk
=1 w k L k
L total =
λ e L E + (1 − λ e )
ˆ L A Get gradients and update factors θ t +1 , {∇ w n ,λ e } ← META-TARTAN (cid:0) θ t , E, L total )
Update { W All , W I , W T , W R , W O } using ∇ w n
Update
λ
e using ∇ λ e until done
Return : θ T
Guided by Section 4, we build a practical method for exploring a set of objectives, A .
Whilst the dynamic sampling setting described in Section 4 is amenable to theoretical consideration, we make a few practical changes to it.
First, instead of performing alternating gradient descent by sampling f a , f e according to λ e , λ a , we instead use them as multitask weights and perform joint training.
Joint training has been found to produce superior results compared to alternating optimization when leveraging auxiliary objectives (Aghajanyan et al., 2021).
We perform gradient descent on the following total loss which interpolates between the end-task and the auxiliary loss
L total =
λ e L E +
[Equation]
1 − λ e ) L K .
Here, K is a chosen subset of
A .
Second, as indicated in Section 4, given K , we can write the set as a single objective
[Equation]
By Prescription P1, we want to choose { w k } such that f a has a small ∆ with the end-task f e .
We would also like to set λ e such that the bound on ϵ gen is minimized.
Whilst a closed form exists for the optimal weightings λ e , { w k } , it depends on variables like { ∆ k } , { β ka } , L that are hard to estimate.
We therefore propose to learn λ e , { w k } in an online, data-driven way.
To do this, we build on top of the META-TARTAN algorithm proposed by Dery et al.
(2021b).
META-TARTAN is a meta-learning algorithm that learns adaptive weights for different auxiliary tasks in a way that prioritizes end-task generalization.
It learns { w k } by minimizing the loss on the end-task validation set: ∂ L val E
∂w k ≈ − (cid:0) ∇ θ L f ka (cid:1) T (cid:0) ∇ θ L val E (cid:1) .
This corresponds to learning { w k } such that (cid:0) ∇ θ f a (cid:1) T (cid:0) ∇ θ f e ) is maximized.
This minimizes one of the terms that contributes to ∆ and thus attempts to fulfil
Prescription P1.
We can similarly learn λ
e to minimize the end-task validation loss.
Please find a more detailed discussion of META-TARTAN in Appendix B
So far, we have introduced independent weights, { w k } , for each objective.
This is sufficient in the case of unrelated objectives.
However, the objectives in A share an underlying structure.
We recognize this by using a factored approach to model each w k .
We introduce a factor vector for each of the 4 stages introduced in Section 3: W D ∈ R |D| , W T ∈ R |T | , W R ∈ R |R| and W O ∈ R |O| .
This ties together the weights of objectives that share primitives in common.
To capture the fact that an objective can be more than the sum of it parts, we also introduce an independent weight for each objective : W All ∈ R |D|×|T |×|R|×|O| .
Consider the objective k which is generated by the composition of the operations { d ∈ D , t ∈ T , r ∈ R , o ∈ O} , its weighting is computed as : w k ∝ exp (cid:0)
W
All ( d,t,r,o )
+ W I d + W T t + W R r + W
O
o
cid:1) .
Our factored approach not only allows us to share information between objectives but it also allows us to analyze which stages and primitives are most important to a particular end-task after training is completed (Section 7).
Prescription P2 from Section 4, advocates for introducing as much auxiliary data as possible.
As such, instead of fixing to a specific subset throughout training for a particular end-task, we propose to utilize all the objectives in A .
This also avoids the combinatorial explosion that comes with exploring subsets of A at a time.
|A| can be large and descending on all of A at once can be computationally prohibitive.
As an efficient work around, at each training step, we sample a subset of
A for execution with META-TARTAN.
Our samples are drawn from all of A so any objective can get used at any timestep.
Because we model each w k via a factored approach, even if an objective is not sampled its weight is implicitly updated.
Our approach is reminiscent of stochastic-relaxation weight sharing (Pham et al., 2018; Dong & Yang, 2019; Li et al., 2020) where sampled architectural primitives result in updates to shared model weights which can be used by other primitives that are not sampled.
We coalesce all the ideas we have introduced so far into Algorithm 1 which we dub AANG ( A utomated A uxiliary Learni NG ). At a high-level, given an end-task E : 1.
We generate a space of auxiliary objectives A based on E . A may contain auxiliary tasks that can improve our performance on E . 2. We leverage (MAML-style (Finn et al., 2017)) meta-learning to adaptively weight the objectives in A based on measuring each objective’s influence on E ’s validation set loss.
We make our algorithm scalable by sub-sampling the tasks A .
By exploiting the underlying structure of the objectives in A via a factored approach to modeling task weights, we reduce the impact of the inexact sub-sampling approximation made above.  E XPERIMENTAL S ETTING
Our exploration of auxiliary learning has made the following transitions from the status-quo: manual to automated, single task to multitask, end-task agnostic to end-task aware.
In this section, we set up experiments to validate these deviations from the standard.
We focus on continued pre-training (Gururangan et al., 2020; Aghajanyan et al., 2021).
In this setting, we perform further auxiliary learning on an already pre-trained model.
We favor this setting over pre-training from scratch (Liu et al., 2019b; Yang et al., 2019)
not only because it is a more computationally feasible arena for experimentation but also because it is more relevant to modern
ML systems where building upon pre-trained models is the norm (Qiu et al., 2020; Du et al., 2020).
Model Details and Datasets: We use a pre-trained RoBERTa base (Liu et al., 2019b) as the shared model base.
We implement each auxiliary objective as a separate head on top of this shared base.
For classification based objectives, the output head is a 2-layer multi-layer perceptron (MLP) that receives representations for the special classification token
[CLS] (Devlin et al., 2018) from
RoBERTa base .
For sequence generation objectives, we make a copy of the pre-trained output layer of RoBERTa base for each task.
Table 4 in Appendix C provides details of the 5 datasets used.
All datasets are low-resource classification tasks.
Not only are these datasets more amenable to meta-learning from a computational standpoint, but low-resource tasks also benefit the most from auxiliary learning.
We also choose these tasks because they feature in previous work which we use as baselines (Gururangan et al., 2020;
Dery et al., 2021b)
Baselines and Search Spaces: The following methods are end-task agnostic baselines.
By end-task agnostic, we mean that these do not multitask with the end-task.
Finetuning on the end-task occurs after training on the auxiliary objective.
1. RoBERTa
(Liu et al., 2019b): We simply finetune a pre-trained RoBERTa base on the end-task. 2.
TAPT (Gururangan et al., 2020):
Continue training RoBERTa base on masked language modelling on end-task data itself before finetuning on the end-task.
The following named objectives are end-task aware baselines that use META-TARTAN (Dery et al , 2021b) but utilize only 1 auxiliary task.
Each auxiliary objective is multi-tasked with the end-task.
GPT-style: We perform end-task aware training with a denoising auxiliary objective based on left-to-right causal masking for computing representations.
{I = End-task data, T =
No-op, R =
Left-To-Right, O =
Denoise Token } .
XLNET-style: This is a denoising auxiliary objective that uses randomized masking for computing representations.
{I = End-task data, T =
No-op, R =
Random-factorized, O = Denoise Token } .
BERT-style / TAPT:
Denoising inputs corrupted via BERT-Op : 80% masking and 10% random replacement.
{I = End-task data, T = BERT-Op , R =
Bi-directional, O = Denoise Token } .
Please note that this baseline is equivalent to META-TARTAN as introduced in Dery et al.
(2021b).
[Table]
Table 1 details the search spaces that we evaluate against the above baselines.
This is by no means the most encompassing search space but we leave more expansive space design to future work.
Please note that all tasks within AANG -TD, and those with {I =
End-task } in AANG -TD+ED, are instantiations of task augmentation as introduced in Section 3.
Training Details : Please see Appendix D for more details about hyper-parameter configurations.
R ESULTS AND D ISCUSSION
In this section, we experimentally validate our case for automating the creation of auxiliary objectives and using them in an end-task aware multitask fashion.
7. G OING A L ONG W AY W ITHOUT E XTERNAL D ATA
We first consider the setting where we rely solely on end-task data (task augmentation), and work with the AANG -TD search space.
This search space has 24 objectives.
Table 2 shows that automatically generating auxiliary objectives from only task data and using them appropriately is productive.
End-task awareness is key:
From Table 2, methods that are end-task aware result in over 1 .
12% average improvement over those that are end-task agnostic even under the most generous comparison (GPT-style 79 .
84% vs task-agnostic TAPT 78 .
Knowing the end-task means that at each iteration, AANG can make informed gradient updates by adapting task weights so the resulting auxiliary task better aligns with the end-task (Prescription P1).
Amongst the single task objectives,
BERT-style performs best.
We posit that this is because RoBERTa was trained from scratch on a similar objective and so this objective represents minimal shift in training distributions.
Adaptive multi-task auxiliary learning improves performance: We compare single-task end-task aware auxiliary learning to its multitask variant.
Table 2 shows that multitasking our 3 different types of language modelling tasks results in improved average performance over using the tasks individually (81.12% for the BERT-style and 81.55% for combining the three single task objectives).
We get our best performance when we multitask 24 auxiliary objectives automatically generated with our framework using AANG -TD.
Boosting the number of objectives from 3 to 24 resulted in a 0.66% improvement in average performance across tasks.
This is in line with Prescription P2 from Section 4 since we are increasing the effective amount of auxiliary data.
We further posit that introducing more auxiliary objectives also serves to implicitly regularize the end-task during training.
[Table]
7. I NTRODUCING E XTERNAL D ATA
For the ACL-ARC task, we experiment with introducing auxiliary tasks based on external data.
AANG -TD+ED has 40 tasks, 16 of which are based on domain data.
We introduce CS domain data (from the S2ORC dataset (Lo et al., 2019)) that is n = 10 × the size of the task data. From
Figure 3 we see that AANG -TD+ED makes better use of domain-data than doing end-task aware training using only BERT-style objective with task (TAPT) and domain-data (DAPT) jointly as in Dery et al.
(2021b).
However, AANG -TD+ED ( 73 . 70 ) does not significantly improve over AANG -TD ( 73 . 26 ) on the ACL-ARC task (Figure 3).
This might seem at odds with Prescription P2 since the TD+ED search space introduces more data.
However, note that the AANG search algorithm is approximate and as such, with a larger search space, it can be harder to find composite tasks with a small ∆ as suggested by Prescription P1.
We posit that we need more external data than n = 10 × in order to see marked improvements to offset our inexact search of the space of composite functions.
However, such scales are outside our computational budget.
7. W HY DOES AANG W ORK ?
To better understand why our auxiliary learning pipeline improves end-task performance, we perform multiple ablations under AANG -TD.
Static versus Dynamic Weighting: We ablate the impact of using static task weights throughout training, as against adaptive task weights.
Just as with AANG , we sub-sample n tasks from the search space at every iteration ( n is cross-validated exactly as AANG is – Table D ).
Each sampled tasks weight is initialized to 1 n and this remains unchanged throughout training.
This is the Static
Multitask-TD baseline in Table2.
AANG -TD improves upon the static multitask baseline by over 1.1% on average.
With adaptive weighting, AANG down-weights objectives that are harmful to the end-task whilst up-weighting relevant ones (Prescription P1).
However, using static weightings is more compute friendly since we do not have to calculate task-weight meta-gradients.
This computevs-performance trade-off is left for practitioners to resolve based on their available resources.
Impact of number of sampled objectives: Due to computational constraints, AANG sub-samples the set of generated objectives.
Whilst this sampling can result in approximation error when inferring task weightings, it can also introduce stochasticity which can help regularize the learned model.
From
Table 3 (Appendix A) we find that for some tasks (ACL-ARC and SCIERC) sampling a larger number of tasks helps.
SE-2016-6 and CHEMPROT on the other hand benefit from smaller number of sampled tasks.
Our recommendation is that the number of sampled tasks be cross-validated on a per-task basis.
Learned task weight trajectories: AANG learns interesting trajectories for weighting design stage primitives.
From Table 2, the fact that AANG -TD roughly matches the best single task performance ( 72 . 46 1 . 65 versus 72 .
60 for BERT-style) on the SE-2016-6 task suggests that it may be learning to mostly up-weight this task.
Figure 4 provides evidence of this.
For the SE-2016-6 task (row 1), composing the highest weighted primitive from each stage [BERT ◦ None ◦ DENOISE] results in
BERT-style, the best single task objective.
Figure 4 also shows that AANG can adapt to overfitting.
[Figure]
What tasks are important and when they are important?
We study which tasks are most highly weighted early in training (first 10% of learning trajectory) and later in training (last 50%).
We aggregate statistics across 3 datasets.
Note that early in training, objectives based on the self-
[Figure]
supervised output O = { DENOISE } are highly weighted but later, objectives based on supervised signal,
O = { Task } play a larger role.
AANG rediscovers the common practice of training on self-supervised objectives before introducing supervised ones.
It is also interesting to note that many newly generated objectives (outside of the 3 named single task baselines in Table 2) such as simple input reconstruction were discovered to have relevant impact on the end-tasks.
This means
AANG can automatically surface new, previously unexplored objectives relevant to the end-task.
L IMITATIONS AND C ONCLUSION
Our work has some limitations that we leave for future work.
First, because AANG relies on meta-learning, it presents extra compute burden over simple multitasking.
This is because, we have to independently compute meta-gradients for each auxiliary task thus requiring O ( n ) forward-backward operations for n sampled tasks compared to O (1) for static multitasking.
In Table 2, we show that our static Multitask-TD method outperforms all other non-task-adaptive methods by ≈ 2 . 4% and is thus a viable alternative when runtime is a signficant constraint.
Secondly, AANG as presented is an approximate algorithm – primarily due to sub-sampling the space of tasks.
Thus as mentioned in Section 7.2, we do not get as much gain as desired when our search space becomes larger.
We leave finding an efficient exact search algorithm for future exploration.
This paper presents a procedure for automating the creation of auxiliary objectives.
We showed, theoretically, how auxiliary learning impacts end-task generalization.
This resulted in prescriptions that informed the design of AANG , an algorithm to search the space of generated objectives in an end-task aware multitask fashion.
Our experiments show that AANG is a promising first step in automating auxiliary learning.
A M ORE A BLATION T ABLES
[Table]
B D ISCUSSION OF META-TARTAN (D ERY ET AL ., 2021 B )
META-TARTAN (Dery et al., 2021b) is a MAML style (Finn et al., 2017) meta-learning algorithm that learns to adaptively weight a given set of tasks based on their influence on the end-task validation performance. META-TARTAN achieves this by formulating the following bi-level optimization problem : [Equation]
where
[Equation]
Note that E is the end-task and A is the set of auxiliary tasks.
Since the above bi-level problem is difficult to solve directly, Dery et al.
(2021a) relax the problem and into an alternating optimization problem where task weights are updated based on 1-step improvement to the validation performance of the end-task :
[Equation]
To prevent the above relaxation from finding the trivial solution of just upweigting solely the end-task,
Dery et al.
(2021b) introduce a special dev-head which they use for estimating the meta-gradient :
[Equation]
Where ϕ ∗ t is the special dev-head and θ body is the body of the model.
For even more details about
META-TARTAN, please see Section 3 of Dery et al.
(2021b).
Though we leverage MET-TARTAN, compared to Dery et al.
(2021b), we make three distinct contributions to the field of auxiliary learning.
We list them below
Novel Problem Formulation : As far as we are aware of, we are the first to formulate the problem of automated auxiliary learning.
Specifically, we presented an approach for automatically constructing a suite of auxiliary objectives based on existing objectives.
Please note that Dery et al.
(2021b) perform auxiliary learning with only the DAPT/TAPT variants of the BERT objective.
They effectively assume that the search space of objectives (thethey explore) is given before-hand.
Our approach automatically creates the search space.
Theoretical Novelty :
To the best of our knowledge, we are the first work to provide an exploration of why auxiliary learning improves primary task performance via algorithmic stability.
Dery et al.
(2021b)
in introducing META-TARTAN do not attempt to give a theoretical characterization of why the algorithm improves end-task performance.
Algorithm Improvements to META-TARTAN : Please note that META-TARAN as presented in Dery et al.
(2021b) was used with only 2 auxiliary tasks.
When scaling to more tasks, using META-TARTAN naively becomes computationally prohibitive.
Specifically, on a search space of N tasks, META-TARTAN requires O ( N ) order computation per step.
We improve upon this by introducing the task sub-sampling of ( k ≪ N ) which reduces the compute overhead to O ( k ) .
To account for the impact of sub-sampling as an approximation, we introduced the factorised modelling of task weights which allows sharing of information between auxiliary tasks that might themselves be related
[Table]
C D ATASET D ETAILS
[Table]
D M ORE T RAINING D ETAILS
We run each hyper-parameter configuration across 3 seeds { 0, 1, 2 } .
We use a batch size offor all end-tasks tasks except H.PARTISAN where we use a batch size of 64.
The auxiliary task batch-size, aux bsz , is shared across all the n sub-sampled auxiliary objectives according to the objective’s weight.
We use the AdamW optimizer (Loshchilov & Hutter, 2017), with weight decay of 0.01 for all experiments.
[Table]
[Table]
[Table]
META-TARTAN introduces a dev-head which is trained sporadically during training for estimating the meta-gradients.
We use the following hyper-parameters for training this dev-head : we sampleexamples (8 examples in the case of H.PARTISAN) and perform full batch gradient descent with a learning rate of 1e-2 for 10 iterations.
The dev-head is trained with the AdamW optimizer with weight decay set to 0.1.
We copy the end-task agnostic baseline results from (Dery et al., 2021b) when available.
We use the hyper-parameters specified for TAPT in Gururangan et al.
(2020) to train for the SE-2016-6 task.
All models were trained on one of two types of gpus: NVIDIA A100 or NVIDIA A6000.
All models fit within a single gpu.
We used gradient accumulation to expand the effective batch sizes used for our experiments.
E G ENERALIZATION E RROR B OUND FOR E ND - TASK A WARE T RAINING E. D EFINITIONS
Definition E.1.
A function, f : Ω → R is L -Lipschitz if ∀ u, v ∈ dom( f ) :
[Equation]
Note that L -Lipschitz implies bounded gradients.
[Equation]
Definition E.2.
A function, f : Ω → R is β -smooth if ∀ u, v ∈ Ω :
[Equation]
Definition E.3.
An update rule, G is σ -bounded if :
[Equation]
Consider the following general setting.
There is an unknown distribution D e over examples from some space Z .
We receive a sample S =
( z 1 , . . .
, z N e ) of N e examples drawn i.i.d.
from D e .
Our goal is to find a model w , that parameterizes the function f e , with small population risk defined as:
Definition E.4. Population Risk
[Equation]
Definition E.5. Empirical Risk
Since we have a finite number of samples, we can only compute the empirical risk which is :
[Equation]
Let A be a potentially randomized algorithm (such as Stochastic Gradient Descent) that is a function of the S such that w =
A ( S ) .
Definition E.6.
Generalization Error ϵ
[Equation]
Definition E.7.
Uniform Stability
A randomized algorithm A is ϵ -uniformly stable if for all data sets S, S ′ ∈ Z , | S | = | S ′ | =
N e such that S and S ′ differ in at most one example, we have
[Equation]
Here, the expectation is taken only over the internal randomness of A.
We will denote by ϵ stab ( A, N e ) the infimum over all ϵ for which the above holds.
E. R ELEVANT T HEOREMS
Theorem E.1 (Uniform Stability implies Generalization in expectation) .
Let Algorithm A be ϵuniformly stable.
Then,
[Equation]
For full proof see Theorem 2.2 of Hardt et al.
Theorem E.2 (Stochastic Gradient Method is stable) .
Assume that f e (; z ) ∈ [0 , 1] is an L -Lipschitz and β e -smooth loss function for every z .
Suppose that we run SGM for T steps with monotonically non-increasing step sizes α t ≤ ct .
Then, SGM has uniform stability with :
[Equation]
where q = β e c
We can simplify this to only terms involving T and N e
[Equation]
Proof.
For the full proof, see Theorem 3.12 of Hardt et al.
E. G ROWTH F UNCTIONS
Lemma E.3 (Growth Recursion Under Dynamic Sampling) .
We consider the Stochastic Gradient update rule G : Ω → Ω :
[Equation]
Fix an arbitrary sequence of updates G f 1 , . . .
, G f T and another G ′ f 1 , . . .
, G ′ f T .
Let w 0 = w ′ 0 be a starting point in Ω given that f : Ω → R and define
[Equation]
where w t , w ′ t are defined recursively through :
[Equation]
Then we have the recurrence relation :
[Equation]
G f t , G ′ f t are σ -bounded Note P f is a distribution over the support { f f 2 } according to probabilities { λ λ 2 | λ 1 + λ 2 = 1 }
{ f f } have smoothness β β
Proof.
The second bound on δ t is taken directly from Lemma 2.5 of Hardt et al.
We now derive the first-half of the first bound
[Equation]
Loss of Generality
[Equation]
let
[Equation]
Using Assumption A
[Equation] [Equation]
Triangle
[Equation]
function
To obtain the second half of the first bound :
[Equation]
E. S TABILITY OF D YNAMIC S AMPLING
We repeat the description of our Auxiliary Learning with Dynamic Sampling Setting here for ease of access.
Setting : We are given an auxiliary objective f a ( · ; z ) ∈ [0 , 1] with N a samples S a
=
( z 1 , . . .
, z N a ) from the distribution D a .
At any iteration of SGD, we sample a choice of either the end-task function f e or the auxiliary objective f a according to the probabilities λ e , λ a | λ e + λ a = 1 .
Given the chosen objective, we sample a data-point and perform stochastic gradient descent (SGD) based on the sampled data-point.
An equivalent way to instantiate this procedure to create S A by drawing N ′ =
N e + N a total samples from the end-task and auxiliary task according to P λ .
S ′
A is then created by replacing 1 end-task sample in S A .
At each step, a sample is drawn from a distribution :
z i , z ′ i ∼ P S A , P S ′ A and a gradient step is taken on the function corresponding to the set the sample was drawn from.
Lemma E.4 (Stability of dynamic sampling) .
We denote the outputs of T steps of SGM on S A and
S ′
A with the dynamically sampled functions, as w T and w ′ T respectively.
Then, for every z e ∈ Z e and every t 0 > 0 , under both the random update rule and the random permutation rule, we have :
[Equation]
Where N ′ =
N e + N a and γ
=
λ e · N ′ N e = λ e λ r .
Proof.
Let E =
[ δ t 0 = 0] denote the event that δ t 0 = 0 .
We have
[Equation]
because f e is non-
[Equation]
because f
[Equation]
L
[Equation]
Lipschitz
[Equation]
We now proceed to bound P {E c } .
Let i ∗ ∈
[ N ′ ] denote the position in which S A , S ′
A differ and consider the random variable I assuming the index of the first time step in which SGM uses the example z
i ∗ e .
Note that when I > t 0 , then we must have that δ t 0 = 0 since the two samples are identical up until this point.
[Equation]
Using the selection rule specified above (sample either f e , f a according to the probabilities λ e , λ a and then sample uniformly from the selected task data) we have that :
[Equation]
Theorem E.5 (Stability Bound on Dynamic Sampling) .
Assume that f e (; z e ) , f a (; z a ) ∈ [0 , 1] are
L -Lipschitz and β e and β a -smooth loss functions.
Consider that we have N ′ =
N e + N a total samples where f e and f a have N e and N a samples respectively.
Suppose that we run SGM for T steps with monotonically non-increasing step sizes α t ≤ ct by dynamically sampling the tasks according to λ e and λ a .
Then, with respect to f e , SGM has uniform stability with :
[Equation]
Where
[Equation]
Given that β ∗ = min { β e , β a } and λ ∗ is the corresponding weighting of the function with smaller smoothness.
Depending on which one gives a tighter bound the pair ( ¯ β, ρ ) can be :
[Equation]
or
[Equation]
When (¯ β, ρ ) 1 gives the tighter bound, we can simplify to :
[Equation]
As presented in Section 4.
Proof.
Let S A , S ′
A be two sample of size N ′ =
N e + N a as described in lemma E.4.
Consider the gradient updates G f 1 , . .
, G f T and G ′ f 1 , . . .
, G ′ f T induced by running SGM on samples S A and S ′
A
respectively.
Let w T and w ′ T denote the corresponding outputs of SGM.
By lemma E.4 we have :
[Equation]
Let Ψ T =
E [ δ T | δ t 0 = 0] .
We will bound Ψ T as function of t 0 and then minimize for t 0 .
Note the following :
• At any step t , with probability (cid:0) 1 − γN ′ (cid:1) , the sample selected is the same in both S A and S ′ A .
In this case G f t =
G ′ f t
and we use the corresponding expansivity rule from lemma E.
This gives :
[Equation]
Where β ∗ =
min { β e , β a } and λ ∗ is the corresponding weighting of the function with smaller smoothness.
To avoid deriving the bound independently for each case,
we
perform a variable substituation that captures the two cases :
[Equation]
¯
β
= (cid:8) λ ∗ β ∗ , λ e β e
+ λ a β a (cid:9) and ρ = (cid:8) (1 − λ ∗ ) (cid:0) ∆ + 2 L (cid:1) , 0 (cid:9) .
We can present the final bound in terns of these variables which can be substituted depending on the minimizer.
• With probability γN ′
the selected example is different.
Note that in this case, we know that we are evaluating the end-task function f e .
We use that both G f t and G ′
f t are ( σ t = α t L )- bounded according to lemma E.3 since f e is L -Lipschitz.
Combining the above we have :
[Equation]
We use 1 + x ≤ exp( x ) ∀ x ≤ exp (cid:18)(cid:0)
[Equation]
Where ¯ ρ =
[Equation]
We can unwind the recurrence until Ψ t 0 = 0 .
[Equation]
We can upper bound the sum over t with an integral + drop negative terms
[Equation]
Plugging this bound back into Equation 8 and using the fact that f e ∈ [0 , 1] :
[Equation]
We let q ∗ =
c ¯ β , we can minimize the R.H.S by setting :
[Equation]
Plugging this in gives us :
[Equation]
Recall that :
[Equation]
We can choose whichever of the pairs for ¯ β, ρ that minimizes the bound :
F D ISCUSSION OF G ENERALIZATION E RROR B OUNDS
[Equation]
We consider the setting where
[Equation]
Assuming the ρ term dominates Equation 12 in this setting is :
[Equation]
This is Equation 1 from Section
[Equation]
In going from the first line to the second we consider the setting where ∆ ≫ 2 L .
This is a case where the auxiliary task is sufficiently different from the primary task.
Some observations about this setting:
Smaller ∆ implies auxiliary task is similar to main task and leads to improving the bound.
Dependence of the bound on N ′ is a bit more nuanced.
Note that increasing N ′ increases γ unless we reduce λ e appropriately .
Remember that λ e is the rate at which we sample the primary task.
Thus, if we add more auxiliary data but still sample the primary task at the original rate, then we are effectively ignoring the extra auxiliary data.
It might be tempting to assume that we can get arbitrary improvements in this setting by setting λ e = 0 .
However, note that whilst this might reduce the generalization error , it means that we are seeing none of the end-task which would result in large increase in the training error 4.
Note that (¯ β = λ ∗ β ∗ ≤ β e ) always.
So we get improvements on the dependence on T compared to Theorem E.2.
We can optimize λ e , λ a to minimize ϵ auxdynstab .