Venue: NeurIPS 2021 Conference

Reviews:

final_score: rating: 7: Good paper, accept
review_content: summary: The paper proposes a new solution to multi-task learning  that should improve in cases with gradients conflict of a task loss and the average loss gradient. The solution optimizes for an update vector that maximizes the worst task loss relative improvement. Experiments show the superiority of the proposed solution over similar prior methods.

main_review: The paper is very well written and easy to follow. 
The proposed solution is sound and seem to overcome the existing optimization difficulties of multi-task learning.
Extensive experiments are carried on, targeting different interesting questions. 
Method performance is superior or comparable to existing methods. 
The main down side is the optimization for an update vector after each update, however, the authors proposed a dual objective with the number of optimized parameters equal to the number of tasks being learned.  Further an approximation is proposed to reduce the computation cost where random tasks are selected for the optimization. This alternative is comparable in performance to existing methods. 

On line 88, first order Taylor approximation is used but no discussion on this choice.
Line 95, a hyperparameter is introduced with no discussion its role. However, in the experiments section it is effect is shown empirically. 
The practical speedup  is not well motivated and justified.
limitations_and_societal_impact: NA
review_title: null

final_score: rating: 5: Marginally below the acceptance threshold
review_content: summary: Multi-task learning (MTL) is an efficient way of learning multiple tasks efficiently by training all tasks together, amortizing their cost by sharing some parameters across tasks. In order to perform this, a weighted sum of the task losses is usually optimized, which can lead to poor final results due to sub-optimal optimization, an effect produced by the competition between tasks for the shared resources. Specifically, when computing the gradient updates for the shared resources, gradients of different tasks can conflict with each other, cancelling each other out (an effect known as *conflicting gradients*).

This work introduces CAGrad, an algorithm which minimizes the average loss function (the network's loss), while maximizing the worst local improvement across all tasks, provably converging to a local minimum of the average loss. This algorithm results in a generalization of the usual gradient descent, as well as the MGDA algorithm. Empirical results show the effectiveness of the method.
main_review: **Clarity and significance:** I enjoyed reading this paper. I think the paper is well-structured and well-presented, making it joyful to read. This is also partly because of its significance, as I can see CAGrad being impactful and used by the community, resulting in a strict improvement over MGDA. When it comes to the way CAGrad is described and introduced, while everything said is true, I find it a bit misleading. For me, it was way more interesting and clarifying to read the remark in line 339 of the appendix:
> The major difference between MGDA and CAGrad is that the new update vector d is searched around the 0 vector for MGDA and $g_0$ for CAGrad.

This line and the results in that page made me better understand CAGrad and its connections with MGDA, and I truly believe this should be put into the main text.

**Related work and experimental comparisons:** This is one of the weakest points of the paper. While the paper does a good job at presenting PCGrad and MGDA, it leaves out several works completely related with the topic of the paper:
1.  [GradNorm](http://arxiv.org/abs/1711.02257) is mentioned but never compared with (GradNorm's goal is to normalize gradients, and it scales losses just because the gradient is a linear operation). 
2. [IMTL-G](https://openreview.net/forum?id=IMPnRXEWpvr) is another method for gradient scaling which is not even mentioned.
3. [RotoGrad](https://arxiv.org/abs/2103.02631) is a method that focuses on reducing negative transfer by aligning task gradients.
4. [GradDrop](https://proceedings.neurips.cc//paper_files/paper/2020/hash/16002f7a455a94aa4e91cc34ebdb9f2d-Abstract.html) is another gradient conflicting solution, contemporary to PCGrad, which solves the issue by randomly dropping gradient elements based on a sign-purity score.   

**Working on the last-shared representation:** Most of these recent works address the inherent scalability issues of modifying the gradients of the shared parameters by simply modifying those of the last shared representation (the output of the backbone). Whilst I am not entirely sure how this would apply in the case of using MTAN rather than a usual hard parameter-sharing architecture, I am surprised that this was not thought as a way of scaling CAGrad. 

This overlook is even more surprising since the authors claim to compare with the MGDA version of Sener et. al (e.g. in Table 4) rather than the one originally proposed by Jean-Antoine Désidéri. Both papers are mentioned in the manuscript, and my understanding is that the main contribution of the paper of Sener et. al. was proposing MGDA-**UB** (upper-bound), which showed that MGDA could scale for MTL settings by working on the output of the backbone. In reality, here CAGrad is compared with the original MGDA algorithm by Désidéri.

**Experiments.** While the experiments are well described, I have some questions for the authors:
- Why using a shrunk version of LeNet?
- How did you choose the parameters for the FashionMNIST experiments? I have worked with very similar datasets and with 50 epochs convergence was not guaranteed. I would like to know why there are only 3 independent runs in such a simple experiment?
- Do you apply some kind of loss normalization to ensure that losses have comparable values?
- Regarding this last question, I find Figure 4 really confusing. You attempt to minimize the average of the losses, and so one could expect that the optimum of the average of the losses is achieved when both tasks losses are equal (at the end, "you care the same" about both losses), which is what MGDA achieves. I think this figure would be way more understandable (and therefore the discussion) if you showed the results normalizing each task by their initial loss during training.
- Why did you choose c based on the *training* loss instead of the validation loss? This should not be the case.
- Did you run MTAN on NYUv2 with data augmentation? This was included in the official repository of MTAN.

**Minor comments:**
- Caption on tables should be placed above the table.
- Eq. (2) is a bit confusing, I would rather see the first part written as $min \{\frac{1}{\alpha} (L_i(\theta) - L_i(\theta - \alpha d))\}$. 
- MTAN references are wrong in the experiments. 
- Figure 3 is hardly readable. I would remove the right-most and increase the size of the rest.

I think this is a great paper with a lot of potential, and I will be happy to increase my score if the problems raised above are addressed.

---

**Update:** While I have few concerns when it comes its technical part, I still remain concerned regarding the way the paper presents existing work. It is missing important baselines (e.g. IMTL-G) and completely omits any reference to the set of methods that work on only the last shared representation of the architecture. 

I do not feel this is properly justified after rebuttal. First, if not comparing with it, this line of work should be mentioned as it is relevant. Second, in the response this was justified by the chosen experimental setup, but to me this is upside-down: the experimental setup should be chosen to compare with all relevant methods, and no the other way around.

I am thus lowering my score to 5 as I expected a better justification by the authors and I am afraid that, given the nice quality of the paper, it is likely to get some attention and as a consequence harm relevant (and future) work by omitting any reference to prior approaches.
limitations_and_societal_impact: I find the discussion of the limitations of the work rather disappointing. In practice, MGDA is slow when it comes to time complexity (because of solving $min_\omega ||g_w||$). This term also appears in CAGrad, does that mean that CAGrad also suffers the same overhead? Why? (lines 244 to 246 make me think so)
review_title: null

final_score: rating: 7: Good paper, accept
review_content: summary: This work presents a first-order multi-task learning method which uses, in place of the average task gradient, a vector which maximises the minimum local single-task improvement in a neighborhood of the average task gradient.

In multi-task learning, the goal is to find the optimal point achieving low losses across all tasks. However, gradient descent methods commonly used for single tasks in computer vision and reinforcement learning achieve suboptimal performance when applied on the average task loss due to conflicting gradients (single tasks gradients pointing in opposite directions). Recently, several methods have proposed modification to the update direction that alleviate this problem. However, these methods are either heuristics or can converge to any point in the pareto optimal set of the task losses (e.g. MGDA [5]), which might not be a minimum of the average task loss. 

The proposed method, called Conflict-Averse Gradient descent (CAGrad), introduces an additional hyperparameter $c \geq 0$ which allows to interpolate between gradient descent ($c = 0$) and MGDA ($c \to \infty$). Furthermore, CAGrad provably converges to a stationary point of the average task loss with the same rate as gradient descent (when $c < 1$) or to a pareto stationary point (when $c \geq 0$). At each step of the method, the update direction is obtained by solving  an optimization problem in $K$ dimensions, where $K$ is the number of tasks, but has an overhead comparable to state of the art multi-task learning methods of the same kind (see last plot of Figure 5). Experiments on several computer vision and reinforcement learning multi-task benchmarks, where the method is used to optimize deep network parameters, show that the method achieves state of the art performance in all the settings.

main_review: #### **Originality**
1. The method can be considered a fairly straightforward extension of MGDA [5] and it seems novel.  Related works are appropriately cited and it is very clear how the proposed approach compares to them. However, I am not very familiar with recent progress in multitask learning. Contributions are clearly stated in lines 43-51 but I have doubts on some of the claims (see quality section). 

#### **Quality**

2. The authors claim that when $c -> \infty$ the algorithm is equivalent to MGDA [5] (line 107). However, while intuitively minimizing $F(w)$ will correspond to the same minimization problem solved by MGDA, the final update direction will be scaled by $\sqrt{\phi} = c ||g_0||$.

3. The authors write that one of the main advantages of the method is that it has convergence guarantees to the stationary point of the average task loss, which PCGrad and MGDA lack. While this is true for MGDA it is usually not true for PCGrad, which either converges to a stationary point of the average task loss or to a point where the directions of the task gradients cancel out [34], although the latter does not usually occur in practice when taking stochastic gradients. 

4. All methods in Tables 1 and 2 achieve largely better performance than what is reported in [34]. Why is that? I think this should be discussed in the paper.

5. The proofs before the convergence analysis section seem correct. Theorem 3.3 in the main is different from the one in the supplementary. I will assume the latter to be the correct one. Theorem 3.3 1)  (convergence to stationary point of average task loss with $c < 1$) is proved correctly while the proof for 2) (all fixed points of the method are pareto stationary) is not clear to me: I could not understand how a fixed-point of the algorithm is a pareto stationary point when $g_0 (\theta) = 0$ (lines 382 and 383). 2) is a fundamental result of the proposed method, without it even if you can show that when $c \geq 1$ the method converges you cannot guarantee for it to converge to a pareto stationary point. Furthermore the convergence with $c \geq 1$ is guaranteed (in the supplementary) with time-varying step sizes not used in the experiments or discussed. In the realistic experiments $c < 1$.

6. The experiments are extensive and show a clear advantage of CAGrad in all settings considered. However, the authors should discuss more about the introduced hyperparameter $c$ and how much it is difficult to tune, as a potential limitation of the approach. Note that PCGrad and MGDA, which are the main contenders, have the same hyperparameters as gradient descent.  The experiments in Section 5.1 only study the final training loss varying $c$ for a single artificial setup and the toy example, while the other experiments select the best $c$ looking at the average training error and the optimal value varies largely among different scenarios. Including sensitivity analysis for $c$  in some of the realistic settings and discussing this limitation in the conclusion could address this issue.

#### **Clarity**

7. The main paper is well written and easy to follow. I really appreciated the toy example in Figures 1 and 3 and the illustration in Figure 2 which visually compare CAGrad with other methods. The supplementary was less clear and contained more typos.

#### **Significance**
8. Studying multi-task learning is important to widen the scope of applicability of machine learning models. This work develops a principled, efficient and effective method which can be applied in combination with deep learning models and optimizers and thus it is important for a large part of the machine learning community. 

#### **Final Score**

9. I am giving a 5. The proposed method seems promising but the theoretical justification  is lacking and I have some doubts on the experiments. However, I am not very familiar with the topic and I am willing to increase the score if the authors properly address my concerns in the quality section.


#### **Additional comments**

10. In some parts of the paper, like the abstract and intro it is written that the method converges to a minimum or to optimal points. It would be better to say that it converges to stationary points instead since the single task and the average task losses are non-convex both in the theoretical results and in the experiments.

11. eq. (2) and (3) could be misleading. Going forward in the paper shows that the objective that the authors actually minimize is the LHS of (3) but this could also be said close to line 94.
 
12. Line 199. The authors could briefly describe what the two tasks are (one is to classify the MNIST image and the other to classify the Fashion mnist one).

13. Figure 4. I think that using the same set of seeds for the algorithms could help to make the point more concrete.

14. An interesting addition would be the comparison/discussion on MGDA-UB, which seems to greatly improve the time complexity of MGDA by using an upper bound on the objective used to obtain the update direction. Can a similar upper bound be derived for CAGrad?

#### **Post Rebuttal**
The authors have addressed very well my concerns in the quality section of the review by conducting experiments which analyse the newly introduced hyperparameter c and clarifying parts of the paper I did not fully grasp before. Thus I am increasing the score from 5 to 7 and the confidence from 2 to 3.

#### **References**

[5] Jean-Antoine Désidéri. Multiple-gradient descent algorithm (mgda) for multiobjective optimization.Comptes Rendus Mathematique, 350(5-6):313–318, 2012.

[25] Ozan Sener and Vladlen Koltun. Multi-task learning as multi-objective optimization. arXiv preprint arXiv:1810.04650, 2018.


[34] Tianhe Yu, Saurabh Kumar, Abhishek Gupta, Sergey Levine, Karol Hausman, and Chelsea Finn. Gradient surgery for multi-task learning.arXiv preprint arXiv:2001.06782, 2020.

limitations_and_societal_impact: The authors address some but not all the limitations of the method. They do not discuss enough about the newly introduced $c$ hyperparameter which is absent in related methods (see point 6 of the main review). 

The authors write in the checklist that their work does not have a negative societal impact. I agree
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: Authors propose a multitask learning approach to reduce gradient conflict by minimizing harm to the worst-performing task given any gradient update. Proofs are provided for convergence and pareto optimality of the resultant weight configuration. Experiments are run on a variety of settings, including computer vision and multitask reinforcement learning, with good results throughout.

main_review: Overall, I enjoyed reading this paper and find the analysis to be exciting. The results themselves are rather marginal/middling, but given that these are complicated models and multitask learning is known to be quite a messy, high-variance problem setting, I'm happy to be a bit lenient on that. I am glad to see the mathematical analysis and general intuition behind the method, although I have some concerns regarding various elements (including motivation, robustness, and compute overhead). As a lot of this is more clarifications on the method and presumably addressable within the author response, I think the ideas within the paper could be worthwhile to publish at NeurIPS. 

(1) My biggest issue with the idea is that I suspect converging to an optimum of the average loss is not necessarily a desideratum. Indeed, given that there is so much literature around balancing loss function weights (MGDA, Uncertainty Weighting, GradNorm, etc.), I suspect that CAGrad is quite brittle when loss function magnitudes are off-balance. MGDA may not converge to the average loss minimum, but that's a feature not a bug, as MGDA is premised on the idea that relative loss magnitudes need to be retuned. For instance, one could arbitrarily increase weight to one loss function until the network is dominated by that task, and in that case it seems that finding a stationary point of the average loss will be a bad idea. So why should we actually want to fit to the average of arbitrarily weighted loss functions?

(2) Have authors tried some of the loss balance methods (listed previously in (1)) in tandem with CAGrad? At the very least it would be nice to benchmark CAGrad against those balancing methods, which I noticed the authors did not do across their different benchmarks. 

(3) It would also be interesting to see a benchmark against Gradient Sign Dropout (https://arxiv.org/abs/2010.06808) which is a stochasticity-based method that appeared at NeurIPS last year and was shown to outperform PCGrad in some settings. This particular method at a very high level sparks some similarities as it also starts with the average gradient an then makes slight adjustments based on where the gradient vectors disagree.

(4) Only a computational efficiency comparison is provided between CAGrad, PCGrad, and MTAN. Notably, both CAGrad and PCGrad require multiple full backpropagation passes, while other methods like MGDA, Gradnorm, etc. mitigate the computational overhead by only requiring the backpropagation back to a downstream activation layer. Could authors provide computational comparisons to those methods as well, as this efficiency is some cause for concern?

(5) Authors sweep their main hyperparameter through 10 values - did they take this into account when calculating statistical significance between CAGrad and other baselines?

(6) Is the primary reason for focusing on the worst-case gradient so that the dual problem formulation would work out? Or is there a more intuitive non-mathematical reason for why this is the right optimization problem to solve?

(7) There is always an interesting disconnect in gradient-based MTL methods where the method itself is optimized on the training set while the experiments are all run on the test set. Could the authors comment on potential drawbacks of overfitting to the average loss in the context of generalizability?

(8) Given that there are quite a large corpus of papers at this point that talk about gradient conflict for MTL, the title of the paper is rather ambiguous. Maybe modifying it to explicitly mention the minimax nature of the proposed method would be more appropriate. 

**Post-review**: Thanks to the authors for their thoughtful response. I think it is an interesting paper, and I think I am in agreement with authors that further work on loss scaling could further improve the work. As it is now I will maintain my rating at a 6.

limitations_and_societal_impact: Yes
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This work proposes a method to reduce conflicting gradients during training of multi-task learning paradigms via gradient modification. Rather than simply take an average of the per-task gradients, the authors propose to learn a model-wide gradient direction $d$ to update the shared parameters by solving a dual objective to find per-task loss weights. Simply, the proposed method (CAGrad) finds a direction which maximizes the worst local improvement among all tasks, and then applies this gradient update to the shared parameters. 
main_review: This work naturally builds on prior efforts (notably MGDA and MOO) to propose a new algorithm inspired by past work on conflicting gradients (PCGrad) that simply tries to maximize the smallest per-objective change in loss after applying a gradient update (i.e. maximize the worst local improvement among all tasks). The paper is incredibly well-written and easy to read/understand. 

It is my opinion that this method is not especially novel or surprising; however, strong empirical findings as well as comprehensive theoretical analysis could more than make up for the lack of novelty. The theoretical results are compelling, while the author's suggested speed-up by sampling a subset of tasks to reduce training-time overhead is also welcome. Nevertheless, there are several areas where the paper could be improved. 


-------------
Quite a bit of recent related work is missing from this paper. For instance, recent methods improving upon PCGrad (namely [1] and [2]) are entirely absent. 

[1] Just Pick A Sign: Optimizing Deep Multitask Models with Gradient Sign Dropout (NeurIPS, 2020)

[2] Gradient Vaccine: Investigating and Improving Multi-task Optimization in Massively Multilingual Models (ICLR, 2021)

Similarly, the concept of exploring the rate of loss decrease to modify optimization processes has been recently explored in [3] and equation (2) of this paper is remarkably similar to Line 2 of Equation (3) in [4]. 

[3] Measuring and Harnessing Transference in Multi-Task Learning

[4] Adaptive Auxiliary Task Weighting for Reinforcement Learning

-------------

I would also ask the authors to address the following concerns:

1. **Comparison with prior work.** From Section 5.2, it seems as if Uncertainty Weights are not added to PCGrad to create a "fair comparison"; although PCGrad uses this augmentation for all results reported in their paper.  Given CAGrad solving for $w^{*}$ at every step, thereby dynamically changing the loss weights, how is this fair? Am I missing something? 

2. **Loss values as a function of time.** Plotting the train loss as a function of steps to show overfitting/underfitting is not occurring on MultiMNIST for any of the methods presented in Figure 4. Providing the analogous plots for Figure 5 (test loss on NYUv2 and Cityscaps) would also strengthen this paper's empirical findings. 

3. **RL Training efficiency.** Similar to point 2, reformulating Table 3 in a similar manner to PCGrad's Figure 3 would be helpful for understanding the relative learning efficiency and convergence of CAGrad.

4. **Hyperparameter tuning discrepancies.** Is the hyperparameter tuning of $c$ done for the experimental results analogous to hyperparameter tuning of the learning rate? Would it be appropriate to tune the learning rate for the other baseline methods in a similar manner (such that the total update magnitude is roughly equivalent, a small grid search over the learning rate)? 

5. **Runtime Comparison with PCGrad.** Is the training-time comparison to PCGrad in Figure 5 fair (i.e. using the efficient vectorized_map implementation by the official repo)? How are the quantities so different (600 -- what I assume to be minutes..? compared with just over 400) when both methods take the gradient w.r.t. each task? How does training time compare on MultiFashion/MNIST? What type of hardware is used (see Checklist item 3d)? 

For these reasons, I think the experimental results, as presented, are insufficient. I am happy to revise my review during the rebuttal if they can be resolved to strengthen this facet of the paper.
limitations_and_societal_impact: The authors did not discuss the societal impacts of their work. I think they could consider the possible ramifications as done in similar NeurIPS publications on this topic (see [1] and [5]). 

[5] Gradient Surgery for Multi-Task Learning (NeurIPS, 2020)
review_title: null

Meta-review: The manuscript is proposing a multi-task learning method using multi-objective optimization. The proposed algorithm extends the MGDA line of work by simply changing the objective from finding a descent direction that is consistent with all objectives to finding a descent direction that is consistent with all objectives and closest to the average gradient. The proposed algorithm is later analyzed theoretically with Pareto stationarity and convergence guarantees. The authors provide an extensive empirical study with very promising results. Reviewers all enjoyed reading the paper and appreciated the algorithm. Most of the major issues about the paper are on the set-of-baselines side which the authors addressed successfully with additional experiments during the rebuttal perior. I believe the paper is interesting and warrant acceptance.
Decision: Accept (Poster)