Mitigating Task Interference in Multi-Task Learning

578 concepts454 papers2 proposals

Multi-task learning (MTL) promises a compelling efficiency: by training a single neural network on multiple objectives simultaneously, the model can learn shared representations that benefit all tasks. However, in practice, naively combining diverse objectives often leads to a "jack-of-all-trades, master of none" scenario. Instead of cooperating, tasks frequently compete for the model's limited capacity. This phenomenon is known as task interference or negative transfer.

As observed across domains ranging from natural language generation (Junyi Li et al. in MVP: Multi-task Supervised Pre-training for Natural Language Generation) to reinforcement learning (Lasse Espeholt in IMPALA: Scalable Distributed Deep-RL with Importance Weighted Actor-Learner Architectures), optimization for one specific task can actively degrade performance on another. To build models that truly generalize, researchers have developed strategies to diagnose, bypass, and resolve these conflicts.

The Mechanics of Interference: Why Tasks Clash

To understand why tasks interfere, we must look at the optimization landscape. When a model shares all its parameters across multiple objectives, three primary points of friction arise:

  1. Conflicting Gradients: During backpropagation, different tasks may demand opposite updates to the same shared weights. For instance, in evaluating language models, Seungone Kim et al. note in Prometheus 2: An Open Source Language Model Specialized in Evaluating Other Language Models that direct assessment and pairwise comparison tasks generate conflicting gradient updates. The internal representations required for absolute scoring fundamentally clash with those needed for relative comparison.
  2. Loss Scale Disparities: If one task has a significantly larger loss magnitude or is inherently easier to optimize, its gradients will dominate the training process. Anish Lakkapragada et al. point out in Mitigating Negative Transfer in Multi-Task Learning with Exponential Moving Average Loss Weighting Strategies (Student Abstract) that these numerical imbalances pull the shared architecture toward a biased solution, neglecting secondary objectives.
  3. Feature Overwriting: In joint training, simpler tasks can dilute or overwrite the specialized features required for complex tasks. Yaxin Fan demonstrates this in Improving Dialogue Discourse Parsing via Reply-to Structures of Addressee Recognition, showing how features from a simpler task can wash out the nuanced logic needed for discourse parsing. This manifests as a "seesaw phenomenon," where one task's gains directly cause another's decline (Liangcai Su et al. in STEM: Unleashing the Power of Embeddings for Multi-Task Recommendation).

Dynamic Loss Weighting and Gradient Bargaining

One way to resolve this tug-of-war is to dynamically adjust how task losses and gradients are aggregated during optimization. Instead of a simple uniform summation, researchers treat multi-task optimization as a game of compromise.

Aviv Navon et al. reframe this in Multi-Task Learning as a Bargaining Game by modeling gradient aggregation as a cooperative bargaining game. By applying the classic Nash Bargaining Solution, their algorithm (Nash-MTL) finds an update direction that is proportionally fair to all tasks, ensuring no single task's gradient is completely sacrificed.

Naively Summed Gradients:  Task A ──>  +  Task B <──  =  Destructive Cancellation (Zero Progress)
Nash Bargaining Solution:  Task A ──>  +  Task B ──>  =  Pareto-Optimal Compromise Direction

Alternatively, scale imbalances can be mitigated via adaptive loss smoothing. Anish Lakkapragada et al. use an Exponential Moving Average (EMA) to normalize loss magnitudes on the fly, preventing high-magnitude tasks from hijacking the network. At a larger scale, Amelie Royer et al. show in Scalarization for Multi-Task and Multi-Domain Learning at Scale that simple scalarization (weighted averaging) optimized via Population-Based Training (PBT) can match or exceed complex gradient manipulation methods without incurring heavy memory overhead.

Modular Parameter Separation and Routing

Rather than forcing all tasks to share 100% of the model's parameters, a prominent architectural solution isolates task-specific knowledge while sharing a core foundational backbone. This prevents destructive interference by giving each task its own parameter "sandbox."

Adapter Differentiation and Routing

Zhi Chen et al. introduce AdapterShare: Task Correlation Modeling with Adapter Differentiation, a framework that dynamically decides which layers should share parameters based on measured gradient interference. Similarly, Lucas Caccia shows in Multi-Head Adapter Routing for Cross-Task Generalization that splitting adapters into independent heads and routing them selectively helps decouple conflicting task signals during training, leading to cleaner cross-task generalization.

Low-Rank Tensor Decomposition

In Low-Rank Updates of pre-trained Weights for Multi-Task Learning, Alexandre Audibert et al. propose MORRIS, which stacks weight updates for multiple tasks into a 3D tensor. By applying Canonical Polyadic Decomposition (CPD), the authors mathematically separate shared foundational knowledge from task-specific tweaks, training as little as 0.3% of the original parameters per task.

Isolated Embeddings and Backbones

In recommendation systems, where user preferences across actions (e.g., clicking a video vs. finishing it) often conflict, Liangcai Su et al. break the shared-embedding paradigm in STEM: Unleashing the Power of Embeddings for Multi-Task Recommendation. They utilize task-specific embeddings and stop-gradients to block cross-contamination.

For retrieval-augmented generation, Kaisi Guan et al. implement BSharedRAG: Backbone Shared Retrieval-Augmented Generation for the E-commerce Domain, using distinct LoRA modules on top of a shared Large Language Model (LLM) backbone to prevent contrastive retrieval objectives from degrading next-token generation capabilities.

Curating the Task Mixture and Schedule

Interference can also be managed before gradients are even computed—by carefully selecting which tasks train together and when. Naively throwing every available dataset into a single training run often yields diminishing returns due to data distribution clashes (Zhuosheng Zhang et al. in Task Compass: Scaling Multi-task Pre-training with Task Prefix).

To address this, Sumit Bhatia et al. develop SMART in SMART: Submodular Data Mixture Strategy for Instruction Tuning, using submodular functions to prune redundant or noisy tasks that would otherwise overwhelm the model's capacity.

Furthermore, instead of static training schedules, Hongqiu Wu et al. propose MOMETAS in Forging Multiple Training Objectives for Pre-trained Language Models via Meta-Learning. This meta-learning sampler dynamically learns the optimal curriculum for multiple objectives, preventing zero-sum competition between tasks by introducing them only when the model is ready to absorb them.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 409 papers
  2. Version 1 · 2026-10-04 · 533 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_negative_transfer_task_interference_6dea3cd5,
  title = {negative transfer (task interference)},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/negative-transfer-task-interference/rdr_6dea3cd53b5e45f396c2d2f64186a0d2},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 2, frozen text):

@misc{lacuna_negative_transfer_task_interference_6dea3cd5_v2,
  title = {negative transfer (task interference)},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/negative-transfer-task-interference/rdr_6dea3cd53b5e45f396c2d2f64186a0d2/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake