Fantastic Multi-Task Gradient Updates and How to Find Them In a Cone

Chao Gao; Chunhua Zhou; Kunlin Zhang; Muhammad Kamran Janjua; Negar Hassanpour; Sepehr Lavasani; Xiaowen Zhang

REVIEW 4 major objections 5 minor 29 references

Fantastic Multi-Task Gradient Updates and How to Find Them In a Cone

T0 review · 4 major / 5 minor · reviewed 2026-08-09 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that a closed-form conic-constrained gradient update can balance conflicting multi-task gradients, converge at an O(1/T) rate on the reference objective, and stay cheap in high-dimensional parameter spaces.

desk verdict A neat computational trick and solid empirical sweep are undermined by a load-bearing algebra error: the derived update does not satisfy the paper's own cone constraint, so the theory and the geometric claims collapse. read the letter →

arxiv 2502.00217 v1 pith:DNC3O576 submitted 2025-01-31 cs.LG cs.AIcs.CV

Negar Hassanpour , Muhammad Kamran Janjua , Kunlin Zhang , Sepehr Lavasani , Xiaowen Zhang , Chunhua Zhou , Chao Gao This is my paper · ORCID

classification cs.LGcs.AIcs.CV MSC 68T0790C2990C46

keywords multi-tasklearninggradientconflictsconstrainedoptimizationangularconstraintmulti-objectiveconvergenceguaranteeSherman-Morrisonformulaupdate

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Multi-task learning fails when task gradients point against each other, and ConicGrad tries to fix this by computing one update vector per step that maximizes the worst task-specific progress while keeping the update inside a cone around the mean (reference) gradient. The paper derives a closed-form solution for this constrained problem, replacing an expensive inner optimization with a scalar inverse via the matrix inversion lemma. It claims an O(1/T) convergence rate for the reference loss under standard smoothness assumptions, and reports strong average per-task improvements over a dozen baselines on NYUv2, CityScapes, CelebA, and MetaWorld MT10. If the derivation holds, the method gives practitioners a cheap, scalable gradient-aggregation rule with an explicit geometric meaning: the cone angle c is the maximum allowed angular deviation from the average gradient.

What carries the argument

The load-bearing object is the closed-form cone-restricted gradient $d^* = (c^2\|g_0\|^2 I - g_0 g_0^\top)^{-1} g_\omega$, a rank-one perturbation of a scaled identity matrix. The matrix inversion lemma reduces its inversion to a scalar division, so the per-step cost stays close to the cost of computing the task gradients themselves. The cone angle $c$ directly encodes how far the update may deviate from the reference gradient, and the simplex weights $\omega$ are adjusted on the dual objective, which is the piece that keeps the method from merely reproducing the average gradient.

What would settle it

Take a two-dimensional two-task problem with $g_1=(1,0)$ and $g_2=(0,1)$, so $g_0=(1/2,1/2)$. At ConicGrad's initialization $\omega=(1/2,1/2)$, Equation (8) gives $d^* = -g_0/((1-c^2)\|g_0\|^2)$, which is anti-parallel to $g_0$. Measuring the cosine $\langle g_0, d^*\rangle/(\|g_0\|\|d^*\|)$ for any $c\in(0,1]$ would immediately show whether the declared cone constraint holds; if the cosine is negative, the closed form does not implement the constraint it was derived from.

Watch

Extended reading notes

Core claim

The central claim is that the update vector $d^* = (c^2\|g_0\|^2 I - g_0 g_0^\top)^{-1} g_\omega$, with $\lambda$ set to 1 and $\omega$ optimized over the simplex, solves the max-min problem $\max_d \min_i \langle g_i, d\rangle$ subject to $\langle g_0, d\rangle/(\|g_0\|\|d\|) \ge c$. ConicGrad treats this as a Lagrangian dual whose Slater condition holds for $c<1$, computes $d^*$ inexpensively using the Sherman-Morrison-Woodbury identity, normalizes $d^*$ to the norm of $g_0$, and updates the task weights $\omega$ by one step on the dual objective before every parameter update. The paper further claims that under $L$-Lipschitz gradients and a bounded-below reference loss, this schedule drives the reference gradient norm to zero at rate $O(1/T)$, and that setting $c=1$ collapses the method to plain gradient descent.

Load-bearing premise

The derivation assumes that requiring the update to point within angle $\arccos(c)$ of the reference gradient is equivalent, inside the Lagrangian, to the squared double-cone inequality $c^2\|g_0\|^2\|d\|^2 - (g_0^\top d)^2 \le 0$, even though that quadratic condition also admits updates pointing opposite to $g_0$.

Editorial extensions

If this is right

Multi-task training can use a single closed-form update per step, so the per-step cost stays close to one forward-backward per task rather than an inner optimization loop.
The reference loss converges at $O(1/T)$, matching gradient descent's rate while still allowing task-specific trade-offs through the simplex weights.
Because the cone angle $c$ is explicit, users can tune the trade-off between alignment with the average gradient and freedom to resolve conflicts; $c=1$ recovers plain gradient descent.
On the paper's toy benchmark, all five listed initializations reach the global minimum, and ConicGrad reaches it in fewer training steps than the compared baselines.
The same update rule transfers from dense-prediction benchmarks to a 40-task classification benchmark and multi-task reinforcement learning, with the reported MT10 success rate close to the single-task upper bound.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorial extension, not in the paper: the same rank-one inversion trick would apply to any gradient-combination constraint that can be written as a cone together with a scale-invariant norm, potentially simplifying other multi-task update rules.
Editorial extension: the paper leaves dynamic selection of $c$ for future work; a natural testable variant is to anneal $c$ upward during training because the $O(1/T)$ bound suggests early steps tolerate wider cones while later steps need tighter alignment.
Editorial extension: since the closed form depends only on $g_0$ and $g_\omega$, ConicGrad's computation is compatible with gradient accumulation or compressed communication, so measuring wall-clock speedup in communication-limited settings would be a direct stress test.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The short version: the paper has one genuinely useful piece—the Sherman-Morrison-Woodbury closed form for the update—and a broad, honest empirical study, but the central derivation is wrong in a checkable way. Equation (4) is not the Lagrangian of Equation (3). The quadratic c^2||g0||^2||d||^2 - (g0^T d)^2 <= 0 defines the double cone |cos| >= c, not the single cone >= c||g0||||d||. With the algorithm's own uniform initialization, gω = g0, and the closed form gives d* = -g0/((1-c^2)||g0||^2), which is anti-parallel to g0. So the first computed direction is normalized gradient ascent on the reference loss, not a descent inside a cone. That is not a subtle sign slip; it means the closed form, the feasibility argument, and Theorem 3.2's reliance on g0^T d* >= c||g0||||d*|| all fail.

To give credit where it is earned: the SMW trick is real and makes the update cheap, the omega-subproblem is a reasonable way to adapt task weights, and the paper evaluates on standard supervised and RL benchmarks with three seeds and error bars for the proposed method. The MT10 number (0.89 ± 0.02) is interesting, and the per-epoch scaling plot is useful. The citations to CAGrad, SDMGrad, and the rest are fair; the paper says outright that the cone is a cousin of those constraints.

The soft spots, in proportion: the primal in Equation (3) is unbounded whenever any feasible ray improves all tasks, since there is no norm bound. The Lagrangian inner maximization is also unbounded for λ > 0 because Z has a negative eigenvalue along g0. The authors' own Appendix A.2 concedes that no finite λ optimizes E(λ) and simply sets λ = 1; that is a free parameter, not a derived constant. The convergence theorem is stated for -1 <= c <= 1, but the proof needs 2κc - 1 > 0, which fails for c = 0.25 (their CityScapes setting) and for all negative c. These are internal inconsistencies, not just disagreements with prior work. The empirical wins are also sometimes within one standard error of the runner-up, and per-dataset c and γ choices carry real weight, as the ablation shows.

Who should read it: people working on gradient surgery might find the SMW trick worth borrowing, but they should not build on the convergence claims. The paper as written does not support the headline theory. I would send it to a serious referee—the empirical variant might be salvageable as a heuristic—but the referee report should ask for a corrected derivation or a reframing that drops the theoretical guarantees.

Referee Report

4 major / 5 minor

Summary. The paper proposes ConicGrad, a multi-task gradient balancing method that, at each optimization step, solves max_d min_i <g_i, d> subject to a cone constraint confining d within angle arccos(c) of the reference gradient g0. It claims a closed-form update via a Lagrangian and matrix inversion (Eq. (8)), an efficient Sherman-Morrison implementation, an O(1/T) convergence guarantee (Theorem 3.2), and state-of-the-art empirical results on NYUv2, CityScapes, CelebA, and MetaWorld MT10. The empirical section includes a toy example, supervised MTL benchmarks, an RL benchmark, scalability experiments, and hyperparameter ablations.

Significance. If the closed-form update were valid, ConicGrad would offer a useful and cheap alternative to CAGrad, FAMO, NashMTL, and SDMGrad: one matrix-vector product per step, no inner optimization loop, and a convergence guarantee. The empirical study is reasonably careful in its use of standard benchmarks, three seeds, and reported standard errors in Appendix D.1. However, the central derivation of Eq. (8) is algebraically invalid: the quadratic relaxation in Eq. (4) replaces the single cone by a double cone, and the resulting closed form violates the declared constraint under the algorithm's own initialization. Because the closed form, the geometric interpretation, and the convergence proof all rely on this equivalence, the paper's main theoretical claims do not stand. No code is released, so the empirical results are not independently checkable from the manuscript.

major comments (4)

[Section 3, Eqs. (3)-(4)] The constraint in Eq. (3), for c>0, is g0^T d >= c||g0||||d||, which requires d to be positively aligned with g0. The quadratic inequality in Eq. (4), c^2||g0||^2||d||^2 - (g0^T d)^2 <= 0, is equivalent to |g0^T d| >= c||g0||||d||, i.e., a double cone that also admits vectors anti-parallel to g0. Squaring loses the sign information, and d=0 satisfies the quadratic but not the original constraint. Therefore Eq. (4) is not the Lagrangian of Eq. (3), and Proposition 3.1, which derives d* from stationarity of Eq. (4), does not solve the declared problem.
[Section 3, Eq. (8) and Algorithm 1] Under Algorithm 1's initialization, omega is uniform, so g_omega = g0. For Z = c^2||g0||^2 I - g0 g0^T, direct algebra gives Z^{-1} g0 = -g0 / ((1-c^2)||g0||^2), hence g0^T d* = -1/(1-c^2) < 0 for every c in (0,1). After the normalization d~ = d* ||g0||/||d*||, the update is d~ = -g0/||g0||, so theta <- theta - eta d~ = theta + eta g0/||g0||, which is normalized gradient ascent on the reference loss, not descent within the declared cone. No argument in the paper shows that the subsequent omega update (Eq. (9)) restores the cone constraint, and the convergence proof simply assumes g0^T d* >= c||g0||||d*||. The closed-form claim, the geometric interpretation in Section 3.3, and Theorem 3.2 therefore do not follow.
[Section 3, Eq. (5) and Appendix A.2] Strong duality is not available for the reformulated problem. For fixed lambda>0 and any omega, the inner maximization over d in Eq. (5) has quadratic form -lambda/2 d^T Z d; since e = g0/||g0|| satisfies e^T Z e = -(1-c^2)||g0||^2 < 0 for c in (0,1), the objective is unbounded above along the ray +/- t g0. Appendix A.2 confirms that no finite lambda optimizes E(lambda) and simply sets lambda=1, which makes lambda an additional free parameter rather than a derived Lagrange multiplier. This undermines the claim that Eq. (8) is a principled optimal solution of Eq. (3).
[Theorem 3.2 and Appendix A.3] The convergence proof requires the coefficient 2κc - 1 to be positive (with κ=1 after normalization, 2c-1>0), but the theorem is stated for -1 <= c <= 1. For c <= 0.5 the right-hand side of Eq. (15) is nonpositive, so the bound is meaningless; the CityScapes experiments use c=0.25 (Appendix D.1), where the theorem does not apply. The proof also relies on the unproven assertion ∥d*∥ ≈ κ∥g0∥ and on the cone inequality g0^T d* >= c||g0||||d*||, which Eq. (8) does not guarantee, as shown above. Thus no valid convergence guarantee is established.

minor comments (5)

[Section 4.1, Figure 1 caption] The caption contains a grammatical error ('while and 3 for NashMTL'), and the trajectory comparison should be stated cleanly.
[Section 3.1, Eqs. (12)-(14)] The inverse in Eq. (12) is a scalar, not a matrix, because it is the inverse of a 1x1 object; the notation D = (...) could confuse readers into thinking a matrix inversion is needed.
[Appendix D.1] There is a typo ('an d 2'), and hyperparameter choices are reported only for ConicGrad while comparison methods' numbers are taken from their original papers, making cross-method comparisons sensitive to implementation differences.
[General] The paper does not release code or seeds, which limits reproducibility of the empirical claims; the notation is also inconsistent between 'CONICGRAD' and 'CONIC GRAD' throughout the text and tables.
[Table 2] The LS and SI rows for CityScapes are numerically identical on every reported metric; this is suspicious and should be explained or corrected.

Circularity Check

1 steps flagged · score 2.0 of 10

No fitted-input circularity; the only self-referential element is in the convergence proof, which assumes the computed update satisfies the cone constraint that Eq. (8) was supposed to deliver.

other [Appendix A.3, proof of Theorem 3.2 (inequality chain leading to Eq. 23)]
"≤ −αc∥g0(θt)∥∥d∗(θt)∥ + α/2 ∥d∗(θt)∥^2 by constraint in Equation (3) ... = −αc∥g0(θt)∥κ∥g0(θt)∥ + α/2 (κ∥g0(θt)∥)^2 because we enforce ∥d∗(θt)∥ ≈κ∥g0(θ)∥."

The convergence bound is derived by replacing −αg0^T d* with −αc||g0||||d*||, i.e., by assuming the computed update d* satisfies the cone constraint of Eq. (3). That feasibility is precisely the property Proposition 3.1 and Eq. (8) were intended to establish, and it is not established. Under Algorithm 1's uniform initialization (ω_i = 1/K), g_ω = g_0, and Eq. (8) yields Z^{-1}g_0 = −g_0/((1−c^2)||g_0||^2), so g_0^T d* = −1/(1−c^2) < 0 for every c ∈ (0,1). Hence the O(1/T) conclusion is not a consequence of the stated algorithm; it is assumed as the method's defining property.

full rationale

The empirical claims are not circular: c and γ are selected by validation/ablation, and performance is reported on external benchmarks NYUv2, CityScapes, CelebA, and MetaWorld MT10 against other published methods. I found no load-bearing self-citation, no imported uniqueness theorem, and no prediction that is statistically forced by a fitted parameter. The main self-referential element is confined to the theoretical convergence proof: it assumes the computed d* lies in the cone of Eq. (3), although Eq. (8) under the algorithm's own initialization produces a direction anti-parallel to g_0. This is better characterized as a correctness gap in the proof than as a fitted-input circularity of the empirical results, so the circularity score is correspondingly low.

Assumptions & free parameters 5 free parameters · 6 assumptions · 0 invented entities

The paper's derivations rest on six premises beyond standard smoothness: the single-cone/double-cone equivalence, which fails for the algorithm's own initialization, the feasibility of d* and a constant norm ratio kappa, assumed in the convergence proof, the hand-set multiplier lambda, and a well-shaped omega-subproblem. Together these show the principled derivation is closer to a heuristic with hand-set constants than to a parameter-free derivation.

free parameters (5)

Lagrange multiplier lambda = 1
Appendix A.2 shows dE/dlambda = -C/lambda^2 has no finite zero for C != 0; the paper sets lambda = 1 by hand and reports it works well empirically.
cone angle parameter c = 0.25 (CityScapes); 0.75 (NYUv2); 0.5 (CelebA); 0.75 (MT10)
Chosen per dataset from {0.1, 0.25, 0.5, 0.75, 0.9} using validation performance (Section 4.5 and Appendix D.1).
regularization coefficient gamma = 0.001 (CityScapes, CelebA); 0.01 (NYUv2, MT10)
Selected from the same ablation grid; it enters the omega-update in Equation (9) and affects the reported margins.
omega learning rate eta2 = not reported
Input to Algorithm 1 line 7 but never given a value anywhere in the paper; needed to reproduce the task-weight dynamics.
normalization constant kappa = implicitly 1 after normalization; unquantified in the proof
Appendix A.3 assumes ||d*|| is approximately kappa ||g0|| for a constant kappa; the actual update is normalized to ||g0|| only after the inequality chain that uses kappa.

assumptions (6)

standard math Task gradients L_i are L-Lipschitz and L0 is bounded below
Stated in Theorem 3.2; a standard smoothness assumption for gradient descent bounds.
domain assumption Slater condition holds for c < 1 with a strictly feasible direction
Proposition A.4 constructs ds = alpha g0; needed to claim strong duality, although the claimed zero duality gap is not established for the indefinite Lagrangian.
ad hoc to paper Quadratic constraint c^2||g0||^2||d||^2 - (g0^T d)^2 <= 0 is equivalent to the cone constraint <g0,d>/(||g0|| ||d||) >= c
Section 3, between Eq. (3) and Eq. (4). The quadratic defines the double cone |cos| >= c; the sign of <g0,d> is dropped. This is the load-bearing assumption that fails for uniform task weights.
ad hoc to paper The computed d* satisfies the cone constraint and has norm approximately kappa ||g0||
Appendix A.3 uses 'by constraint in Equation (3)' and 'because we enforce ||d*(theta_t)|| approximately kappa ||g0(theta)||'; both properties are assumed, not derived, for the actual d*.
ad hoc to paper lambda = 1 is an acceptable choice for the Lagrangian multiplier
Appendix A.2 shows no finite lambda optimizes the dual objective; the paper asserts lambda = 1 works well empirically.
ad hoc to paper The omega-subproblem in Equation (9) is well-shaped and one iterative step suffices
Equation (9) minimizes an indefinite quadratic over the simplex, generally non-convex; Algorithm 1 takes a single eta2 step without specifying projection or solver details.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Fantastic Multi-Task Gradient Updates and How to Find Them In a Cone." pith.science (2026). https://pith.science/paper/DNC3O576

@misc{pith2026250200217,
  author       = {Pith},
  title        = {Pith review of: Fantastic Multi-Task Gradient Updates and How to Find Them In a Cone},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DNC3O576}},
  note         = {Machine review of arXiv:2502.00217}
}

read the original abstract

Balancing competing objectives remains a fundamental challenge in multi-task learning (MTL), primarily due to conflicting gradients across individual tasks. A common solution relies on computing a dynamic gradient update vector that balances competing tasks as optimization progresses. Building on this idea, we propose ConicGrad, a principled, scalable, and robust MTL approach formulated as a constrained optimization problem. Our method introduces an angular constraint to dynamically regulate gradient update directions, confining them within a cone centered on the reference gradient of the overall objective. By balancing task-specific gradients without over-constraining their direction or magnitude, ConicGrad effectively resolves inter-task gradient conflicts. Moreover, our framework ensures computational efficiency and scalability to high-dimensional parameter spaces. We conduct extensive experiments on standard supervised learning and reinforcement learning MTL benchmarks, and demonstrate that ConicGrad achieves state-of-the-art performance across diverse tasks.

Figures

Figures reproduced from arXiv: 2502.00217 by the authors.

**Figure 1.** Toy Experiment. The four plots on the left-side visualize the loss trajectories of various MTL methods from 5 initialization points (•) on a toy 2-task learning problem (see Section 4.1 and Appendix C for more details). Trajectories transition from blue to green, indicating progress over time. All 5 initialization points for FAMO reach the Pareto front (gray curve), while and 3 for NashMTL and all 5 for both CAGrad … view at source ↗

**Figure 2.** Visual Illustration of Update Vectors. Inspired by (Liu et al., 2021a), we illustrate the update vector d (in red) for a two-task learning problem using various gradient descent methods: GD, MGDA, PCGrad, CAGrad, and CONICGRAD. Task-specific gradients g1 and g2 are in black and the reference objective gradient g0 is in blue. PCGrad projects each gradient onto the plane orthogonal to the other (dashed arrows) and ave… view at source ↗

**Figure 3.** Visualizing Conic vs. Directional Constraints. We visualize CONICGRAD and CAGrad (Liu et al., 2021a) constraints in a toy setup. The x and y axes denote all possible direction vectors in 2D space R 2 , and the plot indicates which vectors in this space satisfy CONICGRAD and CAGrad constraints. 2D vector space, demonstrating how CONICGRAD permits a broader range of feasible directions while maintaining alignment wit… view at source ↗

Figures from the paper (4 more)

**Figure 4.** Figure 4: Scalability Experiments on CelebA. We measure the computational overhead of MTL methods as the model size increases (in terms of number of parameters) to illustrate how these methods scale. 4.3. Multi-Task Reinforcement Learning In addition to supervised multi-task le…

**Figure 5.** Figure 5: Contour Plots of c and γ on three MTL benchmarks. We ablate the hyperparameters γ ∈ [0.001, 0.01] on the x-axes and c ∈ {0.1, 0.25, 0.5, 0.75, 0.9} on the y-axes. The raw data consists of discrete values for γ and c at specific points, and we use interpolation to fill …

**Figure 6.** Figure 6: Geometric Interpretation of CONICGRAD. The black arrow indicates the main objective gradients vector g0, and the region covered in pink indicates the valid region. We plot several values of c to visualize how the region of admissible update direction vectors changes. 1…

**Figure 7.** Figure 7: Loss Landscape of the Toy Example. (a) First objective, L1(θ); (b) Second objective, L2(θ); (c) The overall objective, 1 2 [PITH_FULL_IMAGE:figures/full_fig_p015_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 17 canonical work pages

[1]

Just pick a sign: Optimizing deep multitask models with gradient sign dropout

Chen, Z., Ngiam, J., Huang, Y., Luong, T., Kretzschmar, H., Chai, Y., and Anguelov, D. Just pick a sign: Optimizing deep multitask models with gradient sign dropout. Advances in Neural Information Processing Systems, 33: 0 2039--2050, 2020

work page 2020
[2]

The cityscapes dataset for semantic urban scene understanding

Cordts, M., Omran, M., Ramos, S., Rehfeld, T., Enzweiler, M., Benenson, R., Franke, U., Roth, S., and Schiele, B. The cityscapes dataset for semantic urban scene understanding. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 3213--3223, 2016

2016
[3]

Multiple-gradient descent algorithm (mgda) for multiobjective optimization

D \'e sid \'e ri, J.-A. Multiple-gradient descent algorithm (mgda) for multiobjective optimization. Comptes Rendus Mathematique, 350 0 (5-6): 0 313--318, 2012

work page 2012
[4]

Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor

Haarnoja, T., Zhou, A., Abbeel, P., and Levine, S. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In International conference on machine learning, pp.\ 1861--1870. PMLR, 2018

2018
[5]

Mask r-cnn

He, K., Gkioxari, G., Doll \'a r, P., and Girshick, R. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pp.\ 2961--2969, 2017

2017
[6]

Higham, N. J. Accuracy and stability of numerical algorithms. SIAM, 2002

work page 2002
[7]

Multi-task learning using uncertainty to weigh losses for scene geometry and semantics

Kendall, A., Gal, Y., and Cipolla, R. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 7482--7491, 2018

2018
[8]

Kingma, D. P. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014

arXiv 2014

Show all 29 references

[9]

Lin, B., Ye, F., Zhang, Y., and Tsang, I. W. Reasonable effectiveness of random weighting: A litmus test for multi-task learning. arXiv preprint arXiv:2111.10603, 2021

2021 arXiv
[10]

Mtmamba: Enhancing multi-task dense scene understanding by mamba-based decoders

Lin, B., Jiang, W., Chen, P., Zhang, Y., Liu, S., and Chen, Y.-C. Mtmamba: Enhancing multi-task dense scene understanding by mamba-based decoders. In European Conference on Computer Vision, pp.\ 314--330. Springer, 2025

2025
[11]

Conflict-averse gradient descent for multi-task learning

Liu, B., Liu, X., Jin, X., Stone, P., and Liu, Q. Conflict-averse gradient descent for multi-task learning. Advances in Neural Information Processing Systems, 34: 0 18878--18890, 2021 a

2021
[12]

Famo: Fast adaptive multitask optimization

Liu, B., Feng, Y., Stone, P., and Liu, Q. Famo: Fast adaptive multitask optimization. In Oh, A., Naumann, T., Globerson, A., Saenko, K., Hardt, M., and Levine, S. (eds.), Advances in Neural Information Processing Systems, volume 36, pp.\ 57226--57243, 2023

2023
[13]

Towards impartial multi-task learning

Liu, L., Li, Y., Kuang, Z., Xue, J., Chen, Y., Yang, W., Liao, Q., and Zhang, W. Towards impartial multi-task learning. iclr, 2021 b

2021
[14]

Liu, S., Johns, E., and Davison, A. J. End-to-end multi-task learning with attention. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp.\ 1871--1880, 2019

2019
[15]

Deep learning face attributes in the wild

Liu, Z., Luo, P., Wang, X., and Tang, X. Deep learning face attributes in the wild. In Proceedings of the IEEE international conference on computer vision, pp.\ 3730--3738, 2015

2015
[16]

Fully convolutional networks for semantic segmentation

Long, J., Shelhamer, E., and Darrell, T. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 3431--3440, 2015

2015
[17]

Multi-task learning as a bargaining game

Navon, A., Shamsian, A., Achituve, I., Maron, H., Kawaguchi, K., Chechik, G., and Fetaya, E. Multi-task learning as a bargaining game. arXiv preprint arXiv:2202.01017, 2022

2022 arXiv
[18]

and Koltun, V

Sener, O. and Koltun, V. Multi-task learning as multi-objective optimization. Advances in neural information processing systems, 31, 2018

2018
[19]

Indoor segmentation and support inference from rgbd images

Silberman, N., Hoiem, D., Kohli, P., and Fergus, R. Indoor segmentation and support inference from rgbd images. In Computer Vision--ECCV 2012: 12th European Conference on Computer Vision, Florence, Italy, October 7-13, 2012, Proceedings, Part V 12, pp.\ 746--760. Springer, 2012

2012
[20]

and Zhang, A

Sodhani, S. and Zhang, A. Mtrl - multi task rl algorithms. Github, 2021. URL https://github.com/facebookresearch/mtrl

2021
[21]

ptflops: a flops counting tool for neural networks in pytorch framework, 2018-2024

Sovrasov, V. ptflops: a flops counting tool for neural networks in pytorch framework, 2018-2024. URL https://github.com/sovrasov/flops-counter.pytorch

2018
[22]

Sutton, R. S. Reinforcement learning: An introduction. A Bradford Book, 2018

2018
[23]

Multi-task learning for dense prediction tasks: A survey

Vandenhende, S., Georgoulis, S., Van Gansbeke, W., Proesmans, M., Dai, D., and Van Gool, L. Multi-task learning for dense prediction tasks: A survey. IEEE transactions on pattern analysis and machine intelligence, 44 0 (7): 0 3614--3633, 2021

2021
[24]

Direction-oriented multi-objective learning: Simple and provable stochastic algorithms

Xiao, P., Ban, H., and Ji, K. Direction-oriented multi-objective learning: Simple and provable stochastic algorithms. Advances in Neural Information Processing Systems, 36, 2024

2024
[25]

Multi-task reinforcement learning with soft modularization

Yang, R., Xu, H., Wu, Y., and Wang, X. Multi-task reinforcement learning with soft modularization. Advances in Neural Information Processing Systems, 33: 0 4767--4777, 2020

2020
[26]

Gradient surgery for multi-task learning

Yu, T., Kumar, S., Gupta, A., Levine, S., Hausman, K., and Finn, C. Gradient surgery for multi-task learning. Advances in Neural Information Processing Systems, 33: 0 5824--5836, 2020 a

2020
[27]

Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning

Yu, T., Quillen, D., He, Z., Julian, R., Hausman, K., Finn, C., and Levine, S. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on robot learning, pp.\ 1094--1100. PMLR, 2020 b

2020
[28]

Sgw-based multi-task learning in vision tasks

Zhang, R., Chen, Y., Liu, J., Xi, D., Huo, Y., Liu, J., and Wu, C. Sgw-based multi-task learning in vision tasks. In Asian Conference on Computer Vision, pp.\ 124--141. Springer, 2025

2025
[29]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.

[1] [1]

Just pick a sign: Optimizing deep multitask models with gradient sign dropout

Chen, Z., Ngiam, J., Huang, Y., Luong, T., Kretzschmar, H., Chai, Y., and Anguelov, D. Just pick a sign: Optimizing deep multitask models with gradient sign dropout. Advances in Neural Information Processing Systems, 33: 0 2039--2050, 2020

work page 2020

[2] [2]

The cityscapes dataset for semantic urban scene understanding

Cordts, M., Omran, M., Ramos, S., Rehfeld, T., Enzweiler, M., Benenson, R., Franke, U., Roth, S., and Schiele, B. The cityscapes dataset for semantic urban scene understanding. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 3213--3223, 2016

2016

[3] [3]

Multiple-gradient descent algorithm (mgda) for multiobjective optimization

D \'e sid \'e ri, J.-A. Multiple-gradient descent algorithm (mgda) for multiobjective optimization. Comptes Rendus Mathematique, 350 0 (5-6): 0 313--318, 2012

work page 2012

[4] [4]

Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor

Haarnoja, T., Zhou, A., Abbeel, P., and Levine, S. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In International conference on machine learning, pp.\ 1861--1870. PMLR, 2018

2018

[5] [5]

Mask r-cnn

He, K., Gkioxari, G., Doll \'a r, P., and Girshick, R. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pp.\ 2961--2969, 2017

2017

[6] [6]

Higham, N. J. Accuracy and stability of numerical algorithms. SIAM, 2002

work page 2002

[7] [7]

Multi-task learning using uncertainty to weigh losses for scene geometry and semantics

Kendall, A., Gal, Y., and Cipolla, R. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 7482--7491, 2018

2018

[8] [8]

Kingma, D. P. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014

arXiv 2014