Year: 2021

Abstract:
Supervised federated learning (FL) enables multiple clients to share the trained model without sharing their labeled data. However, potential clients might even be reluctant to label their own data, which could limit the applicability of FL in practice. In this paper, we show the possibility of unsupervised FL whose model is still a classifier for predicting class labels, if there is sufficient class-prior shift among the unlabeled data owned by the clients and the class priors are known to the clients. We propose federation of unsupervised learning (FedUL), where the unlabeled data are transformed into surrogate labeled data for each of the clients, a modified model is trained by supervised FL, and the wanted model is recovered from the modified model. FedUL is a very general solution to unsupervised FL: it is compatible with many supervised FL methods, and the recovery of the wanted model can be theoretically guaranteed as if the data have been labeled. Experiments on benchmark and real-world datasets demonstrate the effectiveness of FedUL. Anonymous code download link is given in Appendix and will be open source later.

heading: 1 INTRODUCTION
text: Federated Learning (FL) has received significant attention from both academic and industrial perspectives in that it can bring together separate data sources and allow multiple clients to train a central model in a collaborative but private manner (McMahan et al., 2017; Kairouz et al., 2019; Yang et al., 2019). So far, the majority of FL researches focused on the supervised setting, requiring collected data at each client to be fully labeled—this may hinder the spread of FL in practice since labeling large-scale training data can be extremely costly due to laborious mannual annotations, and sometimes may not even be possible for privacy concerns, e.g., in medical diagnosis (Ng et al., 2021).
In this paper, we are interested in a challenging unsupervised FL problem where only unlabeled (U) data are available at each client. Our goal remains to train a classification model that can predict accurate class labels in the FL setup. It is often observed that each client collects their own data at different time points or from different geographic locations, e.g., a hospital (data center) may store patient data every month or a particular user (mobile device) may take photos at different places. Therefore, we consider a realistic setting that the U data at a client come in the form of separate data sets: the data distribution of each U set and the number of U sets available at each client may vary.
Without any labels, FL becomes significantly harder than before. In this work, we show that the aforementioned unsupervised FL problem can be solved if the class prior probability shifts between the available U sets at each client, and these class priors are known to the clients. Such a learning scenario can be conceivable in many real-world problems. For example, the hospital may not release the patients’ diagnostic labels due to privacy reasons, but the morbidity rates of diseases (corresponding to the class priors) may change over time and can be accessible from related public medical reports (Croft et al., 2018); moreover, in many cases it is possible to estimate the class priors much more cheaply than the ground-truth labels (Quadrianto et al., 2009a).
Based on these findings, we propose the federation of unsupervised learning (FedUL) (cf. Figure 1), where the original clients with U data are transformed to surrogate clients with (surrogate) labeled data and then supervised FL can be applied. The difficulty is how to infer our wanted model for the original classification task from the surrogate model learned by the surrogate task. We solve this problem by bridging the original and surrogate class probabilities with certain injective transition
functions. Then we implement it by adding a transition layer to the output of each client model, so that the learned model is guaranteed to be a good approximation of the original class probability.
On one hand, FedUL is a very general and flexible: it works as a wrapper that transforms the original clients to the surrogate ones, such that it is compatible with many supervised FL methods, e.g., FedAvg, and add no additional communication cost. On the other hand, FedUL is computationally efficient and easy-to-implement: since the added transformation layer is fixed and determined by the class priors, FedUL adds no more burden on hyper-parameter tuning and/or optimization. Our contributions can be summarized as follows:
• Methodologically, we propose a novel FedUL method that employs a surrogate FL task, providing new perspectives for dealing with U data in FL.
• Theoretically, we prove that the optimal global model learned by FedUL with only U data converges to the optimal global model learned by supervised FL with fully labeled data under mild conditions.
• Empirically, we demonstrate the effectiveness of FedUL on benchmark and real-world datasets.
Related Work: FL has been extensively studied in the supervised setting. One of the most popular supervised FL paradigms is FedAvg (McMahan et al., 2017) which aggregates the local updates at the server and transmits the averaged model back to local clients. In contrast, FL in the unsupervised setting is less explored. Recent studies have shown the possibility of federated clustering with U data (Ghosh et al., 2020; Dennis et al., 2021). However, these clustering based methods rely on geometric or information-theoretic assumptions to build their learning objectives (Chapelle et al., 2006), and are sub-optimal for classification goals. Our work is intrinsically different from them in the sense that we show the possibility of federated classification with U data based on empirical risk minimization (ERM) (Vapnik, 1998), and therefore the optimal model recovery can be guaranteed.
Learning from U datasets has also been studied in the classical centralized learning. Mainstream directions include learning with label proportions (LLP) (Quadrianto et al., 2009b) and Um classification (Lu et al., 2021). The former learns a multi-class classifier from U datasets based on empirical proportion risk minimization (EPRM) (Yu et al., 2014), while the latter learns a binary classifier from U datasts based on ERM. EPRM is inferior to ERM since its learning is not consistent. Yet, it is still unexplored how to learn a multi-class classification model from U datasets based on ERM. To the best of our knowledge, this work is the first attempt to tackle this problem in the FL setup, which is built upon the binary Um classification in the centralized learning.

heading: 2 STANDARD FEDERATED LEARNING
text: In this section, we review standard FL of a classification model. We consider a K-class classification problem with the feature space X ⊂ Rd and the label space Y = [K], where d is the input dimension and [K] := {1, . . . ,K}. Let x ∈ X and y ∈ Y be the input and output random variables following an underlying joint distribution with density p(x, y), which can be identified via the class priors {πk = p(y = k)}Kk=1 and the class-conditional densities {p(x | y = k)}Kk=1. Let f : X → R
K be a classification model that assigns a score to each of the K classes for a given input x and then outputs the predicted label by ypred = argmaxk∈[K](f(x))k, where (f(x))k is the k-th element of f(x).
In standard FL setup with C clients, each client c ∈ [C] has access to a labeled training set Dc = {(xci , yci )} nc i=1∼pc(x, y) of sample size nc and learns its local model fc by minimizing the following risk:
Rc(fc) := E(x,y)∼pc(x,y)[`(fc(x), y)], (1)
where E denotes the expectation, ` : RK × Y → R+ is a proper loss function, e.g., the softmax cross-entropy loss, i.e., `ce(fc(x), y) = − ∑K k=1 1(y = k) log(fc(x))k = − log(fc(x))y, and 1(·) is the indicator function. In practice, ERM is a common practice that computes an approximation of Rc(fc) based on the client’s local data Dc by R̂c(fc;Dc) = 1nc ∑nc i=1 `(fc(x c i ), y c i ).
The goal of standard FL (McMahan et al., 2017) is that the C clients collaboratively train a global classification model f that generalizes well with respect to p(x, y), without sharing their local data Dc. The problem can be formalized as minimizing the aggregated risk:
R(f) = 1
C ∑C c=1 Rc(f). (2)
In practice, we typically employ a server to coordinate the iterative distributed training as follows:
• in each global round of training, the server broadcasts its current model f to all the clients {fc}Cc=1; • each client c copies the current server model fc = f , performs L local step updates:
fc ← fc − αl · ∇R̂c(fc;Dc), (3)
where αl is the local step-size, and sends fc − f back to the server; • the server aggregates the updates from all clients {fc − f}Cc=1 to form the new server model using
FedAvg:
f ← f − αg · ∑C
c=1 (fc − f), (4)
where αg is the global step-size.

heading: 3 FEDERATED LEARNING: NO LABEL NO CRY
text: In this section, we formulate the novel problem setting of FL with only unlabeled datasets, propose our method called federation of unsupervised learning (FedUL), and provide theoretical analysis of FedUL. All the proofs are given in Appendix C.

heading: 3.1 PROBLEM FORMULATION
text: In this paper, we consider a challenging setting: instead of fully labeled training data, each client c ∈ [C] observes Mc (Mc ≥ K, ∀c)1 sets of unlabeled samples, Uc = {Umc } Mc m=1, where Umc = {xc,mi } nc,m i=1 denotes the collection of the m-th U set for client c with sample size nc,m. Each U set can be seen as a set of data points drawn from a mixture of the original class-conditional densities:
Umc ∼ pmc (x) = ∑K
k=1 πm,kc p(x | y = k), (5)
1Note that we do not require each client has the same number of U sets. We only assume the condition Mc ≥ K, ∀c to ensure the full column rank matrix Πc, which is essential for FL with U datasets.
where πm,kc = p m c (y = k) denotes the k-th class prior of the m-th U set. These class priors form a full column rank matrix Πc ∈ RMc×K with the constraint that each row sums up to 1. Note that we do not require any labels to be known, only assume the class priors within each of the involved data sets are available, i.e., the training class priors πm,kc and the test class prior π k = p(y = k).
Our goal is the same as standard FL, i.e., the C clients are interested in collaboratively training a global classification model f that generalizes well with respect to p(x, y), but using only unlabeled datasets Uc on each local client.

heading: 3.2 PROPOSED METHOD
text: As introduced in Section 2, FedAvg is a representative approach for aggregating clients in the FL framework and serves as the basis for many advanced federated aggregation techniques, e.g., Fedprox (Li et al., 2020), FedNova (Wang et al., 2020), and SCAFFOLD (Karimireddy et al., 2020). However, these methods cannot handle clients without labels, which are necessary for them to compute the local gradients. To tackle this problem, we consider the construction of surrogate clients by transforming the local U datasets to labeled datasets and modifying the local models so that they are compatible with the transformed data for updating.
Local Data Transformation First, we transform the data of the clients. For each client c ∈ [C], let y be the index of given U sets, and pc(x, y) be an underlying joint distribution for the random variables x ∈ X and y ∈ [M ], where M = maxc∈[C]Mc.2 By treating y as a surrogate label, we may transform the original U training sets Uc = {Umc } Mc m=1 to a labeled training set for client c,
Uc = {xi, yi} nc i=1 ∼ pc(x, y). (6)
Obviously, the surrogate class-conditional density pc(x | y = m) corresponds to pmc (x) in Eq. (5), for m ∈ [Mc]. If ∃Mc < m ≤ M , we pad pc(x | y = m) = 0. The surrogate class-prior πmc = pc(y = m) can be estimated by π m c = nc,m/( ∑Mc m=1 nc,m).
Based on the data transformation, we then formulate a surrogate supervised FL task: the C clients aim to collaboratively train a global classification model g : X → RM that predicts surrogate labels y for given inputs x, without sharing their local data Uc. This task can be easily solved by standard supervised FL methods. More specifically, we minimize
J(g) = 1
C ∑C c=1 Jc(g) := E(x,y)∼pc(x,y)[`(g(x), y)] (7)
by employing a server g that iteratively broadcasts its model to all local clients {gc}Cc=1 and aggregates local updates from all clients using e.g., FedAvg, where the local and global update procedures exactly follow Eq. (3) and Eq. (4) in standard FL.
Now, a natural question arises: can we infer our desired classification model f from the surrogate model g? To answer this question, we study the relationship of the original and surrogate class probabilities in the following theorem. Theorem 1. For each client c ∈ [C], let ηc : X → ∆M−1 and η : X → ∆K−1 be the surrogate and original class probability functions, where (ηc(x))m = pc(y = m | x) for m ∈ [M ], (η(x))k = p(y = k | x) for k ∈ [K], ∆M−1 and ∆K−1 are the M - and K-dimensional simplexes. Let πc = [π 1 c , · · · , πMc ]> and π = [π1, · · · , πK ]> be vector forms of the surrogate and original class priors, and Πc ∈ RM×K be the matrix form of πm,kc defined in Eq. (5). Then we have
ηc(x) = Qc(η(x);π,πc,Πc), (8)
where the unnormlized version of vector valued functionQc is given by
Q̃c(η(x);π,πc,Πc) = Dπc ·Πc ·D−1π · η(x).
Da denotes the diagonal matrix with diagonal terms being vector a and · denotes matrix multiplication. Qc is normalized by the sum of all entries, i.e., (Qc)i =
(Q̃c)i∑ j(Q̃c)j .
2To make the problem well-defined, for client c with Mc < M , we set Umc = ∅, ∀Mc < m ≤M .
Algorithm 1 Federation of unsupervised learning (FedUL) Server Input: initial f , global step-size αg , and global communication round R Client c’s Input: local model fc, unlabeled datasets Uc = {Umc } Mc m=1, class priors Πc and π, local step-size αl, and local updating iterations L 1: We start with initializing clients with Procedure A. 2: For r = 1→ R rounds, we run Procedure B and Procedure C iteratively . 3: procedure A. CLIENTINIT(c) 4: transform Uc to a surrogate labeled dataset Uc according to Eq. (6) 5: modify f to gc = Qc(f), whereQc is computed according to Theorem 1 6: end procedure 7: procedure B. CLIENTUPDATE(c) 8: fc ← f . Receive updated model from SERVEREXECUTE 9: gc ← Qc(fc) 10: for l = 1→ L do 11: gc ← gc − αl · ∇Ĵc(gc;Uc) . SGD updates based on objective Eq. (7) 12: fc ← fc − αl · ∇Ĵc(Qc(fc);Uc) . The update on gc induces an update on fc 13: end for 14: send fc − f to SERVEREXECUTE 15: end procedure 16: procedure C. SERVEREXECUTE(r) 17: receive local models’ updates fc − f from CLIENTUPDATE 18: f ← f − αg · ∑C c=1(fc − f) . FL aggregation 19: broadcast f to CLIENTUPDATE 20: end procedure
Note that π, πc, and Πc are all fixed,Qc is deterministic and can be identified with the knowledge of π, Πc, and an estimate of πc. In addition, we note that if Mc < M , the last M −Mc entries ofQc are padded with zero by construction. We further study the property ofQc in the following lemma. Lemma 2. For each client c ∈ [C], the transition functionQc : (X → ∆K)→ (X → ∆M ) defined in Theorem 1 is an injective function.
In this sense, the transition function Qc naturally bridges the class probability of our desired task η(x) and that of the learnable surrogate task ηc(x) given only unlabeled datasets. This motivates us to embed the estimation of η(x) into the estimation of ηc(x) at each client.
Local model modification Second, we modify the model for the clients. Let f(x) be the original global model output that estimates η(x). At each client c ∈ [C], we implementQc by adding a transition layer following f and then we have gc(x) = Qc(f(x)). Based on the model transformation, Eq. (7) can be reformulated as follows:
J(f) = 1
C ∑C c=1 Jc(Qc(f)) := E(x,y)∼pc(x,y)[`(Qc(f(x)), y)]. (9)
Therefore, local updates on the surrogate client model gc naturally yield updates on the underlying model f . Now we can aggregate these surrogate clients with our selected standard FL scheme. A detailed algorithm, using FedAvg as an example, is given in Algorithm 1.
Remarks The relationship elucidating the supervised and surrogate FL paradigms (for a single client) is visually shown in Figure 2. The blue part illustrates a supervised FL scheme: the global model is f(x) parameterized by θ; the loss is R(f ; y) in Eq. (2) where labels y are observed. However, we cannot observe y and thus employ a surrogate FedUL scheme which is shown in green: the global model is g(x) directly modified from f ; the loss is J(g; y) in Eq. (7) where y are surrogate labels.

heading: 3.3 THEORETICAL ANALYSIS
text: In what follows, we provide theoretical analysis on the convergence and optimal model recovery for the proposed method.
Convergence of the algorithm In supervised FL, convergence analysis has been studied with regularity conditions (see Section 3.2.2 in Kairouz et al. (2019) for a comprehensive survey), e.g. bounded gradient dissimilarity (Karimireddy et al., 2020) that associates the client model with the server model for non-IID data distributions.3 In our analysis, we focus on the behaviour of our surrogate learning objective J with the effect from transformationQc.
Proposition 3 (Theorem V in Karimireddy et al. (2020)). Assume that J(g) in Eq. (7) satisfies (A1)-(A3) in Appendix C.3. Denote g∗ = argming∈G Ĵ(g), where Ĵ(g) = 1C ∑C c=1 Ĵc(g) :=
1 nc ∑nc i=1 `(g(xi), yi). Let the global step-size αg ≥ 1 and local step-size αl ≤ 1 8(1+B2)βLαg
, FedUL given by Algorithm 1 is expected to have contracting gradient: with the initialized model g0, F := J(g0)− J(g∗) and constant M = σ √ 1 + Cη2g , in R rounds, the learned model gR satisfies
E[‖∇J(gR)‖2] ≤ O ( βM √ F√
RLC + β1/3(FG)2/3 (R+ 1)2/3 + βB2F R
) .
Note that the proposition statement is w.r.t. the convergence of g learned from the surrogate task. By model construction, g is built fromQc(f). By Lemma 2, the convergence of trained model g to the optimal model g∗ in the function class G implies the convergence of the retrieved model f to the optimal model f∗ = argminf∈F Ĵ(f) in the corresponding function class F (induced by G), where Ĵ(f) = 1C ∑C c=1 Ĵc(Qc(f)) := 1 nc ∑nc i=1 `(Qc(f(xi)), yi) is the empirical version of Eq. (9).
Optimal model recovery In our context, the model is optimal in the sense that the minimizer of the surrogate task J(f ; y) coincide with the minimizer of the supervised task R(f ; y) , as if all the data have been labeled. Based on the convergence of surrogate learning, we show that FedUL can recover this optimal model.
Theorem 4. Assume that a proper loss function, e.g., the cross-entropy loss, is chosen for `, and the model used for g is very flexible, e.g., deep neural networks, so that g∗∗ ∈ G where g∗∗ = argming J(g; y). Let f
∗ = argminf∈F Ĵ(f) be the optimal classifier learned with FedUL by Algorithm 1, and f? = argminf R(f ; y) be the optimal classifier learned with supervised FL. By assumptions in Proposition 3, we have f∗ = f?.

heading: 4 EXPERIMENTS
text: In this section, we conduct experiments to validate the effectiveness of the proposed FedUL method under various testing scenarios. Compared with alternative strategies, FedUL consistently achieves superior results on both benchmark and real-world datasets. The detailed experimental settings and additional supportive results are presented in the Appendix D & E.

heading: 4.1 BENCHMARK EXPERIMENTS
text: Settings: As proof-of-concepts, we first perform experiments on widely adopted benchmarks MNIST (LeCun et al., 1998) and CIFAR10 (Krizhevsky et al., 2009). For all experiments, we split 20% training data for validation and model selection. We generate M sets of U training data according to Eq. (5) for each client c ∈ [C]. The total number of training samples nc on each client is fixed, and the number of instances contained in each set indexed by m is also fixed as nc/M . In order to simulate the real world cases, we uniformly select class priors πm,kc = p m c (y = k) from range [0.1, 0.9] and then regularize them to formulate a valid Πc ∈ RMc×K as discussed in Section 3.1. 3The IID case is equivalent to batch sampling from the same distribution, where the analysis is less interesting associated with our FL setting and we omit here.
For model training, we use the cross-entropy loss and Adam (Kingma & Ba, 2015) optimizer with a learning rate of 1e−4 and train 100 rounds. If not specified, our default setting for local update epochs (E) is 1 and batch size (B) is 128 with 5 clients (C) in our FL system. We use LeNet (LeCun et al., 1998) and ResNet18 (He et al., 2016) as backbone for MNIST and CIFAR10, respectively. Here, we investigate two different FL settings: IID and Non-IID, where the overall label distribution across clients is the same in the IID setting, whereas clients have different overall label distributions in the non-IID setting. Specially, for Non-IID setting, we impose class-prior shift following:
• The classes are divided into the majority and minority classes, where the fraction of each minority class is less than 0.08 while the fraction of each majority class is in the range [0.15, 0.25].
• The training data for every client are sampled from 2 majority classes and 8 minority classes. • The test data are uniformly sampled from all classes.
Baselines: We compare our method with the following baselines: (1) Federated Pseudo labeling (FedPL) (Diao et al., 2021): At each client of a FedAvg system, we choose the label with the largest class prior in a U set as the pseudo labels for all the data in this set. During local training, the pseudo labels are boosted by Mixup (Zhang et al., 2017) high-confidence data and low-confidence data, where the confidence is given by model predictions. (2) Federated LLP (FedLLP) (Dulac-Arnold et al., 2019): We update each client model by minimizing the distance between ground truth label proportion and the predicted label proportion, and aggregate them using FedAvg; (3) FedLLP with virtual adversarial training (FedLLP-VAT) (Tsai & Lin, 2020): We add a consistency term to FedLLP as regularization for optimizing client model in FedAvg. (4) FedAvg with 10% labeled data (FedAvg 10%): Followng he classical unsupervised classification literature (Chen et al., 2020), we compare with supervised training using FedAvg on only 10% of total data samples with true labels. The detailed baseline settings are depicted in Appendix D.
Results and Analysis: Table 1 shows the results of our method and baselines on two benchmark datasets under IID and Non-IID settings. The results are reported in mean error (std) format over clients with three independent runs. Given the limited number of total data available in the benchmark datasets, we compare our method with baselines in an FL system with five clients and vary the number of sets in each client M ∈ {10, 20, 40}. In this regard, each set contains a sufficient number of data samples to train the model.
Note that our proposed FedUL method outperforms other baseline methods by a large margin under both Non-IID and IID settings. Moreover, we have the following observations: 1) When varying the number of sets M ∈ {10, 20, 40}, FedUL not only achieves lower classification errors but also shows more stable performance compared to baselines; 2) As we use FedAvg as the default aggregation method for all the strategies, the performances of FedUL, FedPL, and FedAvg all degrade under the
inter client Non-IID setting, as expected. The error rates of FedLLP and FedLLP-VAT are high and unstable, which demonstrates that the EPRM based methods are inferior as discussed in Section 1.

heading: 4.2 ABLATION STUDIES
text: In the following, we present a comprehensive investigation on the ablation studies of the proposed FedUL method on MNIST benchmark.
Robustness with Noisy Priors: To investigate the robustness of our method, we further apply FedUL in a noisy environment. Specifically, the class priors πm,kc are perturbed by a random noise γ. In this case, the noisy class prior π̃m,kc = π m,k c · ((2 − 1)γ + 1), where γ uniform randomly take values in [0, 1] and ∈ {0, 0.2, 0.4, 0.8, 1.6}, so that the method would treat noisy π̃m,kc ∈ [πm,kc (1 − γ), πm,kc (1 + γ)] as the true πm,kc during the whole learning process. The experimental setup is the same as before except for the replacement of πm,kc . Note that we tailor the noisy πm,kc to [0, 1] if it surpasses the range. Here we conduct experiments with five clients and ten sets in every client. From Figure 3(a), we can see that FedUL performs stably even with very challenging noise perturbation (the noise ratio > 0).
Effects of the Number of Accessible Non-IID Data: The purpose of FL is utilizing more data to empower model performance. While how unlabeled data, especially unlabeled Non-IID data, can contribute to FL model performance needs investigation. To this end, we analyze the effects of the number of accessible Non-IID data. We set each client with nc = 500 samples ∀c ∈ [C] and conduct experiments by changing the amount of accessible Non-IID data by increasing the number of clients C ∈ {10, 20, 30, 40, 50}. As shown in Figure 3(b), the model performance improves by a large margin as the number of accessible Non-IID data increases.
Analysis of Local Updating Epochs: The frequency of aggregation may sometimes influence the model performance in an FL system. We would like to explore if FedUL is stable when the local clients are updated with different local epochs E. In Figure 3(c), we explore E ∈ {1, 2, 4, 8, 16} with fixed B = 128 and C = 5. The results demonstrate that with different E, the performance of FedUL are reasonably stable.
Effects of Batch Size: The training batch size is always an important factor in machine learning tasks, especially in an FL system. Hence here, we study how batch size affects our model performance. Specifically, we train the model using three different batch sizes B ∈ {16, 64, 128, 512,∞} with fixed E = 1 and C = 5. Here B =∞ stands for loading all of the samples from the training data into a single batch. The results in Figure 3(d) indicate that FedUL can effectively work under a wide range of batch sizes.

heading: 4.3 CASE STUDY ON REAL-WORLD PROBLEM
text: To demonstrate the feasibility of our proposed FedUL scheme to the real problem, we test FedUL on a medical application for the diagnosis of brain disease. In the rest of this section, we introduce the problem formulation, data and setting, and then discuss the results.
Real Problem Formulation: For a real-world scenario, we consider a clinical setting for disease classification in C different healthcare systems. Suppose each healthcare system has M hospitals located in different regions, each associated with a unique class priors due to population diversities.
Medical data are not shareable between the healthcare systems for privacy. We assume patient-wise diagnosis information is unavailable, but each hospital provides the prevalence of these patients (a.k.a. class priors of the disease classes).
Dataset and Settings: We use the RSNA Intracranial Hemorrhage Detection dataset (Flanders et al., 2020) (Fig. 4) to simulate this real-world scenario. This dataset contains large-scale Magnetic Response Image (MRI) data from several hospitals. There are 106k samples in the dataset belonging to six classes, including five types of intracranial hemorrhage (Epidural, Intraparenchymal, Intraventricular, Subarachnoid, and Subdural) and healthy control type. We model an FL system with five healthcare systems (a.k.a clients). Each healthcare system contains 21.2k data samples. To show the effect on the number of samples in each set, we vary the number of hospitals (a.k.a sets) in each system M = 12, 24, and 48. Here we generate each πm,kc for the k-th class in m-th set at c-th client from range [0.1, 0.9] and check that the generated class priors are not all identical. For model training, we use the cross-entropy loss and Adam (Kingma & Ba, 2015) optimizer with a learning rate of 1e− 4 and train 100 rounds. We use ResNet18 (He et al., 2016) as backbone for experiments. Results and Analysis: As indicated in our proof of concept (Table 1), FedPL consistently outperforms the other two LLP baselines, i.e., FedLLP and FedLLP-VAT. Here we focus on comparing FedUL with FedPL. We also include the supervised baseline FedAvg with 10% data. We report the results of each hospital in mean error (std) format over three runs in Table 2. We can see that our method FedUL consistently outperforms FedPL and FedAvg 10% for all the hospitals and under different site number settings. The superiority of FedUL in this challenging real-world FL system further indicates the effectiveness and robustness of our algorithm. These results are inspiring and bring the hope of deploying FedUL to the healthcare field, where data are often very costly to be labeled, heterogeneous, and distributed.

heading: 5 CONCLUSION
text: In this paper, we propose FedUL, a novel FL algorithm using only U data. FedUL works as a wrapper that transforms the client data and modify the client model to form a surrogate supervised learning task, which can be easily solved using existing FL paradigms. Theoretically, we prove that the optimal model learned by supervised FL can be recovered from the FedUL training scheme under mild conditions. Through extensive experiments on benchmark and real datasets, we show FedUL can significantly overperform the baseline methods under different settings. As a wrapper, we expect FedUL can be further improved by incorporating advanced FL aggregation or optimization schemes for the non-IID setting (Wang et al., 2020; Li et al., 2020; 2021; Karimireddy et al., 2020).

heading: ETHICS STATEMENT
text: Collecting sample-wise labels for training can be costly and may violate data privacy. Considering data in the real world are often collected distributed, we provide a pioneer and promising solution to perform multi-class classification on distributed U data in the FL system. Our method FedUL can be widely applied to data-sensitive fields, such as healthcare, politics, and finance, where the sample-wise label is not available, but populational prevalence can be accessed. With FedUL, we hope the future FL can enjoy significant labeling cost reduction and improve its privacy. Therefore, we believe our proposed method and its potential application have a positive impact on society. The real datasets used in this work are publicly available with appropriate prepossessing to de-identify patients’ identities. We provide proper references to the datasets, libraries, and tools used in our study. This study does not have any legal compliance, conflict of interest, or research integrity issues.

heading: REPRODUCIBILITY STATEMENT
text: We provide the codes to reproduce the main experimental results via the anonymous download link indicated in Appendix. We further provide experimental details and additional information of the datasets in the supplementary materials.

heading: A DATA AND CODE AVAILABILITY
text: The trained models, guidelines for data downloading and preparation, code for training, validation, testing of all the methods, readme file, libraries requirement, and environment setup for our benchmark experiments are available at the anonymous link: https://drive.google.com/drive/folders/1kcMO0_XoxoPFhv1ZgcZ6bV_HTzZo-zPs?usp=sharing. Due to size limitation, we could not share the preprocessed large scale real-world datasets. We are very happy to release all materials in the final version.

heading: B NOTATION TABLE

heading: C PROOFS
text: In this appendix, we prove all theorems.

heading: C.1 PROOF OF THEOREM 1
text: By the Bayes’ rule, ∀m ∈ [M ] we have:
(ηc(x))m = pc(x, y = m)
pc(x)
= pc(x, y = m)∑Mc m=1 pc(x, y = m) = pc(x | y = m)pc(y = m)∑Mc m=1 pc(x | y = m)pc(y = m) = pmc (x)π
m c∑Mc
m=1 p m c (x)π m c = πmc ∑K k=1 π
m,k c p(x | y = k)∑Mc
m=1 π m c ∑K k=1 π m,k c p(x | y = k)
= πmc ∑K k=1 π m,k c
(η(x))k πk∑Mc
m=1 π m c ∑K k=1 π m,k c (η(x))k πk . (10)
By transforming (10) to the matrix form, we complete the proof.

heading: C.2 PROOF OF LEMMA 2
text: Given our data generation process in Section 3.1, we have that Mc ≥ k and Πc ∈ RMc×K is a full column rank matrix. With Dπc and D −1 π being non-degenerate, we obtain thatQc(η(x)) presents an injective mapping from η(x) to ηc(x).

heading: C.3 PROOF OF PROPOSITION 3
text: The assumptions (A1)-(A3) are listed as follows.
(A1) Bounded gradient dissimilarity: ∃ constants G ≥ 0 and B ≥ 1 s.t. 1
C ∑C c=1 ‖∇Jc(g)‖2 ≤ G2 +B2‖∇J(g)‖2,∀g.
(A2) β-smooth function Jc satisfies ‖∇Jc(θ)−∇Jc(θ′)‖ ≤ β‖θ − θ′‖,∀c,θ,θ′.
(A3) Unbiased stochastic gradient with bounded variance:
E[‖∇Ĵc(g;Uc)−∇Jc(g)‖2] ≤ σ2,∀c, g, where Ĵc(g;Uc) = 1nc ∑nc i=1 `(g(xi), yi).
Note that this proposition statement is w.r.t. the convergence of model g learned from the surrogate supervised learning task. The proof follows directly from Theorem V in Karimireddy et al. (2020).

heading: C.4 PROOF OF THEOREM 4
text: When a proper loss (Reid & Williamson, 2010) is used for `, the mapping of g∗∗ is the unique minimizer of J(g). We show an example of the a widely used proper loss function: the cross-entropy loss (De Boer et al., 2005) defined as
`ce(g(x), y) = − ∑M
m=1 1(y = m) log(g(x))m = − log(g(x))y.
We can see that the cross-entropy loss is non-negative by its definition. Therefore, minimizing J(g) can be obtained by minimizing the conditional risk Ep(y|x)[`(g(x), y) | x] for every x ∈ X . So we are now optimizing
φ(g) = − M∑ m=1 p(y = m | x) · log(g(x))m, s.t. M∑ m=1 (g(x))m = 1.
By using the Lagrange multiplier method (Bertsekas, 1997), we have
L = − M∑ m=1 p(y = m | x) · log(g(x))m − λ · ( M∑ m=1 (g(x))m − 1).
The derivative of L with respect to g is
∂L ∂g =
[ −p(y = 1 | x)
(g(x))1 − λ, · · ·,−p(y = M | x) (g(x))M − λ ]> .
By setting this derivative to 0 we obtain
(g(x))m = − 1
λ · p(y = m | x), ∀m = 1, . . . ,M and ∀x ∈ X .
Since g ∈ ∆M−1 is the M -dimensional simplex, we have ∑M m=1(g ∗∗(x))m = 1 and ∑M m=1 p(y = j | x) = 1. Then M∑ m=1 (g∗∗(x))m = − 1 λ · M∑ m=1 p(y = m | x) = 1. Therefore we obtain λ = −1 and (g∗∗(x))m = p(y = m | x) = (η(x))m,∀m = 1, . . . ,M and ∀x ∈ X , which is equivalent to g∗∗(x) = η̄(x). Similarly, we obtain f?(x) = η(x). Given Proposition 3 and the assumption that the model used for g is sufficiently flexible, we obtain the classification model learned with FedUL by Algorithm 1 g∗ = g∗∗. By our model construction, g is built fromQc(f). We have f∗ = f∗∗ = argminf J(f) which is induced by the convergence of g. Given Theorem 1 and Lemma 2, we obtain that g∗∗(x) = η̄(x) if and only if f∗∗(x) = η(x). So we obtain f∗ = f?.

heading: D EXPERIMENTAL DETAILS
text: We illustrate our model architectures and training details of the benchmark and real-world experiments in this section.

heading: D.1 MODEL ARCHITECTURE
text: For our benchmark experiment on MNIST, we use a six-layer convolutional neural network. The network details are listed in Table D.2. For our benchmark experiment on CIFAR10 and real-world experiment, we use ResNet18 as our backbone. The network details are listed in Table D.3.

heading: D.2 TRAINING DETAILS
text: Benchmark Experiments: We implement all the methods by PyTorch and conducted all the experiments on an NVIDIA TITAN X GPU. Please note for all experiments, we split 20% training data for validation and select model. During training process, we use Adam optimizer with learning rate 1e − 4 and cross-entropy loss, we set batch size to 128 and training rounds to 100. To avoid overfitting, we use L1 regularization. The detailed weight of L1 regularization used in benchmark experiments is shown in Table D.4.
The detailed number of samples in each client for MNIST and CIFAR10 under IID and Non-IID setting is given in Table D.5 and Table D.6, respectively.
We describe details of the baseline methods and corresponding hyper-parameters as follows.
• FedPL (Diao et al., 2021): this method is based on empirical classification risk minimization. The learning objective is
R̂(f) = 1
C C∑ c=1 Mc∑ m=1 Lfix + λLmix, (11)
where
Lfix = ` ( f ( x+b ) , y+b ) (12)
is the "fix" loss, where (x+b , y + b ) represents for a sample x + b with high confidence pseudo label y+b and
Lmix = λmix · ` ( f (xmix) , y + b ) + (1− λmix) · ` ( f (xmix) , y − b )) (13)
is the "mix" loss, in which
λmix ∼ Beta(a, a), xmix ← λmixx+b + (1− λmix)x − b , (14)
where a is the mixup hyper-parameter and (x−b , y − b ) represents for a sample x − b with low confidence pseudo label y−b . Following the default implementation in (Diao et al., 2021),
Real-world Experiments: We perform a study case on an important clinical task — intracranial hemorrhage diagnosis. Intracranial hemorrhage, described as bleeding that occurs inside the cranium, is a severe health problem. The distribution of intracranial hemorrhage depends on the patient’s ethnicity, such as age (Camacho et al., 2015). Thus, considering age distributions vary in different regions, this dataset and problem naturally fits into our setting.
We use the RSNA Intracranial Hemorrhage Detection dataset (Flanders et al., 2020) (Fig. 4), which contains large-scale Magnetic Response Image (MRI) data from several hospitals.There are 106k samples in the dataset belonging to six classes, including five types of intracranial hemorrhage (Epidural, Intraparenchymal, Intraventricular, Subarachnoid, and Subdural) and healthy control type. In our experiments, we simulate a real-world scenario with five healthcare systems (a.k.a. clients) and assume the number of hospitals (a.k.a sets) in each healthcare systems varies M = 12, 24, and 48.
At first, we randomly split the whole dataset for five healthcare systems equally, so each healthcare systems is assigned 21.2k samples. Then we generate πmc for m-th set in c-th client from range [0.1, 0.9] for all the hospitals with U data only. We check that the generated class priors are not all identical. Finally, we load samples for each the hospitals following the generated π. Detailed dataset statistics is given in Table D.7.
During training process, we use Adam optimizer with learning rate 1e− 4 and cross-entropy loss, we set batch size to 128 and training rounds to 100. To avoid overfitting, we use L1 regularization. We set the weight of L1 regularization as 2e−6, 8e−7 and 4e−7 for 10, 20 and 40 sets, respectively. In real-world experiments, we use the same hyper-parameters as benchmark experiments for all methods except FedLLP-VAT. For FedLLP-VAT, we set the hyper-parameter the weight of consistency loss α = 0.05 and the perturbation weight µ = 6.0.
Training Efficiency: We further evaluate the training efficiency of our method with comparison to baseline methods. The detailed one epoch training time (mean) and forward FLOPs are given in Table D.8. The computation time is evaluated on a PC with one Nvidia TITAN X GPU. We can see that our method slightly increase the forward FLOPs and can achieve higher training efficiency compared with FedPL and FedLLP-VAT.

heading: E MORE EXPERIMENTAL RESULTS ON BENCHMARK DATASET MNIST

heading: E.1 DETAILED STATISTICS OF FIGURE 3(A)
text: We show detailed statistics of figure 3(a) in Table E.9. With different noisy class priors, even challenging = 0.8 and = 1.6, our method still achieves low error rate, which strongly verify the robustness and effectiveness of our method.
Table E.9: Inaccurate class priors experiments with different noise ratio on MNIST under Non-IID setting with 5 clients and 10 sets in every client (mean error (std)).
= 0 (Clean) = 0.2 = 0.4 = 0.8 = 1.6 2.98 (1.72) 3.02 (1.30) 3.10 (0.96) 3.02 (1.36) 3.49 (1.74)

heading: E.2 DETAILED STATISTICS OF FIGURE 3(B)
text: We show detailed statistics of figure 3(b) in Table E.10. With more Non-IID data can be accessed, our method performs better, which validate that more unlabeled Non-IID data can be helpful for FL.
Table E.10: Experiments on accessible data amount under the Non-IID setting (mean error (std)). 5k 10k 15k 20k 25k

heading: 3.56 (0.09) 2.62 (0.07) 1.97 (0.38) 1.75 (0.11) 1.72 (0.13)

heading: E.3 DIFFERENT COMBINATIONS OF E AND B
text: We compare our method with different combinations of E and B on benchmark dataset MNIST with the Non-IID setting. The classification error rate (mean and std) are consistently small as presented (cf. Table E.11), which indicates our method can work under a wide range combinations of E and B.
Table E.11: Experiments using different combinations of training batch size B and local update epoch E on benchmark dataset MNIST with the Non-IID setting (mean error (std)).
E 1 4 16 B 16 128 ∞ 16 128 ∞ 16 128 ∞
Error 7.99 (9.83) 2,93 (1.20) 3.69 (0.88) 2.54 (1.09) 4.16 (3.44) 2.81 (0.37) 2.92 (1.12) 3.51 (1.88) 2.88 (1.06)

heading: F BENCHMARK EXPERIMENTS ON CLIENTS WITH DIFFERENT SETS
text: Here we conduct experiments on benchmark datasets under IID and Non-IID setting with 5 clients and different sets in each client (10, 20, 30, 40, 50). The experimental results are shown in Table F.12, which further indicates the effectiveness of our method even under this challenging setting.
Table F.12: Quantitative comparison of our method with the baseline methods on benchmark datasets under Non-IID and IID setting (mean error (std)) with different sets in each client. The best method (paired t-test at significance level 5%) is highlighted in boldface.
IID Task with 5 Clients Dataset FedPL FedLLP FedLLP-VAT FedUL FedAvg 10% MNIST 3.74 (0.78) 5.22 (5.38) 2.24 (0.05) 1.19 (0.11) 2.21 (0.07) CIFAR10 45.49 (2.74) 84.16 (0.71) 86.01 (2.54) 31.17 (2.80) 42.27 (1.06) Non-IID Task with 5 Clients Dataset FedPL FedLLP FedLLP-VAT FedUL FedAvg 10% MNIST 12.03 (2.89) 4.26 (3.20) 3.88 (2.89) 2.31 (1.14) 3.42 (0.20) CIFAR10 59.06 (3.73) 62.44 (16.99) 59.72 (18.73) 35.46 (1.40) 53.13 (0.22)

heading: G BENCHMARK EXPERIMENTS WITH MORE CLIENTS
text: To study the influence of the number of clients, here we further conduct benchmark experiments on both MNIST and CIFAR10 with 10 clients. The detailed results are shown in Table G.13, in which we has the similar observations as in Table 1.
Table G.13: Quantitative comparison of our method with the baseline methods on benchmark datasets under Non-IID and IID setting (mean error (std)). The best method (paired t-test at significance level 5%) is highlighted in boldface.
IID Task with 10 Clients Dataset Sets FedPL FedLLP FedLLP-VAT FedUL FedAvg 10%
MNIST 10 2.19 (0.04) 10.11 (7.12) 25.83 (22.64) 0.74 (0.14)
1.58 (0.23)20 2.55 (0.30) 24.23 (17.52) 28.40 (23.20) 1.05 (0.05) 40 3.13 (0.25) 32.53 (16.93) 34.46 (15.46) 1.47 (0.11)
CIFAR10 10 40.47 (0.58) 76.23 (1.47) 76.25 (1.65) 20.40 (0.63)
33.57 (1.03)20 46.44 (0.71) 78.10 (3.58) 76.26 (3.83) 21.61 (0.23) 40 51.58 (1.18) 79.10 (2.34) 80.44 (1.60) 22.71 (0.17)
Non-IID Task with 10 Clients Dataset Sets FedPL FedLLP FedLLP-VAT FedUL FedAvg 10%
MNIST 10 12.24 (1.36) 20.81 (14.72) 17.26 (10.39) 1.91 (0.16)
3.03 (0.24)20 5.73 (0.89) 17.67 (11.48) 18.45 (4.30) 1.45 (0.27) 40 4.16 (0.56) 14.98 (10.11) 13.62 (5.47) 1.27 (0.12)
CIFAR10 10 68.53 (1.14) 84.11 (2.63) 82.17 (2.58) 39.20 (0.79)
52.48 (1.55)20 61.49 (1.42) 71.69 (7.59) 72.34 (7.39) 34.12 (0.57) 40 55.89 (2.19) 58.21 (4.95) 59.42 (9.59) 32.21 (1.02)

heading: H RELATED WORK
text: Considering the heterogeneity of data, clients, systems, and applications in FL, personalized FL is a natural and trending solution to improve FL performance in heterogeneous settings. Many efforts have been made for personalized FL to address the challenges of heterogeneity. FedProx(Li et al., 2020), FedCurv (Shoham et al., 2019) and FedCL (Yao & Sun, 2020) proposed regularization-based method by including special regularization terms to improve FL model generalizing to various clients. Meta-learning was involved to train highly-adaptable to achieve personalized FL by Jiang et al. (2019); Fallah et al. (2020); Li et al. (2019). Different from the above-mentioned methods that yield a single generalizable model, multiple FL models can be trained using clustering strategies to achieve personalization (Sattler et al., 2020; Ghosh et al., 2020). Different local FL models also can be achieved by introducing personalized layers (Li et al., 2021; Arivazhagan et al., 2019).
However, our learning settings and methods are very different from the existing personalized FL approaches. Firstly, our framework focuses on unsupervised FL. Specifically, 1) If inter-clients are iid, FedUL yields the same proxy model gc (c is the index of clients) and federated model f for all the clients. 2) If inter-clients are non-iid, although gc are different, the underlying model f (what we want) is still the same. Secondly, our method differs from the previous personalized FL approaches by its surrogate training nature: it works as a wrapper that transforms the unlabeled clients to (surrogate) labeled ones and is compatible with many supervised FL methods.

Review summaries:
This work presents a novel federated learning scheme to address the problem of learning from only unlabeled data. The main idea is clean and interesting, which constructs a global (server) model by aggregating the surrogate clients’ tasks from observing only unlabeled data for the classification tasks. The unlabeled data are transformed at each client to make them compatible with supervised federated learning; consequently, the learned models are transformed accordingly. Existing federated aggregation techniques, e.g. FedAvg, are applied on these transformed clients (where they call surrogate clients). Theoretical results are provided for learning the optimal model and experiments on benchmark and real data show superior performance compared to baselines. 

The authors are proposing an approach for unsupervised Federated Learning. The authors propose to use Emperical risk minimizing for unsupervised learning. The authors assign labels to each of the class and uses a prior for the classes so that each of the client can learn without any labels.  The authors have shown theoretical properties for their proposed solution. Theorem 1 showing that there is a map that that exist to transform the data to the classes, Lemma 2 shows that there is a transition function for each of the clients. The authors have also shown convergences of the algorithm by deriving the upper bound.