user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Beyond Shared Hierarchies: Deep Multitask Learning through Soft Layer Ordering

Paper content:
Existing deep multitask learning (MTL) approaches align layers shared between tasks in a parallel ordering.
Such an organization significantly constricts the types of shared structure that can be learned.
The necessity of parallel ordering for deep MTL is first tested by comparing it with permuted ordering of shared layers.
The results indicate that a flexible ordering can enable more effective sharing, thus motivating the development of a soft ordering approach, which learns how shared layers are applied in different ways for different tasks.
Deep MTL with soft ordering outperforms parallel ordering methods across a series of domains.
These results suggest that the power of deep MTL comes from learning highly general building blocks that can be assembled to meet the demands of each task.
In multitask learning (MTL) BID4 , auxiliary data sets are harnessed to improve overall performance by exploiting regularities present across tasks.
As deep learning has yielded state-ofthe-art systems across a range of domains, there has been increased focus on developing deep MTL techniques.
Such techniques have been applied across settings such as vision BID2 BID19 BID35 BID37 BID49 BID52 , natural language BID6 BID8 BID12 BID29 BID32 , speech BID16 BID5 BID42 , and reinforcement learning BID7 BID9 BID18 BID40 .
Although they improve performance over single-task learning in these settings, these approaches have generally been constrained to joint training of relatively few and/or closely-related tasks.On the other hand, from a perspective of Kolmogorov complexity, "transfer should always be useful"; any pair of distributions underlying a pair of tasks must have something in common BID33 BID34 .
In principle, even tasks that are "superficially unrelated" such as those in vision and NLP can benefit from sharing (even without an adaptor task, such as image captioning).
In other words, for a sufficiently expressive class of models, the inductive bias of requiring a model to fit multiple tasks simultaneously should encourage learning to converge to more realistic representations.
The expressivity and success of deep models suggest they are ideal candidates for improvement via MTL.
So, why have existing approaches to deep MTL been so restricted in scope?MTL
is based on the assumption that learned transformations can be shared across tasks. This
paper identifies an additional implicit assumption underlying existing approaches to deep MTL: this sharing takes place through parallel ordering of layers. That
is, sharing between tasks occurs only at aligned levels (layers) in the feature hierarchy implied by the model architecture. This
constraint limits the kind of sharing that can occur between tasks. It requires
subsequences of task feature hierarchies to match, which may be difficult to establish as tasks become plentiful and diverse. This paper
investigates whether parallel ordering of layers is necessary for deep MTL. As an alternative
, it introduces methods that make deep MTL more flexible. First, existing
approaches are reviewed in the context of their reliance on parallel ordering. Then, as a foil
to parallel ordering, permuted ordering is introduced, in which shared layers are applied in different orders for different tasks. The increased ability
of permuted ordering to support integration of information across tasks is analyzed, and the results are used to develop a soft ordering approach to deep MTL. In this (a) Classical
approaches
add a task-specific decoder to the output of the core single-task model for each task; (b) Columnbased approaches
include a network column for each task, and define a mechanism for sharing between columns; (c) Supervision at custom
depths adds output decoders at depths based on a task hierarchy; (d) Universal representations
adapts each layer with a small number of task-specific scaling parameters. Underlying each of these approaches
is the assumption of parallel ordering of shared layers (Section 2.2): each one requires aligned sequences of feature extractors across tasks.approach, a joint model learns how to apply shared layers in different ways at different depths for different tasks as it simultaneously learns the parameters of the layers themselves. In a suite of experiments, soft ordering
is shown to improve performance over single-task learning as well as over fixed order deep MTL methods.Importantly, soft ordering is not simply a technical improvement, but a new way of thinking about deep MTL. Learning a different soft ordering of layers
for each task amounts to discovering a set of generalizable modules that are assembled in different ways for different tasks. This perspective points to future approaches
that train a collection of layers on a set of training tasks, which can then be assembled in novel ways for future unseen tasks. Some of the most striking structural regularities
observed in the natural, technological and sociological worlds are those that are repeatedly observed across settings and scales; they are ubiquitous and universal. By forcing shared transformations to occur at matching
depths in hierarchical feature extraction, deep MTL falls short of capturing this sort of functional regularity. Soft ordering is thus a step towards enabling deep MTL
to realize the diverse array of structural regularities found across complex tasks drawn from the real world.
In the interest of clarity, the soft ordering approach in this paper was developed as a relatively small step away from the parallel ordering assumption.
To develop more practical and specialized methods, inspiration can be taken from recurrent architectures, the approach can be extended to layers of more general structure, and applied to training and understanding general functional building blocks.Connections to recurrent architectures.
Eq.
7 is defined recursively with respect to the learned layers shared across tasks.
Thus, the soft-ordering architecture can be viewed as a new type of recurrent architecture designed specifically for MTL.
From this perspective, Figure 3 shows an unrolling of a soft layer module: different scaling parameters are applied at different depths when unrolled for different tasks.
Since the type of recurrence induced by soft ordering does not require task input or output to be sequential, methods that use recurrence in such a setting are of particular interest BID26 BID27 BID36 BID44 BID50 .
Recurrent methods can also be used to reduce the size of S below O(T D 2 ), e.g., via recurrent hypernetworks BID11 .
Finally, Section 4 demonstrated soft ordering where shared learned layers were fully-connected or convolutional; it is also straightforward to extend soft ordering to shared layers with internal recurrence, such as LSTMs BID15 .
In this setting, soft ordering can be viewed as inducing a higher-level recurrence.Generalizing the structure of shared layers.
For clarity, in this paper all core layers in a given setup had the same shape.
Of course, it would be useful to have a generalization of soft ordering that could subsume any modern deep architecture with many layers of varying structure.
As given by Eq. 7, soft ordering requires the same shape inputs to the element-wise sum at each depth.
Reshapes and/or resampling can be added as adapters between tensors of different shape; alternatively, a function other than a sum could be used.
For example, instead of learning a weighting across layers at each depth, a probability of applying each module could be learned in a manner similar to adaptive dropout BID1 BID25 or a sparsely-gated mixture of experts BID43 .
Furthermore, the idea of a soft ordering of layers can be extended to soft ordering over modules with more general structure, which may more succinctly capture recurring modularity.Training generalizable building blocks.
Because they are used in different ways at different locations for different tasks, the shared trained layers in permuted and soft ordering have learned more general functionality than layers trained in a fixed location or for a single task.
A natural hypothesis is that they are then more likely to generalize to future unseen tasks, perhaps even without further training.
This ability would be especially useful in the small data regime, where the number of trainable parameters should be limited.
For example, given a collection of these layers trained on a previous set of tasks, a model for a new task could learn how to apply these building blocks, e.g., by learning a soft order, while keeping their internal parameters fixed.
Learning an efficient set of such generalizable layers would then be akin to learning a set of functional primitives.
Such functional modularity and repetition is evident in the natural, technological and sociological worlds, so such a set of functional primitives may align well with complex real-world models.
This perspective is related to recent work in reusing modules in the parallel ordering setting BID9 .
The different ways in which different tasks learn to use the same set of modules can also help shed light on how tasks are related, especially those that seem superficially disparate (e.g., by extending the analysis performed for FIG3 ), thus assisting in the discovery of real-world regularities.
This paper has identified parallel ordering of shared layers as a common assumption underlying existing deep MTL approaches.
This assumption restricts the kinds of shared structure that can be learned between tasks.
Experiments demonstrate how direct approaches to removing this assumption can ease the integration of information across plentiful and diverse tasks.
Soft ordering is introduced as a method for learning how to apply layers in different ways at different depths for different tasks, while simultaneously learning the layers themselves.
Soft ordering is shown to outperform parallel ordering methods as well as single-task learning across a suite of domains.
These results show that deep MTL can be improved while generating a compact set of multipurpose functional primitives, thus aligning more closely with our understanding of complex real-world processes.All experiments were run with the Keras deep learning framework BID5 , using the Tensorflow backend BID0 .
All experiments used the Adam optimizer with default parameters BID20 unless otherwise specified.In each iteration of multitask training, a random batch for each task is processed, and the results are combined across tasks into a single update.
Compared to alternating batches between tasks BID32 , processing all tasks simultaneously simplified the training procedure, and led to faster and lower final convergence.
When encoders are shared, the inputs of the samples in each batch are the same across tasks.
Cross-entropy loss was used for all classification tasks.
The overall validation loss is the sum over all per task validation losses.In each experiment, single task, parallel ordering (Eq. 2), permuted ordering (Eq. 3), and soft ordering (Eq. 7) trained an equivalent set of core layers.
In permuted ordering, the order of layers was randomly generated for each task each trial.
Several trials were run for each setup to produce confidence bounds.

assistant: text: Relaxing the constraint of shared hierarchies enables more effective deep multitask learning.