L INEAR S CALARIZATION FOR B YZANTINE - ROBUST LEARNING ON NON -IID DATA
Anonymous authors
Paper under double-blind review
A BSTRACT
In this work we study the problem of Byzantine-robust learning when data among clients is heterogeneous.
We focus on poisoning attacks targeting the convergence of SGD.
Although this problem has received great attention; the main Byzantine defenses rely on the IID assumption causing them to fail when data distribution is non-IID even with no attack.
We propose the use of Linear Scalarization (LS) as an enhancing method to enable current defenses to circumvent Byzantine attacks in the non-IID setting.
The LS method is based on the incorporation of a trade-off vector that penalizes the suspected malicious clients.
Empirical analysis corroborates that the proposed LS variants are viable in the IID setting.
For mild to strong non-IID data splits, LS is either comparable or outperforming current approaches under state-of-the-art Byzantine attack scenarios.
I NTRODUCTION
Most real-world applications using learning algorithms are moving towards distributed computation either: (i)
Due to some applications being inherently distributed, Federated Learning (FL) for instance, (ii) or to speed up computation and benefit from hardware parallelization.
We especially resort to distributing Stochastic Gradient Descent (SGD) to alleviate the heavy computation underlying gradient updates during the training phase.
Especially with the high dimensionality of large-scale deep learning models and the exponential growth in user-generated data.
However, distributing computation comes at the cost of introducing challenges related to consensus and fault tolerance.
In other words, the nodes composing the distributed system need to reach consensus regarding the gradient update.
In the honest setting this can be done simply by a parameter server that takes in charge the aggregation of computation from the workers.
However, machines are prone to hardware failure (crush/stop) or arbitrary behavior due to bugs or malicious users.
The latter is more concerning as machines may collude and lead to convergence to ineffective models.
Since deep learning pipelines are involved in decision making at a critical level (e.g., computer-aided diagnosis, airport security...); it is crucial to ensure their robustness.
We study robustness in the sense of granting resilience against malicious adversaries.
More precisely, poisoning attacks that target the convergence of SGD .
The adversarial model follows the Byzantine abstraction Lamport et al.
The basis of distributed Byzantine attacks is the disruption of SGD ’s convergence by tampering with the direction of the descent or magnitude of the updates.
The robustness problem is highly examined and there exists a plethora of aggregations Blanchard et al.
; Alistarh et al.
; Yin et al.
; Damaskinos et al.
; Boussetta et al.
; El Mhamdi et al.
Nonetheless, recent works Karimireddy et al.
(2022; 2021) highlight the inability of these algorithms to learn on non-IID data.
Indeed, defending against the Byzantine in a heterogeneous setting is not trivial.
Naturally, aggregations rely on the similarity between honest workers to defend against the
Byzantine.
However, as data becomes unbalanced distinguishing malicious workers from honest ones becomes increasingly challenging: an honest worker may slightly deviate from its peers due to skewed data distribution.
Another weakness of current work is that most aggregation discard a subset of information either by dropping full gradient vectors or by eliminating a set of coordinates along each dimension of the submitted vectors.
Nevertheless, dropping users’ updates leads to (i) Degradation of the model’s final accuracy, especially when no Byzantine attackers are present.
(ii) It may also discard minorities with vastly diverging views as elaborated in Mhamdi et al.
Motivated by the latter and the scarcity of work on Byzantine Non-IID defenses, we study the
Byzantine resilience of SGD on non-IID data.
These two problems: (1) learning on non-IID data and (2) defending against Byzantine attacks are similar in the sense that in both cases the central server in charge of aggregating clients’ updates is faced with conflicting information.
In the Byzantine case the conflict stems from the discrepancy between the updates submitted by the malicious users and honest ones.
Whereas, in the non-IID case it is a result of the difference in the data distribution between the users.
In a realistic set up such as FL , the central server is faced with both challenges.
From an optimization perspective, the goal is to find the parameters of a model that simultaneously minimizes the loss associated with the local data of each client f i .
More precisely, the objectives in these cases maybe conflicting.
This type of optimization problem falls under multi-objective and can be formally expressed as follows:
[Equation]
Multi-Objective problems can be solved as mono-objective through linear scalarization.
This solution simply consists in introducing a preference vector λ that defines a trade-off between the nconflicting objectives.
Thereafter, proceed to optimize the weighted sum of the objectives as one.
[Equation]
The vector λ is referred to as the preference or trade-off vector and is typically chosen such that
[Equation]
Our insight is to treat the Byzantine-robust learning problem as multi-objective, then to deploy linear scalarization to solve it.
That is, the trade-off vector can be leveraged to balance users’ updates by penalizing the suspected Byzantine ones without dropping any user’s contribution.
Additionally, this scheme addresses the trade-off between granting Byzantine resilience and inclusion as no client update is fully discarded.
Our contribution can be summarized as follows:
• We propose RAGG -LS, a linear scalarization based aggregation that leverages existing defenses to define a trade-off vector over the n -conflicting objectives in order to grant Byzantine resilience in the non-IID setting.
Moreover, the fact that the trade-off vector is defined through robust aggregations balances out updates according to the level of trust in the corresponding client.
• We evaluate our scheme against state of the art Byzantine attacks.
We compare our approach to that of bucketing introduced in Karimireddy et al.
(2022) as well as the standard IID defenses.
1. N OTATIONS AND S ET UP
Notations.
In the following RAGG ( . )
: Denotes a given Robust Aggregation Rule.
f i : The objective function associated with the i -th worker.
G = { g 1 , g 2 , ..., g n } : corresponds to users gradient vectors.
G t , G b Respectively denote the sets of gradient vectors associated with the set of trusted workers and workers suspected to be Byzantine.
λ : the preference or trade-off vector.
n the total number of clients, among which a subset b behaves maliciously.
δ : The proportion of Byzantine clients, δ max < n 2 .
D i
= { ( x j , y j ) } |D i | j =1 the subset of data of worker i .
C R i denotes a robust metric computed based on the gradient update of user i .
Set Up.
We consider the standard Parameter Server ( PS ) architecture, comprised of a central server in charge of the exchange between the n nodes.
The (PS) architecture assumes that the server is trusted and a proportion δ of the nodes behave arbitrarily or maliciously.
The arbitrary behavior is modelled following the Byzantine abstraction introduced in Lamport et al.
The Byzantine workers maybe omniscient (i.e., they have access to the whole dataset and are able to access other clients’ updates).
We assume data distribution among clients to be non-IID.
We are interested in studying the Byzantine Resilience of Distributed Synchronous SGD.
1. O UTLINE
We structure the paper as follows:
In section 2 we present an overview of key relevant literature.
We then introduce a formulation of our approach in section 3.
The final two sections respectively present the experimental evaluation and concluding remarks.
R ELATED WORK
In this section relevant work is highlighted.
We first present some of the renowned aggregation rules in the IID then in the non-IID setting.
Followed by Byzantine attacks on SGD .
Finally, we present some of the works that deploy linear scalarization to balance trade-offs between the objectives.
IID Defenses : Krum Blanchard et al.
(2017) is an aggregation that filters the gradient submissions based on a trust score defined as follows: s ( i )
= (cid:80) j ∈N i dist ( g i − g j ) 2 where N i denotes the set of n − b − 2 closest vectors of i .
The aggregation selects the gradient vector of the user i minimizing the score s ( i ) .
The authors also introduce a variant namely m -Krum that returns an average of the m vectors with the smallest scores.
The Median Yin et al.
(2018) consists in applying the median along each coordinate of the d -dimensional gradient vectors.
Trimmed-mean Yin et al.
(2018) averages the vectors submissions after discarding a proportion of the highest and smallest values.
MeaMed operates by computing the mean around the median of vector updates.
Bulyan El Mhamdi et al.
(2018) is a meta gradient aggregation rule that grants strong Byzantine resilience (defends against adversaries exploiting the high dimensionality of the model).
It is used as an enhancing method on top of a weak Byzantine aggregation.
Bulyan operates in two steps: First, it uses the initial aggregation to get a set of trusted users.
Then, it uses a variant of the trimmed-mean to aggregate the trusted set.
Aksel Boussetta et al.
(2021) combines the median and norm filtering to construct a robust interval that is used to filter the gradient vectors.
The output of the filtering step is then averaged.
Alistarh et al.
(2018) uses MeaMed (the mean around the meadian) as a gradient aggregation rule (GAR) alongside an iterative scheme that allows the detection of Byzantine workers based on their submissions (meeting an upper bound on the error introduced on the submission in different rounds leads to the elimination of the node’s contribution in subsequent steps).
The work of Guerraoui (2021) offers a standard implementation of state of the art aggregations in a (PS) architecture under two of the powerful attacks against SGD Xie et al.
; Baruch et al.
(2019) and show that introducing Nesterov’s momentum at the workers improves the defenses’ resilience.
Similarly, Karimireddy et al.
(2021) illustrate the role of momentum in strengthening the aggregations capacity of withstanding Byzantine attacks in the non-IID setting.
Non-IID Defenses : Li et al.
(2018) propose a new aggregation RSA that uses an l 1 regularization term to penalize the deference between local iterates and server iterate.
This approach however is unable to defend against state of the art Byzantine attacks (Baruch et al.
; Xie et al.
The work in Karimireddy et al.
(2021) highlights the weakness of standard Byzantine defenses in the non-IID setting and proposes a Centered Clipping (CClip) method and the use of momentum to defend against time coupled attacks.
Karimireddy et al.
(2022) proposes a bucketing technique that reduces inter-client variance by averaging clients updates within buckets.
This approach is simple and can be combined with existing defenses as a prepossessing step.
Byzantine Attacks : The Byzantine abstraction (Lamport et al.
encloses attacks ranging from random outputs, noisy submissions, sign flipping to carefully crafted updates targeting specific algorithms.
In this we focus on malicious attacks that disrupt the convergence of SGD .
A little is enough ALIE (Baruch et al.
(2019)) is a non-omniscient attack wherein the adversaries estimate the mean µ and standard deviation σ of the good gradients, and send µ − zσ to the server where z is a small constant controlling the strength of the attack.
IPM (Xie et al.
(2019)) or Attack by Inner
Product Manipulation is an omniscient attack (i.e., Byzantine workers are assumed to have access to the dataset).
The attackers averages the gradients computed using the full dataset Avg ( G ) then sends - ϵAvg ( G ) where ϵ controls the strength of the attack.
Bit Flip (Sign Flip) is a simple attack that models hardware failures in clients.
A given Byzantine client experiences an internal failure and starts outputting faulty values in this case inverting the sign of the update.
Mimic (Karimireddy et al.
(2022)) is an attack that is designed to take advantage of the non-IID setting.
The malicious workers pick an honest worker i ∗ and mimic its output.
This attack is powerful as it emphasises the heterogeneity by over-representing a worker i ∗ with least significant update.
Linear Scalarization : is a technique used in Multi-Objective Optimization (MOO) to balance conflicting objectives.
The formulation of leaning algorithms as multi-objective problems is indeed a more natural way of addressing them.
In (Sener & Koltun (2018))
Multi-Task Learning (MTL) is modelled as a multi-objective problem, Lin et al.
(2019) propose an efficient method, Pareto MTL, to solve Multi-Task Learning as MOO.
Mohri et al.
(2019) propose a reformulation of Federated Learning namely: Agnostic Federated Learning ( AFL ) to instate fairness among users through the optimization of the weighted sum of the users’ objectives for the worst trade-off vector.
However, we are not aware of any work addressing the Byzantine Learning problem as MOO.
There is however a line of work that deploys weights or trust scores to penalize the Byzantine (Peng et al.
Regatti & Gupta (2020); Fu et al.
; Li et al.
However, for the above-mentioned works lambda is generally used for regularization and not as a trade-off vector i.e., the problem is not solved as LS of conflicting objectives.
Also, defining the trade-off is a crucial part in balancing the objectives.
However, in the aforementioned works lambda is chosen arbitrarily or at best is not carefully tailored to each client in a way that would penalize the Byzantine.
A LGORITHM 3. S TUDIED R OBUST A GGREGATIONS
Given a Robust Aggregation rule RAGG ( . ) , the Byzantine defense generally operates as follows:
Apply a criterion (historical data, robust statistics, distance measure ...) to filter users into two subsets.
Thereafter proceed to aggregate the gradients of trusted users G t .
More precisely (i) Use some trust score or robust statistic C R i to split users into two subsets honest G t and suspected malicious G b .
(ii) Return the aggregation of G t .
The proposed framework serves as an enhancements to existing robust defenses.
We cover three aggregations namely: m -Krum, Aksel and the coordinate-wise median (CM).
First, we explicitly define the procedure followed by each of these aggregations.
m
-Krum Blanchard et al.
For each user i Krum computes a score s i for user i based on the Euclidean distance of g i to g j such that j ∈ N i which denotes the closest n − b − 2 users to i , s ( i ) =
(cid:80) ∥
g i − g j ∥ 2 , then it selects the user with the smallest score, i.e,
[Equation]
The m -Krum variant picks m users with the smallest scores then outputs their average.
CM Yin et al.
The CM, uses the one-dimensional median across each dimension to filter out outliers.
For g i ∈ R d , CM ( G ) =
g M , where g M is a vector with its k -th coordinate being g M [ k ] =
Median { g i [ k ] | i ∈ [ m ] } for k ∈ [ d ] .
Aksel Boussetta et al.
(2021) combines CM and norm filtering to select a subset of trusted gradients
G t .
The aggregation thereafter is the average of selected gradient vectors.
[Equation]
Where g M = CM ( G ) .
S =
{ s ( i ) =
(cid:80) dk
=
( g i [ k ] − g M [ k ]) 2 : i ∈ [ n ] } .
r = Median ( S ) and I the robust interval
I = [0 , r ] and G t = { g i | ∥
g i − g M ∥
2 ∈ I } .
3. B YZANTINE LS APPROACH
Let C R
i denotes a criterion that measures the honesty of a client i .
This is generally a vote/score (e.g., squared sum of Euclidean distance Blanchard et al.
(2017) or the distance to some robust statistic).
Naturally, the goal is to pick the gradient updates associated with the users having the smallest C R i .
Following that, the main idea behind LS is, rather than discarding the suspected users that stray from C R i , each user is penalized according to the degree of derail.
As such, we associate with each user
i a scalar λ
i namely a trade-off that is defined such that
λ i ≈ 1 C Ri .In
the following we summarize the main LS steps
Deploy the selection criterion to define the
Return the weighted sum of all users
LS Leverages the standard aggregations to separate the gradients into honest and suspected Byzantine.
Then, utilizes the filtering metric to define a trade-off vector such that the more suspected a user is to be Byzantine, the smaller its weight is.
That is, our approach keeps all users’ gradient vectors and the λ i serves as a penalty: as such, for i in the subset of discarded gradients, the penalty associated with the re-introduction of g i is computed as follows λ i = α b 1 C Ri . In this case α b defines the trade-off between inclusion and robustness and quantifies the confidence in the C R i . [Equation]
Thereafter, LS can be considered as a generalization to the standard RAGG ( . ) , that pick λ i = 0 for the suspected Byzantine and associates uniform weights with the honest clients.
Additionally, this formulation alleviates the Robustness/Inclusion trade-off.
Algorithm 1 gives the pseudo code of our approach.
Algorithm 1 RAGG-LS
Input G , two hyper parameters α t > 0 and α b ≥ 0 ,
Compute C R i based on the chosen RAGG
Split G into G t (honest clients) and G b (suspected malicous clients) based on the chosen RAGG.
for g i ∈
G t do λ i
= α t C Ri end for for g i ∈
G b do λ
i = α b C Ri end for
Normalise λ
Return RAGGLS ( G ) =
(cid:80) | λ | i
=1 λ
i
g
i
E MPIRICAL E VALUATION
In this section we evaluate the introduced LS approaches on non-IID data when a proportion of the clients is Byzantine.
We first give a detailed description of the experimental set up, namely: The used data sets and the techniques deployed to partition the data between client in a non-IID fashion.
Followed by the models’ architectures alongside all the relevant hyper-parameters.
We also define the threat model and the studied defenses.
Finally, we present Top-1 Accuracy as an evaluation metric.
4. D ESCRIPTION
Data Splits : We study the following datasets namely: MNIST LeCun et al.
(1998), FMNIST Xiao et al.
(2017), SVHN Netzer et al.
(2011) and CIFAR10 Krizhevsky & Hinton (2009).
We experiment with IID and non-IID data splits.
The later is generated by creating label unbalances between clients.
A commonly used non-IID partition method, Latent Dirichlet Sampling.
This split approach uses the Dirichlet distribution Dir ( β ) , such that each party gets assigned a proportion of samples of a given label.
We consider β a hyper-parameter that allows to introduce varying levels of skewness (the smaller the β the more skewed is the resulting split).
Following existing works Li et al.
Tang et al.
(2022), each dataset is partitioned with two different non-IID degrees using β = 0 .
1 for mild non-IID and β = 0 .
01 for high non-IID splits.
Moreover, to verify the impact of LS, we conduct experiments using another type of non-IID partition: C k -classes partition, it is common to use K = 1 a split referred to as pathological non-IID
McMahan et al.
, we however set K = 3 i.e. each client only has access to labels fromclasses.
Learning Model :
• Model : CNN with two convolutional layers, Max-Pooling and a Fully-connected layer of 1k units for MNIST and FMNIST, LeNet 5 LeCun et al.
(1998) for SVHN and V GGSimonyan & Zisserman (2014) for CIFAR10.
• Loss function : Cross Entropy Loss.
• Optimizer : SGD with momentum = 0 .
9 at the workers, a fixed learning rate 0 .
01 and a batch size of 128.
Threat Model : We experiment with two values of Byzantine δ = 20% and δ = 40% i.e., out ofusers respectively 5 or 10 users are byzantine.
The deployed attacks are indicated bellow:
• ALIE (Baruch et al., 2019):
Following the original paper we use z = 0 .
25 computed using the formula from the original paper, this also the value used in Karimireddy et al.
• IPM
(Xie et al., 2019):
We use ϵ = 0 .
1 following Karimireddy et al.
• BF : A Byzantine worker sends −∇ f i instead of ∇ f i due to hardware failures etc.
• Mimic : The goal of the mimic attack as introduced in Karimireddy et al.
(2022) is the over-representation of a user i ∗ with the least significant gradient update, a method to pick i ∗ is introduced, we however implement mimic in a simpler way.
We utilize the entropy of users unbalanced data to get insight on the quality of each users update.
Thereafter, Mimic picks the client i ∗ such that,
[Equation]
Defenses
: We explore the Byzantine resilience of standard defenses and compare them to their
non-IID variants based on Baucketing and LS.
• IID defenses namely, CM, mKrum and Aksel.
Bucketing ( s = 2 ) CM-buck, mKrum-buck and Aksel-buck.
• Linear scalarization variants : We denote the LS variants of the previous methods as follows: CMLS 2 for LS variant of coordinate wise median, mKLS 3 for mKrum LS variant and ALS 4 for Aksel LS variant.
We set the hyper parameters α t = 1 and α b = 19 , as such we keep the trade-off associated with honest workers as is computed and we further penalize the suspected Byzantine by multiplying their λ i by a small constant
4. E XPERIMENTAL R ESULTS
In this section we present the experimental results.
In their work, Karimireddy et al.
(2022) demonstrate the effectiveness of their approach on the MNIST dataset for a given non-IID split under a fixed number of Byzantine namely 20%.
In the following we test the bucketing scheme alongside the introduced LS variants and the defenses they improve under Byzantine attacks (i) On varying degrees of non-IID to the data (ii) on multiple datasets namely: MNIST, CIFAR10 and SVHN.
Additional experiments on both MNIST and FMNIST can be found in the Appendix fig.9, fig.10, fig.
We report Top − 1 Test Accuracy averaged over 5 runs for each GAR for MNIST, 3 runs for SVHN and 2 runs for CIFAR10, under no attack (NA), ALIE, IPM, BF and Mimic for the IID data split and 2 different non-IID scenarios based on label unbalance between the users.
• Our initial results suggest that our approach is viable in the IID case and achieves results comparable to state of the art defenses under different Byzantine attacks fig.
In the mild non-IID case i.e., Data ∼ Dir ( β = 0 . 1) and Data ∼ C 3 , our approach as well as bucketing help the standard aggregations perform better in the non-IID Byzantine setting.
Also in the mild non-IID setting our approaches are either comparable to bucketing or outperform it when the proportion of Byzantine δ = 20% fig.2.
However, when the proportion of byzantine is doubled i.e., δ = 40% our variants are outperforming all the other aggregations including their corresponding bucketing variants
fig.4. •
Finally, in the strongly non-IID case Dir ( β = 0 . 01) the LS based methods are the only ones capable of learning on heterogeneous data in the presence of Byzantine clients.
fig.3.
[Figure] [Figure]
[Figure]
Accuracy for All GARs on Non- data ∼ Dir ( β = 0 .
01) consider this High non- split, all users have access to varying proportions
the
[Figure] [Figure]
[Figure]
Although bucketing does improve the standard aggregations in some scenarios mainly mild non-IID under 20% Byzantine, however as data distribution gets highly unbalanced fig.3 or the proportion of Byzantine augments fig.4 it is no longer efficient in alleviating the impact of heterogeneity on the performance of the aggregations.
On CIFAR10 fig.6 and SVHN fig.5 the LS variants outperform all the other aggregations under 20%
Byzantine attackers (Mimic attack).
On the MNIST dataset, our approaches are either comparable to bucketing or outperform them on the mild non-IID case under 20% of Byzantine.
However, when the number of Byzantine is doubled or non-IID degree is high our variants are the only ones that achieve reasonable accuracy under Byzantine attacks.
C ONCLUSION
In this work we explore the problem of learning on heterogeneous data in the presence of Byzantine clients.
We propose a Linear Scalarization approach that takes advantage of the existing Byzantine defenses to define a trade-off between the client’s objectives.
This formulation allows to balance users’ contribution in a way that the honest workers’ gradient vectors are of great importance and those of suspected workers have a small contribution.
Our approach grants Byzantine robustness while allowing outliers’ contributions.
Thereafter alleviating the Inclusion/Robustness trade-off posed by standard aggregations.
Our LS methods are a generalization of the standard RAGG ( . ) , that pick λ i = 0 for all suspected malicious clients.
Thus, the theoretical guarantees of these methods extend to the particular setting of our methods especially for IID data.
However in non-IID setting, our work still lacks on the theoretical side, this is left for future work.
Another limitation of our work is the reliance on standard aggregation to compute the trade-off vector.
Although the rationale is to make sure the trade-off is based a Byzantine-robust trust score / metric, it however is tied to the computational complexity of the deployed aggregation that in cases like m-Krum is O ( n 2 d ) where d is the dimensionality of the model.
Thus, it would be interesting to investigate more efficient ways of defining suitable trade-offs between the clients.
Additional future improvements may address the tuning of the hyper-parameters α t and α b and the communication efficiency as it is one of the challenges in FL.
A A PPENDIX A. A LGORITHMS
In this section we present the algorithms corresponding to the introduced LS variants.
Algorithm 2 CMLS g M = CM ( G ) and λ M = α t
▷ This is considered the only entry in G t for g i , i ∈ [ n ] do λ i =
α b ∥
g i − g M ∥
▷ Defining the trade-off vector associated with users gradients end for λ
= ( λ M , λ 1 , ..., λ n ) ▷ Normalise λ
Return CMLS ( G ) =
(cid:80) n
+1 i =
λ
i g i
Algorithm 3 MKLS
G t contains the selected vectors using m -Krum.
for g i , i ∈ [ n ] do if g i ∈ G t then ▷
Defining the trade-off vector using m -Krum scores s i λ
i =
α t s i else if g i ∈
G b then λ i =
α b s i end if end for λ
= ( λ 1 , ..., λ n ) ▷ Normalise λ
Return MKLS ( G ) =
(cid:80) ni
=
λ i g i
Algorithm 4 ALS
G t contains the selected vectors using Aksel.
for g i , i ∈ [ n ] do if g i ∈ G t then ▷
Defining the trade-off vector using Aksel λ i = α t ∥
g i − g M ∥
2 else if g i ∈
G b then λ i =
α b ∥ g i − g M ∥ end if end for λ =
( λ 1 , ..., λ n ) ▷ Normalise λ
Return ALS ( G ) =
(cid:80) ni
=
λ i g i
B E MPIRICAL E VALUATION B. D ESCRIPTION
Hardware and software specifications
Our codes are implemented using PyTorch 1.9.0 with cuda 11.1.
Experiments are run on the GPU partition of a cluster on a single node containing:
• 2x AMD EPYC 7713 64-Core Processor 1.9GHz (128 cores in total) • 1000 GiB RAM • 4x NVIDIA A100-SXM4-80GB GPUs • Dual-rail Mellanox HDR200 InfiniBand interconnect
B. E XPERIMENTAL R ESULTS
In this section we present additional experimental results on both MNIST and FMNIST dataset
[Figure] [Figure]
[Figure] [Figure] [Figure]