One Model To Learn Them All

06/16/2017 ∙ by Łukasz Kaiser, et al. ∙ Google UNIVERSITY OF TORONTO 0

Deep learning yields great results across many fields, from speech recognition, image classification, to translation. But for each problem, getting a deep model to work well involves research into the architecture and a long period of tuning. We present a single model that yields good results on a number of problems spanning multiple domains. In particular, this single model is trained concurrently on ImageNet, multiple translation tasks, image captioning (COCO dataset), a speech recognition corpus, and an English parsing task. Our model architecture incorporates building blocks from multiple domains. It contains convolutional layers, an attention mechanism, and sparsely-gated layers. Each of these computational blocks is crucial for a subset of the tasks we train on. Interestingly, even if a block is not crucial for a task, we observe that adding it never hurts performance and in most cases improves it on all tasks. We also show that tasks with less data benefit largely from joint training with other tasks, while performance on large tasks degrades only slightly if at all.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

Code Repositories

2017

The Year in Review 2017 | open guide to natural language processing


view repo
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Recent successes of deep neural networks have spanned many domains, from computer vision

Krizhevsky et al. (2012) to speech recognition Dahl et al. (2012)

and many other tasks. Convolutional networks excel at tasks related to vision, while recurrent neural networks have proven successful at natural language processing tasks, e.g., at machine translation

Sutskever et al. (2014); Bahdanau et al. (2014); Cho et al. (2014)

. But in each case, the network was designed and tuned specifically for the problem at hand. This limits the impact of deep learning, as this effort needs to be repeated for each new task. It is also very different from the general nature of the human brain, which is able to learn many different tasks and benefit from transfer learning. The natural question arises:

Can we create a unified deep learning model to solve tasks across multiple domains?

The question about multi-task models has been studied in many papers in the deep learning literature. Natural language processing models have been shown to benefit from a multi-task approach a long time ago Collobert and Weston (2008), and recently machine translation models have even been shown to exhibit zero-shot learning when trained on multiple langauges Melvin Johnson (2016). Speech recognition has also been shown to benefit from multi-task training Seltzer and Droppo (2013), as have some vision problems, such as facial landmark detection Zhang Z. (2014). But all these models are trained on other tasks from the same domain: translation tasks are trained with other translation tasks, vision tasks with other vision tasks, speech tasks with other speech tasks. Multi-modal learning has been shown to improve learned representations in the unsupervised setting Ngiam et al. (2011) and when used as a-priori known unrelated tasks Romera-Paredes et al. (2012). But no competitive multi-task multi-modal model has been proposed, so the above question remains unanswered. In this work, we take a step toward positively answering the above question by introducing the MultiModel architecture, a single deep-learning model that can simultaneously learn multiple tasks from various domains. Concretely, we train the MultiModel simultaneously on the following 8 corpora:

  1. WSJ speech corpus (Consortium et al., 1994)

  2. ImageNet dataset (Russakovsky et al., 2015)

  3. COCO image captioning dataset (Lin et al., 2014)

  4. WSJ parsing dataset (Marcus et al., 1999)

  5. WMT English-German translation corpus

  6. The reverse of the above: German-English translation.

  7. WMT English-French translation corpus

  8. The reverse of the above: German-French translation.

The model learns all of the above tasks and achieves good performance: not state-of-the-art at present, but above many task-specific models studied in recent past (see the Section 3 for details). Figure 1 illustrates some decodes taken directly from the model: it is clear that it can caption images, categorize them, translate to French and German and construct parse trees. While the MultiModel is only a first step and will be tuned and improved in the future, two key insights are crucial to making it work at all and are the main contributions of this work.

Figure 1: Examples decoded from a single MultiModel trained jointly on 8 tasks. Red depicts a language modality while blue depicts a categorical modality.

Small modality-specific sub-networks convert into a unified representation and back from it.
To allow training on input data of widely different sizes and dimensions, such as images, sound waves and text, we need sub-networks to convert inputs into a joint representation space. We call these sub-networks modality nets

as they are specific to each modality (images, speech, text) and define transformations between these external domains and a unified representation. We design modality nets to be computationally minimal, promoting heavy feature extraction and ensuring that the majority of computation is performed within the domain-agnostic body of the model. Since our model is auto-regressive, modality nets need to both convert the inputs into the unified representation and later convert from this representation into the output space. Two design decisions were important:

  • The unified representation is variable-size. While a fixed-size representation is tempting and easier to implement, it creates a bottleneck and limits the performance of the model.

  • Different tasks from the same domain share modality nets. We avoid creating a sub-network for every task, and prefer only to create one for every input modality. For example, all translation tasks share the same modality-net (and vocabulary), no matter for which language pair. This encourages generalization across tasks and allows to add new tasks on the fly.

Computational blocks of different kinds are crucial for good results on various problems.
The body of the MultiModel incorporates building blocks from mutiple domains. We use depthwise-separable convolutions, an attention mechanism, and sparsely-gated mixture-of-experts layers. These blocks were introduced in papers that belonged to different domains and were not studied before on tasks from other domains. For example, separable convolutions were introduced in the Xception architecture Chollet (2016) and were not applied to text or speech processing before. On the other hand, the sparsely-gated mixture-of-experts Noam Shazeer (2017) had been introduced for language processing tasks and has not been studied on image problems. We find that each of these mechanisms is indeed crucial for the domain it was introduced, e.g., attention is far more important for language-related tasks than for image-related ones. But, interestingly, adding these computational blocks never hurts performance, even on tasks they were not designed for. In fact we find that both attention and mixture-of-experts layers slightly improve performance of MultiModel on ImageNet, the task that needs them the least.

2 MultiModel Architecture

The MultiModel consists of a few small modality-nets, an encoder, I/O mixer, and an autoregressive decoder, as depicted in Figure 2. As already said above, the encoder and decoder are constructed using 3 key computational blocks to get good performance across different problems:

  1. Convolutions allow the model to detect local patterns and generalize across space.

  2. Attention layers allow to focus on specific elements to improve performance of the model.

  3. Sparsely-gated mixture-of-experts gives the model capacity without excessive computation cost.

We start by describing the architecture of each of these 3 blocks and then introduce the encoder, decoder and the architecture of our modality-nets.

Figure 2: The MultiModel, with modality-nets, an encoder, and an autoregressive decoder.

2.1 Convolutional Blocks

To perform local computation, we use blocks of convolutions with ReLU non-linearities and normalization. A block of convolutions gets as input a tensor of shape [batch size, sequence length, feature channels] and returns a tensor of the same shape, processed as follows. For convolution operations, we use depthwise separable convolutions, introduced in

Chollet (2016), in a way similar to Łukasz Kaiser (2017). Depthwise separable convolutions are a parameter- and computationally-efficient variant of the traditional convolution. They are defined by a convolution on each feature channel separately, followed by a pointwise convolution to project to the desired feature depth. We refer the reader to Chollet (2016) for a complete definition; here we will denote a depthwise separable convolution with weights corresponding to kernels of size applied to an input tensor

with stride

and dilated by a factor (see Yu and Koltun (2015)) as . Note that subscripts for stride, dilation and output size are omitted when dilation or stride are equal to 1, or output size is equal to the input’s feature depth. We use convolutions in blocks that consist of three components: a activation of the inputs, followed by a , followed by layer normalization. Layer normalization Ba et al. (2016) acts over the hidden units of the layer below, computing layer-wise statistics for each batch example and normalizing accordingly. These normalized units are then scaled and shifted by scalar learned parameters and respectively, producing the final units to be activated by a non-linearity. The complete convolution step is therefore defined as:

The convolutional steps are composed into blocks by stacking them and adding residual connections as depicted in Figure 

3. We use stacks of four convolutional blocks with two skip-connections between the stack input and the outputs of the second and fourth convolutional steps, and with the first two having kernels and the next two having kernels, with the final one dilated by to provide a wide receptive field. We also add dropout at the end of each block, so the complete block is defined as follows:

2.2 Attention Blocks

For attention, we use a multi-head dot-product attention mechanism inspired by Bahdanau et al. (2014) and similar to Ashish Vaswani (2017), as depicted in Figure 3. The inputs to the attention layer are two tensors: a tensor and a tensor both with the shape The tensor is additively composed with a timing signal and mixed using two convolutional blocks. This mixed tensor is then self-attended using a multi-head dot-product attention, which is a dot-product attention with inputs split into separate tensors representing each attention head, as shown in Figure 3. The timing signals are the main difference between this attention mechanism and the ones used previously. They allow this content-based attention to focus based on their position. They are constructed by concatenating sine and cosine curves:

where represent concatenation of and along the dimension. The tensor is finally passed through two different pointwise convolutions to generate the memory keys and values and the query keys, memory keys and memory values are used to apply the attention mechanism between the self-attended and the (see Figure 3).

2.3 Mixture-of-Experts Blocks

We use sparsely-gated mixture-of-experts layers of the same kind as introduced in Noam Shazeer (2017)

: A mixture-of-experts layer consists of a number of simple feed-forward neural networks (experts) and a trainable gating network which selects a sparse combination of the experts to process each input. We refer the reader to

Noam Shazeer (2017) for details as we use exactly the architecture described there. In particular, during training we select experts out of the whole expert pool and add the additional load-balancing cost as in Noam Shazeer (2017). In each of the two mixture-of-experts layers in our model, we use a pool of experts when training on 8 problems jointly, and experts when training on each problem separately.

2.4 Encoder and Mixer and Decoder

The body of the MultiModel consists of 3 parts: the encoder that only processes the inputs, the mixer that mixes the encoded inputs with previous outputs (autoregressive part), and a decoder that processes the inputs and the mixture to generate new outputs.

Figure 3: Architecture of the MultiModel; see text for details.

The encoder, mixer and decoder are structured similarly to previous fully convolutional sequence to sequence models such as ByteNet Kalchbrenner et al. (2016) or WaveNet van den Oord et al. (2016), but differ in the computational blocks that are used. We depict their architecture in Figure 3

. As can be seen there, the encoder consists of 6 repeated convolutional blocks (described before) with a mixture-of-experts layer in the middle. The mixer consists of an attention block and 2 convolutional blocks. The decoder consists of 4 blocks of convolutions and attention, with a mixture-of-experts layer in the middle. Crucially, the convolutions in the mixer and decoder are padded on the left, so they can never access any information in the future. This allows the model to be autoregressive, and this convolutional autoregressive generation scheme offers large receptive fields over the inputs and past outputs, which are capable of establishing long term dependencies. To allow the decoder to produce outputs for different tasks even with the same modality, we always start decoding with a command-token, such as

To-English or To-Parse-Tree

. We learn an embedding vector corresponding to each of the tokens during training.

2.5 Modality Nets

We have 4 modality nets, for language (text data), images, audio, and categorical data.

2.5.1 Language modality net

Our language-based data is all tokenized using the same vocabulary with 8k subword-units, following the method from Sennrich et al. (2015). The language input modality takes a sequence of tokens ending in a termination token. This sequence of tokens is mapped to the correct dimensionality for the body using a learned embedding. On the output side, the language modality takes the decoded output of the body and performs a learned linear mapping, followed by a

, resulting in a probability distribution over the token vocabulary.

2.5.2 Image modality net

The image input modality is analogous to the Xception entry flow Chollet (2016). The input image’s feature depth is gradually deepened using residual convolution blocks which we call and define as follows:

where

is a max-pooling layer over

with stride and window shape . The ImageModality input flow with network depth (we use ) is defined as:

2.5.3 Categorical modality net

The categorical output modality is analogous to the Xception exit flow Chollet (2016). If the network inputs are two-dimensional data such as image or spectral audio data, then the one-dimensional output from the model body is first reshaped into two-dimensions again, followed by progressive down-sampling:

denotes a mean taken across all spatial and temporal dimensions.

2.5.4 Audio modality net

We accept audio input in the form of a 1-dimensional waveform over time or as a 2-dimensional spectrogram. Both the waveform and spectral input modalities use a stack of 8 blocks from the (Section 2.5.2). The block has the form: . The spectral modality does not perform any striding along the frequency bin dimension, preserving full resolution in the spectral domain.

2.6 Related Models

The MultiModel architecture draws from eariler encoder-decoder architectures applied to neural machine translation. Earlier sequence-to-sequence models for translation

Sutskever et al. (2014); Bahdanau et al. (2014); Cho et al. (2014)

used recurrent neural networks (RNNs) with long short-term memory cells

Hochreiter and Schmidhuber (1997)). Convolutional architectures yielded good results on word-level neural machine translation starting from Kalchbrenner and Blunsom (2013) and later in Meng et al. (2015). These early models used a standard RNN on top of the convolution to generate the output and had a bottleneck there that hurt performance, especially on longer sentences, similarly to the limitations of RNN sequence-to-sequence models without attention Sutskever et al. (2014); Cho et al. (2014). Fully convolutional neural machine translation without this bottleneck was presented in Łukasz Kaiser (2016); Kalchbrenner et al. (2016). The model in Łukasz Kaiser (2016) (Extended Neural GPU) used a recurrent stack of gated convolutional layers, while the model in Kalchbrenner et al. (2016) (ByteNet) did away with recursion and used left-padded convolutions in the decoder. This idea, introduced in WaveNet van den Oord et al. (2016) and also used in MultiModel (see above) significantly improves efficiency. Depthwise separable convolutions were first studied by Sifre Sifre and Mallat (2013) and later they were used to get good results on large-scale image classification with Xception Chollet (2016).

3 Experiments

We implemented the MultiModel architecture described above using TensorFlow and trained it in a number of configurations. In all training runs reported below we used the same set of hyper-parameters and the Adam optimizer

Kingma and Ba (2014)

with gradient clipping. We will release the implementation as open-source together with the details of our setup and all used hyper-parameters. We focused our experiments so as to answer the following questions:

  1. How far is the MultiModel trained on 8 tasks simultaneously from state-of-the-art results?

  2. How does training on 8 tasks simultaneously compare to training on each task separately?

  3. How do the different computational blocks discussed above influence different tasks?

In answering the above questions, we don’t always consider all 8 problems. Especially the 4 translation problems behave very similarly, so we decided to not include them all in each comparison but we focused on the more varied problems instead. To answer question (1), we compare the performance of the 8-problem MultiModel with state-of-the-art results in Table 1. We did not invest much time yet in tuning hyper-parameters of the MultiModel, so we believe that the difference seen there will become much smaller with more tuning. The results we achieve are similar to the ones task-specific models get without heavy tuning, e.g., on English-French translation we improve on the Extended Neural GPU results reported last year Łukasz Kaiser (2016).

Problem MultiModel (joint 8-problem) State of the art
ImageNet (top-5 accuracy) 86% 95%
WMT EN DE (BLEU) 21.2 26.0
WMT EN FR (BLEU) 30.5 40.5

Table 1: Comparing MultiModel to state-of-the-art from Szegedy et al. (2016) and Noam Shazeer (2017).

To answer question (2), we compare the MultiModel trained jointly with MultiModel trained separately just on a single task. When training jointly on 8 tasks, we had a separate worker training on each task with shared parameters of the model. When training on a single task, we used only a single worker training on this task for a similar number of steps. Since we are comparing different instantiations of the same model, we report two internal metrics: the negative log-perplexity and per-token accuracy (measured on the development set). As can be seen from the results in Table 2, the joint 8-problem model performs similarly to single-model on large tasks, and better, sometimes significantly, on tasks where less data is available, such as parsing.

Problem Joint 8-problem Single problem
log(perpexity) accuracy log(perplexity) accuracy
ImageNet 1.7 66% 1.6 67%
WMT ENDE 1.4 72% 1.4 71%
WSJ speech 4.4 41% 5.7 23%
Parsing 0.15 98% 0.2 97%

Table 2: Comparison of the MultiModel trained jointly on 8 tasks and separately on each task.

The large improvement on parsing seen in Table 2 is not that surprising taking into account the large number of text data in translation tasks. But we were curious if training parsing just with ImageNet, a seemingly unrelated task, would also bring any improvements. This is indeed the case, as can be seen in Table 3. The difference in performance is significant, and since we use both dropout and early stopping, we conjecture that it is not related to over-fitting. Rather, it seems, there are computational primitives shared between different tasks that allow for some transfer learning even between such seemingly unrelated tasks as ImageNet and parsing.

Problem Alone W/ ImageNet W/ 8 Problems
log(ppl) acc. full log(ppl) acc. full log(ppl) acc. full
Parsing 0.20 97.1% 11.7% 0.16 97.5% 12.7% 0.15 97.9% 14.5%

Table 3: Results on training parsing alone, with ImageNet, and with 8 other tasks. We report log-perplexity, per-token accuracy, and the percentage of fully correct parse trees.

To answer question (3), we check how training without the mixture-of-experts layers or without the attention mechanism influences performance on different problems. Since both these mechanisms were designed with machine translation in mind, we check the English-French translation. But we also include ImageNet, since this is the problem that stands the least to benefit from those blocks. In fact, one could expect that removing these blocks will improve performance on ImageNet alone if they were truly useless for this task. In contrast, we see in Table 4 that these blocks either don’t affect or slightly improve performance. This leads us to conclude that mixing different computation blocks is in fact a good way to improve performance on many various tasks.

Problem All Blocks Without MoE Without Attention
log(perpexity) accuracy log(perplexity) accuracy log(perplexity) accuracy
ImageNet 1.6 67% 1.6 66% 1.6 67%
WMT ENFR 1.2 76% 1.3 74% 1.4 72%

Table 4: Ablating mixture-of-experts and attention from MultiModel training.

4 Conclusions

We demonstrate, for the first time, that a single deep learning model can jointly learn a number of large-scale tasks from multiple domains. The key to success comes from designing a multi-modal architecture in which as many parameters as possible are shared and from using computational blocks from different domains together. We believe that this treads a path towards interesting future work on more general deep learning architectures, especially since our model shows transfer learning from tasks with a large amount of available data to ones where the data is limited.

References