Pareto Low-Rank Adapters: Efficient Multi-Task Learning with Preferences

## Abstract

Abstract Dealing with multi-task trade-offs during inference can be addressed via Pareto Front Learning (PFL) methods that parameterize the Pareto Front with a single model, contrary to traditional Multi-Task Learning (MTL) approaches that optimize for a single trade-off which has to be decided prior to training. However, recent PFL methodologies suffer from limited scalability, slow convergence and excessive memory requirements compared to MTL approaches while exhibiting inconsistent mappings from preference space to objective space. In this paper, we introduce PaLoRA, a novel parameter-efficient method that augments the original model with task-specific low-rank adapters and continuously parameterizes the Pareto Front in their convex hull. Our approach dedicates the original model and the adapters towards learning general and task-specific features, respectively. Additionally, we propose a deterministic sampling schedule of preference vectors that reinforces this division of labor, enabling faster convergence and scalability to real world networks. Our experimental results show that PaLoRA outperforms MTL and PFL baselines across various datasets, scales to large networks and provides a continuous parameterization of the Pareto Front, reducing the memory overhead 23.8 − 31.7 23.8 31.7 23.8-31.7 23.8 - 31.7 times compared with competing PFL baselines in scene understanding benchmarks.

## 1 Introduction

Building machine learning models with multi-task capabilities is becoming increasingly more prevalent, pursuing the advantages of a shared representation [, ] coupled with the practical benefits of a single model, in memory requirements and inference times.
Striving towards the construction of generalist agents [] by solving simultaneously multiple tasks introduces conflicts and there often does not exist a single optimal solution. Multi-objective optimization problems (MOO) rather have a set of optimal solutions, formally known as the Pareto Front.

Multi-Task Learning (MTL) algorithms provide a single solution corresponding to one trade-off among the objectives. Most methods [, , , , , ] do not account for user-specified preferences but the final solution is rather determined by their inner optimization choices.
Recently, a new class of methodologies [, , ] has emerged that addresses the challenge of optimizing these objectives when trade-offs are dynamic and not known in advance, enabling models to adapt to any given trade-off direction during inference.
These approaches continuously approximate the entire Pareto Front via a mechanism that uses the desired preference as input and generates the model weights to be in the Pareto Set and aligned with the input preference.

Despite these advancements, the applicability of Pareto Front Learning (PFL) methodologies remains limited due to complicated weight generating mechanisms, e.g., hypernetworks [, ] or augmenting the input space with the user preference []. As a result, the mapping from user preference to objective space via the aforementioned mechanism may not be Pareto aligned, i.e., increasing the emphasis on one task might not always result in improving its performance. Hypernetwork or weight ensemble solutions [] further exhibit lower convergence rates compared to their MTL counterparts, since the learning process depends on randomly drawn user preferences that effectively shift the vector objective at every step, and suffer from scalability issues.

In this paper, we introduce Pareto Low-Rank Adaptors (PaLoRA), a novel Pareto Front Learning algorithm that enhances neural network designs with task-specific low-rank adapters [] and establishes a Pareto Set within their convex hull. The method is presented conceptually in Figure 1. Throughout the training process, we create a convex combination of these adapters added to the base neural network parameters and apply a weighted vector across different objectives, thereby linking each adapter directly to its corresponding task. Our design is inspired by recent developments in parameter-efficient fine-tuning [, , ], where a small number of parameters suffice to provide a pre-trained model capabilities on downstream tasks.
While previous PFL methodologies generate all the network parameters from one hypernetwork [] or dedicate a copy of the model to each task [], PaLoRA has a clear division of labor.
The core neural network parameters develop a versatile general representation beneficial for all objectives, whereas the adapters focus on acquiring specific features for each task. As a result, the memory overhead to continuously parameterize the Pareto Front is orders of magnitude smaller compared to previous approaches [, ].

Figure: Figure 1: Conceptual illustration of the method. Each layer consists of the base network’s weight matrix $\bm{W}$ and $T=3$ low-rank adapters $\{(\bm{A}_{t},\bm{B}_{t})\}_{t=1}^{3}$. Assume $\bm{\lambda}=[{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{ 0,0,1}\lambda_{1}},{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb} {1,0,0}\lambda_{2}},{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb }{0,1,0}\lambda_{3}}]\sim\Delta_{3}$ has been sampled. Then each layer’s weights are formed by the weighted sum of the original matrix and the tasks’ low-rank adapters. The overall loss uses the same $\bm{\lambda}$ to weigh the task losses, steering each adapter to learn task-specific features and the shared backbone to learn a general representation.
Refer to caption: x1.png

Specifically, PaLoRA addresses two Pareto Front Learning challenges: lower convergence rate and memory excess via the aforementioned clear division of labor and the lightweight adapters where the bulk of representation remains constant while only the participation of the low-rank adapters varies. To further reinforce these properties, we propose the sampling of multiple preferences per batch with a deterministic schedule that initially focuses on building general features and specializes towards the latest stages of training.
Finally, PaLoRA by design enables Pareto expansion [], i.e., it can also be used a fine-tuning mechanism to expand the Pareto Front in the neighborhood of a pre-trained solution, potentially harnessing the representation of foundation models.

Our experimental results demonstrate that PaLoRA significantly outperforms other Pareto Front Learning methods across multiple benchmarks, has better Pareto alignment and requires fewer parameters. For instance, when training occurs from scratch for CityScapes, PaLoRA requires a $4.2\%$ memory overhead compared to MTL baselines, a $23.8\times$ overhead reduction compared to other PFL baselines, while showing superior performance. When applied as a fine-tuning mechanism, the proposed method is able to quickly align the adapters towards continuously modeling the Pareto Front locally, offering a flexible Pareto expansion mechanism.

Our contributions are as follows:

- •
We present PaLoRA, a novel Pareto Front Learning method that augments any neural network architecture with task-specific low-rank adapters on each layer and discovers a Pareto Set in the convex hull of the adapters.
- •
We propose an annealed deterministic sampling of preferences to guide Pareto Front Learning training, improving on training stability and the functional diversity of the final Pareto Front.
- •
Our experiments on multiple benchmarks and across model sizes show that PaLoRA outperforms PFL baselines, achieving higher hypervolume while incurring orders of magnitude less memory overhead. For CityScapes and NYUv2, PaLoRA introduces an overhead of $4.2\%$ and $6.3\%$, respectively, marking a $23.8\times$ and $31.7\times$ reduction compared to the other competitive baseline, while staying competitive or outperforming MTL baselines.
- •
We show that the proposed method can be easily adapted to a fine-tuning mechanism to expand the Pareto Front continuously in the neighborhood of a pretrained checkpoint.

## 2 Related Work

#### Multi-Task Learning

The pursuit of learning multiple tasks within a single model has deep roots in machine learning [, , , ], evolving in the deep learning era through architectural innovations [, , ] and optimization techniques [, , , ]. In the latter case, a shared-bottom architecture is adopted, meaning that task-specific decoding layers utilize the shared representation found after multiple common encoding layers. The methodologies focus on combining the task contributions, either directly on the loss level [, ], or on the gradient level [, , , , , ]. Chen et al. [] equalize the task-specific gradient magnitudes, Yu et al. [] randomly project the gradients of one task to another, Liu et al. [] equalize the gradient projections to the common descent vector, while Navon et al. []
cast the problem of obtaining the descent vector as a bargaining game.
Liu et al. [] address the memory and runtime overhead of gradient-based approaches via dynamically balanceing the task losses.
However, these techniques do not offer control over the final, unique point in the Pareto Front, since the trajectory in weight space is predetermined by the optimization scheme and the training randomness. In contrast, our method offers direct selection of the Pareto optimal solution corresponding to the desired preference, without sacrificing convergence speed and with low memory overhead.

#### Pareto Front Learning

Désidéri [] extends gradient-based methods to multi-objective optimization (MOO) and proposes Multiple Gradient Descent Algorithm (MGDA) to find descent directions that converge to the Pareto Set. Sener and Koltun [] cast Multi-Task Learning as MOO and scales MGDA to the Deep Learning setting. Lin et al. [] allow the introduction of constraints that encode trade-off preferences to the optimization problem [] and steer the solution to different points in the Pareto Front. However, this approach requires a different training run for each solution and results in a discrete approximation of the Pareto Front. Navon et al. [], Lin et al. [] employ HyperNetworks [] to continuously approximate the Pareto Front, by generating the weights of the target network with the preferred trade-off as input. However, for a hypernetwork with an embedding dimension $d$, its size is $\sim d$ times the size of the target network, limiting the method’s applicability. Ruchte and Grabocka [] augment the input of the network with desired tradeoff, hence achieving a memory efficient solution that can be trained with a single run but the conditioning of the network is obfuscated by the nonlinear dynamics of several layers. Dimitriadis et al. [] offer a geometric view on the dimensionality of the subspace encoding Pareto solutions and employ weight ensembles to continuously approximate the Pareto Front. However, associating each task with its distinct member in the ensemble leads to linear memory complexity and restricts the effectiveness of the method. In contrast, our proposed method models architecturally the alignment of preferences and losses, allocating only the adapters towards task-specific features, while the core neural network remains stable during training, learning general features and improving convergence.

#### Paremeter-Efficient Fine-Tuning

Parameter-efficient fine-tuning strategies have significantly advanced the adaptation of large pre-trained models to specific tasks without extensive re-training. Aghajanyan et al. [] showed that fine-tuning pre-trained models occurs in low-dimensional subspaces and multiple works have algorithms that operate on such subspaces to endow the pre-trained models with new capabilities. Prompt Tuning [] utilizes trainable vectors to guide the model’s predictions, while Prefix Tuning [], employs trainable prefixes to adjust the transformer’s attention mechanisms. [] inserted small trainable modules between pre-trained model layers while [] demonstrated that fine-tuning even minimal parameters, specifically bias terms, can be effective. Hu et al. [] proposed fine-tuning only a low-rank decomposition of each layer’s weight matrix, reducing computational and memory costs. This sparked a series of methodologies; LoRAHub [] allows the composition if multiple LoRA modules trained on different tasks, []
dynamically adjusting the rank of each layer’s decomposition ,
[] reduces the memory overhead by sharing random low-rank matrices across layers and optimizing only small scaling vectors. Compared to this class of methods, we employ low-rank adapters throughout training and not as a fine-tuning mechanism and towards efficiently approximating the Pareto Front, instead of optimizing over a single objective.

## 3 Multi-Objective Optimization and Pareto Front Learning

Consider a dataset $\mathcal{D}=\{(\bm{x}^{(i)},\bm{y}^{(i)})\}_{i=1}^{N}$ for samples $\bm{x}^{(i)}\in\mathcal{X}$ and labels $\bm{y}^{(i)}\in\mathcal{Y}$ and $T$ tasks. Each task $t\in[T]$ is associated with a loss $\mathcal{L}_{t}:\mathcal{Y}_{t}\times\mathcal{Y}_{t}\rightarrow\mathbb{R}_{+}$. The overall goal corresponds to the multi-objective optimization problem of minimizing the vector loss $\bm{L}=[\mathcal{L}_{1},\dots,\mathcal{L}_{T}]$.

We assume a general multi-task architecture comprising of an encoder $g(\bm{x},\bm{\theta}_{\textrm{enc}}):\mathcal{X}\times\Theta_{\textrm{enc}}
\rightarrow\mathcal{Z}$, mapping to embedding space $\mathcal{Z}$ and multiple decoders $f_{t}(\bm{z},\bm{\theta}_{t}):\mathcal{Z}\times\Theta_{t}\rightarrow\mathcal{Y
}_{t},t\in[T]$, where $\theta_{(\cdot)}$ represents network parameters.
Multi-Task Learning focuses on learning a model $f:\mathcal{X}\times\Theta\rightarrow\mathcal{Y}$ that performs well on all tasks. However, in the setting of vector optimization [], no single solution $\bm{\theta}$ can be optimal for all tasks simultaneously. In contrast, optimality is sought in the Pareto sense, i.e., a solution $\bm{\theta}^{*}$ is Pareto optimal if there is no other solution $\bm{\theta}^{\prime}$ that is better for all tasks. Formally:

###### Definition 1 (Pareto Optimality) .

Let $\mathcal{L}_{t}(\mathcal{Y}_{t},f(\mathcal{X}_{t},\bm{\theta}))=\mathcal{L}_{t
}(\bm{\theta})$. Assume two solutions $\bm{\theta},\bm{\theta}^{\prime}\in\Theta$ in parameter space. A point $\bm{\theta}$ dominates a point $\bm{\theta}^{\prime}$ if $\mathcal{L}_{t}(\bm{\theta})\leq\mathcal{L}_{t}(\bm{\theta}^{\prime})$ $\forall t\in[T]$ and $\boldsymbol{L}(\bm{\theta})\neq\boldsymbol{L}(\bm{\theta}^{\prime})$. Then, a point $\bm{\theta}$ is called Pareto optimal if there exists no $\bm{\theta}^{\prime}$ that dominates it. The set of Pareto optimal points forms the Pareto Set $\mathcal{P}_{S}$ and its image in objective space is known as the Pareto Front $\mathcal{P}_{F}$.

Let $\Delta_{T}=\{\bm{\lambda}\in\mathbb{R}^{T}_{+}:\sum_{t=1}^{T}\lambda_{t}=1\}$ be the $T$-dimensional simplex representing the set of all possible user preferences and $\ell:\Theta\rightarrow\mathbb{R}_{+}^{T}$ a mapping from weight to objective space, i.e., $\ell(\bm{\theta})=[\mathcal{L}_{1}(\bm{\theta}),\dots,\mathcal{L}_{T}(\bm{
\theta})]$. For a given preference vector $\bm{\lambda}\in\Delta_{T}$ as input, the overall objective of Pareto Front Learning is a weight generating mechanism $h:\Delta_{T}\rightarrow\Theta$ such that $\mathcal{P}_{S}=h(\Delta_{T})$ and the function $\ell\circ h$ is monotonic, i.e., increasing the importance of one task leads to its loss decrease.

Our goal is discovering a Pareto Subspace [], i.e., a low-dimensional subspace that approximates the Pareto Front in a single training run. In the nect section, we introduce PaLoRA, which effectively addresses this problem by augmenting each layer’s weight matrices with task-specific low rank matrices of appropriate dimensions.

###### Definition 1 (Pareto Optimality) .

## 4 PaLoRA: Pareto Low-Rank Adapters

Consider the case of a single layer parameterized by $\bm{W}\in\mathbb{R}^{n\times m}$. We omit bias terms for simplicity. The output of the layer is $\bm{y}=\bm{W}\bm{x}$ for $\bm{x}\in\mathbb{R}^{m}$. Each task $t\in[T]$ augments the set of learnable parameters by introducing low-rank matrices $\bm{A}_{t}\in\mathbb{R}^{n\times r},\bm{B}_{t}\in\mathbb{R}^{r\times m},t\in[T]$ and $r\ll\min\{n,m\}$. The output of the layer now becomes:

$$ $\bm{y}^{\prime}=\left(\bm{W}+{\color[rgb]{0,0,0}\definecolor[named]{ pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill {0}\frac{\alpha}{r}}\sum\limits_{t=1}^{T}\lambda_{t}\bm{A}_{t}\bm{B}_{t}\right )\bm{x}$ (1) $$

for $\bm{\lambda}=[\lambda_{1},\dots,\lambda_{T}]^{\top}\in\Delta_{T}$ and $\alpha$ a scaling factor that tunes the emphasis on the low-rank residuals [].
During each training iteration, random weightings $\bm{\lambda}$ are drawn, and a direct link between each task and its corresponding adapter is formed by defining the total loss as
$\bm{\lambda}^{\top}\bm{L}=\sum_{t=1}^{T}\lambda_{t}\mathcal{L}_{t}$.
This alignment ensures that the contribution of the adapter matches the loss weight of the task.
Figure 1 illustrates the method in the case of three tasks. PaLoRA establishes a clear division of labor between the base network and the task-specific adapters. The former’s involvement in the weight generation mechanism of Equation 1 is not a function of the drawn preference $\bm{\lambda}$ but always present, helping convergence by keeping the major part of the representation steady.

PaLoRA is based on parameter-efficient approaches [, , , , ] and is, therefore, by design compatible with pre-trained models and able to take advantage of the knowledge embedded in foundation models []. In contrast, previous PFL solutions, e.g. hypernetworks, are not easily adaptable to such settings and do not scale to the size of such large models. As a consequence, our method can be launched as second phase of training, similar to the setting studied by Ma et al. [], where once a multi-task solution has been attained, e.g., using NashMTL [] or linear scalarization, a second phase expands the Pareto Front in the neighborhood of the solution. While our method is based on LoRA [], in principle any other parameter-efficient fine-tuning method [, ] can be employed instead.

### 4.1 Improving convergence with deterministic preference schedule

Previous Pareto Front Learning algorithms suffer from slow convergence rates and may require elaborate learning rate schedules [, ] to produce a wide Pareto Front.
Drawing a single random weighting $\bm{\lambda}$ on every batch introduces variance in the gradient updates, since $\bm{\lambda}$ determines both the model’s representation and the overall scalarized objective. Given that neural networks are believed to initially learn general features and specialize during the later training stages [, , , ], we propose to sample multiple preference vectors per batch with a schedule mimicking the training dynamics. Assuming $M$ samples $\{\bm{\lambda}_{0}^{(m)}\}_{m=1}^{M}$ evenly spaced in the simplex $\Delta_{T}$, the preferences for time $\tau\in[0,1]$, where $\tau=0$ and $\tau=1$ correspond to the beginning and end of training, respectively, are annealed as follows:

$$ $\lambda_{\tau,t}^{(m)}=\frac{\left(\lambda_{0,t}^{(m)}\right)^{\tau/T_{max}}}{ \sum_{k=1}^{T}\left(\lambda_{0,k}^{(m)}\right)^{\tau/T_{max}}}$ (2) $$

where $T_{max}$ is a hyperparameter controlling the temperature of the annealing. In the initial training stages, the preferences are concentrated in the center and progressively more to the faces of the simplex, as shown in Figure 2 for 2 dimensions and in Figure 9 of the appendix for 3 dimensions. The schedule is deterministic in order to minimize the effect of pernicious updates due to potential imbalanced samplings and therefore discards the need for regularization terms [, ].

### 4.2 Memory Complexity

Figure: Figure 2: Deterministic sampling schedule of user preferences for two tasks as a function of time. For each training batch, multiple preferences $\bm{\lambda}=[\lambda,1-\lambda]$ are deterministically drawn, focusing progressively more towards learning task-specific features. We only show the first task weight $\lambda$.

Our proposed method incurs low memory overhead. Each layer can take values in the convex hull formed by the tasks’ LoRA products $\bm{A}_{t}\bm{B}_{t},t\in[T]$ and centered in $\bm{W}$. By modulating the rank $r$ of the adapters, we can control the number of parameters of the layer as well as their expressivity, allowing for task-specific features to be steered to the main backbone or the adapters. In terms of memory requirements, the original layer has $mn$ parameters, while the PaLoRA layer has $mn+Tr(m+n)$.

## 5 Experiments

In this section, we evaluate PaLoRA on a variety of tasks and datasets, ranging from multi-label classification in MultiMNIST to complex scene understanding benchmarks in CityScapes and NYUv2.

#### Baselines

We compare against a diverse set of algorithms, including Single-Task Learning (STL), multi-task learning methodologies based on loss balancing, as in linear scalarization [], UW [], DWA [], RLW []. Our baselines also include gradient balancing MTL approaches in
MGDA [], PCGrad [], IMTL [], Graddrop [], CAGrad [], Nash-MTL [], Auto-$\lambda$ [] and RotoGrad [].
We also explore methods with the same goal as ours, namely approximating the Pareto Front with a single training run, such as
Pareto HyperNetwork (PHN) [],
Conditioned One-shot Multi-Objective Search (COSMOS) , [] and Pareto Manifold Learning (PaMaL) [].
For Pareto Front Learning methods, evaluation is performed on a grid of evenly spaced points spanning the $T$-dimensional simplex $\Delta_{T}=\{\bm{\lambda}\in\mathbb{R}^{T}_{+}:\sum_{t=1}^{T}\lambda_{t}=1\}$. For MultiMNIST and CityScapes, we report the experimental results from previous works [].

Figure: Figure 3: Results on MultiMNIST, Pareto Front Learning methods are presented as lines, while multi-task learning techniques in gray scatter points. We use 3 seeds per method. PaLoRA outperforms baselines and achieves higher average Hypervolume while requiring less memory vs other PFL algorithms.
Refer to caption: x2.png

### 5.1 Multi-Label Classification

First, we test the effectiveness of PaLoRA on MultiMNIST, a digit classification dataset based on MNIST and use a LeNet architecture [], trained for 10 epochs. PaLoRA augments the original shared-bottom model with task-specific low-rank adapters, per task and per layer. Figure 3 presents the results for a combination of scaling $\alpha$ and annealing temperature set via a held-out validation dataset, as outlined in Figure 7 of the appendix. Compared to standard MTL approaches that result in a single point in objective space, Pareto Front Learning methodologies discover a subspace of solutions, parameterized by the user preference $\bm{\lambda}$ in Equation 1. We use rank $r=1$, resulting in $12.5\%$ additional trainable parameters compared to the base multi-task model, i.e., the scatter points in the plot.
In contrast, PaMaL [] doubles the trainable parameters, PHN [] requires $~{}\times 100$ memory overhead and COSMOS [] has low hypervolume. More details can be found in the appendix.
Overall, our method achieves superior performance compared to other PFL methods, while requiring far less parameters.

**Table 1: CityScapes: Test performance averaged over 3 seeds, $\Delta_{p}$ is the parameter count increase w.r.t. the MTL model. We highlight the best and second best results per task. PaLoRA outperforms methods in both categories, while introducing a small parameter increase and allowing for user control.**
|  |  | Segmentation |  | Depth |  | $\Delta_{p}\%\downarrow$ | Controllable |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | mIoU $\uparrow$ | Pix Acc $\uparrow$ |  | Abs Err $\downarrow$ | Rel Err $\downarrow$ |  |  |  |
|  | STL | $70.96$ | $92.12$ |  | $0.0141$ | $38.6435$ |  | $0\%$ | ✗ |
| MTL | LS [] | $70.12$ | $91.90$ |  | $0.0192$ | $124.0615$ |  | $0\%$ | ✗ |
| UW [] | $70.20$ | $91.93$ |  | $0.0189$ | $125.9433$ |  | $0\%$ | ✗ |  |
| MGDA [] | $66.45$ | $90.79$ |  | 0.0141 | 53.1376 |  | $0\%$ | ✗ |  |
| DWA [] | $70.10$ | $91.89$ |  | $0.0192$ | $127.6589$ |  | $0\%$ | ✗ |  |
| PCGrad [] | $70.02$ | $91.84$ |  | $0.0188$ | $126.2551$ |  | $0\%$ | ✗ |  |
| IMTL [] | $70.77$ | $92.12$ |  | $0.0151$ | $74.2300$ |  | $0\%$ | ✗ |  |
| CAGrad [] | $69.23$ | $91.61$ |  | $0.0168$ | $110.1387$ |  | $0\%$ | ✗ |  |
| Nash-MTL [] | $\mathbf{71.13}$ | $\mathbf{92.23}$ |  | $0.0157$ | $78.4993$ |  | $0\%$ | ✗ |  |
| RLW [] | $68.79$ | $91.52$ |  | $0.0213$ | $126.9423$ |  | $0\%$ | ✗ |  |
| Graddrop [] | $70.07$ | $91.93$ |  | $0.0189$ | $127.1464$ |  | $0\%$ | ✗ |  |
| RotoGrad [] | $69.92$ | $91.85$ |  | $0.0193$ | $127.2806$ |  | $0\%$ | ✗ |  |
| Auto-$\lambda$ [] | $70.47$ | $92.01$ |  | $0.0177$ | $116.9594$ |  | $0\%$ | ✗ |  |
| PFL | COSMOS [] | 69.78 | 91.79 |  | 0.0539 | 136.614 |  | $\ll 1\%$ | ✓ |
| PaMaL [] | 70.35 | 91.99 |  | $\underline{0.0141}$ | 54.520 |  | $100\%$ | ✓ |  |
| PaLoRA [ours] | 71.11 | 92.21 |  | $\mathbf{0.0140}$ | 51.2672 |  | $4.2\%$ | ✓ |  |

### 5.2 Scene Understanding

#### CityScapes

We explore the experimental setups of previous works [, , , , ] on scene understanding benchmarks. CityScapes [] contains high-resolution urban street images and we focus on the task combination of semantic segmentation and depth regression. We use 500 of the 2975 training images for validation, and, during training, the images are resized to $128\times 256$ pixels for computational reasons. We train a SegNet [] for 100 epochs, using Adam optimizer [] with learning rate $10^{-4}$ that is halved after 75 epochs. The results are presented in Table 1 for rank $r=4$ and $m=5$.
In terms of PFL baselines, while COSMOS [] increases slightly the number of trainable parameters, its poor performance on the task of depth estimation renders it non-competitive. Compared to PaMaL [], our proposed method leads to improvements across tasks while reducing the memory overhead $\sim 23.8$ times.

#### NYUv2

We also explore the NYUv2 dataset [] of indoor scenes with RGBD images and dense per-pixel labeling with 13 classes. Similar to previous MTL works [, , , ], we consider the tasks of semantic segmentation, depth estimation, and surface normal prediction, and report the results in Table 2. We reserve 95 images for validation and use a setup similar to CityScapes but train for 200 epochs, the full experimental details are provided in the appendix. To the best of our knowledge, and due to scalability, PaLoRA is the first Pareto Front Learning method to explore benchmarks as challenging as NYUv2.
Additionally to Pareto HyperNetworks [], we omit the COSMOS baseline [] due to its poor performance on CityScapes. PaLoRA is the only Pareto Front Learning method that scales to the complexity of the benchmark without incurring large memory costs, while PaMaL [] requires 3 times the memory of the original model, PaLoRA needs $6.3\%$ more parameters.

**Table 2: NYUv2: Test performance averaged over 3 seeds. $\Delta_{p}$ is the parameter count increase w.r.t. the multi-task model. We highlight the best and second best results per task. PaLoRA outperforms methods in both classes, and is superior to PaMaL [] while requiring $31.7\times$ less parameters.**
|  |  | Segmentation |  | Depth |  | Surface Normal |  | $\Delta_{p}\%\downarrow$ | Controllable |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | mIoU $\uparrow$ | Pix Acc $\uparrow$ |  | Abs Err $\downarrow$ | Rel Err $\downarrow$ |  | Angle Distance $\downarrow$ |  | Within $t^{\circ}\uparrow$ |  |  |  |  |  |  |
|  |  |  |  |  |  |  |  | Mean | Median |  | 11.25 | 22.5 | 30 |  |  |  |
|  | STL | $36.58$ | $62.62$ |  | $0.6958$ | $0.2737$ |  | $25.27$ | $18.25$ |  | $32.33$ | $59.09$ | $70.00$ |  | $0\%$ | ✗ |
| MTL | LS [] | $36.33$ | $62.98$ |  | $0.5507$ | $0.2224$ |  | $27.71$ | $21.84$ |  | $26.44$ | $51.72$ | $63.90$ |  | $0\%$ | ✗ |
| UW [] | $31.68$ | $60.11$ |  | $0.5509$ | $0.2242$ |  | $28.30$ | $22.59$ |  | $25.74$ | $50.33$ | $62.49$ |  | $0\%$ | ✗ |  |
| MGDA [] | $31.19$ | $60.22$ |  | $0.5745$ | $0.2267$ |  | $\mathbf{24.84}$ | $\mathbf{18.30}$ |  | $\mathbf{32.45}$ | $\mathbf{59.04}$ | $\mathbf{70.28}$ |  | $0\%$ | ✗ |  |
| DWA [] | $37.09$ | $63.69$ |  | $0.5463$ | $0.2225$ |  | $27.57$ | $21.79$ |  | $26.55$ | $51.78$ | $64.02$ |  | $0\%$ | ✗ |  |
| PCGrad [] | $36.83$ | $63.43$ |  | $0.5504$ | $0.2182$ |  | $27.44$ | $21.57$ |  | $26.90$ | $52.25$ | $64.40$ |  | $0\%$ | ✗ |  |
| IMTL [] | $36.43$ | ${63.96}$ |  | $0.5437$ | $0.2203$ |  | $25.87$ | $19.63$ |  | $30.02$ | $56.19$ | $67.95$ |  | $0\%$ | ✗ |  |
| Nash-MTL [] | $\underline{37.66}$ | $\underline{64.75}$ |  | $\mathbf{0.5279}$ | $\mathbf{0.2109}$ |  | $\underline{25.56}$ | $19.30$ |  | $30.59$ | $\underline{56.90}$ | ${68.55}$ |  | $0\%$ | ✗ |  |
| RLW [] | $33.86$ | $61.49$ |  | $0.5692$ | $0.2271$ |  | $29.06$ | $23.68$ |  | $24.06$ | $48.27$ | $60.67$ |  | $0\%$ | ✗ |  |
| Graddrop [] | $36.98$ | $63.31$ |  | $0.5423$ | $0.2204$ |  | $27.64$ | $21.89$ |  | $26.38$ | $51.64$ | $63.93$ |  | $0\%$ | ✗ |  |
| PFL | PaMaL [] | $33.94$ | $62.55$ |  | $0.5592$ | $0.2188$ |  | $26.60$ | $20.33$ |  | $29.09$ | $54.61$ | $66.35$ |  | $200\%$ | ✓ |
| PaLoRA [ours] | $\mathbf{38.27}$ | $\mathbf{64.79}$ |  | 0.5370 | 0.2150 |  | 25.66 | 19.34 |  | 30.47 | 56.90 | 68.56 |  | 6.3% | ✓ |  |

### 5.3 Continuous Pareto Expansion

Previous sections have studied randomly initialized models trained from scratch. However, PaLoRA is also compatible as a second stage of training, akin to the original intention of low-rank adapters for fine-tuning [].
Similar to Ma et al. [] and given a pre-trained model with parameters $\bm{\theta}_{0}$, we aim to expand the Pareto Front locally and continuously in the neighborhood of $\bm{\theta}_{0}$. For simplicity, we use checkpoints $\bm{\theta}_{0}$ trained with linear scalarization [] and finetune only the adapters with the same learning rate as the final training iteration. The results for MultiMNIST and CityScapes are shown in Figure 4, using the same rank $r$ as the full-training experiments. Fine-tuning lasts 4 and 5 epochs, respectively, which correspond to $40\%$ and $5\%$ of the original training budget. For both datasets, we observe that PaLoRA is able to expand the Pareto Front locally and improves the performance of the initial model.
We observe that the scaling $\alpha$ controls the spread of the Pareto Front, while the middle plot of Figure 4 shows that the annealed deterministic sampling gradually increases functional diversity. For CityScapes, we observed a cold start phenomenon, where the adapters did not become Pareto aligned until after a few epochs.
For CityScapes, PaLoRA introduces a $4.2\%$ memory overhead to store the adapters, provides a linear segment of weight space that maps to the Pareto Front and is aligned with the input preference vector $\bm{\lambda}\in\Delta_{2}$. In contrast, the storage cost of [] is prohibitive, since it requires storing multiple checkpoints generated from the seed weights $\bm{\theta}_{0}$ to form a piecewise-linear Pareto Front.

Figure: Figure 4: Pareto Front Expansion. Given a multi-task checkpoint $\bm{\theta}_{0}$, marked as $\mathbin{\vbox{\hbox{\scalebox{1.0}{$\bullet$}}}}$, PaLoRA expands locally the Pareto Front in its neighborhood $\mathcal{N}(\bm{\theta}_{0})$. (Left) The scaling $\alpha$ of Equation 1 determines the functional diversity of the final MultiMNIST Front. (Middle) The epoch-by-epoch progression of the MultiMNIST Pareto Front expansion. (Right) The final CityScapes Pareto Front.
Refer to caption: x3.png

### 5.4 Division of labor between core neural network and adapters

The separation of feature building objectives among the adapters originates from the training algorithm and visually from Figure 3. While in training we only considered preference vectors $\bm{\lambda}$ in the $T$-dimensional simplex $\Delta_{T}$, we now study the behavior when escaping the simplex and try to remove the task-specific knowledge. We consider the pseudopreferences $\bm{\lambda}\in\{(0,0),(1,-1),(-1,1)\}$, which roughly correspond to the model with only general features, forgetting the second and the first task, respectively. As a control, we also report the performance of actual preferences $\bm{\lambda}\in\{(1,0),(0,1),(0.5,0.5)\}$ and present the results in Figure 5 for the MultiMNIST benchmark. We observe that escaping the training subspace of the unit simplex reveals the specialized knowledge of the adapters. Removing the contribution of the first task, i.e., $\bm{\lambda}=(-1,1)$, significantly reduces its performance, while the effect on the second task is less pronounced. Similarly, the core neural network lacks the discriminative features of the adapters, while subtracting both of them in $\bm{\lambda}=(-1,-1)$ leads to random chance predictions.
This setting is similar to the evaluation of task arithmetic [, , ], where negating the contribution of one task leads to forgetting it. However, the difference lies in
that the adapters are trained in tandem and not independently and, as a consequence, there is still knowledge transfer and not such a clear cut separation.

Figure: Figure 5: Performance as a function of the preference $\bm{\lambda}\in\mathbb{R}^{2}$. While selecting preferences $\bm{\lambda}\in\Delta_{2}$ used in training maintains high performance on both tasks, pseudopreferences $\bm{\lambda}\notin\Delta_{2}$ reveal that adapters are task-specific: negating the contribution of one leads to forgetting the associated task.
Refer to caption: x4.png

### 5.5 Ablation study on preference sampling

We evaluate the effect of the sampling procedure as a function of the number of samples $m\in\mathbb{N}$, whether they are drawn from a random distribution or deterministically and the effect of annealed schedule. The random distribution is a centered Dirichlet $\bm{\lambda}^{(1)},\dots,\bm{\lambda}^{(m)}\sim\textrm{Dirichlet}(p(1-\tau)\bm
{1})$ for timestep $\tau\in[0,1]$ and base concentration $p>0$. As $\tau$ increases the sampled weightings shift focus from the center of the simplex towards the edges.
We consider the cases of $m\in\{3,5,7,9\}$, deterministic and Dirichlet sampling, fixed or annealed schedule and several temperatures for each sampling category. A detailed description of the search space can be found in Appendix C. Figure 6 presents the results in terms of HyperVolume [] and Spearman Correlation. The former metric computes the volume between a reference point and the Pareto Front, focusing on the quality of the solution set, while the latter metric, used in [], is a proxy for the functional diversity and captures the monotonicity outlined in Definition 1. Here, we focus solely on the choice of sampling mechanism, while Figure 10 of the appendix presents the effect of the other hyperparameters of the grid search.
We observe via the color code of Figure 6 that allowing for randomness leads to instability; while a high hypervolume can be achieved, a large portion of the Pareto Front is dominated. On the other hand, a deterministic sampling procedure allows for a well spread Pareto Front and is more robust to the choice of hyper-parameters. Specifically, a deterministic schedule can be used with lower $m$, reducing the memory overhead introduced by the multiple forward passes.

Figure: Figure 6: Ablation Study on the choice of preference vector sampling. Each scatter point corresponds to a different combination of scaling $\alpha$ and number of forward passes $m\in\mathbb{N}$. Deterministic schedules result in lower Spearman correlation reflecting more functionally diverse Pareto Fronts.
Refer to caption: x5.png

## 6 Conclusion and Limitations

In conclusion, PaLoRA, addresses the limitations of existing Pareto Front Learning methodologies by introducing a parameter-efficient approach that augments the original model with task-specific low-rank adapters. Our proposed method effectively separates the learning of general and task-specific features, facilitated by a carefully designed sampling schedule. Our extensive experimental results demonstrate that PaLoRA not only surpasses Pareto Front Learning baselines in multi-label classification and scene understanding tasks but also achieves scalability to larger networks with limited memory overhead while staying competitive or outperforming Multi-Task Learning baselines. By providing a continuous parameterization of the Pareto Front and ensuring efficient use of memory, PaLoRA offers a promising solution for real-world applications. A limitation inherent to Pareto Front Learning is the curse of dimensionality; as the number of tasks increase exploring the preference simplex $\Delta_{T}$ becomes computationally expensive and can hinder convergence. Interesting future directions are investigating how deterministic sampling can alleviate this problem and how other parameter-efficient fine-tuning techniques [, , ] can further reduce the memory overhead of Pareto Front Learning.

## Appendix A Experimental details

All experiments are conducted with PyTorch[] in Tesla V100-SXM2-32GB GPUs. We use three seeds per method. Our source code extends the codebases of previous works [, , ]. We use the MultiMNIST variant from []. For CityScapes and NYUv2, we use the variants from [], that are also explored in [, , , ].

### A.1 Full training

#### MultiMNIST

We use the same settings as []. For all experiments the rank is set to $r=1$. We perform a grid search on the scaling $\alpha\in\{1,2,5,10\}$ and annealing temperature $T$ and report the results in Figure 7 and Figure 8 in terms of validation accuracy and loss. We use 3 seeds per configuration and report the results that achieve the highest average hypervolume []. We train for 10 epochs.

Figure: Figure 7: Ablation on the scaling parameter $\alpha$, defined in Equation 1, and the annealing temperature $T$ for the validation set of MultiMNIST. We omit Pareto Front Learning baselines to reduce visual clutter and present 3 seeds for each configuration. We observe that higher temperatures and scales leads to larger Pareto Fronts. Figure 3 presents the test results for the configuration with the highest mean hypervolume.
Refer to caption: x6.png

Figure: Figure 8: Validation losses for the setting outlined in Figure 7.
Refer to caption: x7.png

#### CityScapes

We use the same settings as []. A modified version of the same experiment was also presented in [, , , ]; the difference is the existence of a validation set and training lasts 100 epochs. We use the SegNet architecture [], not the MTAN [] variant for computational reasons. We train for 100 epochs.

#### NYUv2

We use the experimental settings from []. We use a SegNet architecture [], not the MTAN [] variant for computational reasons. We use 95 out of 795 training images for validation. We train for 200 epochs.

### A.2 Runtime

The runtime depends on the number of forward passes, denoted as $m$. For $m=1$, each experiment takes $\sim 1$ min. We also perform evaluation on a held-out dataset every $k$ epochs. Evaluation for Pareto Front Learning is expensive since we evaluate the performance for models formed for various preferences $\bm{\lambda}\in\Delta_{T}$. Hence, evaluation time scales linearly with the number of sampled points. For instance, for two tasks, we use 11 evenly spaced points in [0,1]. For $m=1$, the experiments on MultiMNIST, CityScapes, NYUv2 take $\sim 1$ min, $\sim 90$ mins and $\sim 4.5$ hours. For the scene understanding benchmarks, we use a gradient balancing algorithm similar to [] and used in [], since the results were superior. Gradient balancing algorithms have longer runtimes compared to loss-balancing ones, e.g., [, ]. The above runtime numbers refer to gradient balancing.

### A.3 Pareto expansion

We use exactly the same settings as in full training, the only difference is the number of epochs. For MultiMNIST we use 4 epochs and for CityScapes 5 epochs. In both cases, the initial checkpoint, denoted as $\bm{\theta}_{0}$ in the main text, corresponds to the first seed of the Linear Scalarization [] baseline.

## Appendix B Deterministic schedule

Section 4.1 discusses the deterministic sampling mechanism. In Equation 2, the preference vectors for a given timestep $\tau\in[0,1]$ are a function of the base preferences $\{\bm{\lambda}_{0}^{(m)}\}_{m=1}^{M}$. For two tasks, we use torch.linspace(0, 1, M) to produce $\lambda$ in $[0,1]$. The vector preference is then $\bm{\lambda}=[\lambda,1-\lambda]$. For 3 tasks, we use the meshzoo library to produce the initial evenly distributed set in the simplex.
Example for the 2d case are provided in Figure 2, while Figure 9 shows the case for three tasks.

Figure: Figure 9: Examples of annealing in the case of 3 tasks for $m=10$ points. Similar to the 2d case, the points are initially set in the center of the simplex and gradually towards the edges.
Refer to caption: x8.png

## Appendix C Details of the Ablation study on preference sampling

This section describes in greater detail the settings of the ablation study of Section 5.5.
We ablate on the following dimensions:

- 1.
number of forward pass $m\in\{3,5,7,9\}$,
- 2.
scaling $\alpha\in\{1,2,5,10\}$, defined in Equation 1,
- 3.
the following sampling schedules:
(a)
Deterministic sampling with annealing, defined in Equation 2. We explore temperature parameters $T_{max}\in\{1,2,5\}$,
(b)
Deterministic sampling without annealing, defined in Equation 2 if $\tau=1$ regardless of training iteration. We explore temperature parameters $T_{max}\in\{1,2,5\}$,
(c)
Random sampling with annealing using the Dirichlet distribution $\textrm{Dirichlet}(p(1-\tau)\bm{1})$ for $p\in\{1,2,5\}$,
(d)
Random sampling without annealing using the Dirichlet distribution $\textrm{Dirichlet}(p\bm{1})$ for $p\in\{1,2,5\}$.

We use 3 seeds per configuration and present the results as a scatter plot in Figure 6. Figure 6 of the main text shows the results focusing on the sampling mechanism only. Figure 10 and Figure 11 are supplementary to Section 5.5 of the main text, showing the effect of other hyperparameters as well.

Figure: Figure 10: [Complement to Figure 6]: Ablation Study on the choice of preference vector sampling (in color) and the effect of scaling $\alpha$ (marker size) and number of forward passes $m\in\mathbb{M}$ (marker shape). Deterministic schedules result in lower Spearman correlation reflecting more functionally diverse Pareto Fronts.
Refer to caption: x9.png

Figure: Figure 11: [Complement to Figure 10]: The y-axis changes to the number of nondiminated points.
Refer to caption: x10.png

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see the weaknesses.
soundness: 2
strengths: 1. This paper is well-organized and clearly written.
2. The idea of decouple a neural network into a general feature extrator and several task-specific low-rank adapters is reasonable.
summary: This paper introduces a new method called PaLoRA (Pareto Low-Rank Adapters) to address efficiency issues in multi-task learning. PaLoRA enhances any neural network architecture by adding task-specific low-rank adapters and continuously parameterizing the Pareto frontier within their convex hull. This approach encourages the original model and adapters to learn general features and task-specific features, respectively, thereby improving the model's flexibility and efficiency.
Additionally, the paper proposes a deterministic sampling schedule. This schedule reinforces the division of labor between tasks, accelerates convergence, and strengthens the validity of the mapping from preference vectors to the objective space. Specifically, the sampling schedule evolves over training time, gradually shifting the focus from learning general features to learning task-specific features, ensuring the effectiveness and stability of the training process.
weaknesses: 1. The key equation (2) is quite similar to LoRA (Low-Rank Adaptation). And there are many multi-LoRA methods proposed for multi-task learning. However, the authors have missed. Please tell us the benefits of the proposed method compared with the multi-LoRA methods (e.g., [1-4]).
2. Fig.2 is difficult to understand. First, how is $\lambda$ changed over time? Second, how to judge the quality of the mappings from preference to objective space?
3. For Fig.3, why are there fewer or even no compared methods in (b) and (c)?
4. In Table 1 and Table 2, the proposed PaLoRA performs similarly to the other MTL methods. If the main purpose is accelerating convergence and reducing the memory requirements, then, I think it should be compared with the multi-LoRA methods [1-4].
5. The effects of the hyper-parameters (e.g., $\alpha$, $r$, and $Q$) on the results are not well studied in the experiments.

[1] Mixture-of-Subspaces in Low-Rank Adaptation, EMNLP 2024.
[2] Loraretriever: Input-aware lora retrieval and composition for mixed tasks in the wild, ACL 2024.
[3] HydraLoRA: An Asymmetric LoRA Architecture for Efficient Fine-Tuning, NeurIPS 2024.
[4] Mixture-of-LoRAs: An Efficient Multitask Tuning for Large Language Models, COLING 2024.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. Why does PaLoRA has a memory overhead compared against the MTL baseline? If I understand this correctly, only the LoRAs are trained, albeit one for each task. But training a LoRA only costs a fraction of the memory required for fine-tuning the whole model, which is needed for MTL if I didn't misunderstand the settings.

2. For M>1, is it essentially doing gradient accumulation? Otherwise what does multiple forward passes refer to?
soundness: 3
strengths: 1. The proposed method uses low-rank adaptors to encode weight updates in multi-task learning, and is more efficient compared to previous work. Specifically, it achieves over $\times 20$ reduction of memory usage. This is particularly impactful in real-world applications, where large neural networks are typically memory-intensive and costly to scale.

2. The proposed deterministic sampling of preference, i.e., $\lambda$, seems like a notable improvement over the existing random sampling strategy. The annealing strategy is fairly well motivated. By gradually moving $\lambda$ from the centre of the simplex to the faces, the sampled point transition from general models to more task-specific ones. This was shown to increase the convergence speed and stability.

3. The paper presented fairly comprehensive experiments across multiple benchmarks and demonstrates the superior performance of the proposed method over existing PFL methods, despite the occasional lower performance compared to MTL methods. The paper also includes rich visualisations that very well illustrates the ideas behind the method and the experimental results.
summary: The paper presented a multi-task learning method using low-rank adaptors. The paper formulates the multi-task learning problem as Pareto Front Learning, where points on the Pareto Front are sampled and optimised in training. Different from previous work which uses random sampling for such point, the paper proposed to use fixed interval, sampled either evenly or using a pre-defined schedule. Across different benchmarks, the method outperforms other Pareto Front Learning methods, while sometimes underperforms conventional multi-task learning methods.
weaknesses: 1. Being able to construct a Pareto Front of models is in itself an interesting result. But what is the practical value of this? The objective of multi-task learning is to produce one model that performs well on two or more tasks. By this definition, it seems sufficient to just have one model, or rather one point on the Pareto Front. I think it will make the paper much stronger if some practicality can be demonstrated, besides the nice theoretical result. Perhaps the Pareto Front can help in OOD scenarios. For instance, after a model is trained on cityscapes for segmentation and depth estimation, when it is tested on MS COCO for segmentation, I imagine MTL methods might be less effective due to the distribution shift, but the proposed method can still adjust the coefficients/preference to the new dataset.

2. The contribution of the fixed schedule is not the most convincing. The disadvantage of random sampling according to the paper seems to be that it produces a tight cluster of sampled points. This may be related to the distribution used rather than the random sampling process. In addition, there doesn't seem to be any experiments showing the improvement of the annealed schedule compared against the even-sampling strategy.

3. The motivation of the annealed strategy seems to be mimicking the training dynamics, where the network learn generic features in early stages while specialise in later stages. I don't think this is a homogeneous behaviour across the entire model. Usually the shallow layers of model extract generic, low-level features while the deeper layers extract task-specific features. Perhaps it makes more sense to apply this annealed schedule layer wise, instead of chronologically. There is in fact an increasing body of work on multi-task learning/model merging using learned layer-wise coefficients, such as Zhang et al. (2024) and Yang et al. (2024). I think the annealed schedule will make more sense in this context. 

Refs:

- Zhang et al., Knowledge Composition using Task Vectors with Learned Anisotropic Scaling. NeurIPS 2024
- Yang et al., AdaMerging: Adaptive Model Merging for Multi-Task Learning. ICLR 2024

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: See weaknesses.
soundness: 3
strengths: 1. This paper proposes to address multi-task learning with multiple low-rank adapters equipped with Pareto Front Learning.
summary: This paper proposes Pareto Low-Rank Adaptors (PaLoRA), which are claimed to address the problem of limited scalability, slow convergence, excessive memory requirements, and inconsistent mappings from preference to objective space that existed in previous methods. The goal is achieved by adding multiple task-specific low-rank adapters and optimizing the weights with Pareto Front. Experiments on multiple tasks and variant datasets show the effectiveness of the proposed method.
weaknesses: 1. It lacks discussions between PaLoRA and MoE-like methods.
2. It lacks discussions between PaLoRA and general adaptive weight learning methods. How is PaLoRA better and why?
3. It seems that this work applies PFL on multiple Lora, any significant differences between general PFL applications?
4. Comparisons between GFLOPS/Memory/Speed with other methods at the inference stage?
5. What is "Functional Diversity" in Sec 4.2? Any definitions or quantitative evaluations?
6. Any comparisons between PaLoRA and other LoRA-using methods on multi-task learning?
7. It points out the problem of " inconsistent mappings from preference to objective space", but no experiments and explanations validate the improvements or the relationship between mapping consistency and good performance/generalization on multiple tasks.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please refer to the "weaknesses".
soundness: 2
strengths: - The proposed method is more efficient regarding number of parameters, i.e., memory complexity, compared to PaMaL and outperforms it as well and they also scale up to larger number of tasks (as shown with the SARCOS).
- Interesting discussion sections that shows the efficiency of their method in converging faster and also the multiple adapters learning different tasks.
summary: PaLoRA presents a method for Pareto Front Learning (PFL) with two main contributions. First, the paper adds a low-rank adapter for each task, significantly reducing the overhead of the additional parameters added to the network. Second, they perform a deterministic (either fixed or annealing) preference sampling, leading to more stable learning and faster convergence.
weaknesses: - What happens if you train longer for the SARCOS dataset? I.e., Figure 3 (c) goes for more than 100 epochs (until convergence of each model)? How does PaLoRA compare to PaMaL?
- Have you done a ablation over different ranks for the LoRA modules? It would be great if you could report the numbers for different ranks.
- Please provide the standard deviation for the runs in Table 1 and also for the numbers for MultiMNIST (given the variance among the performances of PaLoRA on MultiMNIST and MultiMNIST-3).
- Would be great to have another dataset added to the experiments, such as  UCI Census-Income.
- Figure 3 (b) could improve and have the legends in the image.

Meta-review: The contribution of this work lies in utilizing PFL for multi-task learning, demonstrating significant memory efficiency and scalability compared to prior methods. The proposed deterministic sampling strategy for PFL introduces a well-motivated annealing mechanism that improves convergence speed and stability. Extensive experiments across benchmarks substantiate its effectiveness, despite occasional parity with existing multi-task learning methods. While reviewers have concerns on figure/table clarity and some implementation details, the authors sufficiently address their concerns. Weighing all the factors, I believe this paper is marginally above the threshold for acceptance.

Decision: Accept (Poster)