L EARNING THE P ARETO F RONT WITH H YPERNETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
Multi-objective optimization (MOO) problems are prevalent in machine learning.
These problems have a set of optimal solutions, called the Pareto front, where each point on the front represents a different trade-off between possibly conﬂicting objectives.
Recent MOO methods can target a speciﬁc desired ray in loss space, however most approaches still face two grave limitations: (i) A separate model has to be trained for each point on the front; and (ii) The exact trade-off must be known prior to the optimization process.
Here, we tackle the problem of learning the entire Pareto front, with the capability of selecting a desired operating point on the front after training.
We call this new setup Pareto-Front Learning (PFL).
We describe an approach to PFL implemented using HyperNetworks, which we term Pareto HyperNetworks (PHNs).
PHN learns the entire Pareto front simultaneously using a single hypernetwork, which receives as input a desired preference vector and returns a Pareto-optimal model whose loss vector is in the desired ray.
The uniﬁed model is runtime efﬁcient compared to training multiple models, and generalizes to new operating points not used during training.
We evaluate our method on a wide set of problems, from multi-task regression and classiﬁcation to fairness.
PHNs learns the entire Pareto front in roughly the same time as learning a single point on the front, and also reaches a better solution set.
PFL opens the door to new applications where models are selected based on preferences that are only available at run time.
I NTRODUCTION
Multi-objective optimization (MOO) aims to optimize several, possibly conﬂicting objectives.
MOO is abundant in machine learning problems, from multi-task learning (MTL), where the goal is to learn several tasks simultaneously, to constrained problems.
In such problems, one aims to learn a single task while ﬁnding solutions that satisfy properties like fairness or privacy.
It is common to optimize the main task while adding loss terms to encourage the learned model to obtain these properties.
MOO problems have a set of optimal solutions, the Pareto front , each reﬂecting a different trade-off between objectives.
Points on the Pareto front can be viewed as an intersection of the front with a speciﬁc direction in loss space (a ray, Figure 1).
We refer to this direction as preference vector , as it represents a single trade-off between objectives.
When a direction is known in advance, it is possible to obtain the corresponding solution on the front (Mahapatra & Rajan, 2020).
However, in many cases, we are interested in more than one predeﬁned direction, either because the trade-off is not known prior to training, or because there are many possible trade-offs of interest.
For example, network routing optimization aims to maximize bandwidth, minimizing latency, and obey fairness.
However, the cost and trade-off vary from one application running in the network to another, or even continuously change in time.
The challenge remains to design a model that can be applied at inference time to any given preference direction, even ones not seen during training.
We call this problem Pareto front learning (PFL).
Although several recent studies (Yang et al., 2019; Parisi et al., 2016) suggested to learn the trade-off curve in MOO problems, there is no existing scalable and general purpose MOO approach that provides Pareto-optimal solutions for numerous preferences in objective space.
Classical approaches,
[Figure]
like genetic algorithms, do not scale to modern high dimensional problems.
It is possible in principle to run a single-direction optimization multiple times, each for different preference, but this approach faces two major drawbacks: (i) Scalability – the number of models to be trained in order to cover the objective space grows exponentially with the number of objectives; and (ii) Flexibility – the decision maker cannot switch freely between preferences, unless all models are trained and stored in advance.
Here we put forward a new view of PFL as a problem of learning a conditional model, where the conditioning is over the preference direction.
During training, a single uniﬁed model is trained to produce Pareto optimal solutions while satisfying the given preferences.
During inference, the model covers the Pareto front by varying the input preference vector.
We further describe an architecture that implements this idea using HyperNetworks.
Speciﬁcally, we train a hypernetwork, termed
Pareto Hypernetwork (PHN), that given a preference vector as an input, produces a deep network model tuned for that objective preference.
Training is applied to preferences sampled from the m − dimensional simplex where m represents the number of objectives.
We evaluate PHN on a wide set of problems, from multi-class classiﬁcation, through fairness and image segmentation to multi-task regression.
We ﬁnd that PHN can achieve superior overall solutions while being 10 ∼ 50 times faster (see Figure 5).
PHN addresses both scalability and ﬂexibility.
Training a uniﬁed model allows using any objective preference at inference time.
Finally, as PHN generates a continuous parametrization of the entire Pareto front, it could open new possibilities to analyze Pareto optimal solutions in large scale neural networks.
Our paper has the following contributions:
• We deﬁne the Pareto-front learning problem – learn a model that at inference time can operate on any given preference vector, providing a Pareto-optimal solution for that speciﬁed objective trade-off.
• We describe Pareto hypernetworks (PHN), a uniﬁed architecture based on hypernetworks that addresses PFL and show it can be effectively trained.
• Empirical evaluations on various tasks and datasets demonstrate the capability of PHNs to generate better objective space coverage compared to multiple baseline models, with signiﬁcant improvement in training time.
M ULTI - OBJECTIVE OPTIMIZATION
We start by formally deﬁning the MOO problem.
An MOO is deﬁned by m losses (cid:96) i : R d → R + , i = 1 , . . .
, m , or in vector form (cid:96) :
R d → R m + .
We deﬁne a partial ordering on the loss space R m + by setting (cid:96) ( θ 1 ) (cid:22) (cid:96) ( θ 2 ) if for all i ∈ [ m ] , (cid:96) i ( θ 1 ) ≤ (cid:96) i ( θ 2 ) .
We deﬁne (cid:96) ( θ 1 ) ≺ (cid:96) ( θ 2 ) if (cid:96) ( θ 1 ) (cid:22) (cid:96) ( θ 2 ) and for some i ∈ [ m ] , (cid:96) i ( θ 1 ) <
(cid:96) i ( θ 2 ) .
We say that a point θ 1 ∈ R d dominates θ 2 ∈ R d if (cid:96) ( θ 1 ) ≺ (cid:96) ( θ 2 ) .
If a point θ 1 dominates θ 2 , then θ 1 is clearly preferable, as it improves some objectives and is not worse on any other objective.
Otherwise, the solutions present a certain trade-off and selecting between them requires additional information on the user preferences.
A point that is not dominated by any other point is called Pareto optimal .
The set of all Pareto optimal points is called the Pareto front .
Since many modern machine learning models, e.g. deep neural networks, use non-convex optimization, one cannot expect global optimality.
We call a point local Pareto optimal if it is Pareto optimal in some open neighborhood of the point.
The most straightforward approach to MOO is linear scalarization, where we deﬁne a new single loss (cid:96) r ( θ )
=
(cid:80) i r i (cid:96) i ( θ ) given a vector r ∈ R m + of weights. One can then apply standard, single-objective optimization algorithms.
Linear scalarization has two major concerns.
First, it can only reach the convex part of the Pareto front (Boyd et al., 2004, Chapter 4.7), as shown empirically in Figure 1.
Second, if one wishes to target a speciﬁc ray in loss space, speciﬁed by a preference vector, it is not clear which linear weights lead to that desired Pareto optimal point.
In Fliege & Svaiter (2000) the authors propose updating the parameter values along the direction d ( θ ) given by
[Equation]
which they prove is either a descent direction for all losses or a local Pareto optimal point
They show that following this update directions leads to convergence on the Pareto front.
In Désidéri (2012) the author shows similar results for the convex combination of gradients with minimal norm, i.e. d ( θ ) =
arg min d ∈ conv ( {∇ [Equation] i ( θ ) } )
||
d
|| 2 .
In both methods one has no control over which point on the
Pareto front the optimization converges to.
To ameliorate this problem, Lin et al.
(2019) suggested the Pareto multi-task learning (PMTL) algorithm; they split the loss space into separate cones, based on selected rays, and return a solution in each cone by using a constrained version of Fliege & Svaiter (2000).
While this allows the user to get several points on the Pareto front, it scales poorly with the number of cones.
Not only does one need to run and store a separate model per cone, we empirically observe that the run-time for each optimization increases with the number of cones due to the increased number of constraints.
Mahapatra & Rajan (2020) presented Exact Pareto Optimal (EPO), an MOO optimization method that can converge to a desired ray in loss space.
Given a preference ray r , EPO search for an exact Pareto optimal solution, i.e. a solution that is (i) Pareto optimal, and; (ii) Lies on the intersect of the Pareto front and the preference vector r .
The EPO method balances two goals: Finding a descent direction and getting to the desired ray.
EPO searches for a point in the convex hull of the gradients, known by
Désidéri (2012) to include descent directions, that has maximal angle with a vector d bal which pulls the point to the desired ray.
EPO combines gradient descent and controlled ascent enabling it to reach an exact Pareto optimal solution if one exists, or the closest Pareto optimal solution.
R ELATED W ORK
Multitask learning.
In multitask learning (MTL) we simultaneously solve several learning problems, while sharing information among tasks (Zhang & Yang, 2017; Ruder, 2017).
In some cases,
MTL based models outperform their single task counterparts in terms of per task performance and computational efﬁciency (Standley et al., 2019).
MTL approaches map the loss vector into a single loss term using ﬁxed or dynamic weighting scheme.
The most frequently used approach is Linear
Scalarization, in which each loss term’s weight is chosen apriori.
A proper set of weight is commonly selected using grid search.
Unfortunately, such approach scales poorly with the number of tasks.
Recently, MTL methods propose dynamically balance the loss terms using gradient magnitude (Chen et al., 2018), the rate of change in losses (Liu et al., 2019), task uncertainty (Kendall et al., 2018), or learning non-linear loss combinations by implicit differentiation (Navon et al., 2020).
However, those methods seek a balanced solution and are not suitable for modeling tasks trade-offs.
Multi-objective optimization.
The goal of Multi-Objective Optimization (MOO) is to ﬁnd Pareto optimal solutions corresponding to different trade-offs between objectives (Ehrgott, 2005).
MOO has wide variety of applications in machine learning, spanning Reinforcement Learning (Van Moffaert & Nowé, 2014; Pirotta & Restelli, 2016; Parisi et al., 2014; Pirotta et al., 2015; Parisi et al., 2016; Yang et al., 2019), neural architecture search (Lu et al., 2019; Hsu et al., 2018), fairness (Martínez et al., 2020; Liu & Vicente, 2020), and Bayesian optimization (Shah & Ghahramani, 2016; Hernández-Lobato et al., 2016).
Genetic algorithms (GA) are a popular approach for small-scale multi-objective optimization problems.
GAs are designed to maintain a set of solutions during optimization.
Therefore, they can be extended in natural ways to maintain solutions for different rays.
In this area, leading approaches include NSGA-III (Deb & Jain, 2013) and MOEA/D (Zhang & Li, 2007).
However, these gradient free methods scale poorly with the number of parameters and are not suitable for training large scale neural networks.
Sener & Koltun (2018) proposed a gradient based MOO algorithm for MTL, based on MDGA (Désidéri, 2012), suitable for training large scale neural networks.
Other recent works include (Lin et al., 2019; Mahapatra & Rajan, 2020) detailed in Section 2.
Another recent approach that tries to get a more complete view of the Pareto front is Ma et al.
This method extents a given Pareto optimal solution in its local neighborhood.
In a concurrent work, Lin et al. propose extending Lin et al. for approximating the entire Pareto front, by utilizing hypernetworks. The proposed method is conceptually similar to our approach.
Similarly, Dosovitskiy & Djolonga (2019) proposed learning a single model conditioning on the objective weight vector.
The method uses feature-wise linear modulation Perez et al.
and dynamically weighted LS loss criterion.
Hypernetworks.
Ha et al.
(2017) introduced the idea of hypernetworks (HN) inspired by genotypephenotype relation in the human nature.
HN presents an approach of using one network (hypernetwork) to generate weights for second network (target network).
In recent years, HN are widely used in various domains such as computer vision (Klocek et al., 2019; Ha et al., 2017), language modeling (Suarez, 2017), sequence decoding (Nachmani & Wolf, 2019), continual learning (Oswald et al., 2020) and hyperparameter optimization (Mackay et al., 2019; Lorraine & Duvenaud, 2018).
HN dynamically generates models conditioned on a given input, thus obtains a set of customized models using a single learnable network.
P ARETO H YPERNETWORKS
Algorithm while not converged do r ∼ Dir ( α ) φ ( θ, r )
=
h ( θ, r )
Sample mini-batch ( x 1 , y 1 ) , .., ( x B , y B ) if LS then g θ ← 1 B (cid:80) i,j r i ∇ θ (cid:96) i ( x j , y j , φ ( θ, r )) if EPO then β = EPO ( φ ( θ, r ) , (cid:96) , r ) g θ ← 1 B (cid:80) i,j β i ∇ θ (cid:96) i ( x j , y j , φ ( θ, r ))
θ ← θ − ηg θ return θ
We start with describing the basic hypernetworks architecture.
Hypernetworks are deep models that emit the weights of another deep model as their output, named the target network.
The weights emitted by the hypernetwork depend on its input, and one can view the training of a hypernetwork as training a family of target networks simultaneously, conditioned on the input.
Let h ( · ; θ ) denote the hypernetwork with parameters θ ∈ R n , and let f denote the target network whose parameters we denote by φ .
In our implementation, we parametrize h using a feed-forward network with multiple heads.
Each head outputs a different weight tensor of the target network.
More precisely, the input is ﬁrst mapped to higher dimensional space using an MLP, to construct shared features.
These features are passed through fully connected layers to create weight matrix per layer in the target network.
Consider an m − dimensional MOO problem with an objective vector (cid:96) .
Let r =
( r 1 , ..., r m ) ∈ S
m denote a preference vector representing a desired trade-off over the objectives.
Here S m = { r ∈ R m | (cid:80) j r j = 1 , r j ≥ 0 } is the m − dimensional simplex.
Our PHN model acts on the preference vector r to produce the weights φ ( θ, r )
=
h ( r , θ ) of the target network.
The target network is then applied to the training data in a usual manner.
Throughout training, we randomly sample r at each iteration from a Dirichlet distribution with parameter α ∈ R m . At inference time, given a preference direction r , it is provided as input to the HN h , which outputs the corresponding Pareto optimal solution, φ r , namely, a set of model weights for that given r .
We train φ to be Pareto optimal and corresponds to the preference vector.
For that purpose, we explore two alternatives: The ﬁrst, named PHN-LS, uses linear scalarization with the preference vector r as loss weights, i.e the loss for input r is (cid:80) i r
i (cid:96) i .
The second approach, named PHN-EPO, treats the preference r as a ray in the loss space and trains φ ( θ, r ) to reach a Pareto optimal point on the inverse ray r − 1 , namely, r 1 · (cid:96) [-
-]1 = . . .
= r m · (cid:96) m .
This is done by using the EPO update direction for each output of the Pareto hypernetwork.
As the EPO descent direction is a convex combination of the gradients, we use the
EPO algorithm to compute this adaptive weighting and backpropagate the reweighted losses.
See pseudocode in Alg. 1.
PHN-LS: While linear scalarization has some theoretical limitations, it is a simple and fast approach that tends to works well in practice.
One can think of the PHN-LS approach as optimizing the loss (cid:96) LS ( θ ) =
E r ,x,y
[ (cid:80) i r i (cid:96) i ( x, y, φ ( θ, r ))] where we sample a mini-batch and a weighting r .
We note, as a direct result from the implicit function theorem, the following:
Proposition 1.
Let φ (ˆ r ) be a local Pareto optimal point corresponding to weights ˆ r , i.e. (cid:80) ij ˆ r i ∇ (cid:96) i ( x j , y j , φ )
=
and assume the Hessian of (cid:80) i ˆ r
i (cid:96) i has full rank at φ (ˆ r ) .
There exists a neighborhood U of ˆ r and a smooth mapping φ ( r ) such that ∀ r ∈
U : (cid:80) ij r i ∇ (cid:96) i ( x j , y j , φ ( r ))
= 0 .
This shows that, under the full rank assumption, the connection between LS term r and the optimal model weights φ ( r ) is smooth and can be learnable by universal approximation (Cybenko, 1989).
We also observe that if for all r , φ ( θ, r ) is a local Pareto optimal point corresponding to r , i.e., (cid:80) ij r i ∇ (cid:96) i ( x j , y j , φ ( r ))
= 0 , then ∇ θ (cid:96) LS ( θ ) =
and this is a stationary point for (cid:96) LS .
However, there could exists stationary points and even local minima such that ∇ θ (cid:96) LS ( θ ) =
but in general (cid:80) ij r i ∇ (cid:96) i ( x j , y j , φ ( r ))
(cid:54) = 0 and the output of our hypernetwork is not a local Pareto optimal point.
While these bad local minimas exists, similarly to standard deep neural networks, we empirically show that PHNs avoid these solutions to achieve good results.
PHN-EPO: The recent EPO algorithm can guarantee convergence to a local Pareto optimal point on a speciﬁed ray r , addressing the theoretical limitations of LS.
This is done by choosing a convex combination of the loss gradients which is a descent direction for all losses, or moves the losses closer to the desired ray.
The EPO however, unlike LS, cannot be seen as optimizing a certain objective. Therefore, we cannot consider the PHN-EPO optimization, which uses the EPO descent direction, as optimizing a speciﬁc objective.
We also note that since the EPO needs to solve a linear programming step at each iteration, the runtime of EPO and PHN-EPO are longer than the LS and PHN-LS counterparts (see Figure 5).
E XPERIMENTS
We evaluate Pareto HyperNetworks (PHNs) on a set of diverse multi-objective problems.
The experiments show the superiority of PHN over other MOO methods.
We will make our code publicly available in order to facilitate further research.
Compared methods: We compare the following approaches: (1) Our proposed Pareto HyperNetworks ( PHN-LS and PHN-EPO ) algorithm described in Section 4; (2) Linear scalarization (LS) ; (3)
Pareto MTL ( PMTL )
Lin et al.
(2019); (4) Exact Pareto optimal ( EPO ) Mahapatra & Rajan (2020); (5) Continuous Pareto MTL ( CPMTL )
Ma et al.
All competing methods train one model per preference vector to generate Pareto solutions.
As these models optimize on each ray separately, we do not treat them as a baseline but as “ gold standard ” in term of performance.
Their runtime, on the other hand, scales linearly with the number of rays.
Genetic algorithms are perhaps the most popular approaches for MOO.
Two leading approaches in that area which also use preference information are NSGA-III (Deb et al., 2002) and MOEA/D (Zhang & Li, 2007).
Unfortunately, these methods only work on small sized networks (like the toy example in Figure 1, which gave sub-par results even after 100,000 generations), but failed to converge to meaningful solutions in our larger-scale experiments.
For that reason, the experiments below do not compare with GAs.
[Figure] Evaluation metrics: A common metric for evaluating sets of MOO solutions is the Hypervolume indicator (HV) (Zitzler & Thiele, 1999).
It measures the volume in loss space of points dominated by a solution in the evaluated set.
As this volume is unbounded, it is restrict to the volume in a rectangle deﬁned by the solutions and a selected reference point.
All solutions needs to be bounded by the reference point, therefore we select different reference point for each experiment.
see further details in Appendix Section D.
In addition, we evaluate Uniformity , proposed by Mahapatra & Rajan (2020).
This metric is designed to quantify how well the loss vector (cid:96) ( θ ) is align with the input ray r .
Formally, for any point θ in the solution space and reference r we deﬁne the non-uniformity µ r ( (cid:96) ( θ ))
=
D KL (ˆ (cid:96) (cid:107) 1 /m ) , where ˆ (cid:96) j = [Figure] i .
We deﬁne the uniformity as 1 − µ r .
The main metric, HV, measures the quality of our solutions, while the uniformity measures how well the output model ﬁts the desired preference ray.
We stress that the baselines are trained and evaluated for uniformity using the same rays.
Training Strategies:
In all experiments, our target network shares the same architecture as the baseline models.
For our hypernetwork we use an MLP with 2 hidden layers and linear heads.
We set the hidden dimension to 100 for the Multi-MNIST and NYU experiment, and 25 for the Fairness and
SARCOS.
The Dirichlet parameter α in Alg. 1 is set to 0 .
2 for all experiments, as we empirically found this value to perform well across datasets and tasks.
We provide a more detailed analysis on the selection of the hidden dimension and hyperparameter α in Appendix C.5. Extensive experimental details are provided in Appendix A.
Hyperparameter tuning: For our PHN method we select hyperparameters based on the HV computed on a validation set.
Selecting hyperparameters for the baselines is non-trivial as there is no clear criteria that is reasonable in terms of runtime;
In order to select hyperparameters based on HV, each approach needs to be trained multiple times on all rays.
We therefore select hyperparameters based on a single ray, and apply those for all rays.
Our selection criterion is as follow: we collect all models trained using all hyperparameter conﬁgurations, and ﬁlter out the dominated solutions.
Finally, we select the combination of hyperparametrs with the highest uniformity.
5. I LLUSTRATIVE EXAMPLE
We evaluate PHN on an illustrative MOO problem whose Pareto front is known (Fonseca, 1995).
Here,
[Equation]
with parameters θ ∈ R d and d = 100 . This problem has a non-convex Pareto front in R 2 . We compared PHN with EPO, PMTL, MGDA and two genetic algorithms (GAs) NSGA-III and MOEA/D. The results are presented in Figure 1.
Linear scalarization (LS) fails to generate solutions on the concave part of the Pareto front, as theoretically shown in Boyd et al.
PMTL and EPO
[Table]
generate solutions along the entire PF
[Table] but the solutions generated by PMTL are only optimized to be in the vicinity of the preference vector r . Results for MGDA and MOEA/D algorithms are shown in Appendix C.1. Our approach PHN-EPO generates a continuous cover of the PF in a single run.
In addition, PHN returns exact Pareto optimal solutions, mapping an input preference into its corresponding point on the front. We note that similar to the EPO method, PHN-EPO can learn non-convex Pareto fronts. Additional synthetic experiments with non-convex, known Pareto fronts are presented in Appendix C.1.
We start by evaluating all methods on three MOO benchmark datasets: (1) Multi-MNIST (Sabour et al., 2017); (2) Multi-Fashion, and (3) Multi-Fashion + MNIST. In each dataset, two instances are sampled uniformly in random from the MNIST (LeCun et al., 1998) or Fashion-MNIST (Xiao et al., 2017) datasets.
The two images are merged into a new image by placing one on the top-left corner and the other on the bottom-right corner.
The sampled images can be shifted up to four pixels on each direction.
Each dataset consists of 120,000 training examples and 20,000 test set examples.
We allocate 10% of each training set for constructing validation sets.
We train 5 models for each baseline, using evenly spaced rays.
The results are presented in Figure 3 and Table 1.
HV calculated with reference point (2 , 2) .
PHN outperforms all other methods in terms of HV and uniformity, with signiﬁcant improvement in run time.
To better understand the behaviour of PHN while varying the input preference vector, we visualize the per-pixel prediction contribution in Appendix C.3.
5. F AIRNESS
[Table]
Fairness has become a popular topic in machine learning in recent years (Mehrabi et al., 2019), and numerous approaches have been proposed for modeling and incorporating fairness into ML systems (Dwork et al., 2017; Kamishima et al., 2012; Zafar et al., 2019).
Here, we adopt the approach of Bechavod & Ligett (2017).
They proposed a 3-dimensional optimization problem, with classiﬁcation objective, and two fairness objectives: False Positive (FP) fairness, and False Negative (FN) fairness.
We compare PHN with EPO, PMTL and LS on three commonly used fairness datasets:
Adult (Dua & Graff, 2017), Default (Yeh & Lien, 2009) and Bank (Moro et al., 2014). [Figure]
Each dataset is splitted into train/validation/test of sizes 70%/10%/20% respectively.
All baselines are trained and evaluated on 10 preference rays.
We present the results in Table 2.
HV calculated with reference point (1 , 1 , 1) .
PHN achieves best HV performance across all datasets, with reduced training time compared to the baselines.
EPO performs best in terms of uniformity, however, recall it is evaluated on its training rays.
In addition, we visualize the accuracy-fairness trade-off achieved by PHN in Figure 4.
We also tested GAs on this task but the runtime was extremely high (two days, compared with a run time of minutes for gradient-based methods) with poor performance.
5. P IXEL - WISE CLASSIFICATION AND R EGRESSION
Image segmentation and depth estimation are key topics in image processing and computer vision with various applications (Minaee et al., 2020; Bhoi, 2019).
We compare PHN to other methods on NYUv dataset (Silberman et al., 2012).
NYUv2 is a challenging indoor scene dataset consists of 1449 RGBD images and dense per pixel labeling.
We used this dataset as a multitask learning benchmark for semantic segmentation and depth estimation tasks.
We split the dataset into train/validation/test of sizes 70%/10%/20% respectively, and use an ENet-based architecture for the target network (Paszke et al., 2016).
Each baseline method is trained ﬁve times using evenly spaced rays.
The results are presented in Table 3.
HV is calculated with reference point (3 , 3) .
PHN-EPO achieves best HV and uniformity, while also improving upon the baselines in terms of runtime. [Table] [Table]
5. M ULTITASK R EGRESSION
When learning with many objectives using preference-speciﬁc models, generating a good coverage of the solution space becomes too expensive in computation and storage space [Table] as the number of rays needed grows with the number of dimensions. As a result
[Table] PHN provides a major improvement in training time and solution space coverage (measured by HV). To evaluate PHN in such settings [Table]
we use the SARCOS dataset (Vijayakumar) [Table] a commonly used dataset for multitask regression (Zhang & Yang, 2017).
SARCOS presents an inverse dynamics problem with 7 regression tasks andexplanatory variables.
We omit PMTL from this experiment because its training time is signiﬁcantly longer compared to other baselines [Table] with relatively low performance.
For LS and EPO [Table] we trainpreference-speciﬁc models.
The results are presented in Table 4.
HV calculated with reference point
As before, PHN performs best in terms of HV, while signiﬁcantly reducing the overall run-time.
T HE Q UALITY -R UNTIME TRADEOFF
[Figure]
PHN learns the entire front in a single model, but the competing methods need to train multiple models to cover the pareto front.
As a result, these methods have clear trade off between performance and runtime.
To better understand this trade-off, Figure 5 shows the HV and runtime (in log-scale) of
LS and EPO when training various number of models.
For Fashion-MNIST, we trained 25 models, and at inference time, we selected subsets of various sizes (1 ray, 2 rays, etc) and computed their
HV.
The shaded area in Figure 5 reﬂects the variance over different selections of ray subsets.
We similarly trained 30 EPO/LS models for Adult and 40 for SARCOS.
PHN-EPO achieves superior or comparable hypervolume while being an order of magnitude faster.
PHN-LS is even faster, but this may come at the expense of lower hypervolume.
To further understand the source for PHN performance gain, we evaluate the HV on the same rays as the competing methods.
In many cases, PHN outperforms models trained on speciﬁc rays, when evaluated on those exact rays.
We attribute the performance gain to the inductive bias effect that PHN induces on a model by sharing weights across rays.
Results are in Section C.4 of the Appendix.
C ONCLUSION
We proposed a novel MOO approach: Learning the Pareto front using a single uniﬁed model that can be applied to a speciﬁc objective preference at inference time.
We name this learning setup Pareto front learning (PFL).
We implement our idea using hypernetwork and evaluated on a large and diverse set of tasks and datasets.
Our experiments show signiﬁcant gains in both runtime and performance on all datasets.
This novel approach provides the user with the ﬂexibility of selecting the operating point at inference time, and open new possibilities where user preferences can be tuned and changed at deployment.
Appendix: Learning the Pareto Front with Hypernetworks A E XPERIMENTAL D ETAILS
Pixelwise Classiﬁcation and Regression:
For NYUv2 we performed a hyperparameters search over the number of epochs and learning rates { 1 e − 3 , 5 e − 4 , 1 e − 4 } .
We train each method forepochs with Adam (Kingma & Ba, 2015) optimizer and select an optimal set of learning rate and number of epochs according to Sec. 5.
We evaluate PHN over 25 rays.
Image classiﬁcation: For the Multi-MNIST experiments we use a LeNet-based target network (LeCun et al., 1998) with two task-speciﬁc heads.
We train all methods using Adam optimizer with learning rate 1 e − 4 for 150 epochs and batch size 256 .
We then choose the best number of epochs for each method using the validation set.
We evaluate PHN over 25 rays.
Fairness: We use a 3 − layer feed-forward target network with hidden dimensions [40 , 20] .
We use learnable embeddings for all categorical variables.
We train all methods for 35 epochs using Adam optimizer with learning rates { 1 e − 3 , 5 e − 4 , 1 e − 4 } .
We choose the best hyperparameter conﬁguration using the validation set.
Further details on the datasets are provided in Table 5.
We evaluate PHN over a sample of 150 rays.
Multitask regression: For the SARCOS experiment, we use a 4 − layer feed-forward target network with 256 hidden dimension.
All categorical features are passed through embedding layers.
We train all methods for 1000 epochs using Adam optimizer and learning rates { 1 e − 3 , 5 e − 4 , 1 e − 4 } .
We choose the best hyperparameter conﬁguration base on the validation set.
We use 40,036 training examples, 4,448 validation examples, and 4,449 test examples.
We evaluate PHN over a sample of 100 rays.
[Table]
[Figure]
B S CALABILITY
The size of the HN grows linearly with the target network size.
This somewhat limits the applicability of PHN to large-sized target networks.
However, our approach can be easily extended for allowing the training of large NNs.
First, one can learn only part of the target network parameters using HN.
For instance, lower layers in vision applications tend to be highly conserved across classes and often even across tasks (Luan et al., 2018).
Alternative way is to learn preference speciﬁc normalization layers (Huang & Belongie, 2017; Perez et al., 2017) as in Dosovitskiy & Djolonga (2019).
In our experiments, we pass the preference vector through a small MLP to generate shared hidden features, which are used for constructing all target weights.
However, one can use different parts of the shared features to generate different weight tensors, hence reduce the number of HN parameters. Similarly, one can reduce the dimension of that shared preference representation to achieve a similar effect. We investigate the effect of the latter in Appendix C.5. C A DDITIONAL EXPERIMENTS C. K NOWN P ARETO F RONT
We provide two additional experiments over popular MOO benchmarks whose Pareto front is known. In addition in Figure 6, we provide additional results for MGDA (Sener & Koltun, 2018) and MOEA/D (Zhang & Li, 2007) on the illustrative example from Section 5.1. [Figure]
[Figure]
We evaluate PHN on two MOO problems with known, non-convex Pareto front: ZDT2 (Zitzler et al., 2000) and problem two from Evtushenko & Posypkin (2013), henceforth Problem2.
In both problems, the density of solutions across the Pareto-optimal region is non-uniform.
For a solution θ = ( θ 1 , θ 2 ) ∈ [0 , 1] 2 , Problem2 is given by,
[Equation]
and ZDT2 is given by,
[Equation]
The results are presented in Figure 7.
PHN-EPO converges to the entire PF using a single HN model. Interestingly, EPO fails to converge to the PF for all rays in ZDT2, in contrast with PHN-EPO. C. G ENERALIZATION TO U NSEEN RAYS
When the number of objectives is large, it is likely that the rays encountered in test time are "far" from rays encountered during training, because of the curse of dimensionality. Although we evaluated PHN on unseen rays 1 through all experiments, here we would like to better examine PHN’s generalization performance in that scenario.
we conducted an additional, controlled experiment on SARCOS dataset with 7 tasks. During training, we sample rays from a predeﬁned grid. During inference, we measure HV and Uniformity on two sets of rays: (i) Randomly sampled train rays (ii) Randomly sampled test rays from a shifted grid, so they are most distant from the train grid.
In both cases, test samples are different from training samples.
We ﬁnd that testing with unseen test rays only causes a minor decrease in both HV and Uniformity compared with train rays. The insigniﬁcant difference in performance in terms of HV is 0.7337 for the train rays vs. 0.7336, and Uniformaty 0.163 vs.
This experiment indicates that PHN can generalize well to unseen rays, and can be applied to problems with many objectives. We note that the HV results presented here are higher than the ones reported in Section 5.5. We attribute this inconsistency to change of preference vectors distribution used during training. We provide analysis on the robustness to the choice of the Dirichlet distribution parameter α in Appendix C.5.
C. MNIST PHN I NTERPRETATION
[Figure]
Image
In order to better understand the behaviour of PHN while varying the input preference vector, we visualize the per-pixel prediction contribution in Figure 8.
We use the SHAP framework (Lundberg & Lee, 2017) for the visualization.
Red pixels increase the probability for a given class, while blue ones decrease this probability.
The top left and bottom right digits are labeled as { 7 , 3 } respectively.
In the ﬁrst row (ray: (0 . 99 , 0 . 01) ), focused on task 1 (with label 7), most of the red pixels come from the top left digit in column 7 , as expected.
Similarly, in the third row (ray: (0 . 01 , 0 . 99) ) most of the red pixels are focused on the bottom right digit in column 3.
C. S AME - RAY EVALUATION
In Section 5 of the main text we evaluate PHN on multiple evenly spaced rays.
For completeness, we report here the HV and Uniformity achieved by PHN, while evaluated on the same rays used for training and evaluating the baseline methods.
The results are provided in Table 6.
Surprisingly, in many cases PHN achieves better performance. We attribute this to the inductive bias effect of sharing weights across all preference rays.
[Table]
[Figure]
In Section 5 we have used ﬁxed choices of hypernetworks’ hidden dimension and the Dirichlet parameter α (see Alg. 1).
Here we examine the effect of different choices for these hyperparameters.
We use the Multi-Fashion + MNIST dataset, and the PHN-EPO variant of our method.
We ﬁrst ﬁx the hidden dimension to 100 , and vary α from 0 .
1 to 1 (uniform sampling).
The results are presented in Figure 9(a).
It appears that at least for this dataset, PHN is quite robust to changes in α .
Next, we set α = 0 .
2 and examine the effect of changing the dimension of the hidden layers in our hypernetwork.
We present the results in Figure 9(b).
Here, the effect on the HV is stronger, with best HV achieved using hidden dimension of 100 .
C. A DDITIONAL R UNTIME A NALYSIS
[Figure] In this section we extend the runtime analysis from Section 6.
In Figure 10 we provide additional runtime analysis on the Multi-MNIST, Multi-Fashion, and NYUv2 datasets.
For NYUv2 we omit the EPO method, since it was outperformed by LS in both HV and runtime.
D H YPERVOLUME
The hypervolume metric is deﬁned as follows:
Given a set of points S ⊂ R n and a reference point ρ ∈ R n + , the hypervolume of S is measured by the region of non-dominated points bounded above by ρ .
[Equation]
where V OL is the euclidean volume.
We can interpret hypervolume as the measure of the union of the boxes created by the non-dominated points.
[Equation]
As a measure of quality for MOO solutions, it takes into account both the quality of individual solutions, which is the volume they dominate, and also the diversity, measured in the overlap between dominated regions.
See example in Fig.