DeepMTL2R: Transformer Multi-Task Ranking

• DeepMTL2R is a transformer-based multi-task learning to rank framework that optimizes heterogeneous relevance signals from diverse feedback (clicks, dwell time, quality).
• The framework integrates 21 MTL algorithms and combines task-specific losses using gradient-based and scalarization methods to yield Pareto-optimal solutions.
• It effectively models list-context dependencies via self-attention, ensuring robust performance across multiple ranking objectives in real-world systems.

Searching arXiv for the primary paper and closely related multi-task optimization papers mentioned in the source material. DeepMTL2R is an open-source deep learning framework for Multi-task Learning to Rank (MTL2R), a ranking setting in which multiple relevance criteria must be optimized simultaneously. In this formulation, each item in a query-specific list is associated with a feature vector and multiple relevance labels reflecting heterogeneous and often conflicting criteria, and the learner trains a single scoring function while optimizing multiple task objectives. DeepMTL2R integrates heterogeneous relevance signals into a unified, context-aware model by leveraging the self-attention mechanism of transformer architectures, supports multi-objective optimization to identify Pareto-optimal ranking models, and includes 21 multi-task learning algorithms for controlled comparisons across MTL strategies (Dong et al., 16 Feb 2026).

1. Problem formulation and scope

In MTL2R, each item $i$ in a query-specific list has a feature vector $x_i$ and multiple relevance labels

$y_i = (y_i^1, \ldots, y_i^K),$

where the labels reflect heterogeneous criteria such as graded relevance, clicks, dwell time, quality, and related signals. The model learns a scoring function $f_\theta$ that outputs a scalar score

$s_i = f_\theta(x_i)$

for each item while simultaneously optimizing $K$ task objectives $\{L_t(\theta)\}_{t=1}^K$ (Dong et al., 16 Feb 2026).

The motivation is tied to the structure of real-world ranking systems, which are driven by multiple noisy and subjective signals such as clicks, dwell time, sales, and ratings. Optimizing one target often hurts another, and MTL2R explicitly models these trade-offs so that the resulting rankings can better reflect product goals and nuanced user preferences. DeepMTL2R treats this setting as a unified ranking problem rather than as a set of isolated objectives, combining task losses through scalarization or gradient-based multi-objective methods to produce either a single compromise model or a family of Pareto-optimal solutions (Dong et al., 16 Feb 2026).

The framework is designed for heterogeneous labels and objectives. Tasks may use graded labels, binary or implicit feedback, engagement signals, or other domain-specific quality scores. A central practical detail is that labels derived from features are removed from inputs to prevent target leakage in the reported experiments, which is particularly relevant when several supervision channels are constructed from the same original benchmark fields (Dong et al., 16 Feb 2026).

2. Transformer-based ranking architecture

DeepMTL2R uses a transformer-based architecture in which items are treated as tokens in a query-specific list. Self-attention supplies list-level context and captures cross-item dependencies and long-range interactions, so an item’s representation and eventual score can depend on the entire list rather than only on its own features. The attention operator is the standard scaled dot-product form:

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V.$$

This is the core mechanism by which the framework models inter-item competition, redundancy, and diversity (Dong et al., 16 Feb 2026).

The ranking pipeline is specified as follows. For a list of length $l$, each item has features $x_i \in \mathbb{R}^{d_f}$. A shared projection maps each item by $x_i$0. Positional encoding is implicit via the Transformer encoder. The encoder then applies multi-head self-attention and feed-forward blocks over $x_i$1 layers, with residual connections, dropout, and layer normalization. A shared fully connected output head maps the final contextualized representation of each item to a scalar score $x_i$2, and sorting these scores yields the ranking (Dong et al., 16 Feb 2026).

The architectural claim made by the paper is not merely that transformers can be used for ranking, but that they are particularly appropriate for listwise MTL2R because independent per-item models cannot directly condition one item’s representation on all others in the list. The reported empirical discussion emphasizes that capturing cross-item dependencies helps listwise training in MTL2R. At the same time, direct encoder ablations against simpler architectures were not reported, so the architectural comparison is motivated and contextualized rather than established through a dedicated ablation section (Dong et al., 16 Feb 2026).

3. Tasks, losses, and metrics

The multi-task objective is represented as the vector

$x_i$3

DeepMTL2R supports task-specific loss selection across pointwise, pairwise, and listwise paradigms, with the paper describing “9 popular LTR losses.” Representative forms include pointwise binary cross-entropy,

$x_i$4

pairwise hinge and logistic losses,

$x_i$5

$x_i$6

and listwise objectives such as ListMLE,

$x_i$7

and ListNet, formulated via top-1 probability matching with KL minimization. The framework also supports differentiable NDCG surrogates, including Lambda-based or smooth approximations (Dong et al., 16 Feb 2026).

The standard ranking metrics reported include

$x_i$8

and

$x_i$9

These metrics are used both as task-level validation criteria and as part of the broader analysis of trade-offs among objectives (Dong et al., 16 Feb 2026).

For multi-task combination, the general scalarized objective is

$y_i = (y_i^1, \ldots, y_i^K),$0

The paper highlights several implemented weighting and optimization strategies. Uncertainty weighting uses

$y_i = (y_i^1, \ldots, y_i^K),$1

with learnable task uncertainties. Dynamic Weight Averaging sets weights from relative loss descent rates across epochs. PCGrad identifies conflicting gradients through negative cosine similarity and projects away conflicting components. MGDA finds a convex combination of task gradients minimizing $y_i = (y_i^1, \ldots, y_i^K),$2, yielding a Pareto-stationary descent direction. CAGrad interpolates between the average gradient and a calibrated multi-objective direction, and NashMTL interprets MTL as a bargaining game with scale-invariant task weights. The framework also includes Pareto scalarizations such as linear scalarization, scale-invariant linear scalarization, weighted Chebyshev, its smooth log-sum-exp relaxation Soft Weighted Chebyshev, and the $y_i = (y_i^1, \ldots, y_i^K),$3-constraint method (Dong et al., 16 Feb 2026).

4. Algorithmic coverage and Pareto-front analysis

DeepMTL2R includes 21 multi-task algorithms. The paper distinguishes between PF-finding methods, which explicitly explore or evaluate the Pareto front, and non-PF methods, which aim at multi-task convergence and trade-offs without explicit Pareto-front enumeration (Dong et al., 16 Feb 2026).

The PF-finding group comprises Linear Scalarization, Scale-Invariant Linear Scalarization, Weighted Chebyshev, Soft Weighted Chebyshev, EPO, WC_MGDA, and EC. In the descriptions given by the paper, these methods either sweep preferences on the simplex, optimize relative to a reference point, or constrain non-primary objectives in order to trace the Pareto front (Dong et al., 16 Feb 2026).

The non-PF group comprises RLW, Uncertainty Weighting, Dynamic Weight Averaging, MGDA, GradDrop, PCGrad, LOG_MGDA, CAGrad, LOG_CAGrad, IMTL, LOG_IMTL, NashMTL, FAMO, and SDMGrad. These methods represent several distinct families: random or learned loss weighting, gradient surgery, conflict-averse gradient aggregation, impartial or log-transformed variants for scale robustness, bargaining-based reweighting, fast adaptive optimization, and direction-oriented stochastic multi-objective optimization (Dong et al., 16 Feb 2026).

The framework formulates multi-objective ranking as

$y_i = (y_i^1, \ldots, y_i^K),$4

A parameter vector $y_i = (y_i^1, \ldots, y_i^K),$5 is Pareto-optimal if there is no $y_i = (y_i^1, \ldots, y_i^K),$6 such that $y_i = (y_i^1, \ldots, y_i^K),$7 for all $y_i = (y_i^1, \ldots, y_i^K),$8 with strict inequality for at least one task. The paper also gives the Pareto-stationarity condition: there exists $y_i = (y_i^1, \ldots, y_i^K),$9 such that

$f_\theta$0

This condition underlies the gradient-based multi-objective methods included in the library (Dong et al., 16 Feb 2026).

For PF-finding methods, evaluation uses the Hypervolume Indicator (HVI), defined in the paper as the dominated volume relative to a reference point, where higher is better. The library also visualizes losses, NDCG@k, PF scatter plots in objective space, and training dynamics across runs, making trade-offs explicit rather than implicit (Dong et al., 16 Feb 2026).

5. Experimental protocol and reported findings

The experiments are conducted on MSLR-WEB30K (LETOR 4.0) with 136 features. Following Momma et al. (2020), the paper constructs a 5-task setting consisting of Task 0 as the original graded relevance label, Task 131 as Query–URL Click Count (Click), Task 132 as URL Dwell Time (Dwell), Task 133 as Quality Score (QS), and Task 135 as Quality Score 2 (QS2). To prevent leakage, the four feature-derived labels are removed from model inputs during training (Dong et al., 16 Feb 2026).

The reported bi-objective protocol considers all $f_\theta$1 label pairs. For each pair, experiments are run with 10 different reference vectors or preferences. Validation uses NDCG@30 per task, and aggregate performance is summarized with $f_\theta$2:

$f_\theta$3

where $f_\theta$4 and $f_\theta$5 are the metric values of the multi-task model and the single-task baseline on task $f_\theta$6, and $f_\theta$7 if higher is better, as with NDCG (Dong et al., 16 Feb 2026).

The paper reports several qualitative findings. PF methods, including Weighted Chebyshev, recover clearer Pareto fronts, whereas non-PF methods concentrate near central trade-off regions. Among six compared MTL algorithms, WC and LOG_MGDA achieved the best overall $f_\theta$8 and strong NDCG@30 behavior. Training curves for loss and NDCG@30 demonstrate stable convergence across 10 runs, and PF-finding methods cover diverse trade-offs (Dong et al., 16 Feb 2026).

The ablation-related discussion is limited but specific. The paper motivates transformers for list-context modeling and emphasizes that capturing cross-item dependencies helps listwise training in MTL2R, but direct encoder ablations against simpler architectures were not reported. Hyperparameter-sensitivity ablations were also not reported, although the paper notes that practitioners should tune reference vectors, temperatures for SoftWC and DWA, and task losses (Dong et al., 16 Feb 2026).

6. Library organization, usage patterns, and operational considerations

DeepMTL2R is organized as a library rather than only as an experimental code release. Its components include a data layer with loaders and preprocessors for listwise ranking data, including variable-length lists, batching, and standardization; a model zoo with transformer-based list encoders and shared fully connected heads; pointwise, pairwise, and listwise ranking losses with a $f_\theta$9-task interface; 21 MTL optimizers spanning scalarization, gradient surgery and balancing, Pareto, and game-theoretic methods; optimization utilities such as preference or reference-vector generation, $s_i = f_\theta(x_i)$0-constraint schedules, early stopping, and gradient clipping; evaluation and visualization tools for NDCG@k, $s_i = f_\theta(x_i)$1, hypervolume, curve plotting, and PF scatterplots; and a configuration system with YAML/JSON-like experiment specifications, seeds, and logging (Dong et al., 16 Feb 2026).

The usage pattern shown by the paper is modular. A practitioner defines tasks with task-specific ranking losses and metrics, builds a transformer-based ranker with configurable input dimension, hidden dimension, number of layers, number of heads, and dropout, chooses an MTL optimizer such as Weighted Chebyshev or PCGrad, trains on listwise batches by computing per-task losses and combining gradients through the selected MTL method, and then evaluates with NDCG-based metrics and $s_i = f_\theta(x_i)$2. The repository is available at https://github.com/amazon-science/DeepMTL2R (Dong et al., 16 Feb 2026).

The practical guidance in the paper is method-selective. If the goal is to choose from a spectrum of trade-offs, PF methods such as WC, SoftWC, EC, or EPO are recommended, with preference sweeps or $s_i = f_\theta(x_i)$3 schedules and selection through HVI or downstream constraints. If a single compromise solution is needed and tasks exhibit strong conflicts, the paper recommends PCGrad, CAGrad, MGDA, NashMTL, or SDMGrad. For loss-scale issues, it recommends uncertainty weighting, LOG_MGDA, LOG_CAGrad, LOG_IMTL, or scale-invariant scalarization. For small or noisy data, it suggests simpler scalarization or uncertainty weighting; for large data, gradient-based multi-objective methods and PF sweeps are described as more informative (Dong et al., 16 Feb 2026).

The paper also gives typical starting points for hyperparameters: 2–4 encoder layers, 4–8 heads, hidden size 128–512, dropout 0.1–0.3, Adam or AdamW, learning rate $s_i = f_\theta(x_i)$4 to $s_i = f_\theta(x_i)$5, batch size 32–128 lists, and gradient clipping 1.0–5.0. For PF sweeps it suggests 10–20 reference vectors per pair of tasks, $s_i = f_\theta(x_i)$6 for SoftWC in $s_i = f_\theta(x_i)$7, and DWA temperature $s_i = f_\theta(x_i)$8 in $s_i = f_\theta(x_i)$9. For list length, it notes truncation or padding to manageable $K$0, for example 50–200, because self-attention has $K$1 cost. Mixed-precision training is recommended (Dong et al., 16 Feb 2026).

7. Limitations, reproducibility, and future directions

The paper identifies scalability as a central limitation. Full self-attention can be costly on long lists and many tasks, and more efficient attention or list sampling is identified as a useful direction. It also notes that heterogeneous labels may embed selection bias and noise, that per-task loss choices matter, and that Pareto-front selection still requires human or metric-driven preferences. These are structural issues in multi-objective ranking rather than implementation-specific defects (Dong et al., 16 Feb 2026).

Planned extensions include adding more ranking losses and metrics, including fairness-aware objectives, parameter-efficient task conditioning, improved preference or reference selection, and broader domains beyond WEB benchmarks. A plausible implication is that the library is intended not only as a benchmark framework for MTL2R on MSLR-WEB30K, but also as a platform for methodological work on multi-objective ranking under heterogeneous supervision (Dong et al., 16 Feb 2026).

Reproducibility is treated as a first-class concern. The repository provides modular components to reproduce the MSLR-WEB30K experiments, including the 5-label task definitions, removal of label-features from inputs to prevent leakage, PF sweeps with 10 reference vectors per label pair, and validation metrics based on NDCG@30 and $K$2. The paper states that running the provided configurations should reproduce the qualitative findings it reports: clearer PF structure for WC, SoftWC, EC, and EPO variants, strong average trade-off performance for WC and LOG_MGDA, and stable training curves across multiple runs (Dong et al., 16 Feb 2026).