Year: 2018

Abstract:
In this paper, we describe a general framework to systematically analyze current neural models for multi-task learning, in which we find that existing models expect to disentangle features into different spaces while features learned in practice are still entangled in shared space, leaving potential hazards for other training or unseen tasks. We propose to alleviate this problem by incorporating a new inductive bias into the process of multi-task learning, that different tasks can communicate with each other not only by passing hidden variables but gradients explicitly. Experimentally, we evaluate proposed methods on three groups of tasks and two types of settings (IN-TASK and OUT-OF-TASK). Quantitative and qualitative results show their effectiveness.

text: 1 INTRODUCTION
A1 A2 A3 ∇LA1→A2 ∇LA2→A3
(a)
C
A B
∇LA↔C ∇LC↔B
∇LA↔B
(b)
Figure 1: A, B, C represent different tasks.∇θL denotes the gradients with respect to θ. (a). Gradient Passing within a task. (b). Gradient Passing across tasks.
Multi-task learning has been established as an effective learning method in deep learning, driving state-of-theart results to new levels in a number of tasks, ranging from computer vision (Misra et al., 2016; Zamir et al., 2018) to natural language processing (Collobert & Weston, 2008; Luong et al., 2015).
While various kinds of neural multi-task learning approaches have been proposed, a commonality is the two types of feature spaces they defined to store taskspecific features and task-invariant features. And then interaction mechanisms among different feature
spaces will be explored in diverse ways, such as hard sharing (Collobert & Weston, 2008) or soft sharing (Misra et al., 2016; Ruder12 et al., 2017) schemes , flat (Yang et al., 2016; Liu et al., 2016) or structural sharing schemes (Hashimoto et al., 2016; Søgaard & Goldberg, 2016).
Despite their great success, a potential limitation of most existing works is that shared space is entangled with private features since it is not enforced through the use of explicit loss functions (Bousmalis et al., 2016). Specifically, we would have extracted shared features and disentangled them into separated spaces. However, in reality, methods in use just collect all the features together into a common space, instead of learning shared rules across different tasks. This problem, which we define as “pretend-to-share”, clearly suffers from the following issues: 1) IN-TASK SETTING: shared space is redundant and contaminated by task-specific features, leaving potential hazards for other training tasks. 2) OUT-OF-TASK SETTING: the learned model can not effectively adapt to new tasks since a real common structure is not discovered.
A few works explore this problem with adversarial training and shows that explicitly disentangling representations into private and shared spaces will improve model’s performance (Bousmalis et al., 2016; Liu et al., 2017). In this paper, we propose an orthogonal technique to alleviate above problem. Specifically, we first describe a general framework for multi-task learning called Parameters ReadWrite Networks (PRaWNs) that can simply abstract the commonalities between existing typical neural models for multi-task learning. Then, we explain the reason for pretend-to-share problem within PRaWN that each task has the permission to modify shared parameters without any communication protocol, which makes it easier to update parameters along diverse directions.
Therefore, the problem is translated into this question: how to address the conflict among different tasks happening in the process of parameter updating. We resolve this conflict by introducing an inductive bias for multi-task learning. Specifically, different tasks can communicate with each other by sending (or receiving) both hidden variables and gradients. As shown in Fig.1(b), during the forward phase, tasks A, B, C are capable of sending (and receiving) the gradients to (and from) each other. Then during the backward phase, each task is aware of how other tasks are modifying the parameters, making it possible to modify in a more consistent way. Concretely, by communicating with gradients, we can apply consistency constraint to each task during the process of parameter updating, which can prevent private features from slipping into shared space thereby alleviating the pretend-to-share problem. Technically, we explore two kinds of communication mechanisms for gradient passing: pairwise and list-wise communication, where the latter one can take task relatedness into consideration.
We evaluate our models on three groups of multi-task learning datasets, range from natural language processing tasks to computer vision. The results show that our models are more expressive since we can learn a shared space which are more pure, driving task-dependent features away.
To summarize, we make the following contributions:
• We describe a general framework, which can not only help us analyze current models in an unified way [Section 3], but find potential limitations, and move forward with suitable approaches [Section 4].
• We study a task-agnostic problem existing in many multi-task learning models, and propose to alleviate it by allowing different tasks to communicate with gradients.
• We present an elaborate qualitative analysis, giving some insight into the internal mechanisms of proposed gradient passing method.

heading: 2 RELATED WORK
text: Multi-task Learning There is a large body of works relating to multi-task learning, and we will give systematical analysis in next section. This paper studies a task-agnostic problem existing in many multi-task learning models. Existing models expect to disentangle features into different spaces while features learned in practice are entangled in shared space. Several papers (Liu et al., 2017; Chen et al., 2017) also observe this problem more recently and they propose address it with adversarial training . Despite its effectiveness, it suffers from difficult training process to achieve the balance between generator and discriminator. Besides, adversarial multi-task training methods ignore the relationship between different tasks, leading to low-capacity of learned shared space.
Gradient Passing Between Samples Recently, some works begin to model the dependencies of training samples. Specifically, one sample xi can pass gradients to another one xj , in which an intermediate function is used to transform gradients into new weights (called fast weights) for xj . This function usually takes different forms, ranging from recurrent neural networks (Andrychowicz et al., 2016; Ravi & Larochelle, 2016), temporal convolutions with attention (Mishra et al., 2018), or memory networks (Santoro et al., 2016). Meanwhile, Finn et al. (2017) explores a special case where the function is an updating function of SGD. However, the samples’ dependencies studied by these works are within a task as shown in Fig.1(b), whose motivations are to learn a general updating rule, which can achieve fast adaptation to unseen samples. Different with these works (Finn et al., 2017; Gu et al., 2018), we model the samples’ dependencies cross different tasks, aiming to disentangle private and shared features into different spaces.
Domain Adaptation Domain adaptation (DA) alone is a generally well studied area both in natural language processing (Li & Zong, 2008; Blitzer et al., 2007) and computer vision (Saenko et al., 2010) communities. And there are several differences between domain adaptation and multi-task learning (MTL). 1) For domain adaption, there is an explicit pair of source and target domains. Addtionally, the purpose is to adapt the model learned on source domains to target domains. Therefore, DA cares much about the performance on target domains while MTL focuses on performance both in IN-TASK setting and OUT-OF-TASK setting. 2) For domain adaptation, different domains usually have the same label space, and all parameters for different domains are shared, with no need for disentangling
shared and private spaces. More specifically, some recent works introduce meta learning methods for fast domain adaptation (Li et al., 2017; Kang & Feng; Yu et al., 2018). Apart from above two points, the difference with this paper is that our motivation starts from the pretend-to-share problem in multi-task learning, then we seek an approach to learn a shared space, which is not contaminated by private features.

heading: 3 PARAMETERS READ-WRITE NETWORKS
text: Recent years have seen remarkable success in the use of various neural multi-task learning models to natural languange processing and computer vision. The time is ripe to propose a more general framework, in which we can systematically analyze current models, find potential limitations, and move forward with suitable approaches. With above in mind, in this paper, we propose such a framework, called Parameters Read-Write Networks (PRaWNs), which allow us to dissect existing models and explore additional novel variations within this framework. We will first describe details of PRaWNs.

heading: 3.1 CONCEPT DEFINITIONS IN PRAWN
text: Task agents and parameters are two concepts in PRaWN. And the high-level idea of PRaWN to describe multi-task learning process can be expressed as follows: different task agents read information from different types of parameters, and then they write new information to parameters to satisfy some constraints.
Task Agents In PRaWN, each task is regarded as an agent with three elements (D,READ-OP, WRITE-OP) , in which D denotes the data belonging to the current task. READ-OP and WRITE-OP represent two operations that the current task can execute. The forms of the tasks can differ in various ways, such as the domain (multi-domain learning) or the language (cross-lingual learning).
Parameters Parameters are the objects that operations (READ-OPs and WRITE-OPs) of task agents could execute to. Generally, parameters can be classified into different types based on the following aspects.
• Sharable or Private: Sharable parameters can be read and modified by multiple tasks.
• Readable or Non-readable: If θ for the task agent k is readable, it means that READ-OP of task k can be executed.
• Writable or Non-writable: If θ for the task agent k is readable, it means that WRITE-OP of task k can be executed.
According to above three aspects of parameters, we can enumerate four effective modes for general multi-task learning as shown Fig. 2. We use swr to represent them and the r̄ denotes non-readable. For each task, we can understand its sharing schema based on its constituents of parameters. Detailed examples can be found in Appendix.

heading: 3.2 READ OPERATION
text: The purpose of READ-OP is to gather useful information rk based on current input samples X k of task k from all readable parameters.
rk = READ-OP(Θ∗rk ,X k) (1) = OUT(θs̄wrk , ENC(X k, {Θ∗rk − θs̄wrk })) (2)
where we refer to Θ as a set of parameters θ. Θ∗rk = {Θswrk ,Θs̄wrk ,Θs̄w̄rk } represents all readable parameters with respect to task k. OUT denotes output layer while ENC denotes feature encoding layer, ENC can be instantiated as CNN or RNN layer.
For this operation, the key step is how to effectively define readable parameters Θ∗rk , organizing their dependency relationship and then aggregating useful information from them. Specifically, the process to seek for desirable READ-OPs can be abstracted to a architecture searching problem (Chen et al., 2018a), which has raised a large body of existing works on this as shown in Tab.1. Here, we show some typical READ-OPs.
Flat READ-OPs: Θ∗rk = {Θswrk ,Θs̄wrk } and {Θs̄wrk − θs̄wrk } = ∅ Models with flat READ-OP usually assume that all parts of neural network are sharable except output layer , suggesting that different tasks have no private space to encode input samples.
Star-network READ-OPs: Θ∗rk = {Θswrk ,Θs̄wrk } {Θs̄wrk − θs̄wrk } is used for learning task-dependent representations. Different with above models, star-network operation introduces an extra private encoder for each task, aiming to disentangle task-specific and task-invariant features into different spaces.
Structural READ-OPs: Θ∗rk = {Θswrk ,Θs̄wrk ,Θs̄w̄rk } Clearly, for above two operations, there is no definitions of parameters θs̄w̄rk for any k, which means that any two tasks can not directly communicate with each other. To address this problem, structural READ-OPs are proposed, where each task can read information from the parameters of other tasks.

heading: 3.3 WRITE OPERATION
text: For task agent k, the write operation will make modifications to its writable parameters to satisfy some constraints.
Θ∗w∗k = WRITE-OP(Θ w k ,∆Θ∗w∗k L(r k)) (3)
where Θ∗w∗k = {Θswrk ,Θs̄wrk } represents the parameter sets, each of which is writable with respect to task k.
During the writing phase, a key question is how to introduce desirable constraints to modify writable parameters Θ∗w∗k for each tasks. Many existing works try to incorporate different kinds of losses to achieve that, where the task-oriented constraint is commonly used to both update Θswrk and Θ s̄wr k .
Task-Oriented Constraint This constraint usually depends on specific task. For example , for a classification task, Ltask can be defined as:
Ltask = L(READ-OP,Y) (4)
where L represents the cross-entropy loss.
To incorporate more inductive bias, some extra constraints are introduced. For example, adversarial constraint LAdv is used to encourage shared space more pure while orthogonal constraint LDiff introduce an inductive bias that shared and private feature space should be more orthogonal. More descriptions of these two constraints can be found in Appendix.

heading: 4 EXPLORING NEW COMMUNICATION PROTOCOLS FOR PRAWN
text: Given how many specific multi-task learning models have appeared in the literature, an general framework can not only help us deeply understand existing work in an unified way, but can guide us to find potential limitation and motivate us to propose new variations for a specific application.

heading: 4.1 PROBLEMS AND MOVING FORWARD
text: In PRaWN framework, a lot of works focus on designing READ-OPs with different forms, aiming to obtain the most suitable sharing schema. However, the pretend-to-share problem is less studied in multi-task learning. By dissecting multi-task learning models into different phases within PRaWN, we can get more intuitive understanding towards this problem.
Parameters Corruption We attribute the reason for pretend-to-share to the inconsistent WRITEOPs executed by different tasks. Specifically, each task has the permission to modify shared parameters Θswrk without any communication protocol, which makes it easier to update parameters along diverse directions.
Formally, given two tasksA andB, they will both execute WRITE-OP towards their shared parameters Θswrk based on their data DA and DB as follows:
Θ̃swr = WRITE-OP(Θswr,∆ΘswrL(rA,DA)) (5) Θ̃swr = WRITE-OP(Θswr,∆ΘswrL(rB ,DB)) (6)
The independency of WRITE-OPs among different tasks make it hard to let multiple tasks update parameters consistently. Therefore, the shared space we finally learned is redundant and contaminated by task-specific features.

heading: 4.2 GRADIENT PASSING FOR MULTI-TASK COMMUNICATION
text: With above problems in mind, we propose to introduce a new inductive bias for inter-task communication, in which different tasks should tell others what modifications they have made to shared parameters. Additionally, their communication should support a new protocol that modifications induced by different tasks should be as consistent as possible.
To achieve the above idea, in this paper, we propose two types of approaches as a primary exploration, and hopefully, more effective methods can be put as future work.
Pair-wise Communication In this architecture, we only consider the communication of any two tasks. Specifically, for tasks A and B, they can explicitly send their gradient to each other, telling how they modified shared parameters. Simultaneously, the receiver should update parameters with the consideration of the other task’s modifications.
Formally, the model will first computed the gradient∇ΘswrLA based on task A, and then the gradient will be passed to task B.
READ-OP = OUT(θs̄wrB , ENC(XB , {Θ∗rB − θs̄wrB }, ∇ΘswrLA )) (7) In practice, the highlighted term can be used in different ways. Here, we utilize them to generate a fast weight φs based on Θswr: φs = g(Θswr,∇ΘswrLA) (8) where g can be a optimizer or parameterized function, which can be defined similar to many existing works relating to meta learning (Andrychowicz et al., 2016; Ravi & Larochelle, 2016; Finn et al., 2017).
Then, our optimized goal is to produce maximal performance on sample (XB ,YB) using the fast weight φs
LA←BGP = min Θswr L(DB , φs), (9)
Require: A set of training tasks {DTi}Ki=1, where Ti is drawn from p(T )
1: Initialize Θ := {θs, θp1 , · · · , θ p K} 2: while not done do 3: for Tk ∼ p(T ) do 4: Sample a batch of samples BTk = {X,Y } ∈ DTk 5: Evaluate gradients∇θs,θp
k Ltask(θs, θpk,B Tk )
6: Update parameters: θpk ← α∇θpkLtask 7: if Pairwise-Communication then 8: Sample a batch BTj = {X,Y } ∈ DTj . Tk 6= Tj 9: LGP = minθs L(BTj , ∇θsLk , θs) 10: else if Listwise-Communication then 11: Compute a weight list βk 12: for Tj ∼ p(T ) do . Tk 6= Tj 13: Lk←jGP = minθs L(B
Tj , ∇θsLk , θs) 14: end for 15: LGP = ∑ j∼T minθs β
k←jLk←jGP 16: end if 17: Update parameters: θs ← α∇θsLGP 18: end for 19: end while
Figure 3: Gradient Passing for Multi-task Communication. The superscript s and p represent parameters which can be shared or not (private).
List-wise Communication In this approach, each task Tk will be appended with a task list T = {T1, · · · , Tj , · · · , TK−1} (Tj 6= Tk) and a weight list βk = {β1, · · · , βK−1}, where βkj measures the relatedness between task k and j. Moreover, task Tk can communicate with any task from T . Formally, for task k, we pass its gradients to the other tasks and achieve maximal performance on corresponding samples Dj . Lk←·GP =
∑ j∼T min Θswr βk←jLk←j(Dj , φs),
(10) where Dj denotes training samples from task j, βk←j describes the task relationship between k and j, which can be pre-defined empirically or learned dynamically.
Empirical Methods for Obtaining Weight Lists We provide a simple way to compute β for these tasks which have similar output spaces, such as multiple domains or lan-
guages. we take turns choosing one task and use its training data to train a basic model (will be described as follows.). Then, we use the testing data of the remaining tasks to test the basic model. In this way, we can obtain a matrix V ∈ RK×K , in which each cell Vi,j stores the accuracy of testing task j, which is evaluated on model learned from training task i. We then update matrix V as following operation: for each column j:
Ṽi,j =
{ 1 i = j
v 1 q otherwise
(11)
where v = min{Vi,j/Vj,j , 1} and q is a hyper-parameter. Then Ṽi,j can be used as a weight βkj .

heading: 4.3 PUT IT ALL TOGETHER
text: We put task-oriented constraint Ltask and gradient passing LGP together, which can both learn private features and learn more universal shared rules, since explicitly gradient passing allow shared parameters to be updated in a more consistent way.

heading: 5 EXPERIMENT
text: In this section, we investigate the empirical performance of our proposed models on three groups of multi-task learning datasets: text classification (Multi-Sent) (Liu et al., 2017), image aesthetic assessment (Murray et al., 2012) (Multi-AVA), and sequence tagging. Each dataset contains several related tasks. The reason that we utilize these datasets is they can provide a sufficient testing ground (i.e. IN-TASK setting and OUT-OF-TASK setting).

heading: 5.1 TASKS AND DATASETS
text: In this section, we will give a brief description about evaluated tasks and datasets.
Text Classification This dataset contains different text classification tasks involving different popular review corpora, such as “books” and “apparel” Liu et al. (2017). Each sub-task aims at predicting a correct sentiment label (positive or negative) for a given sentence. All the datasets in each task are partitioned into a training set, development set, and test set with the proportions of 1400, 200, and 400 samples respectively.
Sequence Labelling We choose POS, Chunking, and NER as evaluation tasks on Penn Treebank, CoNLL 2000, and CoNLL 2003 respectively.
Image Aesthetic Assessment The image aesthetic assessment can be formulated as a classification problem of predicting an image high- or low-aesthetic categories within the supervised learning framework (Murray et al., 2012; Deng et al., 2017). The multi-domain AVA dataset contains 90,000 images covering 10 different domains For each domain, the data is split into training (6,000), validation (1,000), and testing (2,000) sets.

heading: 5.2 EXPERIMENTAL SETTINGS AND IMPLEMENTATION DETAILS
text: For Multi-Sent and Multi-AVA datasets, we randomly divide 10 tasks into two groups for IN-TASK setting and OUT-OF-TASK setting. As a contrast, each task will first be evaluated separately by corresponding base models. For text classification and sequence labelling tasks, the base models are implemented as (Liu et al., 2017) (LSTM encoder with MLP layer) and (Huang et al., 2015) (LSTM encoder with CRF layer). For image aesthetic assessment task, we adopt a 50-layer Residual Network (He et al., 2016) as the base model. Specifically, for an image I , it will be first vectorized into a feature vector x by the penultimate layer of residual network, which has been pre-trained on Imagenet. Then the obtained feature vector x will be passed into two-layer fully-connected layers, which followed by a softmax function.
Model Settings We evaluate models under two specific evaluation settings, including IN-TASK, OUT-OF-TASK. For OUT-OF-TASK setting, learned shared parameters will be combined with new parameters for a task, which has not be seen during training phase in IN-TASK setting. Then all the parameters will be learned with a few training samples of new task.
Besides, we select different combinations of READ-OPs and constraints of WRITE-OPs as basic multi-task learning frameworks, then investigate their effectiveness when gradient passing mechanism is introduced or not, which results in the following evaluated models:
• FR: Flat READ-OP with task-specific constraint. • SR: Star-network READ-OP with task-specific constraint. • ASR: SR with adversarial training and orthogonal constraints.
Our models are built upon FR and SR, and we use the prefixes “PGP” and “LGP” to denote pair-wise gradient passing and list-wise gradient passing respectively.

heading: 5.3 MAIN RESULTS
text: In-task Setting Tab.2 shows performances of our models on three groups of datasets. For in-task setting, we can obtain the following observations: 1) For different types of tasks, READ-OPs perform
diversely. For example, on Multi-Sent dataset, both flat and star-network READ-OP can achieve significant improvements compared with single task model. However, for tagging task, FR model (flat READ-OP ) works worse than single task model while the performance will be improved when SR is utilized. We attribute the reason to the higher discrepancy existing in tagging tasks. (The output space of each task in tagging is totally different.) 2) The performances of FR and SR can be significantly improved when gradient passing mechanism is introduced. Specifically, LGPSR outperforms other models on Multi-Sent dataset, which not only shows the effectiveness of propose methods but indicates the importance of taking relatedness of tasks into consideration. 3) PGP-SR and LGP-SR can surpass ASP both on Multi-Sent and tagging datasets, which suggests that it’s more effective for multi-task learning to allow different tasks to communicate by gradients.
Out-of-Task Setting This setting is designed to test the transferability of shared knowledge for different models. As shown in Tab.2, on Multi-Sent dataset, our model PGP-SR and LGP-SR can achieve comparable results with single task model, which is trained on 1600 samples, while we just use 200 samples. Additionally, on both Multi-AVA and Multi-Sent datasets, READ-OPs
with gradient passing mechanisms show better generalization to unseen tasks, which further suggests that our models can capture more universal features during the training phase in the IN-TASK setting.

heading: 5.4 ANALYSIS

heading: 5.4.1 IMPACT OF THE DIFFERENT NUMBERS OF TRAINING SAMPLES
text: For OUT-OF-TASK setting, we additionally investigate how the performances changes for different models as the number of training samples (#samples) changes. Specifically, here we plotted the accuracy curves of our model (LGP-SR) against two baselines SR and ASR on five text classification tasks. As shown in Fig.4, we can get following observations: 1) When #samples is less than 500, LGP-SR can achieve the fastest adaptation on last four tasks. 2) For each task, the highest performances are achieved by LGP-SR. Additionally, for “Camera,Health,Music,Video” tasks, the performance of MPS can surpass the model in single-task setting, where 1600 training samples are used. Notably, for “Camera, Music, Video” tasks, performances of LGP-SR can reach the grey horizontal line using half the training data.

heading: 5.4.2 EVOLUTION OF PARAMETERS
text: To get more intuitive understanding of how gradient passing mechanism influences the shared spaces, we visualize how the shared and private parameters’ values evolve under our model PGP-SR compared to the typical baseline SR. Specifically, we randomly chose two tasks “electronics” and “books” to train models SR and PGP-SR. Then, during the training phase, we projected the parameter space using PCA and plot their curves as the epoch increases. As shown in Fig.5, we can observe that: for SR model, when the updating directions of two private parameters are inconsistent, shared parameters will be updated along one of them. However, for PGP-SR as shown in Fig.5-(b), the updating direction of shared parameters is an integration of two private updating directions, which can prevent shared parameters from fitting more task-specific features.

heading: 5.4.3 BEHAVIOURS OF NEURONS IN SHARED LAYER
text: We can gain some insight into the internal mechanisms of gradient passing method by studying the neuron activations in shared layer h ∈ Rd as they process test set data of different tasks (d is the number of neurons). We were particularly interested in looking at which parts of words can be regraded as useful features by neurons in shared layer. To achieve this, we introduce a variable q for each word w, which is used to describe what the possibility is that the word can be regarded as a useful feature by neurons in h. Formally, we refer to nw as the times that w appears in test data and d is the number of neurons. Then, we define q = Nmax(nw×d) , where Nmax denotes how many times neurons achieve the highest activation on the word w. We compute q for each word in V with SR and LGP-SR models, in which V = {V1, · · · , V5} denotes the vocabulary of five test sets (in-task). We then divide V into two parts: the intersection of five sub-vocabularies ⋂5 i Vi and its
Settings Features⋂5 i Vi
SR definitely, excellent, gift, doesnt, fantastic, wonderfully, awesome, pleased, perfectly,alright LGP-SR disappointed, doesnt, reliable, sucks, excellent, pleased, regret, fantastic, perfectly, amazing⋂5
i Vi SR Brosnan, boils, mixes, Lasko, sauce, straightened, breathable, distinctly, havent, sweatpants LGP-SR richness, dissatisfied, havent, roaster, overlong, doesnt, meaty, easiest, orginally, buzzes
Table 3: Top-10 word features in share space with high values of q on two parts of vocabularies. The shared spaces are constructed by SR and LGP-SR models respectively. ⋂K i 5i denotes the intersection
of five sub-vocabularies and
⋂5
i Vi represents its complement. complement ⋂5 i Vi, which allows us to easily analyze the characteristics of learned features in shared space between two models 1.
Tab.3 shows the top 10 word features with high values of q on two parts of vocabularies and we can obtain the following observations: 1) Both SR and LGP-SR can easily pick up useful and sharable words in ⋂5 i Vi. According to our statistics, there are 1073 words in ⋂5 i Vi, and we find the words with high values of p do make sense. For examples, the words with higher ranking “excellent, disappointed, doesnt” are key patterns for all tasks to make prediction of one sentence’s sentiment. 2) For words in ⋂5 i Vi, the SR model mistakenly regards more words involving task-specific information as sharable features, such as the name “Brosnan” and entity “sauce”. By contrast, LGP-SR still can pick up useful words such as “dissatisfied, havent, overlong”.

heading: 6 CONCLUSION
text: In this paper, we introduce an inductive bias for multi-task learning, allowing different tasks to pass gradients explicitly, which makes it available to restrict different tasks make consistent parameter updating. In this way, we can avoid the leakage of private information into the shared space The empirical results not only show the effectiveness of our proposed method, but give some insight into its internal mechanisms.

heading: 7 APPENDIX

heading: 7.1 EXTRA CONSTRAINTS FOR WRITE-OPS
text: Adversarial Constraint This loss is used to encourage shared space more pure,
LAdv = min {Θswr−θswr} ( max θswr L(OUT(θswr, ENC(Yk, {Θswr − θswr}))) )
(12)
where Yk represent the true labels for the types of current tasks.
Orthogonal Constraint This constraint introduce an inductive bias that shared and private feature space should be more orthogonal.
LDiff = ∥∥∥Sk>Pk∥∥∥2
F , (13)
where ‖ · ‖2F is the squared Frobenius norm. S k and Pk are two matrics, whose rows are the output of shared extractor OUT(X k,Θswrk ) and task-specific extractor OUT(X k,Θs̄wrk ) of an input sentence.

heading: 7.2 PARAMETER DESCRIPTIONS WITH OCTANT
text: Intuitively, for parameters, different cases of modes can be described in an octant. And Fig. 6(a-c) illustrate three typical learning models: single task models, mulit-task model with hard-sharing and multi-task model with soft-sharing.

heading: 7.3 TRAINING AND HYPER-PARAMETERS
text: Image Aesthetic Assessment On this task, we randomly crop out a 224 x 224 window to feed into the ResNet-50, which is pre-trained on ImageNet dataset. We utilize the SGD, Adam to optimize the parameters with the fixed learning rate 0.001 for the classification task and regression task, respectively. The mini-batch size is 96 and the number of iterations is 128. The Weight list βk for Multi-AVA can be seen in Tab.4.
Text Classification and Tagging The word embeddings for all of the models are initialized with the 200-dimensional GloVe vectors (840B token version (Pennington et al., 2014)). The other parameters are initialized by randomly sampling from the uniform distribution of [−0.1, 0.1]. The mini-batch size is set to 8. We apply stochastic gradient descent with the diagonal variant of AdaDelta for optimization (Zeiler, 2012). The Weight list βk for Multi-Sent can be seen in Tab.5. For tagging task, we regard each task equally.

Review summaries:
In this paper, the authors propose a general framework for multi-task learning (MTL) in neural models. The framework is general for including some of the current neural models for MTL. Under the framework, the author propose a new method that could allow tasks to communicate each other with explicit gradients. Based on the gradients being communicated, the system could adjust the updates of one task based on the gradient information of the other task. Also, prior task relatedness information could be incorporated to the system.