Original: F EDERATED S EMI -S UPERVISED L EARNING WITH I NTER -C LIENT C ONSISTENCY & D ISJOINT L EARNING
Revised: F EDERATED S EMI -S UPERVISED L EARNING WITH I NTER -C LIENT C ONSISTENCY & D ISJOINT L EARNING

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: While existing federated learning approaches mostly require that clients have fullylabeled data to train on, in realistic settings, data obtained at the client-side often comes without any accompanying labels.
Revised: While existing federated learning approaches mostly require that clients have fullylabeled data to train on, in realistic settings, data obtained at the client-side often comes without any accompanying labels.

Original: Such deﬁciency of labels may result from either high labeling cost, or difﬁculty of annotation due to the requirement of expert knowledge.
Revised: Such deﬁciency of labels may result from either high labeling cost, or difﬁculty of annotation due to the requirement of expert knowledge.

Original: Thus the private data at each client may be either partly labeled, or completely unlabeled with labeled data being available only at the server, which leads us to a new practical federated learning problem, namely Federated SemiSupervised Learning (FSSL).
Revised: Thus the private data at each client may be either partly labeled, or completely unlabeled with labeled data being available only at the server, which leads us to a new practical federated learning problem, namely Federated SemiSupervised Learning (FSSL).

Original: In this work, we study two essential scenarios of FSSL based on the location of the labeled data.
Revised: In this work, we study two essential scenarios of FSSL based on the location of the labeled data.

Original: The ﬁrst scenario considers a conventional case where clients have both labeled and unlabeled data (labels-at-client), and the second scenario considers a more challenging case, where the labeled data is only available at the server (labels-at-server).
Revised: The ﬁrst scenario considers a conventional case where clients have both labeled and unlabeled data (labels-at-client), and the second scenario considers a more challenging case, where the labeled data is only available at the server (labels-at-server).

Original: We then propose a novel method to tackle the problems, which we refer to as Federated Matching (FedMatch).
Revised: We then propose a novel method to tackle the problems, which we refer to as Federated Matching (FedMatch).

Original: FedMatch improves upon naive combinations of federated learning and semi-supervised learning approaches with a new inter-client consistency loss and decomposition of the parameters for disjoint learning on labeled and unlabeled data.
Revised: FedMatch improves upon naive combinations of federated learning and semi-supervised learning approaches with a new inter-client consistency loss and decomposition of the parameters for disjoint learning on labeled and unlabeled data.

Original: Through extensive experimental validation of our method in the two different scenarios, we show that our method outperforms both local semi-supervised learning and baselines which naively combine federated learning with semi-supervised learning.
Revised: Through extensive experimental validation of our method in the two different scenarios, we show that our method outperforms both local semi-supervised learning and baselines which naively combine federated learning with semi-supervised learning.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Federated Learning (FL) (Zhao et al., 2018; Li et al., 2018; Chen et al., 2019a;b), in which multiple clients collaboratively learn a global model via coordinated communication, has been an active topic of research over the past few years.
Revised: Federated Learning (FL) (Zhao et al., 2018; Li et al., 2018; Chen et al., 2019a;b), in which multiple clients collaboratively learn a global model via coordinated communication, has been an active topic of research over the past few years.

Original: The most distinctive difference of federated learning from distributed learning is that the data is only privately accessible at each local client, without inter-client data sharing.
Revised: The most distinctive difference of federated learning from distributed learning is that the data is only privately accessible at each local client, without inter-client data sharing.

Original: Such decentralized learning brings us numerous advantages in addressing real-world issues such as data privacy, security, and access rights.
Revised: Such decentralized learning brings us numerous advantages in addressing real-world issues such as data privacy, security, and access rights.

Original: For example, for on-device learning of mobile devices, the service provider may not directly access local data since they may contain privacy-sensitive information.
Revised: For example, for on-device learning of mobile devices, the service provider may not directly access local data since they may contain privacy-sensitive information.

Original: In healthcare domains, the hospitals may want to improve their clinical diagnosis systems without sharing the patient records.
Revised: In healthcare domains, the hospitals may want to improve their clinical diagnosis systems without sharing the patient records.

Original: Existing federated learning approaches handle these problems by aggregating the locally learned model parameters.
Revised: Existing federated learning approaches handle these problems by aggregating the locally learned model parameters.

Original: A common limitation is that they only consider supervised learning settings, where the local private data is fully labeled.
Revised: A common limitation is that they only consider supervised learning settings, where the local private data is fully labeled.

Original: Yet, the assumption that all of the data examples may include sophisticate annotations is not realistic for real-world applications.
Revised: Yet, the assumption that all of the data examples may include sophisticate annotations is not realistic for real-world applications.

Original: Suppose that we perform on-device federated learning, the users may not want to spend their time and efforts in annotating the data, and the participation rate across the users may largely differ.
Revised: Suppose that we perform on-device federated learning, the users may not want to spend their time and efforts in annotating the data, and the participation rate across the users may largely differ.

Original: Even in the case of enthusiastic users may not be able to fully label all the data in the device, which will leave the majority of the data as unlabeled (See Figure 1 (a)) .
Revised: Even in the case of enthusiastic users may not be able to fully label all the data in the device, which will leave the majority of the data as unlabeled (See Figure 1 (a)) .

Original: Moreover, in some scenarios, the users may not have sufﬁcient expertise to correctly label the data.
Revised: Moreover, in some scenarios, the users may not have sufﬁcient expertise to correctly label the data.

Original: For instance, suppose that we have a workout app that automatically evaluates and corrects one’s body posture.
Revised: For instance, suppose that we have a workout app that automatically evaluates and corrects one’s body posture.

Original: In this case, the end users may not be able to evaluate his/her own body posture at all (See Figure 1 (b)) .
Revised: In this case, the end users may not be able to evaluate his/her own body posture at all (See Figure 1 (b)) .

Original: Thus, in many realistic scenarios for federated learning, local data will be mostly unlabeled .
Revised: Thus, in many realistic scenarios for federated learning, local data will be mostly unlabeled .

Original: This leads us to practical problems of federated learning with deﬁciency of labels, namely Federated Semi-Supervised Learning (FSSL).
Revised: This leads us to practical problems of federated learning with deﬁciency of labels, namely Federated Semi-Supervised Learning (FSSL).

Original: [Figure]
Revised: [Figure]

Original: A naive solution to these scenarios is to simply perform Semi-Supervised Learning (SSL) using any off-the-shelf methods (e.g. FixMatch (Sohn et al., 2020), UDA (Xie et al., 2019)), while using federated learning algorithms to aggregate the learned weights.
Revised: A naive solution to these scenarios is to simply perform Semi-Supervised Learning (SSL) using any off-the-shelf methods (e.g. FixMatch (Sohn et al., 2020), UDA (Xie et al., 2019)), while using federated learning algorithms to aggregate the learned weights.

Original: Yet, this does not fully exploit the knowledge of the multiple models trained on heterogeneous data distributions.
Revised: Yet, this does not fully exploit the knowledge of the multiple models trained on heterogeneous data distributions.

Original: To address this problem, we present a novel framework which we refer to as Federated Matching (FedMatch) , which enforces the consistency between the predictions made across multiple models.
Revised: To address this problem, we present a novel framework which we refer to as Federated Matching (FedMatch) , which enforces the consistency between the predictions made across multiple models.

Original: Further, conventional semi-supervised learning approaches are not applicable for scenarios where labeled data is only available at the server (Figure 1 (b)), which is a unique SSL setting for federated learning.
Revised: Further, conventional semi-supervised learning approaches are not applicable for scenarios where labeled data is only available at the server (Figure 1 (b)), which is a unique SSL setting for federated learning.

Original: Also, even when the labeled data is available at the client (Figure 1 (a)), learning from the unlabeled data may lead to forgetting of what the model learned from the labeled data.
Revised: Also, even when the labeled data is available at the client (Figure 1 (a)), learning from the unlabeled data may lead to forgetting of what the model learned from the labeled data.

Original: To tackle these issues, we decompose the model parameters into two, a dense parameter for supervised and a sparse parameter for unsupervised learning.
Revised: To tackle these issues, we decompose the model parameters into two, a dense parameter for supervised and a sparse parameter for unsupervised learning.

Original: This sparse additive parameter decomposition ensures that training on labeled and unlabeled data are effectively separable, thus minimizing interference between the two tasks.
Revised: This sparse additive parameter decomposition ensures that training on labeled and unlabeled data are effectively separable, thus minimizing interference between the two tasks.

Original: We further reduce the communication costs with both the decomposed parameters by sending only the difference of the parameters across the communication rounds.
Revised: We further reduce the communication costs with both the decomposed parameters by sending only the difference of the parameters across the communication rounds.

Original: We validate FedMatch on both scenarios (Figure 1 (a) and (b)) and show that our models signiﬁcantly outperform baselines, including a naive combination of federated learning with semi-supervised learning, on the training data which are both non-i.i.d.
Revised: We validate FedMatch on both scenarios (Figure 1 (a) and (b)) and show that our models signiﬁcantly outperform baselines, including a naive combination of federated learning with semi-supervised learning, on the training data which are both non-i.i.d.

Original: and i.i.d.
Revised: and i.i.d.

Original: data.
Revised: data.

Original: The main contributions of this work are as follows:
Revised: The main contributions of this work are as follows:

Original: • We introduce a practical problem of federated learning with deﬁciency of supervision, namely Federated Semi-Supervised Learning (FSSL) , and study two different scenarios, where the local data is partly labeled ( Labels-at-Client ) or completely unlabeled ( Labels-at-Server ).
Revised: • We introduce a practical problem of federated learning with deﬁciency of supervision, namely Federated Semi-Supervised Learning (FSSL) , and study two different scenarios, where the local data is partly labeled ( Labels-at-Client ) or completely unlabeled ( Labels-at-Server ).

Original: • We propose a novel method , Federated Matching (FedMatch) , which learns inter-client consistency between multiple clients, and decomposes model parameters to reduce both interference between supervised and unsupervised tasks, and communication cost.
Revised: • We propose a novel method , Federated Matching (FedMatch) , which learns inter-client consistency between multiple clients, and decomposes model parameters to reduce both interference between supervised and unsupervised tasks, and communication cost.

Original: • We show that our method, FedMatch, signiﬁcantly outperforms both local SSL and the naive combination of FL with SSL algorithms under the conventional labels-at-client and the novel labels-at-server scenario, across multiple clients with both non-i.i.d.
Revised: • We show that our method, FedMatch, signiﬁcantly outperforms both local SSL and the naive combination of FL with SSL algorithms under the conventional labels-at-client and the novel labels-at-server scenario, across multiple clients with both non-i.i.d.

Original: and i.i.d.
Revised: and i.i.d.

Original: data.
Revised: data.

Original:  P ROBLEM D EFINITION
Revised:  P ROBLEM D EFINITION

Original: We begin with formal deﬁnition of Federated Learning (FL) and Semi-Supervised Learning (SSL).
Revised: We begin with formal deﬁnition of Federated Learning (FL) and Semi-Supervised Learning (SSL).

Original: Then, we deﬁne Federated Semi-Supervised Learning (FSSL) and introduce two essential scenarios.
Revised: Then, we deﬁne Federated Semi-Supervised Learning (FSSL) and introduce two essential scenarios.

Original: 2. P RELIMINARIES
Revised: 2. P RELIMINARIES

Original: Federated Learning Federated Learning (FL) aims to collaboratively learn a global model via coordinated communication with multiple clients.
Revised: Federated Learning Federated Learning (FL) aims to collaboratively learn a global model via coordinated communication with multiple clients.

Original: Let G be a global model and L = { l k } K k
Revised: Let G be a global model and L = { l k } K k

Original: =1 be a set of local models for K clients.
Revised: =1 be a set of local models for K clients.

Original: Let D = { x i , y i } Ni =1 be a given dataset, where x i is an arbitrary training instance with a corresponding one-hot label y i ∈ { 1 , . .
Revised: Let D = { x i , y i } Ni =1 be a given dataset, where x i is an arbitrary training instance with a corresponding one-hot label y i ∈ { 1 , . .

Original: , C } for the C -way multi-class classiﬁcation problem and N is the number of instances.
Revised: , C } for the C -way multi-class classiﬁcation problem and N is the number of instances.

Original: D is composed of K sub-datasets D l k = { x l k
Revised: D is composed of K sub-datasets D l k = { x l k

Original: i , y l k i } N lk i = privately collected at each client or local model l k .
Revised: i , y l k i } N lk i = privately collected at each client or local model l k .

Original: At each communication round r during training,
Revised: At each communication round r during training,

Original: G ﬁrst randomly selects A local models that are available for training L r ⊂ L and |L
Revised: G ﬁrst randomly selects A local models that are available for training L r ⊂ L and |L

Original: r | =
Revised: r | =

Original: A .
Revised: A .

Original: The global model G then initializes L r with global weights θ G , and the active local models l a ∈ L r perform supervised learning to minimize loss (cid:96) s ( θ l a ) on the corresponding sub-dataset D l a .
Revised: The global model G then initializes L r with global weights θ G , and the active local models l a ∈ L r perform supervised learning to minimize loss (cid:96) s ( θ l a ) on the corresponding sub-dataset D l a .

Original: G then aggregates the learned weights θ G
Revised: G then aggregates the learned weights θ G

Original: ← N la N (cid:80) Aa θ l a and broadcasts newly aggregated weights to local models that would be available at the next round r + 1 , and repeat the learning procedure until the ﬁnal round R .
Revised: ← N la N (cid:80) Aa θ l a and broadcasts newly aggregated weights to local models that would be available at the next round r + 1 , and repeat the learning procedure until the ﬁnal round R .

Original: Semi-Supervised Learning Semi-supervised learning (SSL) refers to the problem of learning with partially labeled data, where the ratio of unlabeled data is usually much larger than that of the labeled data (e.g. 1 : 10 ).
Revised: Semi-Supervised Learning Semi-supervised learning (SSL) refers to the problem of learning with partially labeled data, where the ratio of unlabeled data is usually much larger than that of the labeled data (e.g. 1 : 10 ).

Original: For SSL, D is further split into labeled and unlabeled data.
Revised: For SSL, D is further split into labeled and unlabeled data.

Original: Let S
Revised: Let S

Original: = { x i , y i } Si
Revised: = { x i , y i } Si

Original: = be a set of S labeled data instances and U
Revised: = be a set of S labeled data instances and U

Original: = { u i } Ui =1 be a set of U unlabeled samples without corresponding label.
Revised: = { u i } Ui =1 be a set of U unlabeled samples without corresponding label.

Original: Here, in general, |S| (cid:28) |U| .
Revised: Here, in general, |S| (cid:28) |U| .

Original: With these two datasets, S and U , we now perform semi-supervised learning.
Revised: With these two datasets, S and U , we now perform semi-supervised learning.

Original: Let p θ ( y | x ) be a neural network that is parameterized by weights θ and predicts softmax outputs ˆ y with given input x .
Revised: Let p θ ( y | x ) be a neural network that is parameterized by weights θ and predicts softmax outputs ˆ y with given input x .

Original: Our objective is to minimize loss function (cid:96) final ( θ ) =
Revised: Our objective is to minimize loss function (cid:96) final ( θ ) =

Original: (cid:96) s ( θ )
Revised: (cid:96) s ( θ )

Original: + (cid:96) u
Revised: + (cid:96) u

Original: ( θ ) , where (cid:96) s ( θ ) is loss term for supervised learning on S and (cid:96) u
Revised: ( θ ) , where (cid:96) s ( θ ) is loss term for supervised learning on S and (cid:96) u

Original: ( θ ) is loss term for unsupervised learning on U
Revised: ( θ ) is loss term for unsupervised learning on U

Original: 2. F EDERATED S EMI -S UPERVISED L EARNING
Revised: 2. F EDERATED S EMI -S UPERVISED L EARNING

Original: Now we further describe a practical problem of deﬁciency of labels in federated learning, which we refer to as Federated Semi-Supervised Learning (FSSL), in which the data obtained at the clients may or may not come with accompanying labels.
Revised: Now we further describe a practical problem of deﬁciency of labels in federated learning, which we refer to as Federated Semi-Supervised Learning (FSSL), in which the data obtained at the clients may or may not come with accompanying labels.

Original: Given a dataset D = { x i , y i } Ni =1 , D is split into a labeled set S = { x i , y i } Si =1 and a unlabeled set U = { u i } Ui =1 as in the standard semi-supervised learning.
Revised: Given a dataset D = { x i , y i } Ni =1 , D is split into a labeled set S = { x i , y i } Si =1 and a unlabeled set U = { u i } Ui =1 as in the standard semi-supervised learning.

Original: Under the federated learning framework, we have a global model G and a set of local models L where the unlabeled dataset U is privately spread over K clients hence U l k
Revised: Under the federated learning framework, we have a global model G and a set of local models L where the unlabeled dataset U is privately spread over K clients hence U l k

Original: = { u l k i } U
Revised: = { u l k i } U

Original: lk i =1 .
Revised: lk i =1 .

Original: For a labeled set S , on the other hand, we consider two different scenarios depending on the availability of labeled data at clients, namely the Labels-at-Client and the Labels-at-Server scenario, of which problem settings and learning procedures will be discussed later.
Revised: For a labeled set S , on the other hand, we consider two different scenarios depending on the availability of labeled data at clients, namely the Labels-at-Client and the Labels-at-Server scenario, of which problem settings and learning procedures will be discussed later.

Original:  F EDERATED M ATCHING
Revised:  F EDERATED M ATCHING

Original: We now describe our Federated Matching (FedMatch) algorithm to tackle the federated semisupervised learning problem.
Revised: We now describe our Federated Matching (FedMatch) algorithm to tackle the federated semisupervised learning problem.

Original: We describe its core components in detail in the following subsections.
Revised: We describe its core components in detail in the following subsections.

Original: 3. I NTER -C LIENT C ONSISTENCY L OSS
Revised: 3. I NTER -C LIENT C ONSISTENCY L OSS

Original: Consistency regularization (Xie et al., 2019; Sohn et al., 2020; Berthelot et al., 2019b;a) is one of most popular approaches to learn from unlabeled examples in a semi-supervised learning setting.
Revised: Consistency regularization (Xie et al., 2019; Sohn et al., 2020; Berthelot et al., 2019b;a) is one of most popular approaches to learn from unlabeled examples in a semi-supervised learning setting.

Original: Conventional consistency-regularization methods enforce the predictions from the augmented examples and original (or weakly augmented) instances to output the same class label,
Revised: Conventional consistency-regularization methods enforce the predictions from the augmented examples and original (or weakly augmented) instances to output the same class label,

Original: ||
Revised: ||

Original: p θ ( y | u ) − p θ ( y | π ( u ))
Revised: p θ ( y | u ) − p θ ( y | π ( u ))

Original: || 22 , where π ( · ) is a stochastic transformation function.
Revised: || 22 , where π ( · ) is a stochastic transformation function.

Original: Based on the assumption that class semantics are unaffected by small input perturbations, these methods basically ensures consistency of the prediction across the multiple perturbations of same input .
Revised: Based on the assumption that class semantics are unaffected by small input perturbations, these methods basically ensures consistency of the prediction across the multiple perturbations of same input .

Original: For our federated semi-supervised learning method, we additionally propose a novel consistency loss that regularizes the models learned at multiple clients to output the same prediction.
Revised: For our federated semi-supervised learning method, we additionally propose a novel consistency loss that regularizes the models learned at multiple clients to output the same prediction.

Original: This novel consistency loss for FSSL, inter-client consistency loss, is deﬁned as follows:
Revised: This novel consistency loss for FSSL, inter-client consistency loss, is deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where p ∗ θ h ( y | x ) are helper agents that are selected from the server based on model similarity to the client (which we describe later), that are not trained at the client (* denotes that we freeze the parameters).
Revised: where p ∗ θ h ( y | x ) are helper agents that are selected from the server based on model similarity to the client (which we describe later), that are not trained at the client (* denotes that we freeze the parameters).

Original: The server selects and broadcasts H helper agents at each communication round.
Revised: The server selects and broadcasts H helper agents at each communication round.

Original: We also use data-level consistency regularization at each local client similarly to FixMatch (Sohn et al., 2020).
Revised: We also use data-level consistency regularization at each local client similarly to FixMatch (Sohn et al., 2020).

Original: Our ﬁnal consistency regularization term Φ( · ) can be written as follows:
Revised: Our ﬁnal consistency regularization term Φ( · ) can be written as follows:

Original: [Equation]
Revised: [Equation]

Original: where π ( u ) performs RandAugment (Cubuk et al., 2019) on unlabeld instance u .
Revised: where π ( u ) performs RandAugment (Cubuk et al., 2019) on unlabeld instance u .

Original: ˆ y is our novel pseudo-labeling technique, which we refer to as the agreement-based pseudo label, deﬁned as follows:
Revised: ˆ y is our novel pseudo-labeling technique, which we refer to as the agreement-based pseudo label, deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where 1 ( · ) produces one-hot labels with given softmax values , and Max ( · ) outputs one-hot labels on the class that has the maximum agreements.
Revised: where 1 ( · ) produces one-hot labels with given softmax values , and Max ( · ) outputs one-hot labels on the class that has the maximum agreements.

Original: We discard instances with low-conﬁdent predictions below conﬁdence threshold τ when generating pseudo-labels.
Revised: We discard instances with low-conﬁdent predictions below conﬁdence threshold τ when generating pseudo-labels.

Original: We then perform standard cross-entropy minimization with the pseudo-label ˆ y .
Revised: We then perform standard cross-entropy minimization with the pseudo-label ˆ y .

Original: We select the H helper agents p ∗ θ h j : H ( y | u ) for each client as the most relevant models from other clients.
Revised: We select the H helper agents p ∗ θ h j : H ( y | u ) for each client as the most relevant models from other clients.

Original: Speciﬁcally, we represent each model by its prediction m on the same arbitrary input a located at server (we use random Gaussian noise), such that m l = p θ l ( m | a ) .
Revised: Speciﬁcally, we represent each model by its prediction m on the same arbitrary input a located at server (we use random Gaussian noise), such that m l = p θ l ( m | a ) .

Original: The server tries to keep and update all model embeddings m 1: K from clients once each client updates its weights to server, and creates K-Dimensional Tree (KD Tree) on m in the current round r for nearest neighbor search to rapidly select the H helper agents for each client in the next round r + 1 .
Revised: The server tries to keep and update all model embeddings m 1: K from clients once each client updates its weights to server, and creates K-Dimensional Tree (KD Tree) on m in the current round r for nearest neighbor search to rapidly select the H helper agents for each client in the next round r + 1 .

Original: If a certain client has not yet updated its weights to server in the previous step, then server simply sends random helpers to the client.
Revised: If a certain client has not yet updated its weights to server in the previous step, then server simply sends random helpers to the client.

Original: 3. P ARAMETER D ECOMPOSITION FOR D ISJOINT L EARNING
Revised: 3. P ARAMETER D ECOMPOSITION FOR D ISJOINT L EARNING

Original: In the standard semi-supervised learning approaches, learning on labeled and unlabeled data is simultaneously done with a shared set of parameters.
Revised: In the standard semi-supervised learning approaches, learning on labeled and unlabeled data is simultaneously done with a shared set of parameters.

Original: However, since this is inapplicable to the disjoint learning scenario (Figure 1 (b)) and may result in forgetting of knowledge of labeled data (see
Revised: However, since this is inapplicable to the disjoint learning scenario (Figure 1 (b)) and may result in forgetting of knowledge of labeled data (see

Original: Figure 6 (c)), we separate the supervised and unsupervised learning via the decomposition of model parameters into two sets of parameters, one for supervised learning and another for unsupervised learning.
Revised: Figure 6 (c)), we separate the supervised and unsupervised learning via the decomposition of model parameters into two sets of parameters, one for supervised learning and another for unsupervised learning.

Original: To this end, we decompose our model parameters θ into two variables, σ for supervised learning and ψ for unsupervised learning, such that θ = σ + ψ .
Revised: To this end, we decompose our model parameters θ into two variables, σ for supervised learning and ψ for unsupervised learning, such that θ = σ + ψ .

Original: We perform standard supervised learning on σ , while keeping ψ ﬁxed during training, by minimizing the loss term as follows:
Revised: We perform standard supervised learning on σ , while keeping ψ ﬁxed during training, by minimizing the loss term as follows:

Original: [Equation]
Revised: [Equation]

Original: where x and y are from labeled set S .
Revised: where x and y are from labeled set S .

Original: For learning on unlabeled data, we perform unsupervised learning conversely on ψ , while keeping σ ﬁxed for the learning phase, by minimizing the consistency loss terms as follows:
Revised: For learning on unlabeled data, we perform unsupervised learning conversely on ψ , while keeping σ ﬁxed for the learning phase, by minimizing the consistency loss terms as follows:

Original: [Equation]
Revised: [Equation]

Original: where all λ s are hyper-parameters to control the learning ratio between the terms.
Revised: where all λ s are hyper-parameters to control the learning ratio between the terms.

Original: We additionally add L 2 - and L 1 -Regularization on ψ such that ψ is sparse, while not drifting far from knowledge that σ has learned.
Revised: We additionally add L 2 - and L 1 -Regularization on ψ such that ψ is sparse, while not drifting far from knowledge that σ has learned.

Original: To sum up, our decomposition technique allows us:
Revised: To sum up, our decomposition technique allows us:

Original: • Preservation Reliable Knowledge from Labeled Data : We empirically ﬁnd that learning on both labeled and unlabeled data with a single set of parameters may result in the model to forget about what it learned from the labeled data (see Figure 6 (c)).
Revised: • Preservation Reliable Knowledge from Labeled Data : We empirically ﬁnd that learning on both labeled and unlabeled data with a single set of parameters may result in the model to forget about what it learned from the labeled data (see Figure 6 (c)).

Original: Our method can effectively prevent the inter-task interference via utilizing disjoint parameters only for supervised learning.
Revised: Our method can effectively prevent the inter-task interference via utilizing disjoint parameters only for supervised learning.

Original: • Reduction of Communication Costs : Sparsity on the unsupervised parameter ψ allows to reduce communication cost.
Revised: • Reduction of Communication Costs : Sparsity on the unsupervised parameter ψ allows to reduce communication cost.

Original: In addition, we further minimize the cost by subtracting the learned knowledge for each parameter, such that ∆ ψ = ψ lr − ψ Gr and ∆ σ = σ lr − σ Gr , and transmit only the differences ∆ ψ and ∆ σ as sparse matrices for both client-to-server and server-to-client costs.
Revised: In addition, we further minimize the cost by subtracting the learned knowledge for each parameter, such that ∆ ψ = ψ lr − ψ Gr and ∆ σ = σ lr − σ Gr , and transmit only the differences ∆ ψ and ∆ σ as sparse matrices for both client-to-server and server-to-client costs.

Original: 1: RunServer() 2: initialize σ 0 and ψ3: for each round r = 1 , 2 , ..., R do 4:
Revised: 1: RunServer() 2: initialize σ 0 and ψ3: for each round r = 1 , 2 , ..., R do 4:

Original: L r ← (select random A clients from L ) 5: for each client l ra ∈ L r in parallel do 6: ψ r 1: H ← GetNearestNeighbors( ψ r ) 7: σ ra , ψ ra ← RunClient( σ r , ψ r , ψ r 1: H ) 8:
Revised: L r ← (select random A clients from L ) 5: for each client l ra ∈ L r in parallel do 6: ψ r 1: H ← GetNearestNeighbors( ψ r ) 7: σ ra , ψ ra ← RunClient( σ r , ψ r , ψ r 1: H ) 8:

Original: EmbedLocalModel( σ ra , ψ ra ) 9: end for 10: σ r +1 ← N la N (cid:80) Aa =1 ( σ rl a ) 11: ψ r +1 ← N la N (cid:80) Aa =1 ( ψ rl a ) 12: end for 13: RunClient( σ, ψ, ψ 1: H ) 14: θ l a ← σ + ψ , θ h 1: H ← σ + ψ 1: H 15: for each local epoch e from 1 to E L do 16: for minibatch s ∈ S l a and u ∈ U l a do 17: θ σ + ψ ∗ ← θ σ + ψ ∗ − η ∇ (cid:96) s ( θ σ + ψ ∗ ; θ h 1: H , s ) 18: θ σ ∗ + ψ ← θ σ ∗ + ψ − η ∇ (cid:96) u ( θ σ ∗ + ψ ; θ h 1: H , u ) 19: end for 20: end for
Revised: EmbedLocalModel( σ ra , ψ ra ) 9: end for 10: σ r +1 ← N la N (cid:80) Aa =1 ( σ rl a ) 11: ψ r +1 ← N la N (cid:80) Aa =1 ( ψ rl a ) 12: end for 13: RunClient( σ, ψ, ψ 1: H ) 14: θ l a ← σ + ψ , θ h 1: H ← σ + ψ 1: H 15: for each local epoch e from 1 to E L do 16: for minibatch s ∈ S l a and u ∈ U l a do 17: θ σ + ψ ∗ ← θ σ + ψ ∗ − η ∇ (cid:96) s ( θ σ + ψ ∗ ; θ h 1: H , s ) 18: θ σ ∗ + ψ ← θ σ ∗ + ψ − η ∇ (cid:96) u ( θ σ ∗ + ψ ; θ h 1: H , u ) 19: end for 20: end for

Original: • Disjoint Learning :
Revised: • Disjoint Learning :

Original: In federated semi-supervised learning, labeled data can be located at either client or server, which requires the model’s learning procedure to be ﬂexible.
Revised: In federated semi-supervised learning, labeled data can be located at either client or server, which requires the model’s learning procedure to be ﬂexible.

Original: Our decomposition technique allows the model for the supervised training to be done separately elsewhere.
Revised: Our decomposition technique allows the model for the supervised training to be done separately elsewhere.

Original:  L ABELS - AT -C LIENT S CENARIO 4. 
Revised:  L ABELS - AT -C LIENT S CENARIO 4.

Original: P ROBLEM D EFINITION
Revised: P ROBLEM D EFINITION

Original: The Labels-at-Client scenario posits that the end-users intermittently annotate a small portion of their local data (i.e., 5% of the entire data), leaving the rest of data instances unlabeled as illustrated in
Revised: The Labels-at-Client scenario posits that the end-users intermittently annotate a small portion of their local data (i.e., 5% of the entire data), leaving the rest of data instances unlabeled as illustrated in

Original: Figure 1 (a).
Revised: Figure 1 (a).

Original: This is a common scenario for user-generated personal data, where the end-users can easily annotate the data but may not have time or motivation to label all the data (e.g. annotating faces in pictures for photo albums or social networking).
Revised: This is a common scenario for user-generated personal data, where the end-users can easily annotate the data but may not have time or motivation to label all the data (e.g. annotating faces in pictures for photo albums or social networking).

Original: We assume that clients train on both labeled and unlabeled data, while the server only aggregates the updates from the clients and redistributes the aggregated parameters back to the clients.
Revised: We assume that clients train on both labeled and unlabeled data, while the server only aggregates the updates from the clients and redistributes the aggregated parameters back to the clients.

Original: In this scenario, labeled data S is a set of individual subdatasets S l k
Revised: In this scenario, labeled data S is a set of individual subdatasets S l k

Original: = { x l k i , y l k i } S lk i =1 , yielding K sub-datasets for K local models l 1: K .
Revised: = { x l k i , y l k i } S lk i =1 , yielding K sub-datasets for K local models l 1: K .

Original: The overall learning procedure of the global model is the same as that of conventional federated learning (global model G aggregates updates from the selected subset of clients and broadcasts them), except that active local models l 1: A perform semi-supervised learning by minimizing the loss (cid:96)
Revised: The overall learning procedure of the global model is the same as that of conventional federated learning (global model G aggregates updates from the selected subset of clients and broadcasts them), except that active local models l 1: A perform semi-supervised learning by minimizing the loss (cid:96)

Original: [Table]
Revised: [Table]

Original: =
Revised: =

Original: [Table]
Revised: [Table]

Original: s
Revised: s

Original: [Table]
Revised: [Table]

Original: θ
Revised: θ

Original: [Table]
Revised: [Table]

Original: a )+ (cid:96) u
Revised: a )+ (cid:96) u

Original: ( θ l a ) respectively on S l a and U l a .
Revised: ( θ l a ) respectively on S l a and U l a .

Original: 4. F ED M ATCH A LGORITHM FOR L ABELS - AT -C LIENT S CENARIO
Revised: 4. F ED M ATCH A LGORITHM FOR L ABELS - AT -C LIENT S CENARIO

Original: Now we introduce our FedMatch algorithm for the labels-at-client scenario.
Revised: Now we introduce our FedMatch algorithm for the labels-at-client scenario.

Original: As shown in Figure 3, which illustrates an example case of the labels-at-client scenario, active local models l 1: A at the current round r learn both σ l r 1: A and ψ l r 1: A on both the labeled data S l 1: A and unlabeled data U l 1: A at each local environment.
Revised: As shown in Figure 3, which illustrates an example case of the labels-at-client scenario, active local models l 1: A at the current round r learn both σ l r 1: A and ψ l r 1: A on both the labeled data S l 1: A and unlabeled data U l 1: A at each local environment.

Original: After the completion of local training, the clients update both their learned knowledge σ l r 1: A and ψ l r 1: A to the server.
Revised: After the completion of local training, the clients update both their learned knowledge σ l r 1: A and ψ l r 1: A to the server.

Original: The server then aggregates σ l 1: A and ψ l 1: A , respectively , after embedding local models based on model similarity as well as create KD-Tree to rapidly retrieve the top- H nearest neighbors ψ h 1: H for each client.
Revised: The server then aggregates σ l 1: A and ψ l 1: A , respectively , after embedding local models based on model similarity as well as create KD-Tree to rapidly retrieve the top- H nearest neighbors ψ h 1: H for each client.

Original: At the next round, the server transmits the aggregated σ r +1 and ψ r +1 , as well as the H selected ψ h 1: H to each client connected at the next round.
Revised: At the next round, the server transmits the aggregated σ r +1 and ψ r +1 , as well as the H selected ψ h 1: H to each client connected at the next round.

Original: More details of the training procedures for FedMatch, for the labels-at-client scenario, is described in
Revised: More details of the training procedures for FedMatch, for the labels-at-client scenario, is described in

Original: Algorithm 1.
Revised: Algorithm 1.

Original:  L ABELS - AT -S ERVER S CENARIO
Revised:  L ABELS - AT -S ERVER S CENARIO

Original: 1: RunServer() 2: initialize σ 0 , ψ3: for each round r = 1 , 2 , ..., R do 4: for each server epoch e from 1 to E G do 5: for minibatch s ∈ S G do 6: θ σ + ψ ∗ ← θ σ + ψ ∗ − η ∇ (cid:96) s ( θ σ + ψ ∗ ; s ) 7: end for 8: end for 9:
Revised: 1: RunServer() 2: initialize σ 0 , ψ3: for each round r = 1 , 2 , ..., R do 4: for each server epoch e from 1 to E G do 5: for minibatch s ∈ S G do 6: θ σ + ψ ∗ ← θ σ + ψ ∗ − η ∇ (cid:96) s ( θ σ + ψ ∗ ; s ) 7: end for 8: end for 9:

Original: L r ← (select random A clients from L ) 10: for each client l ra ∈ L r in parallel do 11: ψ r 1: H ← GetNearestNeighbors( ψ r ) 12: ψ ra ← RunClient( σ r +1 , ψ r , ψ r 1: H ) 13:
Revised: L r ← (select random A clients from L ) 10: for each client l ra ∈ L r in parallel do 11: ψ r 1: H ← GetNearestNeighbors( ψ r ) 12: ψ ra ← RunClient( σ r +1 , ψ r , ψ r 1: H ) 13:

Original: EmbedLocalModel( σ r +1 , ψ ra ) 14: end for 15: ψ r +1 ← N la N (cid:80) Aa =1 ( ψ rl a ) 16: end for 17:
Revised: EmbedLocalModel( σ r +1 , ψ ra ) 14: end for 15: ψ r +1 ← N la N (cid:80) Aa =1 ( ψ rl a ) 16: end for 17:

Original: RunClient( σ, ψ, ψ 1: H ) 18: θ l ← σ ∗ + ψ , θ h 1: H ← σ ∗ + ψ 1: H 19: for each local epoch e from 1 to E L do 20: for minibatch u ∈ U
Revised: RunClient( σ, ψ, ψ 1: H ) 18: θ l ← σ ∗ + ψ , θ h 1: H ← σ ∗ + ψ 1: H 19: for each local epoch e from 1 to E L do 20: for minibatch u ∈ U

Original: l a do 21: θ σ ∗ + ψ ← θ σ ∗ + ψ − η ∇ (cid:96) u ( θ σ ∗ + ψ ; θ h 1: H , u ) 22: end for 23: end for
Revised: l a do 21: θ σ ∗ + ψ ← θ σ ∗ + ψ − η ∇ (cid:96) u ( θ σ ∗ + ψ ; θ h 1: H , u ) 22: end for 23: end for

Original: P ROBLEM D EFINITION
Revised: P ROBLEM D EFINITION

Original: We now describe another realistic setting, which is the labels-at-server scenario.
Revised: We now describe another realistic setting, which is the labels-at-server scenario.

Original: This scenario assumes that the supervised labels are only available at the server, while local clients work with unlabeled data as described in Figure 1 (b).
Revised: This scenario assumes that the supervised labels are only available at the server, while local clients work with unlabeled data as described in Figure 1 (b).

Original: This is a common case of real-world applications where labeling requires expert knowledge (e.g. annotating medical images, evaluating body postures for exercises), but the data cannot be shared due to privacy concerns.
Revised: This is a common case of real-world applications where labeling requires expert knowledge (e.g. annotating medical images, evaluating body postures for exercises), but the data cannot be shared due to privacy concerns.

Original: In this scenario, S G is identical to
Revised: In this scenario, S G is identical to

Original: S and is located at server.
Revised: S and is located at server.

Original: The overall learning procedure is the same as that of conventional federated learning, except the global model G performs supervised learning on S G by minimizing the loss (cid:96) s ( θ G ) before broadcasting θ G to local clients.
Revised: The overall learning procedure is the same as that of conventional federated learning, except the global model G performs supervised learning on S G by minimizing the loss (cid:96) s ( θ G ) before broadcasting θ G to local clients.

Original: Then, the active local clients l 1: A at communication round r perform unsupervised learning which solely minimizes (cid:96) u
Revised: Then, the active local clients l 1: A at communication round r perform unsupervised learning which solely minimizes (cid:96) u

Original: ( θ l a ) on the unlabeled data U l a .
Revised: ( θ l a ) on the unlabeled data U l a .

Original: 5. F ED M ATCH A LGORITHMS FOR L ABELS - AT -S ERVER S CENARIO
Revised: 5. F ED M ATCH A LGORITHMS FOR L ABELS - AT -S ERVER S CENARIO

Original: We now describe our FedMatch algorithm for the labels-at-server scenario.
Revised: We now describe our FedMatch algorithm for the labels-at-server scenario.

Original: As depicted in Figure 4, which describes an illustrative running example for labels-at-server scenario, the global model G learns σ on labeled data S G at the server and the active local clients l 1: A at the current round r learn ψ l 1: A on unlabeled data U 1: A at each local environment.
Revised: As depicted in Figure 4, which describes an illustrative running example for labels-at-server scenario, the global model G learns σ on labeled data S G at the server and the active local clients l 1: A at the current round r learn ψ l 1: A on unlabeled data U 1: A at each local environment.

Original: After the completion of local training, clients update their learned knowledge ψ l 1: A to the server.
Revised: After the completion of local training, clients update their learned knowledge ψ l 1: A to the server.

Original: The server then embeds local models based on model similarity and create a KD-Tree for rapid nearest neighbor search for the top- H most similar ψ h 1: H models for each client.
Revised: The server then embeds local models based on model similarity and create a KD-Tree for rapid nearest neighbor search for the top- H most similar ψ h 1: H models for each client.

Original: At the next round, server transmits its learned σ r +

Revised: At the next round, server transmits its learned σ r +

Original: and the aggregated ψ r +1 , as well as top- H similar ψ h 1: H to each client connected at the next communication round.
Revised: and the aggregated ψ r +1 , as well as top- H similar ψ h 1: H to each client connected at the next communication round.

Original: Further training details of FedMatch for the labels-at-server scenario is described in Algorithm 2.
Revised: Further training details of FedMatch for the labels-at-server scenario is described in Algorithm 2.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We now experimentally validate our method, FedMatch , on three tasks, such as Batch-IID, BatchNonIID, and Streaming-NonIID, under both scenarios, Labels-at-Client and Labels-at-Server
Revised: We now experimentally validate our method, FedMatch , on three tasks, such as Batch-IID, BatchNonIID, and Streaming-NonIID, under both scenarios, Labels-at-Client and Labels-at-Server

Original: . 6. E XPERIMENTAL S ETUP
Revised: . 6. E XPERIMENTAL S ETUP

Original: Tasks 1) Batch-IID : We use CIFAR-10 for this task and split 60 , 000 instances into training ( 54 , 000 ), valid ( 3 , 000 ), and test ( 3 , 000 ) sets.
Revised: Tasks 1) Batch-IID : We use CIFAR-10 for this task and split 60 , 000 instances into training ( 54 , 000 ), valid ( 3 , 000 ), and test ( 3 , 000 ) sets.

Original: We extract 5 labeled instances per class ( C = 10 ) for each client ( K = 100 ) as labeled set S , and the rest of instances ( 49 , 000 ) are used as unlabeled data
Revised: We extract 5 labeled instances per class ( C = 10 ) for each client ( K = 100 ) as labeled set S , and the rest of instances ( 49 , 000 ) are used as unlabeled data

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: U , so that we can evenly split S and U into S l 1:100 and U l 1:100 , such that local models l 1:100 learn on corresponding labeled and unlabeled data during training.
Revised: U , so that we can evenly split S and U into S l 1:100 and U l 1:100 , such that local models l 1:100 learn on corresponding labeled and unlabeled data during training.

Original: 2) Batch-NonIID (class-imbalanced) :
Revised: 2) Batch-NonIID (class-imbalanced) :

Original: The setting of this task is mostly the same with the Batch-IID task, except we arbitrarily control the distribution of the number of instances per class for each client to simulate class-imbalanced environments.
Revised: The setting of this task is mostly the same with the Batch-IID task, except we arbitrarily control the distribution of the number of instances per class for each client to simulate class-imbalanced environments.

Original: 3) Streaming-NonIID (class-imbalanced) :
Revised: 3) Streaming-NonIID (class-imbalanced) :

Original: In this task, data streams into each client from class-imbalanced distributions.
Revised: In this task, data streams into each client from class-imbalanced distributions.

Original: We use Fashion-MNIST dataset for this task, and split 70 ,instances into training ( 63 , 000 ), valid ( 3 , 500 ), and test ( 3 , 500 ) sets.
Revised: We use Fashion-MNIST dataset for this task, and split 70 ,instances into training ( 63 , 000 ), valid ( 3 , 500 ), and test ( 3 , 500 ) sets.

Original: From train set, we extractlabeled instances per class ( C = 5 ) for each client ( K = 10 ) for a labeled set S .
Revised: From train set, we extractlabeled instances per class ( C = 5 ) for each client ( K = 10 ) for a labeled set S .

Original: We discard labels for the rest of instances to construct an unlabeled set U ( 62 , 000 ).
Revised: We discard labels for the rest of instances to construct an unlabeled set U ( 62 , 000 ).

Original: Then, we split S and U into S l 1:100 and
Revised: Then, we split S and U into S l 1:100 and

Original: U l 1:100 based on a class-imbalanced distribution.
Revised: U l 1:100 based on a class-imbalanced distribution.

Original: For individual local unlabeled data U l k , we again split all instances into U l k t , t ∈ { 1 , 2 , ..., T } , where T is the number of total streaming steps (we set
Revised: For individual local unlabeled data U l k , we again split all instances into U l k t , t ∈ { 1 , 2 , ..., T } , where T is the number of total streaming steps (we set

Original: T = 10 ).
Revised: T = 10 ).

Original: We train each streaming step for 10 rounds.
Revised: We train each streaming step for 10 rounds.

Original: We describe above tasks under Labels-at-Client scenario.
Revised: We describe above tasks under Labels-at-Client scenario.

Original: For Labels-at-Server scenario, S is simply located at server without any partition.
Revised: For Labels-at-Server scenario, S is simply located at server without any partition.

Original: Please see Figure 7 in Appendix, which we visualize the concepts of dataset conﬁguration.
Revised: Please see Figure 7 in Appendix, which we visualize the concepts of dataset conﬁguration.

Original: Baselines and Training Details
Revised: Baselines and Training Details

Original: Our baselines are: 1) Local-SL : local supervised learning (SL) with full labels ( S + U ) without sharing locally learned knowledge.
Revised: Our baselines are: 1) Local-SL : local supervised learning (SL) with full labels ( S + U ) without sharing locally learned knowledge.

Original: 2) Local-UDA and 3) LocalFixMatch : local semi-supervised learning, including UDA and FixMatch, without sharing local knowledge.
Revised: 2) Local-UDA and 3) LocalFixMatch : local semi-supervised learning, including UDA and FixMatch, without sharing local knowledge.

Original: 4) FedAVG-SL and 5) FedProx-SL : supervised learning with full labels ( S + U ) while sharing local knowledge via FedAvg and FedProx frameworks.
Revised: 4) FedAVG-SL and 5) FedProx-SL : supervised learning with full labels ( S + U ) while sharing local knowledge via FedAvg and FedProx frameworks.

Original: FedAvg-UDA and 7) FedProxUDA : naive combinations of FedAvg/Prox with UDA.
Revised: FedAvg-UDA and 7) FedProxUDA : naive combinations of FedAvg/Prox with UDA.

Original: 8) FedAvg-FixMatch and 9)
Revised: 8) FedAvg-FixMatch and 9)

Original: FedProxFixMatch : naive combination of with FixMatch with FedAvg/Prox.
Revised: FedProxFixMatch : naive combination of with FixMatch with FedAvg/Prox.

Original: For training, we use SGD with adaptive-learning rate decay introduced in (Serra et al., 2018) with the initial learning rate 1e − 3 .
Revised: For training, we use SGD with adaptive-learning rate decay introduced in (Serra et al., 2018) with the initial learning rate 1e − 3 .

Original: We use ResNet-9 networks as the backbone architecture for all baselines and our methods.
Revised: We use ResNet-9 networks as the backbone architecture for all baselines and our methods.

Original: We ensure
Revised: We ensure

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

Original: [Figure]
Revised: [Figure]

Original: that all hyper-parameters are set equally for all base models and ours to perform fair evaluation and comparison.
Revised: that all hyper-parameters are set equally for all base models and ours to perform fair evaluation and comparison.

Original: Please see the Section B in the Appendix for further details.
Revised: Please see the Section B in the Appendix for further details.

Original: For all experiments, we report the mean and the standard deviation over 3 runs.
Revised: For all experiments, we report the mean and the standard deviation over 3 runs.

Original: 6. E XPERIMENTAL R ESULTS
Revised: 6. E XPERIMENTAL R ESULTS

Original: Results on Batch-IID & NonIID Tasks Table 1 shows performance comparison of our models and naive Fed-SSL algorithms on Batch-IID and NonIID tasks under the two different scenarios.
Revised: Results on Batch-IID & NonIID Tasks Table 1 shows performance comparison of our models and naive Fed-SSL algorithms on Batch-IID and NonIID tasks under the two different scenarios.

Original: We observe that our model outperforms all naive Fed-SSL baselines for all tasks and scenarios.
Revised: We observe that our model outperforms all naive Fed-SSL baselines for all tasks and scenarios.

Original: In particular, under labels-at-server scenario, which is more challenging than labels-at-client scenario, we observe that the naive combination models signiﬁcantly suffer from the forgetting issue and their performances keeps deteriorating after a certain communication round.
Revised: In particular, under labels-at-server scenario, which is more challenging than labels-at-client scenario, we observe that the naive combination models signiﬁcantly suffer from the forgetting issue and their performances keeps deteriorating after a certain communication round.

Original: This phenomenon is mainly caused by the base models failing to properly perform disjoint learning, in which case the learned knowledge from the labeled and unlabeled data causes inter-task interference.
Revised: This phenomenon is mainly caused by the base models failing to properly perform disjoint learning, in which case the learned knowledge from the labeled and unlabeled data causes inter-task interference.

Original: Contrarily, our methods show consistent and robust performance regardless where the labeled data exists, which shows that our decomposition techniques effectively handles the challenging disjoint learning scenario.
Revised: Contrarily, our methods show consistent and robust performance regardless where the labeled data exists, which shows that our decomposition techniques effectively handles the challenging disjoint learning scenario.

Original: In addition, when the class-wise distribution is imbalanced for each client (Non-IID task), we observe that the base models’ performance slightly drops by 1 - 3% p , while our methods show consistent or slightly better performance.
Revised: In addition, when the class-wise distribution is imbalanced for each client (Non-IID task), we observe that the base models’ performance slightly drops by 1 - 3% p , while our methods show consistent or slightly better performance.

Original: This shows that our inter-client consistency effectively enhances consistency with the helper agents selected from server based on model similarity, which is good at, in particular, class-imbalanced tasks.
Revised: This shows that our inter-client consistency effectively enhances consistency with the helper agents selected from server based on model similarity, which is good at, in particular, class-imbalanced tasks.

Original: We also visualize the test accuracy curve for our models and naive Fed-SSL in Fig.
Revised: We also visualize the test accuracy curve for our models and naive Fed-SSL in Fig.

Original: Our method (Red line) trains faster and consistently outperforms the base models, and is most robustness against inter-task interference in both scenarios.
Revised: Our method (Red line) trains faster and consistently outperforms the base models, and is most robustness against inter-task interference in both scenarios.

Original: For analysis on the averaged communication costs, please see Section C.3 in the Appendix.
Revised: For analysis on the averaged communication costs, please see Section C.3 in the Appendix.

Original: Results on Streaming-NonIID Task Table 2 shows averaged model performance on StreamingNonIID tasks with 10 synchronized clients.
Revised: Results on Streaming-NonIID Task Table 2 shows averaged model performance on StreamingNonIID tasks with 10 synchronized clients.

Original: In the labels-at-client scenario, there is no big differences of performance between local SSL and Fed-SSL models, while our model outperforms all the base models with large margins in a range of 2 - 10% p (except SL models).
Revised: In the labels-at-client scenario, there is no big differences of performance between local SSL and Fed-SSL models, while our model outperforms all the base models with large margins in a range of 2 - 10% p (except SL models).

Original: This implies that our method effectively utilizes inter-client and reliable knowledge than naive Fed-SSL models do.
Revised: This implies that our method effectively utilizes inter-client and reliable knowledge than naive Fed-SSL models do.

Original: In the labelsat-server scenario, interestingly, the performance of FedProx-SL decreases by around 5% p , while
Revised: In the labelsat-server scenario, interestingly, the performance of FedProx-SL decreases by around 5% p , while

Original: Fed-SSL models obtain improved performance.
Revised: Fed-SSL models obtain improved performance.

Original: We conjecture that this is because for streaming situation the model may not sufﬁciently train on the new data, while Fed-SSL models overcomes it by utilizing only the consistent pseudo-labels.
Revised: We conjecture that this is because for streaming situation the model may not sufﬁciently train on the new data, while Fed-SSL models overcomes it by utilizing only the consistent pseudo-labels.

Original: Even on this task, FedMatch outperforms all baselines with signiﬁcantly smaller communication cost on average (see Section C.3).
Revised: Even on this task, FedMatch outperforms all baselines with signiﬁcantly smaller communication cost on average (see Section C.3).

Original: Effectiveness of Inter-Client Consistency To show the effectiveness of our inter-client consistency loss, we eliminate the loss, while learning on Batch-IID task with 100 clients ( F = 0 . 05 ).
Revised: Effectiveness of Inter-Client Consistency To show the effectiveness of our inter-client consistency loss, we eliminate the loss, while learning on Batch-IID task with 100 clients ( F = 0 . 05 ).

Original: In Figure(a), when we remove our inter-client consistency loss, we observe that the performance has slightly dropped (Pink line) from one with the loss term (Red line).
Revised: In Figure(a), when we remove our inter-client consistency loss, we observe that the performance has slightly dropped (Pink line) from one with the loss term (Red line).

Original: This gap clearly tells us that our interclient consistency loss improves model consistency across multiple models while keeping reliable knowledge.
Revised: This gap clearly tells us that our interclient consistency loss improves model consistency across multiple models while keeping reliable knowledge.

Original: Interestingly, our model without inter-client consistency loss still outperforms base models.
Revised: Interestingly, our model without inter-client consistency loss still outperforms base models.

Original: This additionally implies that our another proposed method, parameter decomposition for disjoint learning, also effectively enhances model performance.
Revised: This additionally implies that our another proposed method, parameter decomposition for disjoint learning, also effectively enhances model performance.

Original: Effectiveness of Parameter Decomposition
Revised: Effectiveness of Parameter Decomposition

Original: Our model with parameter decomposition alone, without inter-client consistency loss, outperforms base models.
Revised: Our model with parameter decomposition alone, without inter-client consistency loss, outperforms base models.

Original: For further analysis, we show the effect of each decomposed variables, σ and ψ , in Figure 6 (b).
Revised: For further analysis, we show the effect of each decomposed variables, σ and ψ , in Figure 6 (b).

Original: Removing either of σ and ψ results in substantial drop in the performance, with larger performance degeneration when dropping σ , which captures much more essential knowledge from labeled data (Green line).
Revised: Removing either of σ and ψ results in substantial drop in the performance, with larger performance degeneration when dropping σ , which captures much more essential knowledge from labeled data (Green line).

Original: Such decomposition is effective since there exists knowledge interference between supervised learning and unsupervised learning.
Revised: Such decomposition is effective since there exists knowledge interference between supervised learning and unsupervised learning.

Original: We show this with an experiment where we perform semi-supervised learning withlabels per class and 1 , 000 unlabeled instances for 100 rounds.
Revised: We show this with an experiment where we perform semi-supervised learning withlabels per class and 1 , 000 unlabeled instances for 100 rounds.

Original: We measure accuracy on the labeled set at each training steps.
Revised: We measure accuracy on the labeled set at each training steps.

Original: As shown in Figure 6 (c), our method effectively preserves learned knowledge from labeled set, while other base models suffer from knowledge interference.
Revised: As shown in Figure 6 (c), our method effectively preserves learned knowledge from labeled set, while other base models suffer from knowledge interference.

Original: This effective separation of supervised and unsupervised learning tasks enhances the overall performance of our methods even without inter-client consistency loss as shown in Figure 6 (a) (shown in pink).
Revised: This effective separation of supervised and unsupervised learning tasks enhances the overall performance of our methods even without inter-client consistency loss as shown in Figure 6 (a) (shown in pink).

Original: Number of Labels per Class We increase the number of labels per class for each client in a range of 1 , 5 , 10 , and 20 on Batch-IID task (CIFAR-10).
Revised: Number of Labels per Class We increase the number of labels per class for each client in a range of 1 , 5 , 10 , and 20 on Batch-IID task (CIFAR-10).

Original: Our method shows consistent performance improvement as the number of labels increases.
Revised: Our method shows consistent performance improvement as the number of labels increases.

Original: Interestingly, we observe that baseline models,
Revised: Interestingly, we observe that baseline models,

Original: FedProx-UDA/FixMatch, show performance degradation even when the labeled data increases ( 5 → 10 ).
Revised: FedProx-UDA/FixMatch, show performance degradation even when the labeled data increases ( 5 → 10 ).

Original: These results show that our method effectively utilize knowledge from labeled and unlabeled data in federated semi-supervised learning settings, while other naive combinations of
Revised: These results show that our method effectively utilize knowledge from labeled and unlabeled data in federated semi-supervised learning settings, while other naive combinations of

Original: FSSL could fail to learn properly from labeled and unlabeled data in federated learning framework.
Revised: FSSL could fail to learn properly from labeled and unlabeled data in federated learning framework.

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

Original: Federated Learning A variety of approaches for averaging local weights at server have been introduced in the past few years.
Revised: Federated Learning A variety of approaches for averaging local weights at server have been introduced in the past few years.

Original: FedAvg (McMahan et al., 2017) performs weighted-averaging on local weights according to the local train size.
Revised: FedAvg (McMahan et al., 2017) performs weighted-averaging on local weights according to the local train size.

Original: FedProx (Li et al., 2018) uniformly averages the local updates while clients perform proximal regularization against the global weights, while
Revised: FedProx (Li et al., 2018) uniformly averages the local updates while clients perform proximal regularization against the global weights, while

Original: FedMA (Wang et al., 2020) matches the hidden elements with similar feature extraction signatures in layer-wise manner when averaging local weights.
Revised: FedMA (Wang et al., 2020) matches the hidden elements with similar feature extraction signatures in layer-wise manner when averaging local weights.

Original: PFNM (Yurochkin et al., 2019) introduces aggregation policy which leverages Bayesian non-parametric methods.
Revised: PFNM (Yurochkin et al., 2019) introduces aggregation policy which leverages Bayesian non-parametric methods.

Original: Beyond focusing on averaging local knowledge, there are various efforts to extend FL to the other areas, such as continual learning under federated learning frameworks (Yoon et al., 2020a) inspired by parameter decomposition techniques proposed by (Yoon et al., 2020b).
Revised: Beyond focusing on averaging local knowledge, there are various efforts to extend FL to the other areas, such as continual learning under federated learning frameworks (Yoon et al., 2020a) inspired by parameter decomposition techniques proposed by (Yoon et al., 2020b).

Original: Recently, interests of tackling scarcity of labeled data in FL are emerging and discussed in (Jin et al., 2020; Guha et al., 2019; Albaseer et al., 2020).
Revised: Recently, interests of tackling scarcity of labeled data in FL are emerging and discussed in (Jin et al., 2020; Guha et al., 2019; Albaseer et al., 2020).

Original: Semi-Supervised Learning While there exist numerous work on SSL, we mainly discuss consistency regularization approaches.
Revised: Semi-Supervised Learning While there exist numerous work on SSL, we mainly discuss consistency regularization approaches.

Original: Consistency regularization techniques(Sajjadi et al., 2016) assume that the class semantics will not be affected by transformations of the input instances, and enforce the model output to be the same across different input perturbations.
Revised: Consistency regularization techniques(Sajjadi et al., 2016) assume that the class semantics will not be affected by transformations of the input instances, and enforce the model output to be the same across different input perturbations.

Original: Some extensions to this technique perturb inputs adversarially (Miyato et al., 2018), through dropout (Srivastava et al., 2014), or through data augmentation (French et al., 2018).
Revised: Some extensions to this technique perturb inputs adversarially (Miyato et al., 2018), through dropout (Srivastava et al., 2014), or through data augmentation (French et al., 2018).

Original: UDA (Xie et al., 2019) and ReMixMatch (Berthelot et al., 2019a) use two sets of augmentations, weak and strong, and enforce consistency between the weakly and strongly augmented examples.
Revised: UDA (Xie et al., 2019) and ReMixMatch (Berthelot et al., 2019a) use two sets of augmentations, weak and strong, and enforce consistency between the weakly and strongly augmented examples.

Original: Recently, in addition to enforcing consistency between weak-strong augmented pairs, FixMatch (Sohn et al., 2020) performs pseudo-label reﬁnement on model predictions via thresholding.
Revised: Recently, in addition to enforcing consistency between weak-strong augmented pairs, FixMatch (Sohn et al., 2020) performs pseudo-label reﬁnement on model predictions via thresholding.

Original: Entropy minimization (Grandvalet & Bengio, 2004) which enforces the classiﬁer to predict low-entropy on unlabeled data, is another popular technique for SSL.
Revised: Entropy minimization (Grandvalet & Bengio, 2004) which enforces the classiﬁer to predict low-entropy on unlabeled data, is another popular technique for SSL.

Original: Pseudo-Label (Lee, 2013) constructs one-hot labels from highly conﬁdent predictions on unlabeled data and uses these as training targets inn a standard cross-entropy loss.
Revised: Pseudo-Label (Lee, 2013) constructs one-hot labels from highly conﬁdent predictions on unlabeled data and uses these as training targets inn a standard cross-entropy loss.

Original: MixMatch (Berthelot et al., 2019c) performs “sharpening" on target distribution on unlabeled data, to further reﬁne the generated pseudo-label.
Revised: MixMatch (Berthelot et al., 2019c) performs “sharpening" on target distribution on unlabeled data, to further reﬁne the generated pseudo-label.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this work, we introduced two practical scenarios of Federated Semi-Supervised Learning (FSSL) where each client learns with only partly labeled data ( Labels-at-Client scenario), or supervised labels are only available at the server, while clients work with completely unlabeled data ( Labels-at-Server scenario).
Revised: In this work, we introduced two practical scenarios of Federated Semi-Supervised Learning (FSSL) where each client learns with only partly labeled data ( Labels-at-Client scenario), or supervised labels are only available at the server, while clients work with completely unlabeled data ( Labels-at-Server scenario).

Original: To tackle the problem, we propose a novel method, Federated Matching (FedMatch), which introduces the inter-client consistency loss that aims to maximize the agreement between the models trained at different clients, and the parameter decomposition for disjoint learning which decomposes the parameters into one for labeled data and the other for unlabeled data for preservation of reliable knowledge, reduction of communication costs, and disjoint learning.
Revised: To tackle the problem, we propose a novel method, Federated Matching (FedMatch), which introduces the inter-client consistency loss that aims to maximize the agreement between the models trained at different clients, and the parameter decomposition for disjoint learning which decomposes the parameters into one for labeled data and the other for unlabeled data for preservation of reliable knowledge, reduction of communication costs, and disjoint learning.

Original: Through extensive experimental validation, we show that FedMatch signiﬁcantly outperforms both local semi-supervised learning methods and naive combinations of federated learning algorithms with semi-supervised learning on diverse and realistic scenarios.
Revised: Through extensive experimental validation, we show that FedMatch signiﬁcantly outperforms both local semi-supervised learning methods and naive combinations of federated learning algorithms with semi-supervised learning on diverse and realistic scenarios.

Original: As future work, we plan to further improve our model to tackle the scenario where pretrained models deployed at each client adapts to a completely unlabeled data stream (e.g. on-device learning of smart speakers).
Revised: As future work, we plan to further improve our model to tackle the scenario where pretrained models deployed at each client adapts to a completely unlabeled data stream (e.g. on-device learning of smart speakers).

Original: A A PPENDIX
Revised: A A PPENDIX

Original: Organization The appendix is organized as follows: We further explain detailed experimental setups, such as our baselines, model architecture utilized for all experiments, and the training conﬁgurations, in Section
Revised: Organization The appendix is organized as follows: We further explain detailed experimental setups, such as our baselines, model architecture utilized for all experiments, and the training conﬁgurations, in Section

Original: B. We also provide additional experimental results and analysis in Section C.
Revised: B. We also provide additional experimental results and analysis in Section C.

Original: B E XPERIMENTAL D ETAILS
Revised: B E XPERIMENTAL D ETAILS

Original: We now further describe our experimental setups in detail, such as our baseline models, network architecture that is used for all base models and our method, and the detailed training setups.
Revised: We now further describe our experimental setups in detail, such as our baseline models, network architecture that is used for all base models and our method, and the detailed training setups.

Original: B. B ASELINE M ODELS
Revised: B. B ASELINE M ODELS

Original: We consider UDA (Xie et al., 2019) and FixMatch (Sohn et al., 2020) as our baselines, since they are state-of-the-art SSL models and are based on the consistency-based mechanisms that are conceptually similar to our inter-client consistency loss.
Revised: We consider UDA (Xie et al., 2019) and FixMatch (Sohn et al., 2020) as our baselines, since they are state-of-the-art SSL models and are based on the consistency-based mechanisms that are conceptually similar to our inter-client consistency loss.

Original: We reimplement UDA with the Training
Revised: We reimplement UDA with the Training

Original: Signal Annealing (TSA) and exponential scheduling for its best performance as reported in their paper (we use RandAugment (Cubuk et al., 2019) for consistency regularization with random magnitude).
Revised: Signal Annealing (TSA) and exponential scheduling for its best performance as reported in their paper (we use RandAugment (Cubuk et al., 2019) for consistency regularization with random magnitude).

Original: We also reimplement FixMatch algorithms with strong augmentation as RandAugment (Cubuk et al., 2019).
Revised: We also reimplement FixMatch algorithms with strong augmentation as RandAugment (Cubuk et al., 2019).

Original: For weak augmentation (ﬁlp-and-shift), however, as the performance has signiﬁcantly dropped when we apply the weak augmentation, we use original images rather than weakly augmenting the images.
Revised: For weak augmentation (ﬁlp-and-shift), however, as the performance has signiﬁcantly dropped when we apply the weak augmentation, we use original images rather than weakly augmenting the images.

Original: We ﬁx conﬁdence threshold τ = 0 . 85 for all FixMatch and our model experiments.
Revised: We ﬁx conﬁdence threshold τ = 0 . 85 for all FixMatch and our model experiments.

Original: For federated learning frameworks, we use FedAvg (McMahan et al., 2017) and FedProx (Li et al., 2018) algorithms since they are the standard baselines for federated learning and can be easily combined with the SSL baselines.
Revised: For federated learning frameworks, we use FedAvg (McMahan et al., 2017) and FedProx (Li et al., 2018) algorithms since they are the standard baselines for federated learning and can be easily combined with the SSL baselines.

Original: Detailed hyper-parameter settings are described in Table 4.
Revised: Detailed hyper-parameter settings are described in Table 4.

Original: B. N ETWORK A RCHITECTURE
Revised: B. N ETWORK A RCHITECTURE

Original: [Table]
Revised: [Table]

Original: We build ResNet-9 networks as our base architecture for all base model and our method.
Revised: We build ResNet-9 networks as our base architecture for all base model and our method.

Original: In the architecture, the ﬁrst two convolutional neural layers have 64 and 128 ﬁlters and the same 3 × 3 kernel sizes followed by 2 × 2 max-pooling layer.
Revised: In the architecture, the ﬁrst two convolutional neural layers have 64 and 128 ﬁlters and the same 3 × 3 kernel sizes followed by 2 × 2 max-pooling layer.

Original: Then we have a skip connection between the subsequent two convolution layers withﬁlters.
Revised: Then we have a skip connection between the subsequent two convolution layers withﬁlters.

Original: We then double the ﬁlter size from 128 to 256 with the next conv layer and down-sample via the following 2 × 2 max-pooling layer.
Revised: We then double the ﬁlter size from 128 to 256 with the next conv layer and down-sample via the following 2 × 2 max-pooling layer.

Original: We repeat the previous step, such that we have 512 ﬁlter size and 4 × 4 kernel size.
Revised: We repeat the previous step, such that we have 512 ﬁlter size and 4 × 4 kernel size.

Original: Then, we perform another skip connection through the two subsequent conv layers with 512 ﬁlters.
Revised: Then, we perform another skip connection through the two subsequent conv layers with 512 ﬁlters.

Original: As a ﬁnal step
Revised: As a ﬁnal step

Original: [Table]
Revised: [Table]

Original: we down-sample the kernel size from 4 × 4 to 1 × 1 , then perform softmax classiﬁer with the last fully connected layer.
Revised: we down-sample the kernel size from 4 × 4 to 1 × 1 , then perform softmax classiﬁer with the last fully connected layer.

Original: All layers are equally initialized based on the varaiance scalining method.
Revised: All layers are equally initialized based on the varaiance scalining method.

Original: The model architecture is described in Table 3.
Revised: The model architecture is described in Table 3.

Original: B. T RAINING D ETAILS
Revised: B. T RAINING D ETAILS

Original: We use Stochastic Gradient Descent (SGD) to optimize our model with initial learning rate 1e-3.
Revised: We use Stochastic Gradient Descent (SGD) to optimize our model with initial learning rate 1e-3.

Original: We also adopt adaptive learning rate decay which is introduced by (Serra et al., 2018).
Revised: We also adopt adaptive learning rate decay which is introduced by (Serra et al., 2018).

Original: The learning rate strategy gradually reduces the learning rate by a factor of 3 for every 3 epochs that validation loss does not consecutively decreases.
Revised: The learning rate strategy gradually reduces the learning rate by a factor of 3 for every 3 epochs that validation loss does not consecutively decreases.

Original: We use L2 weight decay regularization on the base architecture with L2 factor to be 1e-4.
Revised: We use L2 weight decay regularization on the base architecture with L2 factor to be 1e-4.

Original: All hyper-parameters and other training setups are equally set for fair comparison as shown in Table 4.
Revised: All hyper-parameters and other training setups are equally set for fair comparison as shown in Table 4.

Original: In the table, we denote LPC as number of labels per class for each client (or at server).
Revised: In the table, we denote LPC as number of labels per class for each client (or at server).

Original: B S and B U denote batch-size of labeled set S and unlabeled set U .
Revised: B S and B U denote batch-size of labeled set S and unlabeled set U .

Original: µ is a
Revised: µ is a

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: hyper-parameter for FedProx framework.
Revised: hyper-parameter for FedProx framework.

Original: We additionally provide visual illustration of our dataset conﬁguration.
Revised: We additionally provide visual illustration of our dataset conﬁguration.

Original: Please see Figure 7.
Revised: Please see Figure 7.

Original: C A DDITIONAL E XPERIMENTS & A NALYSIS
Revised: C A DDITIONAL E XPERIMENTS & A NALYSIS

Original: In this section
Revised: In this section

Original: [Figure]
Revised: [Figure]

Original: we additionally provide more experimental results and analysis, such as the additional experiment on real-world dataset, the analysis of the communication costs of FedMatch algorithms, experiments with the different backbone networks
Revised: we additionally provide more experimental results and analysis, such as the additional experiment on real-world dataset, the analysis of the communication costs of FedMatch algorithms, experiments with the different backbone networks

Original: [Figure]
Revised: [Figure]

Original: and the analysis on the fraction of available clients per communication round.
Revised: and the analysis on the fraction of available clients per communication round.

Original: C. E XPERIMENTS ON R EAL - WORLD D ATASET
Revised: C. E XPERIMENTS ON R EAL - WORLD D ATASET

Original: Even though the majority of federated learning algorithms have been validated on synthetic datasets due to limited accessibility toward real-world or industrial datasets, validation on such datasets is indeed very important for the potential practical usages in real-world applications.
Revised: Even though the majority of federated learning algorithms have been validated on synthetic datasets due to limited accessibility toward real-world or industrial datasets, validation on such datasets is indeed very important for the potential practical usages in real-world applications.

Original: To show our method consistently work with real-world dataset, particularly, in the medical ﬁeld, we have decided to experiment on COVID-

Revised: To show our method consistently work with real-world dataset, particularly, in the medical ﬁeld, we have decided to experiment on COVID-

Original: Radiography Dataset (Chowdhury et al., 2020).
Revised: Radiography Dataset (Chowdhury et al., 2020).

Original: The COVID-19 dataset contains 219 instances for COVID-19 , 1341 instances for Normal , and 1341 instances for Viral
Revised: The COVID-19 dataset contains 219 instances for COVID-19 , 1341 instances for Normal , and 1341 instances for Viral

Original: Pneumonia images.
Revised: Pneumonia images.

Original: We use 10 clients with fraction 1 . 0 .
Revised: We use 10 clients with fraction 1 . 0 .

Original: We use 5 labels per class for each client.
Revised: We use 5 labels per class for each client.

Original: We
Revised: We

Original: [Table]

Original: [Table]
Revised: [Figure]

Original: compare our method with naive combinations of semi-supervised learning and federated learning models during training 100 rounds.
Revised: compare our method with naive combinations of semi-supervised learning and federated learning models during training 100 rounds.

Original: As shown in the left table of Figure 8, our method consistently outperforms all base models with large margins (around 4% p - 10% p ) in both scenarios.
Revised: As shown in the left table of Figure 8, our method consistently outperforms all base models with large margins (around 4% p - 10% p ) in both scenarios.

Original: The test accuracy curves in Figure 8, we can see that our method trains faster than the base models and shows more stability during training.
Revised: The test accuracy curves in Figure 8, we can see that our method trains faster than the base models and shows more stability during training.

Original: Theses results are clear evidence that our method has strong potential toward a variety of practical usages for real-world applications.
Revised: Theses results are clear evidence that our method has strong potential toward a variety of practical usages for real-world applications.

Original: C. F URTHER A NALYSIS OF THE N UMBER OF L ABELS PER C LASS
Revised: C. F URTHER A NALYSIS OF THE N UMBER OF L ABELS PER C LASS

Original: [Table]
Revised: [Table]

Original: Although we explained our analysis for the Number of Labels per
Revised: Although we explained our analysis for the Number of Labels per

Original: Class under Section 6.2, we further provide additional experimental evidence.
Revised: Class under Section 6.2, we further provide additional experimental evidence.

Original: We conducted experiments of our method without the decomposition technique.
Revised: We conducted experiments of our method without the decomposition technique.

Original: As shown in
Revised: As shown in

Original: Table 5, our method without decomposition technique (indicated as FedMatch (w/o)) shows not much performance improvement when the number of labels per class increases from 5 to 10 (around 3 .
Revised: Table 5, our method without decomposition technique (indicated as FedMatch (w/o)) shows not much performance improvement when the number of labels per class increases from 5 to 10 (around 3 .

Original: x % p ) than from 1 to 5 (around 9 .
Revised: x % p ) than from 1 to 5 (around 9 .

Original: x % p ) or from 10 to( 10 .
Revised: x % p ) or from 10 to( 10 .

Original: x % p ), which are the similar tendency with the baseline models.
Revised: x % p ), which are the similar tendency with the baseline models.

Original: However, our method with the decomposition technique shows consistent performance improvement.
Revised: However, our method with the decomposition technique shows consistent performance improvement.

Original: These results can be clear evidence that our decomposition technique has the effectiveness to preserve reliable knowledge in federated semi-supervised learning scenarios.
Revised: These results can be clear evidence that our decomposition technique has the effectiveness to preserve reliable knowledge in federated semi-supervised learning scenarios.

Original: C. T HE E FFICIENT C OMMUNICATION OF F ED M ATCH
Revised: C. T HE E FFICIENT C OMMUNICATION OF F ED M ATCH

Original: Since the actual bit-level compression techniques are rather implementation issues, which are beyond our research scope, we only consider the reduction of the amount of information that needs to be transmitted between the server and the client.
Revised: Since the actual bit-level compression techniques are rather implementation issues, which are beyond our research scope, we only consider the reduction of the amount of information that needs to be transmitted between the server and the client.

Original: To minimize the communication costs, we not only learn ψ to be sparse, but also subtract the parameters between server and client, such that ∆ ψ = ψ lr − ψ Gr and ∆ σ = σ lr − σ Gr , then send only the difference, ∆ ψ and ∆ σ , as sparse matrices from both directions of server-to-client (S2C) and client-to-server (C2S).
Revised: To minimize the communication costs, we not only learn ψ to be sparse, but also subtract the parameters between server and client, such that ∆ ψ = ψ lr − ψ Gr and ∆ σ = σ lr − σ Gr , then send only the difference, ∆ ψ and ∆ σ , as sparse matrices from both directions of server-to-client (S2C) and client-to-server (C2S).

Original: As shown in Figure 9, we observe that both the C2S and S2C costs are gradually decreased during the learning phases.
Revised: As shown in Figure 9, we observe that both the C2S and S2C costs are gradually decreased during the learning phases.

Original: For ∆ σ , σ could be in general rapidly converged in earlier steps, as both the amount of the labeled data is relatively small (i.e. 5 instances per class) and the knowledge from the labeled data can be effectively captured by σ without inter-task interference.
Revised: For ∆ σ , σ could be in general rapidly converged in earlier steps, as both the amount of the labeled data is relatively small (i.e. 5 instances per class) and the knowledge from the labeled data can be effectively captured by σ without inter-task interference.

Original: Even though we learn σ to be dense, the  fast convergence of σ makes the difference ∆ σ signiﬁcantly small as training steps proceed in both two different direction (C2S and S2C).
Revised: Even though we learn σ to be dense, the [Table] [Table] fast convergence of σ makes the difference ∆ σ signiﬁcantly small as training steps proceed in both two different direction (C2S and S2C).

Original: In particular, we do not even need to send ∆ σ to server under the labels-at-server scenario (Figure 9 C2S cost of ∆ σ in (c) and (d)).
Revised: In particular, we do not even need to send ∆ σ to server under the labels-at-server scenario (Figure 9 C2S cost of ∆ σ in (c) and (d)).

Original: For ∆ ψ , ψ learns knowledge from unlabeled data, and thus it captures relatively more information at client when learning unlabeled data alone (labels-at-server) than learning both labeled and unlabeled data (labels-at-client), as shown in Figure 9 C2S cost of ∆ ψ in (a) and (c), and Figure 9 C2S cost[Figure] of ∆ ψ in (b) and (d).
Revised: For ∆ ψ , ψ learns knowledge from unlabeled data, and thus it captures relatively more information at client when learning unlabeled data alone (labels-at-server) than learning both labeled and unlabeled data (labels-at-client), as shown in Figure 9 C2S cost of ∆ ψ in (a) and (c), and Figure 9 C2S cost of ∆ ψ in (b) and (d).

Original: However, even if the ψ captures more information in the labels-at-server scenario, the C2S cost is still small since we do not send σ to server.
Revised: However, even if the ψ captures more information in the labels-at-server scenario, the C2S cost is still small since we do not send σ to server.

Original: Minimizing the cost of helper agents ψ 1: H are also important, since the helper agents can be multiple, which makes S2C costs heavy.
Revised: Minimizing the cost of helper agents ψ 1: H are also important, since the helper agents can be multiple, which makes S2C costs heavy.

Original: We assume that the parameters also could be effectively reduced by subtracting with the relevant ψ l , which is supposed to be similar to the ψ 1: H , such that ∆ ψ 1: H = ψ 1: H − ψ l .
Revised: We assume that the parameters also could be effectively reduced by subtracting with the relevant ψ l , which is supposed to be similar to the ψ 1: H , such that ∆ ψ 1: H = ψ 1: H − ψ l .

Original: As shown in Figure 9 S2C costs in (a)-(d), we effectively minimize the helper agents costs, since S2C costs
Revised: As shown in Figure 9 S2C costs in (a)-(d), we effectively minimize the helper agents costs, since S2C costs

Original: S2C =
Revised: S2C =

Original: | ∆ σ | + | ∆ ψ | + | ∆ ψ 1: H | is in general less than | ∆ σ | + | ∆ ψ | + H × | ∆ ψ | .
Revised: | [Equation] σ | + | ∆ ψ | + | ∆ ψ 1: H | is in general less than | ∆ σ | + | ∆ ψ | + H × | ∆ ψ | .

Original: C. B ACKBONE A RCHITECTURE
Revised: C. B ACKBONE A RCHITECTURE

Original: Most existing works on federated learning considers smaller networks since the focus is on-device learning of low-resource devices, and thus we utilize a smaller backbone networks than ResNet-9.
Revised: Most existing works on federated learning considers smaller networks since the focus is on-device learning of low-resource devices, and thus we utilize a smaller backbone networks than ResNet-9.

Original: To verify that our method also successfully works on the smaller & different architecture, we adopt
Revised: To verify that our method also successfully works on the smaller & different architecture, we adopt

Original: AlexNet-Like (Serra et al., 2018), of which the ﬁrst three layers are convolutional neural layers with 64 , 128 , and 256 ﬁlters with the 4 , 3 , and 2 kernel sizes followed by the two fully-connected layers of 2048 units, while 2 × 2 max-pooling layers are followed after each convolutional layer.
Revised: AlexNet-Like (Serra et al., 2018), of which the ﬁrst three layers are convolutional neural layers with 64 , 128 , and 256 ﬁlters with the 4 , 3 , and 2 kernel sizes followed by the two fully-connected layers of 2048 units, while 2 × 2 max-pooling layers are followed after each convolutional layer.

Original: In Table 6, for both Streaming-NonIID and Batch-IID tasks, our methods still outperforms all naive Fed-SSL models with the similar tendency with that of the results based on ResNet-9.
Revised: In Table 6, for both Streaming-NonIID and Batch-IID tasks, our methods still outperforms all naive Fed-SSL models with the similar tendency with that of the results based on ResNet-9.

Original: This shows that our methods can be applied to the smaller and different base networks, and still effectively utilize inter-client and reliable knowledge across multiple clients than naive algorithms.
Revised: This shows that our methods can be applied to the smaller and different base networks, and still effectively utilize inter-client and reliable knowledge across multiple clients than naive algorithms.

Original: C. F RACTION OF A VAILABLE C LIENTS PER C OMMUNICATION R OUND
Revised: C. F RACTION OF A VAILABLE C LIENTS PER C OMMUNICATION R OUND

Original: To see the effect of participation rate of clients, we increase the fraction of available clients per communication round in a range of 0 .
Revised: To see the effect of participation rate of clients, we increase the fraction of available clients per communication round in a range of 0 .

Original: 10 , and 0 .
Revised: 10 , and 0 .

Original: This means, for every round, server can connect to the arbitrary 5 , 10 , and 20 available clients out of 100 clients, and perform distributed learning on each individual local data through each client and updates global knowledge by aggregating the locally-learned knowledge.
Revised: This means, for every round, server can connect to the arbitrary 5 , 10 , and 20 available clients out of 100 clients, and perform distributed learning on each individual local data through each client and updates global knowledge by aggregating the locally-learned knowledge.

Original: The experimental results are shown in Table 6 Batch-IID.
Revised: The experimental results are shown in Table 6 Batch-IID.

Original: We observe that the performances of all models are slightly improved when the faction increases.
Revised: We observe that the performances of all models are slightly improved when the faction increases.

Original: This is natural that the more knowledge the client updates, the more the global performance is improved.
Revised: This is natural that the more knowledge the client updates, the more the global performance is improved.

Original: We are not able to ﬁnd any extraordinary phenomenon on the fraction of the number of clients per round.
Revised: We are not able to ﬁnd any extraordinary phenomenon on the fraction of the number of clients per round.