Original: E FFICIENT
Revised: E FFICIENT

Original: S PLIT -M IX
Revised: S PLIT -M IX

Original: F EDERATED
Revised: F EDERATED

Original: L EARNING
Revised: L EARNING

Original: FOR
Revised: FOR

Original: O N -D EMAND AND I N -S ITU C USTOMIZATION
Revised: O N -D EMAND AND I N -S ITU C USTOMIZATION

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Federated learning (FL) provides a distributed learning framework for multiple participants to collaborate learning without sharing raw data.
Revised: Federated learning (FL) provides a distributed learning framework for multiple participants to collaborate learning without sharing raw data.

Original: In many practical FL scenarios, participants have heterogeneous resources due to disparities in hardware and inference dynamics that require quickly loading models of different sizes and levels of robustness.
Revised: In many practical FL scenarios, participants have heterogeneous resources due to disparities in hardware and inference dynamics that require quickly loading models of different sizes and levels of robustness.

Original: The heterogeneity and dynamics together impose signiﬁcant challenges to existing FL approaches and thus greatly limit FL’s applicability.
Revised: The heterogeneity and dynamics together impose signiﬁcant challenges to existing FL approaches and thus greatly limit FL’s applicability.

Original: In this paper, we propose a novel Split-Mix FL strategy for heterogeneous participants that, once training is done, provides in-situ customization of model sizes and robustness.
Revised: In this paper, we propose a novel Split-Mix FL strategy for heterogeneous participants that, once training is done, provides in-situ customization of model sizes and robustness.

Original: Speciﬁcally, we achieve customization by learning a set of base sub-networks of different sizes and robustness levels, which are later aggregated on-demand according to inference requirements.
Revised: Speciﬁcally, we achieve customization by learning a set of base sub-networks of different sizes and robustness levels, which are later aggregated on-demand according to inference requirements.

Original: This split-mix strategy achieves customization with high efﬁciency in communication, storage, and inference.
Revised: This split-mix strategy achieves customization with high efﬁciency in communication, storage, and inference.

Original: Extensive experiments demonstrate that our method provides better in-situ customization than the existing heterogenous-architecture FL methods.
Revised: Extensive experiments demonstrate that our method provides better in-situ customization than the existing heterogenous-architecture FL methods.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Federated learning (Koneˇcný et al., 2015) is a distributed learning paradigm that leverages data from remote participants and aggregates their knowledge without requiring their raw data to be transferred to a central server, thereby largely reducing the concerns from data security and privacy.
Revised: Federated learning (Koneˇcný et al., 2015) is a distributed learning paradigm that leverages data from remote participants and aggregates their knowledge without requiring their raw data to be transferred to a central server, thereby largely reducing the concerns from data security and privacy.

Original: FedAvg (McMahan et al., 2017) is among the most popular federated instantiations, which aggregates knowledge by averaging homogeneous model parameters.
Revised: FedAvg (McMahan et al., 2017) is among the most popular federated instantiations, which aggregates knowledge by averaging homogeneous model parameters.

Original: In many practical federated learning scenarios, the participants usually exhibit a variety of heterogeneity .
Revised: In many practical federated learning scenarios, the participants usually exhibit a variety of heterogeneity .

Original: The training datasets from participants can be non- i.i.d.
Revised: The training datasets from participants can be non- i.i.d.

Original: and therefore lead to data heterogeneity, which has received extensive attention in the community (Li et al., 2020b; Fallah et al., 2020;
Revised: and therefore lead to data heterogeneity, which has received extensive attention in the community (Li et al., 2020b; Fallah et al., 2020;

Original: Hong et al., 2021;
Revised: Hong et al., 2021;

Original: Li et al., 2021).
Revised: Li et al., 2021).

Original: In addition, the participants can also have resource heterogeneity, i.e., participants have different hardware resources available, such as memory, computing power, and network bandwidth (Ignatov et al., 2018).
Revised: In addition, the participants can also have resource heterogeneity, i.e., participants have different hardware resources available, such as memory, computing power, and network bandwidth (Ignatov et al., 2018).

Original: For example, in a learning task for face recognition, clients may use different types of devices (e.g., desktop computers, different generations of tablets or smartphones) to participate in learning, which thereby leads to drastic differences in computational resources for training models, and in sizes of models that can be loaded to the memory and transferred through the network.
Revised: For example, in a learning task for face recognition, clients may use different types of devices (e.g., desktop computers, different generations of tablets or smartphones) to participate in learning, which thereby leads to drastic differences in computational resources for training models, and in sizes of models that can be loaded to the memory and transferred through the network.

Original: The disparity of hardware resources results in varying budgets in both training and inference stages (Xu et al., 2021).
Revised: The disparity of hardware resources results in varying budgets in both training and inference stages (Xu et al., 2021).

Original: To accommodate different model sizes, one can turn to more ﬂexible architectures trained by distillation from ensemble (Lin et al., 2020), partial model averaging (Diao et al., 2021), or directly combining predictions (Shi et al., 2021).
Revised: To accommodate different model sizes, one can turn to more ﬂexible architectures trained by distillation from ensemble (Lin et al., 2020), partial model averaging (Diao et al., 2021), or directly combining predictions (Shi et al., 2021).

Original: Yet besides heterogeneity, the deployment of models usually has a great amount of dynamics .
Revised: Yet besides heterogeneity, the deployment of models usually has a great amount of dynamics .

Original: One type of dynamics is directly related to the resources of participants’ devices.
Revised: One type of dynamics is directly related to the resources of participants’ devices.

Original: For example, memory consumptions and computational capabilities may vary drastically between training and inference stages, and the same dynamics in hardware can also happen during inference (Yu et al., 2018; Xu et al., 2021), depending on how the resource allocation of the running programs is prioritized on a participant’s device.
Revised: For example, memory consumptions and computational capabilities may vary drastically between training and inference stages, and the same dynamics in hardware can also happen during inference (Yu et al., 2018; Xu et al., 2021), depending on how the resource allocation of the running programs is prioritized on a participant’s device.

Original: Another example of dynamics is the requirements of properties of the model, such as adversarial robustness.
Revised: Another example of dynamics is the requirements of properties of the model, such as adversarial robustness.

Original: In autonomous driving, for instance, cloudy and rainy weather can lower the quality of camera and other sensors, and therefore one would like to quickly switch to a more robust prediction model, as compared to the one used on sunny days.
Revised: In autonomous driving, for instance, cloudy and rainy weather can lower the quality of camera and other sensors, and therefore one would like to quickly switch to a more robust prediction model, as compared to the one used on sunny days.

Original: The dynamics along with the low latency requirements for the inference, altogether demand a model that can be customized in situ , meaning that we can instantly tailor our predictive model to a proper size that ﬁts our available budget, and promptly adjust its robustness.
Revised: The dynamics along with the low latency requirements for the inference, altogether demand a model that can be customized in situ , meaning that we can instantly tailor our predictive model to a proper size that ﬁts our available budget, and promptly adjust its robustness.

Original: Most existing federate learning models used a rather static model architecture that prevents such customization.
Revised: Most existing federate learning models used a rather static model architecture that prevents such customization.

Original: A naive solution is to simultaneously train multiple models with wanted architectures and properties, which however may lead to prohibitive training cost and latency of switching models in a budget-limited device.
Revised: A naive solution is to simultaneously train multiple models with wanted architectures and properties, which however may lead to prohibitive training cost and latency of switching models in a budget-limited device.

Original: Moreover, the trade-off between model adversarial robustness and generalization performance can hardly be reconcilable (Tsipras et al., 2019; Merchant et al., 2020), which further complicates the customization.
Revised: Moreover, the trade-off between model adversarial robustness and generalization performance can hardly be reconcilable (Tsipras et al., 2019; Merchant et al., 2020), which further complicates the customization.

Original: To address the aforementioned challenges from heterogeneity and dynamics we study a novel SplitMix federated learning approach for in-situ customization , which follows a communication-efﬁcient paradigm and yields a model whose size and robustness can be efﬁciently customized, without additional training.
Revised: To address the aforementioned challenges from heterogeneity and dynamics we study a novel SplitMix federated learning approach for in-situ customization , which follows a communication-efﬁcient paradigm and yields a model whose size and robustness can be efﬁciently customized, without additional training.

Original: Speciﬁcally, we ﬁrst split the complete knowledge in a large model into several small base sub-networks (shards) according to model widths and robustness levels.
Revised: Speciﬁcally, we ﬁrst split the complete knowledge in a large model into several small base sub-networks (shards) according to model widths and robustness levels.

Original: To complete the knowledge, we let the base models be fully trained on all clients.
Revised: To complete the knowledge, we let the base models be fully trained on all clients.

Original: To provide customized models, we mix selected base models to construct desired widths and required robustness.
Revised: To provide customized models, we mix selected base models to construct desired widths and required robustness.

Original: We illustrate the main idea in Fig.
Revised: We illustrate the main idea in Fig.

Original: 1b.
Revised: 1b.

Original: Overall, our contributions can be summarized in three folds:
Revised: Overall, our contributions can be summarized in three folds:

Original: • Within the domain of heterogeneous federated learning, we are the ﬁrst to study training a model with the capability of in-situ customization with heterogeneous local computation budgets.
Revised: • Within the domain of heterogeneous federated learning, we are the ﬁrst to study training a model with the capability of in-situ customization with heterogeneous local computation budgets.

Original: Illustrated in Fig.
Revised: Illustrated in Fig.

Original: 1a, we show that conventional static-model solutions, such as FedAvg, cannot provide customized models for dynamic client environments, and that its heterogeneous-architecture variant (HeteroFL) suffers from under-training in its large models due to local budget constraints.
Revised: 1a, we show that conventional static-model solutions, such as FedAvg, cannot provide customized models for dynamic client environments, and that its heterogeneous-architecture variant (HeteroFL) suffers from under-training in its large models due to local budget constraints.

Original: • To address the challenge, we propose a novel Split-Mix framework that aggregates knowledge from heterogeneous clients into a width- and robustness-adjustable model structure.
Revised: • To address the challenge, we propose a novel Split-Mix framework that aggregates knowledge from heterogeneous clients into a width- and robustness-adjustable model structure.

Original: Remarkably, due to fewer parameters and modular nature, our framework is not only efﬁcient in federated communication, but also efﬁcient in storage, model loading and inference.
Revised: Remarkably, due to fewer parameters and modular nature, our framework is not only efﬁcient in federated communication, but also efﬁcient in storage, model loading and inference.

Original: • Empirically, we demonstrate that the performance of the proposed method is better than other FL baselines under heterogeneous budget constraints.
Revised: • Empirically, we demonstrate that the performance of the proposed method is better than other FL baselines under heterogeneous budget constraints.

Original: Moreover, we show its effectiveness when facing the challenge of data heterogeneity, i.e., clients’ training datasets suffer from distributional shifts.
Revised: Moreover, we show its effectiveness when facing the challenge of data heterogeneity, i.e., clients’ training datasets suffer from distributional shifts.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Heterogeneous Federated Learning.
Revised: Heterogeneous Federated Learning.

Original: Federated learning with budget-insufﬁcient devices has attracted a great amount of attention.
Revised: Federated learning with budget-insufﬁcient devices has attracted a great amount of attention.

Original: For example, FedDistill (Lin et al., 2020) used logit averages to distill a network of the same size or several prototypes, which will be communicated with users.
Revised: For example, FedDistill (Lin et al., 2020) used logit averages to distill a network of the same size or several prototypes, which will be communicated with users.

Original: FedDistill made an assumption that the central server has access to a public dataset of the same learning task, which is impractical for many applications.
Revised: FedDistill made an assumption that the central server has access to a public dataset of the same learning task, which is impractical for many applications.

Original: He et al.
Revised: He et al.

Original: (2020) introduced a distillation-based method after aggregating private representations from all participants.
Revised: (2020) introduced a distillation-based method after aggregating private representations from all participants.

Original: The method closely resembles centralized learning because all encoded samples are gathered, and however it is less efﬁcient when local clients have large data dimensions or sample sizes.
Revised: The method closely resembles centralized learning because all encoded samples are gathered, and however it is less efﬁcient when local clients have large data dimensions or sample sizes.

Original: Importantly, the method may not transfer adversarial robustness knowledge through the intermediate representations due to the decoupling of the input and prediction.
Revised: Importantly, the method may not transfer adversarial robustness knowledge through the intermediate representations due to the decoupling of the input and prediction.

Original: On the other hand, HeteroFL (Diao et al., 2021) avoids distillation, allowing participants to train different prototypes and sharing parameters among prototypes to reduce redundant parameters.
Revised: On the other hand, HeteroFL (Diao et al., 2021) avoids distillation, allowing participants to train different prototypes and sharing parameters among prototypes to reduce redundant parameters.

Original: However, HeteroFL also reduces the samples available for training each prototype, which leads to degraded performance.
Revised: However, HeteroFL also reduces the samples available for training each prototype, which leads to degraded performance.

Original: FedEnsemble (Shi et al., 2021) is technically related to the proposed approach, which uses ensemble of diverse models to accommodate non- i.i.d.
Revised: FedEnsemble (Shi et al., 2021) is technically related to the proposed approach, which uses ensemble of diverse models to accommodate non- i.i.d.

Original: heterogeneity.
Revised: heterogeneity.

Original: The authors showed that combining multiple base models trained simultaneously in FL can outperform a single base model in testing.
Revised: The authors showed that combining multiple base models trained simultaneously in FL can outperform a single base model in testing.

Original: A critical difference between the proposed approach and FedEnsemble comes from the challenging problem setting of constrained heterogeneous computation budgets.
Revised: A critical difference between the proposed approach and FedEnsemble comes from the challenging problem setting of constrained heterogeneous computation budgets.

Original: Moreover, we show that with fewer model parameters and training time, the ensemble of a subset of trained base models could outperform a single model of the same width but trained in a heterogeneous-architecture way.
Revised: Moreover, we show that with fewer model parameters and training time, the ensemble of a subset of trained base models could outperform a single model of the same width but trained in a heterogeneous-architecture way.

Original: Customizable Models.
Revised: Customizable Models.

Original: To our best knowledge, this is the ﬁrst paper discussing in-situ customization in federated learning and here we review similar concepts in central learning.
Revised: To our best knowledge, this is the ﬁrst paper discussing in-situ customization in federated learning and here we review similar concepts in central learning.

Original: First, customization of robustness and accuracy was discussed by Wang et al.
Revised: First, customization of robustness and accuracy was discussed by Wang et al.

Original: (2020), where an adjustable-conditional layer together with decoupled batch-normalization were used.
Revised: (2020), where an adjustable-conditional layer together with decoupled batch-normalization were used.

Original: The conditional layer enables continuous trade-off but also brings in over 50% more parameters.
Revised: The conditional layer enables continuous trade-off but also brings in over 50% more parameters.

Original: In comparison, a simple weighted combination without additional parameters is used in our method and is very efﬁcient in both communication and inference.
Revised: In comparison, a simple weighted combination without additional parameters is used in our method and is very efﬁcient in both communication and inference.

Original: In terms of model complexity, a series of work on dynamic neural networks were proposed to provide instant, adaptive and efﬁcient trade-off between accuracy and latency (mainly related to model complexity) of neural networks at the inference stage.
Revised: In terms of model complexity, a series of work on dynamic neural networks were proposed to provide instant, adaptive and efﬁcient trade-off between accuracy and latency (mainly related to model complexity) of neural networks at the inference stage.

Original: Typically, sub-path networks of different complexity (Liu & Deng, 2018) or sub-depth networks (Huang et al., 2018; Wu et al., 2019; Wang et al., 2018; Zhang et al., 2021) are trained together.
Revised: Typically, sub-path networks of different complexity (Liu & Deng, 2018) or sub-depth networks (Huang et al., 2018; Wu et al., 2019; Wang et al., 2018; Zhang et al., 2021) are trained together.

Original: However, due to the large memory footprint brought by a constant number of channels per layer, the memory footprint at inference is barely reduced.
Revised: However, due to the large memory footprint brought by a constant number of channels per layer, the memory footprint at inference is barely reduced.

Original: To address the challenge, slimmable neural network (SNN) (Yu et al., 2018) was proposed to train networks with adaptive layer widths.
Revised: To address the challenge, slimmable neural network (SNN) (Yu et al., 2018) was proposed to train networks with adaptive layer widths.

Original: Distinct from SNN, we consider a more challenging scenario with distributed and non-sharable data and heterogeneous client capabilities.
Revised: Distinct from SNN, we consider a more challenging scenario with distributed and non-sharable data and heterogeneous client capabilities.

Original:  P ROBLEM S ETTING
Revised:  P ROBLEM S ETTING

Original: The goal of this work is to develop a federated learning (FL) strategy, that yields a global model, which can be instantly customized for dynamic needs.
Revised: The goal of this work is to develop a federated learning (FL) strategy, that yields a global model, which can be instantly customized for dynamic needs.

Original: Formally, FL minimizes the objective
Revised: Formally, FL minimizes the objective

Original: [Equation]
Revised: [Equation]

Original: x
Revised: x

Original: [Equation]
Revised: [Equation]

Original: W ) , y ) with distributed data { D k } Kk =1 across K participants/clients, where L is loss function, e.g., cross-entropy loss, f is a model parameterized by W , and x, y are a sample and a label, respectively.
Revised: W ) , y ) with distributed data { D k } Kk =1 across K participants/clients, where L is loss function, e.g., cross-entropy loss, f is a model parameterized by W , and x, y are a sample and a label, respectively.

Original: In this paper, we consider two kinds of customization: adjustable model sizes to trade off between execution complexity and accuracy, adjustable robustness for dynamic security sensitivity.
Revised: In this paper, we consider two kinds of customization: adjustable model sizes to trade off between execution complexity and accuracy, adjustable robustness for dynamic security sensitivity.

Original: Though other types of customization could be considered, for example, neural-architecture search or fairness, we believe the two types considered are quite representative for both architecture and non-architecture knowledge (Wang et al., 2020).
Revised: Though other types of customization could be considered, for example, neural-architecture search or fairness, we believe the two types considered are quite representative for both architecture and non-architecture knowledge (Wang et al., 2020).

Original: When training customizable/adjustable models, signiﬁcant challengs arise from heterogeneity among clients.
Revised: When training customizable/adjustable models, signiﬁcant challengs arise from heterogeneity among clients.

Original: In this paper, we consider the following: 1) Heterogeneous computational budgets during training of clients constrain the maximal complexity of local models.
Revised: In this paper, we consider the following: 1) Heterogeneous computational budgets during training of clients constrain the maximal complexity of local models.

Original: The complexity of deep neural networks can be deﬁned in multiple dimensions, like depths or widths (Zagoruyko & Komodakis, 2017; Tan & Le, 2019).
Revised: The complexity of deep neural networks can be deﬁned in multiple dimensions, like depths or widths (Zagoruyko & Komodakis, 2017; Tan & Le, 2019).

Original: In this paper, we consider the width of hidden channels, because it can signiﬁcantly reduce not only the number of model parameters but also the layer output cache.
Revised: In this paper, we consider the width of hidden channels, because it can signiﬁcantly reduce not only the number of model parameters but also the layer output cache.

Original: Thus, we assume clients have conﬁned width capabilities { R k ∈ (0 , 1] } Kk =1 , deﬁned by width ratios w.r.t.
Revised: Thus, we assume clients have conﬁned width capabilities { R k ∈ (0 , 1] } Kk =1 , deﬁned by width ratios w.r.t.

Original: the original model, i.e., × R k net as presented in Fig.
Revised: the original model, i.e., × R k net as presented in Fig.

Original: 1b.
Revised: 1b.

Original: Similar to FedAvg and HeteroFL, the same architecture is used by clients and therefore the model width can be tailored according to local budgets.
Revised: Similar to FedAvg and HeteroFL, the same architecture is used by clients and therefore the model width can be tailored according to local budgets.

Original: Imbalance computation budgets.
Revised: Imbalance computation budgets.

Original: In many applications, there are usually a signiﬁcant number of devices with insufﬁcient computational budgets (Enge, 2021).
Revised: In many applications, there are usually a signiﬁcant number of devices with insufﬁcient computational budgets (Enge, 2021).

Original: Without loss of generality, we assume exponentially distributed budgets in uniformly divided client groups: R k = (1 / 2) (cid:100) 4 k/K (cid:101) , i.e., the ﬁrst group with 1 / 4 clients is capable for a 1 -width and the rest are for 0 .
Revised: Without loss of generality, we assume exponentially distributed budgets in uniformly divided client groups: R k = (1 / 2) (cid:100) 4 k/K (cid:101) , i.e., the ﬁrst group with 1 / 4 clients is capable for a 1 -width and the rest are for 0 .

Original: 125 -widths respectively.
Revised: 125 -widths respectively.

Original: Such a budget distribution could result in additional challenges in the presence of data heterogeneity, e.g., non- i.i.d.
Revised: Such a budget distribution could result in additional challenges in the presence of data heterogeneity, e.g., non- i.i.d.

Original: features, D k ∼ D i for ordered domain i , since training a single model on multiple domains (Li et al., 2020b) or models in a single domain (due to budget constraints)
Revised: features, D k ∼ D i for ordered domain i , since training a single model on multiple domains (Li et al., 2020b) or models in a single domain (due to budget constraints)

Original: (Hong et al., 2021) are known to be suboptimal on average performance.
Revised: (Hong et al., 2021) are known to be suboptimal on average performance.

Original: Finally, following the standard FL setting (McMahan et al., 2017), only model parameters can be shared to protect privacy.
Revised: Finally, following the standard FL setting (McMahan et al., 2017), only model parameters can be shared to protect privacy.

Original: In summary, the problem setting has challenges from 1) resource heterogeneity, where disparity in computation budgets will signiﬁcantly affect the training of large models because they can only be trained scarce budget-sufﬁcient clients; 2) data heterogeneity, where the under-trained large models may perform poorly on unseen in-domain or out-of-domain samples.
Revised: In summary, the problem setting has challenges from 1) resource heterogeneity, where disparity in computation budgets will signiﬁcantly affect the training of large models because they can only be trained scarce budget-sufﬁcient clients; 2) data heterogeneity, where the under-trained large models may perform poorly on unseen in-domain or out-of-domain samples.

Original:  M ETHOD
Revised:  M ETHOD

Original: To provide efﬁcient in-situ customization, we introduce a simple yet powerful principle, Split-Mix: shatter complete knowledge into smaller pieces, and customize by ﬂexible formations of pieces.
Revised: To provide efﬁcient in-situ customization, we introduce a simple yet powerful principle, Split-Mix: shatter complete knowledge into smaller pieces, and customize by ﬂexible formations of pieces.

Original: Based on the principle, we propose customizations of model size and robustness in the following.
Revised: Based on the principle, we propose customizations of model size and robustness in the following.

Original: 4. C USTOMIZE M ODEL S IZE
Revised: 4. C USTOMIZE M ODEL S IZE

Original: For motivation, we ﬁrst set up a non- i.i.d.
Revised: For motivation, we ﬁrst set up a non- i.i.d.

Original: FL experiment to compare model performance with/without budget constraint, where the same 6 -domain DomainNet images are uniformly distributed intoclients for both cases (refer to experimental details in Section 5).
Revised: FL experiment to compare model performance with/without budget constraint, where the same 6 -domain DomainNet images are uniformly distributed intoclients for both cases (refer to experimental details in Section 5).

Original: [Figure]
Revised: [Figure]

Original: Case 1: FL without budget constraint.
Revised: Case 1: FL without budget constraint.

Original: First, we individually train networks of different widths by FedAvg.
Revised: First, we individually train networks of different widths by FedAvg.

Original: We see that the slimmer networks converge slower and are less generalizable, even though they are trained on all clients (solid lines in Fig. 2).
Revised: We see that the slimmer networks converge slower and are less generalizable, even though they are trained on all clients (solid lines in Fig. 2).

Original: The results justiﬁed the motivation of training wider networks than slimmer ones.
Revised: The results justiﬁed the motivation of training wider networks than slimmer ones.

Original: Case 2: FL with budget constraint.
Revised: Case 2: FL with budget constraint.

Original: Following the above budget constraint, i.e., R k = (1 / 2) (cid:100) 4 k/K (cid:101) , we deploy HeteroFL to train budget-compatible prototype models locally.
Revised: Following the above budget constraint, i.e., R k = (1 / 2) (cid:100) 4 k/K (cid:101) , we deploy HeteroFL to train budget-compatible prototype models locally.

Original: We note that data are not fully used by HeteroFL: each model prototype is only trained by 1 / 4 of clients, when clients of the R k =budget can actually afford all slimmer models.
Revised: We note that data are not fully used by HeteroFL: each model prototype is only trained by 1 / 4 of clients, when clients of the R k =budget can actually afford all slimmer models.

Original: Therefore, we extend HeteroFL to a slimmable version (SHeteroFL) by training all affordable prototypes locally.
Revised: Therefore, we extend HeteroFL to a slimmable version (SHeteroFL) by training all affordable prototypes locally.

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 2, wider models (e.g., × 1 net) converge to validation accuracy lower than not only the FedAvg counterparts, but also the slimmer × 0 .
Revised: 2, wider models (e.g., × 1 net) converge to validation accuracy lower than not only the FedAvg counterparts, but also the slimmer × 0 .

Original: 25 net, showing that the widest model may not be a good candidate model.
Revised: 25 net, showing that the widest model may not be a good candidate model.

Original: Intuitively, as a consequence of the budget constraint, fewer training clients are able to participate in the learning of wider networks, where the reduced sample size or model size greatly impacted the generalization.
Revised: Intuitively, as a consequence of the budget constraint, fewer training clients are able to participate in the learning of wider networks, where the reduced sample size or model size greatly impacted the generalization.

Original: Since FL does not allow global data sharing to mitigate the issue, the key is to study how the scarcity of data or smaller width affects model generalization in FL.
Revised: Since FL does not allow global data sharing to mitigate the issue, the key is to study how the scarcity of data or smaller width affects model generalization in FL.

Original: We hypothesize that a model may pick up signals from more features for reasoning a class if trained with more data.
Revised: We hypothesize that a model may pick up signals from more features for reasoning a class if trained with more data.

Original: For validation, we investigate the features that draw signiﬁcant attention of different networks in
Revised: For validation, we investigate the features that draw signiﬁcant attention of different networks in

Original: Fig.
Revised: Fig.

Original: We found that both FedAvg and SHeteroFL × 1 nets extract richer features than the slimmer × 0 .
Revised: We found that both FedAvg and SHeteroFL × 1 nets extract richer features than the slimmer × 0 .

Original: 125 net.
Revised: 125 net.

Original: This may partially explain why the slimmer network generalizes poorly.
Revised: This may partially explain why the slimmer network generalizes poorly.

Original: On the other side, though the SHeteroFL × 1 net has the same capacity as the FedAvg × 1 net and thereby extracted similarly-rich features, its accuracy is lower than FedAvg.
Revised: On the other side, though the SHeteroFL × 1 net has the same capacity as the FedAvg × 1 net and thereby extracted similarly-rich features, its accuracy is lower than FedAvg.

Original: This suggests that the features learned from limited data could be less generalizable.
Revised: This suggests that the features learned from limited data could be less generalizable.

Original: For example, the SHeteroFL loses attention of edges of the feather in the ﬁfth image.
Revised: For example, the SHeteroFL loses attention of edges of the feather in the ﬁfth image.

Original: Thus, more diverse or higher-quality features are desired.
Revised: Thus, more diverse or higher-quality features are desired.

Original: The importance of features for generalization was also echoed by a recent study ( ? ), The study showed that encouraging neural networks to extract diverse features can boost testing accuracy.
Revised: The importance of features for generalization was also echoed by a recent study ( ? ), The study showed that encouraging neural networks to extract diverse features can boost testing accuracy.

Original: S H e t e r o
Revised: S H e t e r o

Original: F L × 1 n e t
Revised: F L × 1 n e t

Original: F e d
Revised: F e d

Original: A v g × 1 n e t
Revised: A v g × 1 n e t

Original: F e d A v g × 0 .n
Revised: F e d A v g × 0 .n

Original: e t
Revised: e t

Original: More images in Fig.
Revised: More images in Fig.

Original: Motivated by the above observations, we propose to train multiple base models from different random initializations to encourage their diversity.
Revised: Motivated by the above observations, we propose to train multiple base models from different random initializations to encourage their diversity.

Original: The diverse bases likely extract different features from the same image (see Fig. 4).
Revised: The diverse bases likely extract different features from the same image (see Fig. 4).

Original: The overall FL algorithm is summarized in Algorithm 3.
Revised: The overall FL algorithm is summarized in Algorithm 3.

Original: To craft a wide model, we combine the output of a number of base models until the size of the ensemble reaches the same as the number of channels.
Revised: To craft a wide model, we combine the output of a number of base models until the size of the ensemble reaches the same as the number of channels.

Original: Therefore, the ensemble predicts based on a variety of features, resembling an integrated wide network.
Revised: Therefore, the ensemble predicts based on a variety of features, resembling an integrated wide network.

Original: To facilitate these base models to extract generalizable features, we want to train base models in all clients.
Revised: To facilitate these base models to extract generalizable features, we want to train base models in all clients.

Original: Inspired by FedEnsemble (Shi et al., 2021), we randomly sample a set of bases for each client in Algorithm 1.
Revised: Inspired by FedEnsemble (Shi et al., 2021), we randomly sample a set of bases for each client in Algorithm 1.

Original: In each client, we speed up the local training of multiple independent base models by direct parallelization (see Algorithm 2).
Revised: In each client, we speed up the local training of multiple independent base models by direct parallelization (see Algorithm 2).

Original: Note however that the parallelism is limited by the maximal width in local, as wider channels result in larger intermediate layer cache (activations).
Revised: Note however that the parallelism is limited by the maximal width in local, as wider channels result in larger intermediate layer cache (activations).

Original: We thus limit the total channels of ensemble by client’s budgets.
Revised: We thus limit the total channels of ensemble by client’s budgets.

Original: Note that since the federated training processes of base models are independent without interference, the training could be as stable as
Revised: Note that since the federated training processes of base models are independent without interference, the training could be as stable as

Original: FedAvg with partial participants.
Revised: FedAvg with partial participants.

Original: Different from sequential training, the parallelism speeds up the local training and reduces the possible client blocking time on communication.
Revised: Different from sequential training, the parallelism speeds up the local training and reduces the possible client blocking time on communication.

Original: In addition, slimmer base models can conform a variety of client budgets while maintaining the same model width.
Revised: In addition, slimmer base models can conform a variety of client budgets while maintaining the same model width.

Original: e
Revised: e

Original: E do y
Revised: E do y

Original: ˆ w i r ∈
Revised: ˆ w i r ∈

Original: ˆ W k parallel
Revised: ˆ W k parallel

Original: : ˆ w
Revised: : ˆ w

Original: ← ˆ w
Revised: ← ˆ w

Original: − η f
Revised: − η f

Original: 4. C USTOMIZE A DVERSARIAL R OBUSTNESS
Revised: 4. C USTOMIZE A DVERSARIAL R OBUSTNESS

Original: In many existing robustness learning approaches, model robustness and generalization are typically irreconcilable, and a trade-off between the two has to be determined when applying robust models.
Revised: In many existing robustness learning approaches, model robustness and generalization are typically irreconcilable, and a trade-off between the two has to be determined when applying robust models.

Original: In this section, we study the customization of model robustness, and speciﬁcally adversarial robustness .
Revised: In this section, we study the customization of model robustness, and speciﬁcally adversarial robustness .

Original: The adversarial robustness of a model reﬂects its prediction accuracy when subtle and predictionﬂipping adversarial noise presents.
Revised: The adversarial robustness of a model reﬂects its prediction accuracy when subtle and predictionﬂipping adversarial noise presents.

Original: Recently, adversarial training (AT) (Madry et al., 2018) becomes a popular approach that uses on-the-ﬂy adversarial samples as augmentation to improve adversarial robustness.
Revised: Recently, adversarial training (AT) (Madry et al., 2018) becomes a popular approach that uses on-the-ﬂy adversarial samples as augmentation to improve adversarial robustness.

Original: Formally, AT minimizes the following augmented loss:
Revised: Formally, AT minimizes the following augmented loss:

Original: [Equation]
Revised: [Equation]

Original: where δ is a subtle adversarial noise which maximizes the loss in a given constraint (cid:15) .
Revised: where δ is a subtle adversarial noise which maximizes the loss in a given constraint (cid:15) .

Original: The addition of δ transfers a clean sample x into an adversarial sample .
Revised: The addition of δ transfers a clean sample x into an adversarial sample .

Original: In Eq.
Revised: In Eq.

Original: (1), the ﬁrst term characterizes the cross-entropy loss ( L CE ) on clean samples while the later one on adversarial samples.
Revised: (1), the ﬁrst term characterizes the cross-entropy loss ( L CE ) on clean samples while the later one on adversarial samples.

Original: The
Revised: The

Original: Input
Revised: Input

Original: Send
Revised: Send

Original: Aggregate
Revised: Aggregate

Original: | 8:
Revised: | 8:

Original: Server descending validation
Revised: Server descending validation

Original: 10: Output customizable
Revised: 10: Output customizable

Original: =
Revised: =

Original: 11: Customize an R width model by F
Revised: 11: Customize an R width model by F

Original: K R
Revised: K R

Original: i
Revised: i

Original: 1 f w i r
Revised: 1 f w i r

Original: K R hyper-parameter λ n trades off robustness and accuracy.
Revised: K R hyper-parameter λ n trades off robustness and accuracy.

Original: When λ n = 0 or 1 , the optimization yields a standard-training (ST) model or an AT model, respectively.
Revised: When λ n = 0 or 1 , the optimization yields a standard-training (ST) model or an AT model, respectively.

Original: Since an adversarially-trained model is commonly less accurate in predicting standard images (Tsipras et al., 2019), there is usually no such a sweet point of λ n simultaneously maximizing robustness and accuracy, and one typically needs to carefully gauge the trade-off according to the demand of robustness in speciﬁc application context.
Revised: Since an adversarially-trained model is commonly less accurate in predicting standard images (Tsipras et al., 2019), there is usually no such a sweet point of λ n simultaneously maximizing robustness and accuracy, and one typically needs to carefully gauge the trade-off according to the demand of robustness in speciﬁc application context.

Original: [Figure]
Revised: [Figure]

Original: Splitting and sharing parameters.
Revised: Splitting and sharing parameters.

Original: Since standard performance and adversarial robustness are irreconcilable, we can directly use two separated
Revised: Since standard performance and adversarial robustness are irreconcilable, we can directly use two separated

Original: ST and AT models to maximally capture the each property.
Revised: ST and AT models to maximally capture the each property.

Original: But do we really need two totally separated models?
Revised: But do we really need two totally separated models?

Original: Intuitively, the two models share some common knowledge, given that an adversarial image share a large part of common features with its original version.
Revised: Intuitively, the two models share some common knowledge, given that an adversarial image share a large part of common features with its original version.

Original: As introduced by (Xie & Yuille, 2019; Xie et al., 2020), sharing all parameters except the batch-normalization (BN) layers can maximize robustness and accuracy by expertised BNs, respectively.
Revised: As introduced by (Xie & Yuille, 2019; Xie et al., 2020), sharing all parameters except the batch-normalization (BN) layers can maximize robustness and accuracy by expertised BNs, respectively.

Original: Accordingly, we propose to split BN layers (instead of the whole model) into two sub-components: one for standard performance and the other for robustness.
Revised: Accordingly, we propose to split BN layers (instead of the whole model) into two sub-components: one for standard performance and the other for robustness.

Original: At training time, the ﬁrst cross-entropy loss of Eq.
Revised: At training time, the ﬁrst cross-entropy loss of Eq.

Original: (1) is computed with clean BN (BN c ) merely and the second adversarial loss is computed with noised BN (BN n ).
Revised: (1) is computed with clean BN (BN c ) merely and the second adversarial loss is computed with noised BN (BN n ).

Original: The FL local training is elaborated in Algorithm 4.
Revised: The FL local training is elaborated in Algorithm 4.

Original: As the two BNs are decoupled, there is no more trade-off in loss Eq.
Revised: As the two BNs are decoupled, there is no more trade-off in loss Eq.

Original: and thereby we choose λ n = 0 .
Revised: and thereby we choose λ n = 0 .

Original: 5 to balance their effects on parameter updates.
Revised: 5 to balance their effects on parameter updates.

Original: Layer-wise mixing.
Revised: Layer-wise mixing.

Original: After training, the problem is how to mix the two models (with different BNs) for prediction.
Revised: After training, the problem is how to mix the two models (with different BNs) for prediction.

Original: A straightforward solution is averaging their outputs.
Revised: A straightforward solution is averaging their outputs.

Original: However, forwarding memory footprint will be doubled in this way, as the two models have to be both executed separately.
Revised: However, forwarding memory footprint will be doubled in this way, as the two models have to be both executed separately.

Original: To avoid the cache of double size of intermediate outputs, a gate function can be used to adaptively switch between two BNs like (Liu et al., 2020).
Revised: To avoid the cache of double size of intermediate outputs, a gate function can be used to adaptively switch between two BNs like (Liu et al., 2020).

Original: Inspired by the method, we further propose a simple parameter-free method by weighted-averaging outputs of each BN layer (see Fig. 5):
Revised: Inspired by the method, we further propose a simple parameter-free method by weighted-averaging outputs of each BN layer (see Fig. 5):

Original: [Equation]
Revised: [Equation]

Original: given a BN-layer input x .
Revised: given a BN-layer input x .

Original: We note that the averaging strategy is entirely training-free and does not use extra parameters, and the customization weight λ is intuitive for trade-offs between SA and RA.
Revised: We note that the averaging strategy is entirely training-free and does not use extra parameters, and the customization weight λ is intuitive for trade-offs between SA and RA.

Original: Lastly, it is remarkable that the DBN structure is rather lightweight in terms of model complexity.
Revised: Lastly, it is remarkable that the DBN structure is rather lightweight in terms of model complexity.

Original: As investigated in (Yu et al., 2018)
Revised: As investigated in (Yu et al., 2018)

Original: (Table 2), the parameters of BN is no more than 1% in popular deep architectures, e.g., ResNet or MobileNet.
Revised: (Table 2), the parameters of BN is no more than 1% in popular deep architectures, e.g., ResNet or MobileNet.

Original: Therefore, we can plug DBN into base models in place of
Revised: Therefore, we can plug DBN into base models in place of

Original: BN, replace Algorithm 2 with Algorithm 4, and jointly customize robustness and model widths.
Revised: BN, replace Algorithm 2 with Algorithm 4, and jointly customize robustness and model widths.

Original:  E MPIRICAL S TUDIES
Revised:  E MPIRICAL S TUDIES

Original: We design experiments to compare the proposed method against FL classiﬁcation benchmarks.
Revised: We design experiments to compare the proposed method against FL classiﬁcation benchmarks.

Original: Conﬁgurations.
Revised: Conﬁgurations.

Original: For i.i.d conﬁguration, we use CIFAR10 dataset (Krizhevsky, 2009) with preactivated
Revised: For i.i.d conﬁguration, we use CIFAR10 dataset (Krizhevsky, 2009) with preactivated

Original: ResNet (PreResNet18) (He et al., 2016).
Revised: ResNet (PreResNet18) (He et al., 2016).

Original: CIFAR10 contains over 50 , 000 32 × 32 images ofclasses.
Revised: CIFAR10 contains over 50 , 000 32 × 32 images ofclasses.

Original: The CIFAR10 data are uniformly split into 100 clients.
Revised: The CIFAR10 data are uniformly split into 100 clients.

Original: For non- i.i.d conﬁguration, we use
Revised: For non- i.i.d conﬁguration, we use

Original: Digits with a CNN deﬁned and DomainNet datasets (Li et al., 2020b) with AlexNet extended with
Revised: Digits with a CNN deﬁned and DomainNet datasets (Li et al., 2020b) with AlexNet extended with

Original: BN layers after each convolutional or linear layer (Li et al., 2020b).
Revised: BN layers after each convolutional or linear layer (Li et al., 2020b).

Original: Data.
Revised: Data.

Original: The ﬁrst dataset is a subset (30%) of Digits, a benchmark for domain adaption (Peng et al., 2019b).
Revised: The ﬁrst dataset is a subset (30%) of Digits, a benchmark for domain adaption (Peng et al., 2019b).

Original: Digits has 28 ×images and serves as a commonly used benchmark for FL (Caldas et al., 2019; McMahan et al., 2017;
Revised: Digits has 28 ×images and serves as a commonly used benchmark for FL (Caldas et al., 2019; McMahan et al., 2017;

Original: Li et al., 2020a).
Revised: Li et al., 2020a).

Original: The dataset includes 5 different domains: MNIST (Lecun et al., 1998), SVHN (Netzer et al., 2011), USPS (Hull, 1994), SynthDigits (Ganin & Lempitsky, 2015), and MNIST-M (Ganin & Lempitsky, 2015).
Revised: The dataset includes 5 different domains: MNIST (Lecun et al., 1998), SVHN (Netzer et al., 2011), USPS (Hull, 1994), SynthDigits (Ganin & Lempitsky, 2015), and MNIST-M (Ganin & Lempitsky, 2015).

Original: The second dataset is DomainNet (Peng et al., 2019a) processed by (Li et al., 2020b), which contains 6 distinct domains of large-size 256 × 256 real-world images:
Revised: The second dataset is DomainNet (Peng et al., 2019a) processed by (Li et al., 2020b), which contains 6 distinct domains of large-size 256 × 256 real-world images:

Original: Clipart, Infograph, Painting, Quickdraw, Real, Sketch.
Revised: Clipart, Infograph, Painting, Quickdraw, Real, Sketch.

Original: Each domain of Digits (or DomainNet) are split into 10 (or 5) clients, and therefore 50 (or 30) clients in total.
Revised: Each domain of Digits (or DomainNet) are split into 10 (or 5) clients, and therefore 50 (or 30) clients in total.

Original: We defer other details such as hyper-parameters to Appendix A, and focus on discussing the results.
Revised: We defer other details such as hyper-parameters to Appendix A, and focus on discussing the results.

Original: 5. C USTOMIZE MODEL SIZES
Revised: 5. C USTOMIZE MODEL SIZES

Original: In this section, we evaluate the proposed Split-Mix on tasks of customizing model sizes through adjusting model widths.
Revised: In this section, we evaluate the proposed Split-Mix on tasks of customizing model sizes through adjusting model widths.

Original: Recall that in Section 3, we assume a speciﬁc heterogeneous training budget to facilitate our discussion, such that one client can only train models within a maximal width, and the resource distribution is imbalance among clients: R k = (1 / 2) (cid:100) 4 k/K (cid:101) .
Revised: Recall that in Section 3, we assume a speciﬁc heterogeneous training budget to facilitate our discussion, such that one client can only train models within a maximal width, and the resource distribution is imbalance among clients: R k = (1 / 2) (cid:100) 4 k/K (cid:101) .

Original: Following the common FL setting, we do not consider algorithms that use public data or representation sharing in our baselines.
Revised: Following the common FL setting, we do not consider algorithms that use public data or representation sharing in our baselines.

Original: Baselines .
Revised: Baselines .

Original: As an ideal upper bound but a memory-incompatible baseline, we (re-)train networks from scratch by FedAvg to obtain individual models with different widths.
Revised: As an ideal upper bound but a memory-incompatible baseline, we (re-)train networks from scratch by FedAvg to obtain individual models with different widths.

Original: The state-of-the-art heterogeneous-architecture FL method is HeteroFL (Diao et al., 2021), which trains different slim models in different clients.
Revised: The state-of-the-art heterogeneous-architecture FL method is HeteroFL (Diao et al., 2021), which trains different slim models in different clients.

Original: For a fair comparison, we extend HeteroFL with bounded-slimmable training in clients who can afford the larger models, named SHeteroFL .
Revised: For a fair comparison, we extend HeteroFL with bounded-slimmable training in clients who can afford the larger models, named SHeteroFL .

Original: For example, if a client in
Revised: For example, if a client in

Original: HeteroFL can afford × 0 .
Revised: HeteroFL can afford × 0 .

Original: 5 net, then the client meanwhile trains × 0 .
Revised: 5 net, then the client meanwhile trains × 0 .

Original: 25 net and other smaller subnets in slimmable training manner (Yu et al., 2018) by SHeteroFL.
Revised: 25 net and other smaller subnets in slimmable training manner (Yu et al., 2018) by SHeteroFL.

Original: Convergence.
Revised: Convergence.

Original: In Fig.
Revised: In Fig.

Original: 6, we compare the convergence curves of full-width models on three datasets.
Revised: 6, we compare the convergence curves of full-width models on three datasets.

Original: For FedAvg, the budget-compatible width is × 0 .
Revised: For FedAvg, the budget-compatible width is × 0 .

Original: Both for SHeteroFL and Split-Mix, the fullwidth is × 1 .
Revised: Both for SHeteroFL and Split-Mix, the fullwidth is × 1 .

Original: Compared to baselines, the proposed Split-Mix converges faster, largely due to the splitting strategy.
Revised: Compared to baselines, the proposed Split-Mix converges faster, largely due to the splitting strategy.

Original: Speciﬁcally, because all base models are independently trained, the convergence of each base model mainly depends on how frequently they are trained.
Revised: Speciﬁcally, because all base models are independently trained, the convergence of each base model mainly depends on how frequently they are trained.

Original: When enough clients participate
Revised: When enough clients participate

Original: FL, the training frequency of the × 1 net is more than one, as all bases will be selected at least once in a communication round.
Revised: FL, the training frequency of the × 1 net is more than one, as all bases will be selected at least once in a communication round.

Original: Performance.
Revised: Performance.

Original: In Table 1, we compare the test accuracy of different model widths.
Revised: In Table 1, we compare the test accuracy of different model widths.

Original: We measure the latency in terms of MACs (number of multiplication-and-addition operations) and model size in parameter numbers.
Revised: We measure the latency in terms of MACs (number of multiplication-and-addition operations) and model size in parameter numbers.

Original: With the same width, our method outperforms SHeteroFL, using much fewer parameters and thus conducts inference in much lower latency.
Revised: With the same width, our method outperforms SHeteroFL, using much fewer parameters and thus conducts inference in much lower latency.

Original: Remarkably, compared to the best model by SHeteroFL, e.g., 81 . 8% × 1 net in CIFAR10, Split-Mix uses only 1.8% parameters and 1.6% MACs ( × 0 .
Revised: Remarkably, compared to the best model by SHeteroFL, e.g., 81 . 8% × 1 net in CIFAR10, Split-Mix uses only 1.8% parameters and 1.6% MACs ( × 0 .

Original: 125 net) to reach a similar level of test accuracy.
Revised: 125 net) to reach a similar level of test accuracy.

Original: We notice that SHeteroFL has a much lower test accuracy with × 0 .
Revised: We notice that SHeteroFL has a much lower test accuracy with × 0 .

Original: 125 net on the CIFAR10 dataset.
Revised: 125 net on the CIFAR10 dataset.

Original: By investigating the loss curves, we ﬁnd that the inference between parameter-shared different prototypes results in unstable convergence of the × 0 .
Revised: By investigating the loss curves, we ﬁnd that the inference between parameter-shared different prototypes results in unstable convergence of the × 0 .

Original: 125 net.
Revised: 125 net.

Original: Attributed to the independent splitting, our method is more stable
Revised: Attributed to the independent splitting, our method is more stable

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: - i.i.d FL × 0 .
Revised: - i.i.d FL × 0 .

Original: 125 61.6% 24.8M 0.9M 59.4% 24.8M 0.9M 63.5% 24.8M 0.9M × 0 .69.3% 75.5M 3.6M 62.3% 75.5M 3.6M 67.3%
Revised: 125 61.6% 24.8M 0.9M 59.4% 24.8M 0.9M 63.5% 24.8M 0.9M × 0 .69.3% 75.5M 3.6M 62.3% 75.5M 3.6M 67.3%

Original: 49.5M 1.8M × 0 .72.

Revised: 49.5M 1.8M × 0 .72.

Original: % 254.8M 14.3M 62.2%
Revised: % 254.8M 14.3M 62.2%

Original: 254.8M 14.3M 68.7% 99.0M 3.6M ×72.5% 925.0M 57.1M 56.2% 925.0M 57.1M 69.8% 198.1M 7.2M
Revised: 254.8M 14.3M 68.7% 99.0M 3.6M ×72.5% 925.0M 57.1M 56.2% 925.0M 57.1M 69.8% 198.1M 7.2M

Original: [Figure]
Revised: [Figure]

Original: on convergence with different widths.
Revised: on convergence with different widths.

Original: Remarkably, Split-Mix only requires 12.7% parameters and 19.8% MACs (by × 1 ensemble) to achieve the comparable accuracy as the × 1 individual network on Digits.
Revised: Remarkably, Split-Mix only requires 12.7% parameters and 19.8% MACs (by × 1 ensemble) to achieve the comparable accuracy as the × 1 individual network on Digits.

Original: Results on CIFAR10 and DomainNet show a potential limitation of our method.
Revised: Results on CIFAR10 and DomainNet show a potential limitation of our method.

Original: The accuracy of Split-Mix is not comparable with the wider individual models due to the locally limited complexity.
Revised: The accuracy of Split-Mix is not comparable with the wider individual models due to the locally limited complexity.

Original: However, the limitation is more from the problem setting itself, and will not undermine our advantage in budget-limited FL, since wide individual models cannot be trained in this case.
Revised: However, the limitation is more from the problem setting itself, and will not undermine our advantage in budget-limited FL, since wide individual models cannot be trained in this case.

Original: In addition to comparisons of inference on average, we also demonstrate the statistics of test accuracy and the training and communication efﬁciency in Fig.
Revised: In addition to comparisons of inference on average, we also demonstrate the statistics of test accuracy and the training and communication efﬁciency in Fig.

Original: Conforming the budget constraints, our method outputs more accurate full-width models, transfer fewer parameters per round and execute fewer multiplication-and-add operations for gradient descent than SHeteroFL, either in terms of average or variance.
Revised: Conforming the budget constraints, our method outputs more accurate full-width models, transfer fewer parameters per round and execute fewer multiplication-and-add operations for gradient descent than SHeteroFL, either in terms of average or variance.

Original: Because only the individual × 0 .
Revised: Because only the individual × 0 .

Original: 125 net can ﬁt into the budget constraint, FedAvg requires the least MACs and parameters, which however signiﬁcantly sacriﬁces the ﬁnal accuracy.
Revised: 125 net can ﬁt into the budget constraint, FedAvg requires the least MACs and parameters, which however signiﬁcantly sacriﬁces the ﬁnal accuracy.

Original: To understand why Split-Mix outperforms SHeteroFL, we investigate the total percentage of parameters that can be trained in each domain, in Fig.
Revised: To understand why Split-Mix outperforms SHeteroFL, we investigate the total percentage of parameters that can be trained in each domain, in Fig.

Original: 8 (Left).
Revised: 8 (Left).

Original: We count the total parameters that were ever trained in clients of a domain during the learning.
Revised: We count the total parameters that were ever trained in clients of a domain during the learning.

Original: Thanks to the base-model sampling strategy (i.e.,
Revised: Thanks to the base-model sampling strategy (i.e.,

Original: Algorithm 1), Split-Mix allows all base models, rather than a subset, to be trained on all clients.
Revised: Algorithm 1), Split-Mix allows all base models, rather than a subset, to be trained on all clients.

Original: On the other hand, varying client budgets greatly impacted SHeteroFL by limiting the width of models trained in budget-insufﬁcient clients, e.g., in the clipart, infograph and painting domains.
Revised: On the other hand, varying client budgets greatly impacted SHeteroFL by limiting the width of models trained in budget-insufﬁcient clients, e.g., in the clipart, infograph and painting domains.

Original: Hence,
Revised: Hence,

Original: SHeteroFL leaves a large amount of parameters under-trained and suffers from larger accuracy losses in the three domains and wider models.
Revised: SHeteroFL leaves a large amount of parameters under-trained and suffers from larger accuracy losses in the three domains and wider models.

Original: In comparison, Split-Mix not only has less accuracy drop but is also more stable in all domains.
Revised: In comparison, Split-Mix not only has less accuracy drop but is also more stable in all domains.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: 5. C USTOMIZE ROBUSTNESS
Revised: 5. C USTOMIZE ROBUSTNESS

Original: Training and evaluation.
Revised: Training and evaluation.

Original: For local AT, we use an n -step projected gradient descent (PGD) attack (Madry et al., 2018) with a constant noise magnitude (cid:15) .
Revised: For local AT, we use an n -step projected gradient descent (PGD) attack (Madry et al., 2018) with a constant noise magnitude (cid:15) .

Original: Following (Madry et al., 2018), we set ( (cid:15), n ) =
Revised: Following (Madry et al., 2018), we set ( (cid:15), n ) =

Original: (8 / 255 , 7) , and attack inner-loop step size 2 / 255 , for training, validation, and test.
Revised: (8 / 255 , 7) , and attack inner-loop step size 2 / 255 , for training, validation, and test.

Original: For simplicity, we temporarily relax the budget constraint R k and let the base model be × 1 net.
Revised: For simplicity, we temporarily relax the budget constraint R k and let the base model be × 1 net.

Original: For comparison, we extend FedAvg with AT which yields individual models optimized with different trade-off variables, i.e., λ n ∈ { 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 } .
Revised: For comparison, we extend FedAvg with AT which yields individual models optimized with different trade-off variables, i.e., λ n ∈ { 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 } .

Original: Also, we extend FedAvg with state-of-the-art in-situ trade-off method, OAT (Wang et al., 2020), as a baseline.
Revised: Also, we extend FedAvg with state-of-the-art in-situ trade-off method, OAT (Wang et al., 2020), as a baseline.

Original: Split-Mix+DAT is an extension of
Revised: Split-Mix+DAT is an extension of

Original: Split-Mix by the proposed DBN-based AT in Algorithm 4.
Revised: Split-Mix by the proposed DBN-based AT in Algorithm 4.

Original: We evaluate and contrast models in two metrics: standard accuracy (SA) on the clean test samples and robust accuracy (RA) on adversarial images generated from the clean test set by the PGD attack.
Revised: We evaluate and contrast models in two metrics: standard accuracy (SA) on the clean test samples and robust accuracy (RA) on adversarial images generated from the clean test set by the PGD attack.

Original: Both metric values are averaged by users.
Revised: Both metric values are averaged by users.

Original: We evaluate the trade-off effectiveness by comparing the RA-SA curves, which is better approaching the right-upper corner.
Revised: We evaluate the trade-off effectiveness by comparing the RA-SA curves, which is better approaching the right-upper corner.

Original: To plot the curves for FedAvg+OAT and Split-Mix+DAT, we vary their condition variable λ in { 0 , 0 . 2 , 0 . 5 , 0 . 8 , 1 } .
Revised: To plot the curves for FedAvg+OAT and Split-Mix+DAT, we vary their condition variable λ in { 0 , 0 . 2 , 0 . 5 , 0 . 8 , 1 } .

Original: Trade-off curves are presented in Fig.
Revised: Trade-off curves are presented in Fig.

Original: 9 (a) and (b).
Revised: 9 (a) and (b).

Original: Since the naive extension of OAT with FedAvg adopts heterogeneous objectives and over-parameterization of conditional layers which suffers from convergence issues, its adversarial training does not converge and RA is incredibly poor in some cases.
Revised: Since the naive extension of OAT with FedAvg adopts heterogeneous objectives and over-parameterization of conditional layers which suffers from convergence issues, its adversarial training does not converge and RA is incredibly poor in some cases.

Original: As a result, the trade-off curve is not smooth.
Revised: As a result, the trade-off curve is not smooth.

Original: Instead, the proposed Split-Mix+DAT method has a smoother trade-off curve without heavy conditional training or over-parameterization.
Revised: Instead, the proposed Split-Mix+DAT method has a smoother trade-off curve without heavy conditional training or over-parameterization.

Original: By training in one pass, Split-Mix+DAT even outperforms and is more efﬁcient than the FedAvg+AT baselines.
Revised: By training in one pass, Split-Mix+DAT even outperforms and is more efﬁcient than the FedAvg+AT baselines.

Original: Joint customization of width and robustness under budget constraints.
Revised: Joint customization of width and robustness under budget constraints.

Original: Now we consider the width customization and the training budgets as Section 5.1.
Revised: Now we consider the width customization and the training budgets as Section 5.1.

Original: Due to the constraint, FedAvg can only train × 0 .
Revised: Due to the constraint, FedAvg can only train × 0 .

Original: 125 net.
Revised: 125 net.

Original: We omit OAT for its unstable convergence and use SplitMixDAT as a short name of Split-Mix+DAT.
Revised: We omit OAT for its unstable convergence and use SplitMixDAT as a short name of Split-Mix+DAT.

Original: In Fig.
Revised: In Fig.

Original: 9 (c) and (d), the trade-off curves with different widths are depicted.
Revised: 9 (c) and (d), the trade-off curves with different widths are depicted.

Original: As the width increases, both RA and SA of SplitMixDAT are improved, when they are smoothly traded off.
Revised: As the width increases, both RA and SA of SplitMixDAT are improved, when they are smoothly traded off.

Original: The results demonstrate the ﬂexibility and the modular nature of our method.
Revised: The results demonstrate the ﬂexibility and the modular nature of our method.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we proposed a novel federated learning approach for in-situ and on-demand customization to address challenges arise from resource heterogeneity and inference dyanmics.
Revised: In this paper, we proposed a novel federated learning approach for in-situ and on-demand customization to address challenges arise from resource heterogeneity and inference dyanmics.

Original: We proposed a
Revised: We proposed a

Original: Split-Mix strategy that efﬁciently transfer clients’ knowledge to collaboratively learn a customizable model.
Revised: Split-Mix strategy that efﬁciently transfer clients’ knowledge to collaboratively learn a customizable model.

Original: Extensive experiments demonstrate the effectiveness of the principle in adjusting model widths and robustness when much fewer parameters are used compared to baselines.
Revised: Extensive experiments demonstrate the effectiveness of the principle in adjusting model widths and robustness when much fewer parameters are used compared to baselines.

Original: A E XPERIMENTS
Revised: A E XPERIMENTS

Original: In this section, we provide more details about our experiments and additional evaluation results.
Revised: In this section, we provide more details about our experiments and additional evaluation results.

Original: A. E XPERIMENTAL CONFIGURATIONS
Revised: A. E XPERIMENTAL CONFIGURATIONS

Original: In Algorithm 4, we elaborate the local training of DBN.
Revised: In Algorithm 4, we elaborate the local training of DBN.

Original: Speciﬁcally, each BN is trained independent with different input samples.
Revised: Speciﬁcally, each BN is trained independent with different input samples.

Original: The maximization problem in Algorithm 4 can be solved by an n -step projected gradient descent, and is commonly known as PGD attack (Madry et al., 2018).
Revised: The maximization problem in Algorithm 4 can be solved by an n -step projected gradient descent, and is commonly known as PGD attack (Madry et al., 2018).

Original: [Table]
Revised: [Table]

Original: Data .
Revised: Data .

Original: Both CIFAR10 and Digits are 10-way classiﬁcation tasks.
Revised: Both CIFAR10 and Digits are 10-way classiﬁcation tasks.

Original: We follow the non- i.i.d benchmark of Li et al.
Revised: We follow the non- i.i.d benchmark of Li et al.

Original: (2020b) to extract 10 classes from DomainNet, which is publicly available in FedBN codes.
Revised: (2020b) to extract 10 classes from DomainNet, which is publicly available in FedBN codes.

Original: To illustrate the multiple-domain datasets, we sample several images from Digits and DomainNet datasets in Fig.
Revised: To illustrate the multiple-domain datasets, we sample several images from Digits and DomainNet datasets in Fig.

Original: mnist svhn usps syn mnistm clipart infograph painting quickdraw real sketch
Revised: mnist svhn usps syn mnistm clipart infograph painting quickdraw real sketch

Original: Hyper-parameters.
Revised: Hyper-parameters.

Original: In general, for local optimization we use stochastic gradient descent (SGD) with 0.9 momentum and 5 × 10 − 4 weight decay.
Revised: In general, for local optimization we use stochastic gradient descent (SGD) with 0.9 momentum and 5 × 10 − 4 weight decay.

Original: Dataset speciﬁc settings are stated as follows.
Revised: Dataset speciﬁc settings are stated as follows.

Original: CIFAR10:
Revised: CIFAR10:

Original: Following HeteroFL
Revised: Following HeteroFL

Original: (Diao et al., 2021), we train with 5 local epochs and 400 global communication rounds.
Revised: (Diao et al., 2021), we train with 5 local epochs and 400 global communication rounds.

Original: Globally, we initialize the learning rate as 0 . 01 and adjust the learning rate at 150, 250 communication rounds with a scale rate of 0 . 1 .
Revised: Globally, we initialize the learning rate as 0 . 01 and adjust the learning rate at 150, 250 communication rounds with a scale rate of 0 . 1 .

Original: Locally, we use a larger batch size of 128, to speed up the training in simulation.
Revised: Locally, we use a larger batch size of 128, to speed up the training in simulation.

Original: Digits: We use a cosine annealing learning rate decaying from 0 .
Revised: Digits: We use a cosine annealing learning rate decaying from 0 .

Original: 1 to 0 across 400 global communication rounds.
Revised: 1 to 0 across 400 global communication rounds.

Original: SGD is executed with one epoch for each local client.
Revised: SGD is executed with one epoch for each local client.

Original: DomainNet: We use a constant learning rate 0 .
Revised: DomainNet: We use a constant learning rate 0 .

Original: 01 and run 400 communication rounds in total.
Revised: 01 and run 400 communication rounds in total.

Original: Similar to Digits, SGD is executed with one epoch for each local client.
Revised: Similar to Digits, SGD is executed with one epoch for each local client.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: , ReLU
Revised: , ReLU

Original: [Equation]
Revised: [Equation]

Original: FC
Revised: FC

Original: [Equation]
Revised: [Equation]

Original: Network architectures .
Revised: Network architectures .

Original: Architectures of modiﬁed AlexNet (for DomaiNet) and CNN (for Digits) can be found in (Li et al., 2020b) and public codes 1 .
Revised: Architectures of modiﬁed AlexNet (for DomaiNet) and CNN (for Digits) can be found in (Li et al., 2020b) and public codes 1 .

Original: For reader’s reference, we provide the layer details in in Tables 2 and 3.
Revised: For reader’s reference, we provide the layer details in in Tables 2 and 3.

Original: For the convolutional layer (Conv2D or Conv1D), the ﬁrst argument is the number channel.
Revised: For the convolutional layer (Conv2D or Conv1D), the ﬁrst argument is the number channel.

Original: For a fully connected layer (FC), we list the number of hidden units as the ﬁrst argument.
Revised: For a fully connected layer (FC), we list the number of hidden units as the ﬁrst argument.

Original: The implementation of the preactivated ResNet can be found in the repository of HeteroFL (Diao et al., 2021).
Revised: The implementation of the preactivated ResNet can be found in the repository of HeteroFL (Diao et al., 2021).

Original: A. C USTOMIZE MODEL SIZES
Revised: A. C USTOMIZE MODEL SIZES

Original: Batch-normalization .
Revised: Batch-normalization .

Original: As pointed out by Diao et al.
Revised: As pointed out by Diao et al.

Original: (2021), HeteroFL relies on mini-batch batchnormalization to stabilize the training and compute the statistics afterwards.
Revised: (2021), HeteroFL relies on mini-batch batchnormalization to stabilize the training and compute the statistics afterwards.

Original: To eliminate the impact of biased mini-batch BN statistics, we let all compared algorithms using the same strategy.
Revised: To eliminate the impact of biased mini-batch BN statistics, we let all compared algorithms using the same strategy.

Original: Another advantage of such strategy is on federation of multi-domain clients.
Revised: Another advantage of such strategy is on federation of multi-domain clients.

Original: Li et al.
Revised: Li et al.

Original: (2020b) showed that using local batch-normalization helps model personalization for local features.
Revised: (2020b) showed that using local batch-normalization helps model personalization for local features.

Original: As min-batch BN statistics simulate the local BN idea, which should enjoy the similar beneﬁt.
Revised: As min-batch BN statistics simulate the local BN idea, which should enjoy the similar beneﬁt.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: 2 https://github.com/pytorch/captum/tree/master
Revised: 2 https://github.com/pytorch/captum/tree/master

Original: [Figure]
Revised: [Figure]

Original: B A DDITIONAL E XPERIMENTS FOR R EBUTTAL
Revised: B A DDITIONAL E XPERIMENTS FOR R EBUTTAL

Original: Content in this section is added in the period of rebuttal, which will be re-organized after acceptance.
Revised: Content in this section is added in the period of rebuttal, which will be re-organized after acceptance.

Original: B. P ARALLEL IMPLEMENTATION OF S PLIT -M IX AND CONVERGENCE
Revised: B. P ARALLEL IMPLEMENTATION OF S PLIT -M IX AND CONVERGENCE

Original: In this section, we elaborate on the implementation and efﬁciency of Split-Mix.
Revised: In this section, we elaborate on the implementation and efﬁciency of Split-Mix.

Original: In Fig.
Revised: In Fig.

Original: 14, we conceptually compare the training by three methods, when two clients capable of training × 1 and × 0 .
Revised: 14, we conceptually compare the training by three methods, when two clients capable of training × 1 and × 0 .

Original: 5 are considered.
Revised: 5 are considered.

Original: FedAvg can train the × 1 net on the × 1 -capable client but not on the × 0 .
Revised: FedAvg can train the × 1 net on the × 1 -capable client but not on the × 0 .

Original: 5capable client.
Revised: 5capable client.

Original: Through parameter sharing among different model widths, SHeteroFL can train multiple widths in a sequential manner and can ﬁt into × 0 .
Revised: Through parameter sharing among different model widths, SHeteroFL can train multiple widths in a sequential manner and can ﬁt into × 0 .

Original: 5 -capable clients.
Revised: 5 -capable clients.

Original: Unlike SHeteroFL,
Revised: Unlike SHeteroFL,

Original: Split-Mix trains four base models in one parallel pass and therefore is the most efﬁcient and ﬂexible method.
Revised: Split-Mix trains four base models in one parallel pass and therefore is the most efﬁcient and ﬂexible method.

Original: Remarkably, in the worst case, training × 1 net of Split-Mix is as efﬁcient as FedAvg and more efﬁcient than SHeteroFL, if all the base weights, w l 0 ,r , . . .
Revised: Remarkably, in the worst case, training × 1 net of Split-Mix is as efﬁcient as FedAvg and more efﬁcient than SHeteroFL, if all the base weights, w l 0 ,r , . . .

Original: , w l 3 ,r ∈ R r × r (where r = 0 .here), are embedded into a 4 r × 4 r weight matrix 3 .
Revised: , w l 3 ,r ∈ R r × r (where r = 0 .here), are embedded into a 4 r × 4 r weight matrix 3 .

Original: When base models are embedded into a full net, non-trainable parameters can be masked out (grey areas) to avoid interference between base models.
Revised: When base models are embedded into a full net, non-trainable parameters can be masked out (grey areas) to avoid interference between base models.

Original: [Figure]
Revised: [Figure]

Original: With the aforementioned implementation, we compare the convergence versus the wall-clock time in
Revised: With the aforementioned implementation, we compare the convergence versus the wall-clock time in

Original: Fig.
Revised: Fig.

Original: We implement all algorithms in PyTorch 1.4.1 run on a single NVIDIA RTX
Revised: We implement all algorithms in PyTorch 1.4.1 run on a single NVIDIA RTX

Original: A
Revised: A

Original: GPU and a 104-thread CPU.
Revised: GPU and a 104-thread CPU.

Original: Fig.
Revised: Fig.

Original: 15 shows the elapsed computation time from the initialization to a maximal number of iterations.
Revised: 15 shows the elapsed computation time from the initialization to a maximal number of iterations.

Original: The maximal number of iterations is set to be the same for all methods, such that it is easier to compare the stopping time.
Revised: The maximal number of iterations is set to be the same for all methods, such that it is easier to compare the stopping time.

Original: In Fig.
Revised: In Fig.

Original: 15, Split-Mix is much more efﬁcient than the SheteroFL.
Revised: 15, Split-Mix is much more efﬁcient than the SheteroFL.

Original: Note that FedAvg can only train the × 0 .
Revised: Note that FedAvg can only train the × 0 .

Original: 125 net which includes much fewer parameters, For this reason, Split-Mix is slightly slower than FedAvg, but the degradation of efﬁciency trades in better accuracy than FedAvg.
Revised: 125 net which includes much fewer parameters, For this reason, Split-Mix is slightly slower than FedAvg, but the degradation of efﬁciency trades in better accuracy than FedAvg.

Original: [Figure]
Revised: [Figure]

Original: B. E XPERIMENTS WITH CLASS NON - I . I . D FL
Revised: B. E XPERIMENTS WITH CLASS NON - I . I . D FL

Original: In addition to feature non- i.i.d FL settings, we experiment with class non- 
Revised: In addition to feature non- i.i.d FL settings, we experiment with class non- i

Original: i.i.d FL where each client will randomly select 3 out of 10 classes from the CIFAR10 dataset.
Revised: [Figure] i.d FL where each client will randomly select 3 out of 10 classes from the CIFAR10 dataset.

Original: To mitigate the effect of missing classes locally, we use the same masked cross-entropy as introduced by HeteroFL (Diao et al., 2021).
Revised: To mitigate the effect of missing classes locally, we use the same masked cross-entropy as introduced by HeteroFL (Diao et al., 2021).

Original: Results are included in Table 4.
Revised: Results are included in Table 4.

Original: We observe a great drop in the accuracy compared to the i.i.d experiments, which is a common phenomenon that non-iid FL will perform worse globally.
Revised: We observe a great drop in the accuracy compared to the i.i.d experiments, which is a common phenomenon that non-iid FL will perform worse globally.

Original: The similar performance degradation was observed in (Diao et al., 2021), as well.
Revised: The similar performance degradation was observed in (Diao et al., 2021), as well.

Original: Besides the degradation, our method outperforms baselines consistently.
Revised: Besides the degradation, our method outperforms baselines consistently.

Original: Furthermore, our method performs better in larger widths, whose performance approaches that of unconstrained individual FedAvg.
Revised: Furthermore, our method performs better in larger widths, whose performance approaches that of unconstrained individual FedAvg.

Original: [Table]
Revised: [Table]

Original: B. M ORE BUDGET DISTRIBUTIONS
Revised: B. M ORE BUDGET DISTRIBUTIONS

Original: In our experiments
Revised: In our experiments

Original: [Table]
Revised: [Table]

Original: we generally use an exponential budget distribution: R k = (1 / 2) (cid:100) 4 k/K (cid:101) .
Revised: we generally use an exponential budget distribution: R k = (1 / 2) (cid:100) 4 k/K (cid:101) .

Original: Though the distribution represents the imbalance between the budget-sufﬁcient and budget-insufﬁcient clients, real-world applications may encounter a wider variety of budget distributions.
Revised: Though the distribution represents the imbalance between the budget-sufﬁcient and budget-insufﬁcient clients [Table] real-world applications may encounter a wider variety of budget distributions.

Original: Thus, we extend our problem assumption to budget distributions with more budget-sufﬁcient clients where we let more groups to have × 1 or × 0 .
Revised: Thus, we extend our problem assumption to budget distributions with more budget-sufﬁcient clients where we let more groups to have × 1 or × 0 .

Original: 5 net training capability and with step-increase budgets where we increase budgets by a ﬁxed step (e
Revised: 5 net training capability and with step-increase budgets where we increase budgets by a ﬁxed step (e

Original: [Table]
Revised: [Table]

Original: g., × 0 . 25 ).
Revised: g., × 0 . 25 ).

Original: Fig.
Revised: Fig.

Original: 16 reports the per-width accuracy for Split-Mix and SHeteorFL on the Digits dataset.
Revised: 16 reports the per-width accuracy for Split-Mix and SHeteorFL on the Digits dataset.

Original: For SHeteroFL, we only report the evaluated performance on trained withs.
Revised: For SHeteroFL, we only report the evaluated performance on trained withs.

Original: In other words, if the maximal width is × 0 . 5 , we will not report results of the ×net.
Revised: In other words, if the maximal width is × 0 . 5 , we will not report results of the ×net.

Original: For Individually-trained FedAvg (Ind. FedAvg), models individually trained for each width are reported, which ignores the width constraints by users and therefore only serves as reference upper bounds.
Revised: For Individually-trained FedAvg (Ind. FedAvg), models individually trained for each width are reported [Table] which ignores the width constraints by users and therefore only serves as reference upper bounds.

Original: Regardless of the budget distributions, for instance, more budget-sufﬁcient clients (Fig. 16a) or non
Revised: Regardless of the budget distributions, for instance, more budget-sufﬁcient clients (Fig. 16a) or non-exponential distributions (Fig. 16b), Split-Mix outperforms SHeteroFL with larger widths.

Original: [Table]
Revised: Because of varying communication conditions in deployment, the times that clients actively and successfully upload their models could be fewer than expected. To evaluate the robustness of customization federated algorithms, we conduct federated experiments with a varying number of active clients per round in Fig. Because of the limited number of communication rounds (within 300 rounds), the test accuracy decreases by fewer contact clients.

Original: (Fig. 16b)
Revised: This is a common phenomenon because lower contact rates requires more communication rounds to reach the same performance as the full-contact competitors do. Though global performance generally decreases, we ﬁnd that the wider networks are more accurate if trained by SplitMix. One source for the advantage is the modular base models in SplitMix, which can be easily distributed into different rounds for training. Rather, the wider integrated networks in SHeteroFL lower their chance to be aggregated globally and therefore their global performance declines

Original: [Figure]
Revised: [Figure]

Revised: 8-4-2-1, means × 1 / 8 , × 1 / 4 , × 1 / 2 and × 1 width constraints for each group, respectively.

Revised: The lower ﬁgures compare the performance of trained models with customized withs.

Original: [Figure]
Revised: [Figure]

Revised: B. N EGATIVE IMPACT OF CONSTRAINED BUDGETS ON WIDER NETWORKS

Revised: In Fig.

Revised: 2, we show how the SHeteroFL fails to train wider networks with budget-constrained clients.

Revised: To show the generality of such a problem, we extend the experiments to Digits and CIFAR10 datasets in Fig.

Revised: Though wider networks converges faster at the beginning, they meanwhile overﬁt limited data in a few clients and therefore their validation accuracy no longer improves.

Revised: [Figure]

Revised: [Figure]