blog1

Domain Shift in FL

  • DA 常用数据集：Office-31，Office-Caltech-10，MINIST+USPS，更多的见：https://github.com/jindongwang/transferlearning/blob/master/data/dataset.md

  • 一个 baseline 方法：DDC，见：https://github.com/jindongwang/transferlearning/tree/master/code/DeepDA

  • domain adaption 的 setting: source domain 有 labeled data，target domain 没有或者只有少量 labeled data（可以有大量 unlabeled data）。在 FL 下可能的 setting：

    • client 有 target unlabeded data，server 有 source labeled data
    • client 有 target unlabeded data + server 共享的 source labeled data
    • client 之间 target unlabeled data 存在 non-iid

  • Personalized FL

  • 先是一个 survey: Towards Personalized Federated Learning

  • 可以分成 data-based, model-based；其中 model-based 按照 FL 阶段会产生多少个不同的 model，有可以分成 single-model，multi-model，和 n-model

  • Data-based

    • FedPer_Federated Learning with Non-IID Data：Server 给 client 发一小部分 shared data，减少 weight deviation
    • 还可以对不均衡样本进行 over-sampling，down-sampling, GAN 之类的方法

  • Model-based

    • Single model –> Meta-learning

      • Per-FedAvg
      • pFedMe
      • FedFomo
      • On Data Efficiency of Meta-learning_AISTATS21: 详细对比分析了 Reptile，MAML，ProtoNet 3种 meta-learning 的方法 MAML 偏好需要很多 task，每个task的 data point 可以比较少，而 reptile 正好相反

    • Single model –> Regularization

      • Debiasing Model Updates for Improving Personalized Federated Training_ICML21，见 weights & Biases
      • 其他的比如 Elastic Weight Consolidation (EWC) 等

    • Parameter-decoupling

    • N-model

      • Transfer Leraning/ Knowledge Distillation.上传对于一个 (public dataset + private dataset) 的 logit 预测结果（作为 knowledge）。server 对 knowledge 进行 aggregate，client 利用 aggregated knowledge 进行知识蒸馏（local model 作为学生）。但这类方法需要一个 public dataset 来做知识蒸馏，算是传统 FL 形式的拓展

        FedMD: Heterogenous Federated Learningvia Model Distillation：知识蒸馏在 client 端进行，server 负责 aggregate logit；classifier所需的分类数 = public dataset类别数 + private dataset类别数

      • Multiple-Model –> Clustering ClusterFL, FedDL

Non-iid

  • 通过改 server 端 aggregation 算法

    • Federated Learning on Non-IID Data Silos: An Experimental Study* (挺有启发的一篇文章)：比较了 FedAvg, FedProx, SCAFFOLD, FedNova 几种算法，有几个观察：

      • IID 时，FedAvg 不比其他3个方法差；Feature distribution skew, quantity skew 情况下，准确率下降不明显，并且 FedAvg 甚至比其他三个更好（The state-of-the-art algorithms signifi-cantly outperform FedAvg only in several cases）
      • Label distribution skew（也即 label non-iid）确实会带来巨大准确率下降。极端 non-iid 情况下，FedProx 比 FedAvg 稍好
      • SCAFFOLD, FedNova 在很多情况下不稳定（可以排除掉了）
      • Dirichlet 分布产生的 Label distribution skew 相比每个 client 只有一类这种极端情况，要稍微好一点。另外这篇文章也提到，只有一类这种极端情况在现实中也可能存在，比如 speaker recognition

    • FedMA_Federated learning withmatched averaging_ICLR20：对于每一层（以FC为例），local dataset 训练得到的 weight 是 optimal 乘上一个 L*L 的矩阵，其中 L 是 hidden unit 数量。在 server 端，可以先求出来每一层的这个变换矩阵（通过迫使 global model 和 local model 变换后接近），再 aggregate；缺点是不支持 BN 层

    • FedBN: Federated Learning on Non-IID Features via Local Batch Normalization_ICLR21：server does not aggregate BN layers，探索的是 BN 层怎么 aggregate 的问题

    • FedDF_Ensemble Distillation for Robust Model Fusion in Federated Learning_NIPS20

      • 最终目标还是产生一个 model，不是 personalized FL；其中知识蒸馏在 server 端进行，client 还是只需要上传 model
      • 相比于 FedAvg（算法第6行为止），FedDF 多了在 server 上的 N 次迭代；每次迭代中，将 client models 对于 samples d 的 logit 的平均值作为 teacher，global model（x_{t, j-1}）作为 student

https://www.cnblogs.com/orion-orion/p/15897853.html)

NOIID

BLOG,CODE

数据分割的方式：

1.Label distribution skew 标签分布倾斜

  • Quantity-based label imbalance：基于数量的标签不平衡

    每一方只能获得特定个数的标签（例如在MNIST中，只能获得任意2个标签的样本构成数据集）

    对于有相同标签的一组参与方，将对应标签的数据集随机并平均地分配到参与方手中

  • Distribution-based label imbalance：基于分布的标签不平衡

    根据狄利克雷分布，每一方将获得对应地数据集，具体来说： pk∼DirN(β)

    其中 pk,i 记为类别k分到第i方的数据量

2.Feature distribution skew 特征分布倾斜

  • Noise-based feature imbalance 基于噪声的

    首先将数据平均并随机分配至各参与方手中

    对图像数据集加上x ∼ Gau(σ · i/N ) 均值为0，方差为σ · i/N的高斯噪声

  • Synthetic feature imbalance 生成特征不平衡

    文章中生成了一个feature imbalance的数据集FCUBE

  • Real-world feature imbalance 现实世界的特征不平衡

    EMNIST数据集中，手写数字来自于不同的人，因此将不同的人的数据分发给不同的参与方，即可实现天然的feature imbalance

3.Quantity skew 数量偏移

  • 各参与方数据集大小不同

–

狄利克雷分布(Dirichlet Distribution)

BLOG

可视化

可视化2

可视化3、

（第一次采用Dirichlet分布来划分数据集的论文为《Measuring the Effects of Non-Identical Data Distribution for Federated Visual Classification》[2]）。

auc

ACC（Accuracy）是模型的准确率，即模型正确预测的样本数占总样本数的比例。ACC 可以用来评估模型在整体上的分类效果，但它不能很好地反映模型在不同类别上的表现差异。

AUC（Area Under the Curve）是 ROC 曲线下的面积，可以用来评估模型在不同阈值下的分类效果。AUC 的取值范围在 0.5 到 1 之间，值越大表示模型性能越好。当 AUC = 0.5 时，表示模型预测效果与随机猜测一样；当 AUC = 1 时，表示模型完全正确地区分了正负样本。

1

auc = metrics.roc_auc_score(y_true, y_prob, average="micro")

这段代码使用了sklearn.metrics模块中的roc_auc_score函数来计算接收者操作特征曲线下面积（Area Under the Receiver Operating Characteristic Curve，简称AUC）。AUC是一个用于评估分类模型性能的指标，特别是在不平衡的数据集上。

下面是代码中各部分的解释：

  • y_true: 真实标签，通常是一个数组或列表，其中包含每个样本的真实类别（例如，0和1）。
  • y_prob: 预测概率，通常是一个数组或列表，其中包含模型为每个样本预测的属于正类的概率。
  • average: 这个参数决定了如何计算多类问题的AUC。在二分类问题中，这个参数通常不需要设置。但在多类问题中，你可以设置它为"micro", "macro", "weighted"等，以决定如何平均每个类别的AUC。
    • "micro": 计算总体的真正例（True Positives, TP）和假正例（False Positives, FP），然后基于这些值计算AUC。这基本上是将多类问题视为一个单一的二分类问题。
    • "macro": 计算每个类别的AUC，然后取平均值，不考虑类别的样本数量。
    • "weighted": 计算每个类别的AUC，然后取加权平均，权重是每个类别的样本数量。

因此，auc = metrics.roc_auc_score(y_true, y_prob, average="micro")这段代码的意思是：计算基于真实标签y_true和预测概率y_prob的AUC，其中对于多类问题，AUC是通过"micro"方式计算的。

请注意，为了使roc_auc_score正常工作，y_true应该只包含二进制的标签（例如，0和1），而y_prob应该包含模型为每个样本预测的属于正类的概率。如果你直接使用了模型的输出标签（而不是概率），你可能需要修改你的代码以使用模型的概率输出。

20中不同颜色区分tab20

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

 plt.figure(figsize=(12, 8))
    colors = plt.cm.get_cmap('Accent', num_clients)
    plt.hist([id for id in client_dist], stacked=True,
             bins=np.arange(-0.5, num_classes+ 1.5, 1),
             label=["Client {}".format(i) for i in range(num_clients)],color=[colors(i) for i in range(num_clients)],
             rwidth=0.5)
    plt.xticks(np.arange(n_classes), classes,rotation=45)
    plt.xlabel("标签类型")
    plt.ylabel("样本数")
    plt.legend(loc="upper right")
    plt.title("每个标签在不同客户端上的分布")
    plt.tight_layout()
    plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

(Pdb) p len(train_data)
60000
(Pdb)  p len(test_data)
10000
(Pdb) p type(train_data[0])
<class 'tuple'>
(Pdb) train_data[0][1]
5
(Pdb) train_data[0][0].shape
torch.Size([1, 28, 28])

(Pdb) p classes
['0 - zero', '1 - one', '2 - two', '3 - three', '4 - four', '5 - five', '6 - six', '7 - seven', '8 - eight', '9 - nine']
(Pdb) p n_classes
10

# 合并了训练集和测试集
(Pdb) p labels
array([5, 0, 4, ..., 4, 5, 6], dtype=int64)
(Pdb) p type(labels)
<class 'numpy.ndarray'>
(Pdb) p len(labels)
70000

# 将所有数据集划分到 10 client 对应的下标
(Pdb) p type(client_idcs)
<class 'list'>
(Pdb) p len(client_idcs)
10
# 每个客户端的数据量
(Pdb) p len(client_idcs[0])
6955
(Pdb) p len(client_idcs[1])
9462

# 
(Pdb) p label_distribution
[[], [], [], [], [], [], [], [], [], []]
(Pdb) p c_id
0
(Pdb) p idc #客户端0 对应数据的下标
array([   1,   21,   34, ..., 1177, 1194, 1221], dtype=int64)
(Pdb) p len(idc)
6955
(Pdb) p labels[idc]# client 0 对应数据的下标
array([0, 0, 0, ..., 9, 9, 9], dtype=int64)
#每个客户端含有标签的数量

for idx in idc:
    label_distribution[labels[idx]].append(c_id)
# client 0 的所有数据 对应下标为idc
(Pdb) p idc
array([   1,   21,   34, ..., 1177, 1194, 1221], dtype=int64)
(Pdb) p len(idc)
6955
(Pdb) p idx
1
(Pdb) p labels[idx]# 数据 对应的标签
0
(Pdb) p label_distribution# 标签
[[0], [], [], [], [], [], [], [], [], []]
(Pdb) p len(label_distribution)
10
# 每个标签对应的client id
标签为0的数据在每个客户端上的id



 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

(Pdb) p dataset_image.shape
(70000, 1, 28, 28)
(Pdb) p dataset_label
array([5, 0, 4, ..., 4, 5, 6], dtype=int64)
(Pdb) p len(dataset_label)
70000

(Pdb) p p_client_id
[0]
(Pdb) p p_label_id
[array([0, 1, 4, 5, 7, 8, 9], dtype=int64)]
(Pdb) p p_label_num
[[(0, 140), (1, 890), (4, 1), (5, 319), (7, 29), (8, 1067), (9, 184)]]
----
seed=42
(Pdb) p p_client_id
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
(Pdb) p p_label_id
[array([0, 1, 4, 5, 7, 8, 9], dtype=int64), array([0, 2, 5, 6, 8, 9], dtype=int64), array([0, 3, 6, 9], dtype=int64), array([0, 4, 7, 8], dtype=int64), array([0, 1, 3, 5, 6, 8, 9], dtype=int64), array([1, 3, 4, 8, 9], dtype=int64), array([1, 2, 3,
6, 8, 9], dtype=int64), array([1, 2, 3, 5, 7, 8], dtype=int64), array([0, 1], dtype=int64), array([0, 1, 2, 4, 6], dtype=int64), array([0, 1, 2, 3, 4, 5], dtype=int64), array([2, 3, 5], dtype=int64), array([0, 1, 2, 5], dtype=int64), array([1, 2, 4
, 5, 7], dtype=int64), array([5, 7], dtype=int64), array([0, 3, 5, 6, 7, 8], dtype=int64), array([0], dtype=int64), array([1, 2, 3, 4, 5, 7, 8], dtype=int64), array([0, 5, 6], dtype=int64), array([0, 1, 2, 3, 4, 9], dtype=int64)]
(Pdb) p p_label_num
[[(0, 140), (1, 890), (4, 1), (5, 319), (7, 29), (8, 1067), (9, 184)], [(0, 5), (2, 27), (5, 19), (6, 335), (8, 6), (9, 107)], [(0, 3), (3, 143), (6, 1461), (9, 23)], [(0, 155), (4, 1), (7, 2381), (8, 4)], [(0, 71), (1, 13), (3, 207), (5, 1129), (6
, 6), (8, 40), (9, 451)], [(1, 38), (3, 1), (4, 39), (8, 25), (9, 6086)], [(1, 873), (2, 176), (3, 46), (6, 42), (8, 13), (9, 106)], [(1, 21), (2, 5), (3, 11), (5, 787), (7, 4), (8, 441)], [(0, 1), (1, 3599)], [(0, 633), (1, 1997), (2, 89), (4, 519
), (6, 768)], [(0, 920), (1, 2), (2, 1450), (3, 513), (4, 134), (5, 97)], [(2, 159), (3, 3055), (5, 558)], [(0, 8), (1, 180), (2, 3277), (5, 148)], [(1, 237), (2, 343), (4, 6), (5, 453), (7, 1095)], [(5, 2719), (7, 3011)], [(0, 31), (3, 1785), (5,
16), (6, 4), (7, 756), (8, 2856)], [(0, 3628)], [(1, 26), (2, 1463), (3, 1379), (4, 335), (5, 60), (7, 17), (8, 2373)], [(0, 998), (5, 8), (6, 4260)], [(0, 310), (1, 1), (2, 1), (3, 1), (4, 5789), (9, 1)]]


(Pdb) p statistic
[[(0, 810), (6, 736), (7, 2092)], 
 [(0, 313), (1, 6633)], 
 [(1, 997), (2, 352), (3, 4), (4, 128), (8, 16), (9, 17)], 
 [(4, 223), (5, 52), (6, 6), (8, 900), (9, 138)], [(0, 7), (2, 6), (6, 3853)], 
 [(1, 112), (3, 6), (7, 90), (8, 284), (9, 783)], 
 [(1, 6), (2, 2), (3, 96), (5, 1471), (6, 31), (7, 511)], 
 [(0, 12), (1, 1), (2, 112), (4, 1193), (5, 483), (6, 2), (8, 1)], 
 [(0, 68), (1, 3), (2, 12), (4, 1992), (6, 104), (8, 3), (9, 4063)], 
 [(0, 3055), (1, 98), (2, 5762)], 
 [(0, 2013), (2, 2), (3, 900),(5, 58), (6, 187), (7, 3187)],
 [(3, 2031), (4, 380), (5, 1316)], [(0, 159), (6, 1548), (7, 391), (8, 21), (9, 1845)], [(2, 3), (4, 967), (5, 1149), (7, 795), (8, 4090)], [(0, 13), (1, 11), (2, 2), (3, 24), (4, 14), (7, 225), (8, 4), (9, 25)], [(1,
12), (3, 3997)], [(0, 32), (2, 3), (4, 45), (5, 1), (6, 372), (7, 1), (8, 293), (9, 74)], [(0, 162), (2, 2), (3, 2), (4, 198), (5, 1), (6, 36), (8, 894), (9, 10)], [(0, 258), (1, 3), (2, 699), (3, 79), (5, 77), (8, 236), (9, 3)], [(0, 1), (1, 1), (
2, 33), (3, 2), (4, 1684), (5, 1705), (6, 1), (7, 1), (8, 83)]]
# 20个client
(Pdb) p len(statistic)
20
# 每个client对应的标签和数量
(Pdb) p statistic[0]
[(0, 810), (6, 736), (7, 2092)]
(Pdb)

域自适应KD3A

http://localhost:1313/post/fl_da/

个性化-相互学习

http://localhost:1313/post/fl_pfl/

paper

面向非独立同分布数据的个性化联邦学习算法研究 paper

面向数据分布不平衡问题的联邦学习算法研究 paper

第二篇论文

fedala

ala 权重损失

如果 losses 的长度大于 self.num_pre_loss，并且最后 self.num_pre_loss 个 losses 元素的标准差小于 self.threshold

首先，ALA模块的主要目标是提供一个有效的初始化策略，使得每个客户端的本地模型能够在训练开始时就具备较好的起点。通过在第一轮本地初始化时训练到收敛，ALA模块能够确保初始模型已经充分学习到了全局和本地的数据特征，从而为后续的微调阶段打下坚实的基础。

其次，随着训练的进行，模型逐渐接近其最优解，此时再进行大规模的训练可能会导致过拟合或训练效率的降低。因此，在后续轮次中，微调成为了一个更为合适的选择。微调能够在保持模型基本结构不变的情况下，对模型参数进行小幅度的调整，以适应新的数据分布和学习任务。这种方式既能够避免过拟合，又能够提高训练效率。

此外，联邦学习的环境本身具有一些特殊性，例如数据分布的非独立同分布性和客户端之间的不平衡性。这些特性使得在每个客户端上独立训练模型变得更为困难。然而，通过ALA模块的初始化策略和后续的微调策略，FedALA算法能够在这样的环境下实现个性化的联邦学习，使得每个客户端的模型都能够更好地适应其本地数据。

综上所述，ALA模块仅在第一轮本地初始化时训练到收敛，而后续轮次只需要微调的原因在于：这样既能够确保初始模型的质量，又能够提高后续训练的效率；同时，这种策略也能够适应联邦学习环境的特殊性，实现个性化的本地聚合。

FedALA（Federated Adaptive Local Aggregation）算法中的ALA（Adaptive Local Aggregation）模块在第一轮本地初始化时进行训练到收敛的原因是为了建立一个全局的权重调整策略。这种策略能够根据用户的数据分布和模型性能，动态地调整各个本地模型更新在最终聚合模型中的权重。

在第一轮训练时，ALA模块学习如何根据用户的本地数据特性和模型性能来分配不同的权重，以便在后续的联邦学习过程中能够更好地整合各个用户的本地模型更新。一旦ALA模块在第一轮训练中收敛，它就找到了一个能够反映大多数用户数据分布和性能要求的权重调整方案。

在后续的联邦学习轮次中，由于ALA模块已经学会了如何根据用户的数据分布进行权重调整，因此只需要进行微调而不是完全重新训练。这样做的好处是：

  1. 效率提升：不需要在每一轮联邦学习中都从头开始训练ALA模块，这样可以显著减少计算资源的消耗和通信成本。
  2. 快速适应：通过微调，ALA模块可以迅速适应用户数据分布的微小变化，而不必经历完整的训练周期。
  3. 模型稳定性：已经收敛的ALA模块提供了一个稳定的权重调整框架，后续微调可以在此基础上进一步优化模型性能，而不会引入大的扰动。
  4. 个性化学习：在后续轮次中，ALA模块通过微调可以更好地支持个性化学习，即允许不同的用户拥有更适合自己数据分布的模型权重，从而提高整体的模型性能和用户满意度。

综上所述，FedALA算法中ALA模块在第一轮训练到收敛后，后续轮次只需微调是为了提高算法的效率，同时保持足够的灵活性以适应不断变化的数据分布，进而在保持数据隐私的前提下实现个性化的模型学习。

–

FedALA算法中ALA（Adaptive Local Aggregation）模块在第一轮本地初始化时训练到收敛的原因在于，ALA模块的目的是学习一个适用于所有参与用户的全局权重调整策略。这种策略能够反映用户数据分布的普遍特性和模型性能需求。

在第一轮训练中，ALA模块通过收集所有用户的本地模型更新并进行聚合，然后根据聚合后模型的性能反馈调整权重分配策略。这个过程会重复进行，直到找到一个稳定的权重分配方案，这个方案能够使得聚合后的全局模型在不同用户的数据上都有较好的性能表现。

一旦ALA模块在第一轮训练中收敛到一个稳定的权重调整策略，它就可以作为一个全局的元模型被应用到后续的联邦学习轮次中。在后续轮次中，虽然用户的本地数据可能会发生变化，但是ALA模块通过微调可以迅速适应这些变化，而不必进行完全的重新训练。

微调的好处在于，它可以在保持ALA模块已有的全局权重调整框架的基础上，进一步优化模型性能，同时节省计算资源和通信成本。此外，微调还可以使得ALA模块更好地支持个性化学习，即允许不同的用户拥有更适合自己数据分布的模型权重，从而提高整体的模型性能和用户满意度。

因此，FedALA算法中ALA模块在第一轮训练到收敛后，后续轮次只需微调的原因在于提高算法的效率、快速适应变化、保持模型稳定性以及支持个性化学习。

–

全局的元模型（Global Meta-Model）在工程和机器学习领域中指的是一个经过训练，能够捕捉和总结多个任务或数据集共同特性的模型。在联邦学习的背景下，全局元模型是指一个在多个设备或用户之间共享，能够整合不同数据源信息的模型。它通常在初始阶段通过多轮的训练和学习，从各个局部模型中提取共性，形成一个能够代表整体数据分布的模型。

在FedALA算法中，全局元模型就是ALA（Adaptive Local Aggregation）模块学习到的权重调整策略。这个策略在第一轮训练中收敛后，就成为了一个全局的元模型。在后续的联邦学习轮次中，这个全局元模型不需要重新训练，只需要根据新的数据和反馈进行微调，以适应可能的数据分布变化，确保模型的性能持续优化。全局元模型的存在使得算法能够在保持计算效率的同时，实现个性化学习和快速适应新的数据变化。

–

后续轮次不需要重新训练的原因在于，在初始阶段已经通过多次迭代学习到了一个全局的元模型，这个模型能够反映出参与学习的所有用户或任务的共同特征和模式。在联邦学习的上下文中，全局元模型是一个权重调整策略，它指导了如何根据不同用户的本地模型更新来进行有效的全局模型聚合。

一旦全局元模型在第一轮或初期训练中收敛，它就已经捕捉到了足够的信息来指导后续的学习过程。在后续的轮次中，尽管用户的本地数据可能会有所变化，但全局元模型已经具有了足够的泛化能力，能够通过微调来适应这些变化。微调是一个轻量级的过程，相比于从头开始的完整训练，它需要较少的计算资源和时间。

此外，重新训练全局元模型可能会导致之前学习到的知识丢失，特别是在数据分布相对稳定的情况下。微调能够在不破坏原有的全局知识结构的前提下，对模型进行局部优化，从而提高模型的整体性能和适应性。

综上所述，后续轮次不需要重新训练的核心原因是全局元模型已经学习到了足够的信息，并且具备了适应新数据变化的能力，通过微调即可实现性能的持续优化，而无需进行耗时且资源密集的完整训练过程。

–

本地模型自适应聚合模块的作用在于提高每个客户端的本地模型质量。该模块在每次本地训练之前，将全局模型与本地模型进行自适应聚合，以捕获全局模型中的有用信息，并用于初始化本地模型。这样做有助于解决全局模型对单个客户端同时具有期望和不期望的信息，泛化能力较差的问题。通过优先为每个客户端训练本地模型，该模块可以更好地适应不同客户端的数据分布特性，从而提高模型的性能和泛化能力。

此外，本地模型自适应聚合模块还具有降低通信开销的潜在优势。由于它仅下载一个全局模型并在每个客户端上传一个本地模型，因此与一些其他联邦学习方法相比，具有相同的通信开销。这种设计减少了客户端之间下载和上传模型的频率，从而降低了通信成本。

fedsoup

当前的 FL 算法面临着局部和全局性能之间的权衡。具体来说，个性化 FL 方法倾向于过度拟合本地数据，导致局部模型中的山谷尖锐，并抑制其泛化到分布外数据的能力。在本文中，我们提出了一种新的联邦模型汤方法（即模型参数的选择性插值）来优化局部和全局性能之间的权衡。具体来说，在联邦训练阶段，每个客户端通过监控局部模型和全局模型之间插值模型的性能来维护自己的全局模型池。这使我们能够减轻过度拟合并寻求平坦的最小值，这可以显着提高模型的泛化能力。

selective interpolation of model parameters

模型参数的选择性插值

根据某些标准（如参数的重要性、不确定性、与其他参数的关联性等）选择特定的模型参数进行插值。

这种选择性插值的目的通常是为了在保持模型性能的同时，减少计算复杂性、提高模型的鲁棒性或解决过拟合等问题。

**Weight Interpolation（权重插值）**是一种插值方法，其原理在于根据已知数据点的权重来估计未知数据点的值。这里的“权重”通常反映了已知数据点对未知数据点影响的大小或重要性。在进行权重插值时，会计算每个已知数据点的权重，并根据这些权重对它们进行加权平均，从而得到未知数据点的估计值。

权重插值的作用主要体现在以下几个方面：

  1. 提高估计准确性：通过合理地分配权重，权重插值可以使估计值更加接近真实值。在数据分布不均匀或存在噪声的情况下，这种方法尤其有效。
  2. 适应不同数据特性：权重插值可以根据数据的特性调整权重，使其更加适应不同的应用场景。例如，在处理具有空间相关性的数据时，可以根据距离或其他相关指标来设置权重。
  3. 灵活性：权重插值允许用户根据具体需求自定义权重分配方式。这使得它能够在各种复杂场景下进行有效的数据估计和预测。

总之，权重插值是一种灵活且有效的数据估计方法，它通过引入权重概念来提高估计的准确性和适应性。在机器学习、数据处理、地理信息系统等领域都有广泛的应用。

问题：

最近的研究 [28] 已经确定了当前 FL 算法的一个重要问题，即遇到分布变化时局部和全局性能之间的权衡。个性化 FL (PFL) 技术通常用于通过权衡每个客户端的分布内 (ID) 数据来解决数据异质性问题。例如，FedRep [5] 在本地更新期间学习整个网络，并从全局同步中保留部分网络。然而，它们有过度拟合本地数据的风险 [23]，尤其是当客户端本地数据有限时，并且在分布外 (OOD) 数据上的泛化能力较差。另一项工作通过正则化局部模型的更新来研究异质性问题。例如，FedProx[15]约束本地更新更接近全局模型。

评估 FL 泛化能力的一种有效方法是研究其在 [28] 之后的联合全局分布上的性能，它指的是在 ⋃{Di} 上测试 FL 模型，其中 Di 表示客户端 i 的分布 4。不幸的是，现有的工作没有发现个性化（局部）和共识（全局）模型之间的最佳点。

在异构设置（Di 6 = Dj）中，Dj 被视为客户端 i 的 OOD 数据。

我们发现 FL 中的过度个性化会导致对本地数据的过度拟合，并将模型捕获到损失景观的尖锐山谷中（对参数扰动高度敏感，参见第 2.2 节中的详细定义），从而限制了其泛化性。避免损失景观中尖锐山谷的有效策略是强制模型获得平坦的最小值。在集中式领域，权重插值已被探索为寻找平坦最小值的一种手段，因为它的解决方案更接近高性能模型的质心，这对应于更平坦的最小值 [11,3,6,24]。然而，对这些插值方法的研究在FL中被忽略了。

在此基础上，我们建议在联合训练过程中跟踪局部模型和全局模型，并执行模型插值来寻求最优平衡。我们的见解是从模型汤方法[27]中提取的，这表明具有相同初始参数的多个训练模型的平均权重可以增强模型的泛化能力。然而，原始模型汤方法需要训练具有不同超参数的大量模型，这在 FL 期间的通信方面可能非常耗时且成本高昂。鉴于通信成本高，无法在 FL 中从头开始训练，我们利用单个训练会话中不同时间点的全局模型作为使模型汤方法 [27] 适应 FL 的成分

我们提出了一种新的联邦模型汤方法(FedSoup)，从局部和全局模型生成集成模型，以实现更好的局部-全局权衡。第一个是时间模型选择，旨在选择合适的模型组合成一个模型。第二个模块是联邦模型修补[10]，它指的是一种微调技术，旨在在不影响已经令人满意的全局表现的情况下增强个性化。

对于第一个模块，时间模型选择，我们使用基于局部验证性能的贪心模型选择策略。这避免了合并可能位于不同错误景观盆地的模型，而不是局部损失景观（如图 1 所示）。因此，每个客户端都有自己的个性化全局模型汤，由基于其本地验证集选择的历史全局模型的子集组成。

图1：而我们的联邦模型汤方法通过寻找平坦最小值来平衡局部和全局损失。与之前的 pFL 方法相比，我们的方法引入了全局模型选择模块和 全局模型的局部模型插值（称为模型修补）

我们的主要贡献如下：（i）提出了一种新的 FL 方法，称为联邦模型 Soup（FedSoup），通过促进平滑度和寻求平坦最小值来提高泛化和个性化。(ii) FL 设计了一种新的时间模型选择机制，该机制维护一个具有时间历史全局模型的特定于客户端的模型汤，以满足个性化需求，同时不会产生额外的训练成本。(iii)在联邦客户端训练中引入了局部和全局模型之间的创新联邦模型修补方法，以缓解局部有限数据的过拟合。

数据划分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

# noiid 标签分布不平衡
#balance：数量平衡
# dir
python generate_mnist.py iid balance -

Total number of samples: 70000
The number of train samples: [2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2696]
The number of test samples: [874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 899]

Client 0         Size of data: 3495      Labels:  [0 1 2 3 4 5 6 7 8 9]
                 Samples of labels:  [(0, 345), (1, 393), (2, 349), (3, 357), (4, 341), (5, 315), (6, 343), (7, 364), (8, 341), (9, 347)]
--------------------------------------------------
Client 1         Size of data: 3495      Labels:  [0 1 2 3 4 5 6 7 8 9]
                 Samples of labels:  [(0, 345), (1, 393), (2, 349), (3, 357), (4, 341), (5, 315), (6, 343), (7, 364), (8, 341), (9, 347)]

每个类的数量一致

python generate_mnist.py iid - -

Total number of samples: 70000
The number of train samples: [1411, 2191, 992, 1853, 1303, 1632, 1461, 1067, 1401, 1326, 1470, 1380, 1632, 1377, 1570, 1470, 1362, 1055, 1158, 25381]
The number of test samples: [471, 731, 331, 618, 435, 544, 488, 356, 468, 442, 491, 460, 545, 459, 524, 491, 455, 352, 386, 8461]
数量不平衡

Client 0         Size of data: 1882      Labels:  [0 1 2 3 4 5 6 7 8 9]
                 Samples of labels:  [(0, 71), (1, 280), (2, 83), (3, 300), (4, 336), (5, 67), (6, 137), (7, 253), (8, 111), (9, 244)]
--------------------------------------------------
Client 1         Size of data: 2922      Labels:  [0 1 2 3 4 5 6 7 8 9]
                 Samples of labels:  [(0, 269), (1, 391), (2, 347), (3, 230), (4, 250), (5, 294), (6, 300), (7, 267), (8, 253), (9, 321)]

python generate_mnist.py noniid - pat
每个客户端两个类
且数量不平衡

Client 0         Size of data: 2334      Labels:  [0 1]
                 Samples of labels:  [(0, 1233), (1, 1101)]
--------------------------------------------------
Client 1         Size of data: 1318      Labels:  [0 1]
                 Samples of labels:  [(0, 407), (1, 911)]

Total number of samples: 70000
The number of train samples: [1750, 988, 2349, 5996, 996, 1545, 753, 7303, 2280, 2182, 1414, 3975, 1139, 1751, 1446, 6290, 1485, 1429, 1257, 6165]
The number of test samples: [584, 330, 784, 1999, 332, 516, 251, 2435, 761, 728, 472, 1325, 380, 584, 482, 2097, 495, 477, 419, 2056]

python generate_mnist.py noniid balance pat
两个类，数量平衡
Client 0         Size of data: 3694      Labels:  [0 1]
                 Samples of labels:  [(0, 1725), (1, 1969)]
--------------------------------------------------
Client 1         Size of data: 3694      Labels:  [0 1]
                 Samples of labels:  [(0, 1725), (1, 1969)]

Total number of samples: 70000
The number of train samples: [2770, 2770, 2770, 2773, 2649, 2649, 2649, 2651, 2463, 2463, 2463, 2463, 2656, 2656, 2656, 2657, 2583, 2583, 2583, 2586]
The number of test samples: [924, 924, 924, 925, 883, 883, 883, 884, 821, 821, 821, 822, 886, 886, 886, 886, 862, 862, 862, 862]

python generate_mnist.py noniid - dir
Total number of samples: 70000
The number of train samples: [1972, 374, 1222, 1905, 1437, 4641, 942, 951, 2700, 3004, 2337, 2829, 2709, 1600, 4297, 4086, 2721, 4239, 3949, 4577]
The number of test samples: [658, 125, 408, 636, 480, 1548, 314, 318, 900, 1002, 779, 943, 904, 534, 1433, 1362, 907, 1414, 1317, 1526]
Client 0         Size of data: 2630      Labels:  [0 1 4 5 7 8 9]
                 Samples of labels:  [(0, 140), (1, 890), (4, 1), (5, 319), (7, 29), (8, 1067), (9, 184)]
--------------------------------------------------
Client 1         Size of data: 499       Labels:  [0 2 5 6 8 9]
                 Samples of labels:  [(0, 5), (2, 27), (5, 19), (6, 335), (8, 6), (9, 107)]
--------------------------------------------------
Client 2         Size of data: 1630      Labels:  [0 3 6 9]
                 Samples of labels:  [(0, 3), (3, 143), (6, 1461), (9, 23)]
--------------------------------------------------
Client 3         Size of data: 2541      Labels:  [0 4 7 8]
                 Samples of labels:  [(0, 155), (4, 1), (7, 2381), (8, 4)]
--------------------------------------------------

python generate_mnist.py noniid balance dir
和上述区别不大
Client 0         Size of data: 2630      Labels:  [0 1 4 5 7 8 9]
                 Samples of labels:  [(0, 140), (1, 890), (4, 1), (5, 319), (7, 29), (8, 1067), (9, 184)]
--------------------------------------------------
Client 1         Size of data: 499       Labels:  [0 2 5 6 8 9]
                 Samples of labels:  [(0, 5), (2, 27), (5, 19), (6, 335), (8, 6), (9, 107)]
Total number of samples: 70000
The number of train samples: [1972, 374, 1222, 1905, 1437, 4641, 942, 951, 2700, 3004, 2337, 2829, 2709, 1600, 4297, 4086, 2721, 4239, 3949, 4577]
The number of test samples: [658, 125, 408, 636, 480, 1548, 314, 318, 900, 1002, 779, 943, 904, 534, 1433, 1362, 907, 1414, 1317, 1526]

np.random.seed(seed)
seed=42

Total number of samples: 70000
The number of train samples: [2728, 5209, 1135, 989, 2899, 956, 1587, 1353, 4683, 6686, 4760, 2795, 2973, 5253, 238, 3006, 615, 978, 1016, 2633]
The number of test samples: [910, 1737, 379, 330, 967, 319, 530, 451, 1562, 2229, 1587, 932, 991, 1751, 80, 1003, 206, 327, 339, 878]
Client 0         Size of data: 3638      Labels:  [0 6 7]
                 Samples of labels:  [(0, 810), (6, 736), (7, 2092)]
--------------------------------------------------
Client 1         Size of data: 6946      Labels:  [0 1]
                 Samples of labels:  [(0, 313), (1, 6633)]


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

test_metrics

(Pdb) p x.shape
torch.Size([16, 3, 32, 32])
(Pdb) p y.shape
torch.Size([16])
(Pdb) p y
tensor([9, 3, 3, 4, 4, 9, 9, 9, 3, 9, 2, 9, 4, 9, 9, 9])
(Pdb) p torch.argmax(output, dim=1)
tensor([8, 9, 8, 3, 8, 8, 8, 8, 8, 6, 8, 3, 8, 9, 3, 9])
(Pdb) p test_acc
2
(Pdb) p test_num
16

(Pdb) torch.argmax(torch.tensor(y_prob[0]), dim=1)
tensor([8, 9, 8, 3, 8, 8, 8, 8, 8, 6, 8, 3, 8, 9, 3, 9])
---
(Pdb) p y_prob.shape
(616, 10)

(Pdb) p auc
0.6709406214276344
(Pdb) p test_acc
79
(Pdb) p test_num
616

cifar10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

np.random.seed(seed)
seed=42

D:\Python\PycharmProjects\PFL-Non-IID-master\FedALA-main\FedALA-main\dataset>python generate_cifar10.py noniid - dir
Files already downloaded and verified
Files already downloaded and verified
Client 0         Size of data: 5237      Labels:  [0 2 7]
                 Samples of labels:  [(0, 3), (2, 39), (7, 5195)]
--------------------------------------------------
Client 1         Size of data: 4375      Labels:  [3 6 7 8]
                 Samples of labels:  [(3, 1450), (6, 119), (7, 719), (8, 2087)]
--------------------------------------------------
Client 2         Size of data: 459       Labels:  [2 5 7 9]
                 Samples of labels:  [(2, 2), (5, 74), (7, 6), (9, 377)]
--------------------------------------------------
Client 3         Size of data: 5278      Labels:  [0 2 5]
                 Samples of labels:  [(0, 1160), (2, 706), (5, 3412)]

Total number of samples: 60000
The number of train samples: [3927, 3281, 344, 3958, 3378, 3362, 3181, 454, 659, 2256, 2075, 2472, 2328, 2322, 2524, 1350, 1587, 1448, 3262, 825]
The number of test samples: [1310, 1094, 115, 1320, 1126, 1121, 1061, 152, 220, 753, 692, 824, 776, 774, 842, 451, 529, 483, 1088, 276]

fedsoup 生成数据集出错—直接复制fedala中划分的数据集

思路分析

https://kc.sustech.edu.cn/handle/2SGJ60CL/335781：

数据分布不平衡：

  • 数据标签分布不平衡
  • 数据特征分布不平衡

第一章

  • 研究现状
    • 联邦学习–以下挑战
      • 数据异质性：数据分布不同
      • 系统异质性：计算能力、存储能力、通信能力
      • 通信效率：传输参数或梯度
      • 隐私风险：参数也会带有信息
      • 模型安全：防御，攻击中毒
      • 公平性：公平分配资源-根据计算能力的差距
  • 应用
    • 教育–高效评估成绩 FEEDAN Federated Deep Knowledge Tracing（FDKT）
    • 医疗-医学图像 FedMoCo personalized retrogress-resilient framework for real-world medical federated learnin
    • 物联网–减少了上传的数据量和训练所需的通信轮数,区块链
    • 交通–交通流预测

第二章：

  • 优化目标和基本算法fedavg
  • 横向、纵向、迁移
  • 数据分布场景
    • 标签 标签分布不平衡和标签偏好不平衡
      • 标签分布倾斜是指不同客户端的标签分布 𝑃𝑛(𝑦) 不同，而他们的条件特征分 布 𝑃𝑛(𝑥|𝑦) 相同。不同客户端地理位置不容导致的。
        • 每个客户端只包含c(<nc)个类别，且每个类别的样本相同
        • Dirichlet 分布。客户端 𝑛 上类别 𝑐 的样本比例 超参数 𝛽 可以控制类别不平衡的程度。𝛽 越大，则客户端之间的类别不平衡越严重
      • 标签偏好不平衡出现的场景通常是，不同客户端上的样本有重叠，而对于相同的样本，不同的客户端会根据本身不同的偏好为该样本设置不同的标签值。
    • 特征 不同客户端的 𝑃𝑛(𝑥)(特征分布) 互不相同
      • 不重叠特征不平衡–不同客户端之间的特征不存在重叠。这种情况也成为纵向联邦学习
      • 部分重叠特征不平衡–不同客户端之间一部分的特征是共享的。每个客户端会保存不同角度的对于同一个物体的图片。
      • 完全重叠特征不平衡–客户端之间的特征完全重叠。可能是由于诸如扰动噪声等因素导致的，也可能是来自于不同的客户端产生数据时的偏好导致。对于相同的标签，不同风格的图片可以看作是完全重叠特征不平衡下的数据不平衡场景
    • 时序
      • 当客户端上保存的数据是时序数据时，可能会出现时序不平衡的场景。
      • 不同客户端上的数据出现时序不平衡的原因通常是不同的客户端保存不同的时间段的数据。例如客户端 A 保存第一季度的数据，而客户端 B 保存第二季度的数据。
    • 其他：客户端之间的样本数量不同时，会出现数量不平衡

第三章：实际工作

  • 问题描述
  • 相关工作
  • 算法
  • 实验

https://kc.sustech.edu.cn/handle/2SGJ60CL/335681

第一章

  • 背景意义
    • 挑战：通信成本、数据分布的异质性、隐私安全等
  • 研究现状

第二章

  • 联邦学习理论
    • 原理
    • 系统流程
    • 加密方式：同态加密、差分隐私、秘密分享
    • 三类别：横向。。
  • 挑战
    • 昂贵的通信成本–提高通信效率–模型压缩
    • 系统异质性–存储容量，计算能力，通信能力–heterofl根据算力实质模型复杂度
    • 数据分布异质性
      • 特征分布不平衡 –pi(y)不同，pi(x|y)分布相同
      • 标签分布不平衡 –pi(y)不同，pi(y|x)分布相同
      • 数据数量不平衡
      • 相关研究 fedprox scaffold fedbn
    • 隐私安全：同态加密 安全多方计算 差分隐私
  • 个性化联邦学习
    • 迁移学习方法
      • 基础层叠加个性化层 fedper fedhn
      • 对全局模型进行本地个性化处理 per-fedavg pfedme
    • 融合方法：全局模型与本地模型结合得到个性化模型 fedphp pfl-moe
    • 跨客户端协作：fedamp fedfomo

第三章：

  • 引言
  • 算法
    • 概述
    • 算法
  • 实验
    • 实验设置
    • 结果分析
    • 敏感度分析

https://kns.cnki.net/kcms2/article/abstract?v=N5T8oFSaxGEYs4Doh9eEcSrHZktsncl31hPAuMglYnEu6qlnCVdkW9oYhhIx1xCx_duAATgwuOyv6EeUr6IZTG8PTCeUO42oaRSaZVesShvff3kRB8A3rIdSbg4oqQjQeYFDuqJY3YHCm0gfgqfuGw==&uniplatform=NZKPT&language=CHS

面向数据异构场景的高效联邦学习算法研究与系统开发

第一章：

  • 背景意义
    • 隐私保护和分布式训练–fl
    • 挑战
      • 通信瓶颈 –结构化模型检核和梯度压缩减少 数据传输量；加速收敛减少通信回合
      • 数据异构性–fedprox，scaffold，moon
  • 研究挑战和创新
    • iid和数据种类分布不平衡；缓解模型偏移
    • 缓解随机采样导致模型的不稳定收敛
  • 相关工作
    • 本地训练改进
      • 正则化约束项 fedprox 抑制模型漂移，feddyn，
      • 偏差纠正 scaffold
      • 对比学习或可持续学习moon fedcl
    • 模型聚合改进
      • 自适应权重 fedadp自适应的给局部模型分配聚合权重
      • 标准化方法 fednova
      • 概率匹配 pfnm fedma
      • 梯度动量 fedavgm
    • 训练框架改进
      • 引入额外的模块或机制 引入层次聚类，数据监测机制

第二章：相关理论

  • 深度学习模型训练

    • 优化目标
    • 训练过程–前向传播，反向传播，梯度下降
    • SGD adam

  • 联邦学习

    • 联邦学习架构流程：损失函数 目标优化函数
    • 与传统分布式区别：四个特性
      • 数据非独立同分布
      • 数据量不平衡
      • 参与方数量很大
      • 慢速且不可靠的通信、
    • fedavg
    • 非独立同分布 它们的数据分布可能因为地理位置、时间段或者用户模 式不同而产生明显的差异性，并且这种分布的差异性通常是不可控的，而这种非 独立同分布的数据集会直接影响联邦学习的收敛性能
      • 特征分布不平衡（协方差偏移）：具有相同的条件概率p(y|x)，边缘概p(x)率不同
      • 标签分布不平衡(先验概率偏移)：p(x|y)相同，p(y)不同
      • 相同标签对应不同特征(概念偏移)
      • 相同特征对应不同标签（概念偏移）
      • 数据量偏移或不均衡

第三章：

  • 引言(不写标题)
  • 问题分析—包含模型偏移示例图
  • 算法
  • 算法流程
  • 实验流程
    • 不同数 据子集的数据分布情况如图 3-5 所示，其中，我们将β分别设置为 0.2 和 0.5。可 以看出，当 α 为 0.2 时，每个参与方拥有的数据类别更少，且数量更加不均衡。—可视化图
  • 实验结果

https://kns.cnki.net/kcms2/article/abstract?v=N5T8oFSaxGGjRjAfpY6RJGccJ9TwBduPUz-jKk4oyXpEADfNW51Dwh5Hra6gzuQoNqO9M96LqhHXh2HZGc397eEcJXw3zjAwD2ttRCYujZZq0Z88po_gV9TQ7cw2mI1FTgifv63oWyiV5tBj9L4NeQ==&uniplatform=NZKPT&language=CHS

面向异构数据的个性化联邦学习方法

智慧医疗、信贷金融风控、自动驾驶

第一章：

  • 研究背景和意义
    • 数据孤岛
    • 国内外研究现状
    • 主要挑战
      • 系统挑战–计算能力 通信能力 存储能力
      • 统计挑战–NO-IID
        • 增加正则化项，预处理客户端之间的数据
        • 个性化联邦
          • 基于相似度的方法–多任务学习，聚类学习
          • 基于结构的方法–参数解耦和 知识蒸馏
            • 参数解耦 基础层+个性化层
            • 知识蒸馏
      • 资源优化–信道状态更好、存储空间 更大和计算能力更强的客户端将负载更复杂的任务，相反，信道状态较差、存储 空间更小和计算能力更弱的客户端将负载更简单的任务。
      • 隐私保护

第二章：

  • 机器学习基础：
    • 无监督聚类算法
    • 人工神经网络 cnn rnn
    • 分布式机器学习
  • 联邦学习
    • 联邦学习与机器学习
    • 定义和分类，包含分类示意图
    • fedavg
  • 异构数据
    • 属性倾斜 特征
      • 数据属性部分重叠，完成不重叠
    • 标签倾斜
      • 标签分布倾斜–存储类似训练数据的客户端位置的差异所导致的
        • 标签大小不平衡–是不同客户端拥有的数据的标签类别是不平衡
        • 标签分布不平衡–指每个客户端中含有每一类标签的样本个 数是不平衡的
      • 标签偏好倾斜
    • noiid产生的模型偏移现象示意图

第三章：

  • 引言
  • 微调策略
  • 自适应更新权重
  • 算法
  • 结果分析 不同客户端类别数据分布示意图含 10 个客户端的不同类别数据分布示意图

数据孤岛 ：Federated machine learning: Concept and applications paper

随着AlphaGo的成功，人们自然会希望像AlphaGo这样的大数据驱动的人工智能将在我们的生活的所有方面很快实现。然而，现实世界的情况有些令人失望：除了少数行业外，大多数领域只有有限的数据或很差

质量数据，使人工智能技术的实现比我们认为更难。通过跨组织传输数据，是否有可能将数据融合在一起在公共站点。事实上，在许多情况下，打破数据源之间的障碍是非常困难的（如果不是不可能的话）。一般来说，任何 AI 项目所需的数据都涉及多种类型的。例如，在 AI 驱动的产品推荐服务中，产品卖家提供有关产品、用户购买数据的信息，而不是描述用户购买能力和支付习惯的数据。在大多数行业中，数据以孤立的岛屿的形式存在。由于行业竞争、隐私和安全和复杂的行政程序，即使是同一公司不同部门之间的数据集成也面临着沉重的阻力。几乎不可能整合分散在国家和机构周围的数据，或者禁止成本。

人工智能中的传统数据处理模型通常涉及简单的数据事务模型，一方收集和将数据传输到另一方，另一方将负责清理和融合数据。最后，第三方将采用集成数据并为其他各方构建模型以供使用。这些模型通常是作为服务出售的最终产品。这种传统程序面临着上述新数据法规和法律的挑战。此外，由于用户可能不清楚模型的未来用途，因此交易违反了 GDPR 等法律。因此，我们面临一个困境，即我们的数据以孤立的岛屿的形式，但我们在许多情况下禁止收集、融合和使用数据到不同的地方进行 AI 处理。如何合法地解决数据碎片化和隔离问题是当今人工智能研究人员和实践者的主要挑战。

分布式

联邦学习与分布式学习相比具有以下优势：

隐私保护：联邦学习通过在本地训练模型并仅共享模型更新，避免了中心化数据的隐私风险。

数据分散：联邦学习允许在不集中数据的情况下进行模型训练，从而解决了数据存储在不同地方的问题。

减少数据传输：相对于传统的分布式学习，联邦学习通过在本地进行计算，减少了在网络上传输数据的需求，从而降低了通信成本。

增量学习：联邦学习允许在本地进行增量学习，同时共享增量模型的更新，从而有效利用新数据而无需重新训练整个模型。

挑战

wss–研究现状

  • 通信效率
  • 隐私保护
  • 鲁棒性
  1. 统计挑战：由于联邦学习中的数据是分散存储在各个客户端上，且数据分布是非独立同分布的（Non-IID），这给模型的训练带来了很大的挑战。不同的客户端数据可能存在偏差或噪声，导致模型在全局范围内的性能下降。
  2. 隐私保护：尽管联邦学习通过仅共享模型而非原始数据来减少隐私泄露的风险，但仍存在一些潜在的隐私攻击手段，如梯度泄漏和模型反演等。这些攻击手段可能导致原始数据的敏感信息被泄露，从而威胁到用户的隐私安全。
  3. 通信效率：在联邦学习中，各个客户端需要定期上传本地模型的更新信息到服务器进行聚合。然而，由于网络带宽和延迟的限制，频繁的通信可能导致通信成本较高，影响模型的训练效率。
  4. 系统异构性：在实际的联邦学习场景中，各个客户端的设备性能、网络连接和电池电量等条件可能存在较大的差异。这种系统异构性可能导致部分客户端无法及时参与模型的训练，从而影响整体模型的性能。
  5. 安全和鲁棒性：联邦学习面临着各种安全威胁，如投毒攻击、后门攻击等。这些攻击可能导致模型在训练过程中被篡改或破坏，从而影响模型的准确性和可靠性。

为了应对这些挑战，研究者们提出了各种解决方案和技术，如差分隐私、安全多方计算、加密技术等，以增强联邦学习的安全性、隐私性和鲁棒性。同时，针对统计挑战和系统异构性等问题，研究者们也在不断探索和改进联邦学习的算法和架构，以提高其在实际应用中的性能和效率。

应用

  • 在智慧金融领域中，可以根据多方数据建立更准确的业务模型，从而实现合理定价、定向业务推广、企业风控评定等；
  • 在智慧城市中，实现各政府机构之间、企业与政府之间的联合，实现更准确的实时交通预测，更简化的机关办事步骤，更高效的信息内容查询，更全面的安全防控检测等；
  • 在智慧医疗中，联邦学习可以综合各医院之间的数据，提高医疗影像诊断的准确性，预警病人的身体情况等。

数据异构性

https://arxiv.org/pdf/1912.04977.pdf blog

https://xwzheng.gitbook.io/fl/03-efficiency_and_effectiveness

联邦学习中客户端数据Non-IID分布的五种类型： 类型1：Feature distribution skew (convariate shift) 类型2：Label distribution skew (prior probability shift) 类型3：Same label, different features (concept shift) 类型4：Same features, different label (concept shift) 类型5：Quantity skew or unbalancedness

  • 不同客户端数据分布不同

    (x,y)~P_j(x,y)

    • 特征分布倾斜：P(y|x)相同（条件概率），P_i(x)不同；不同人的笔迹不同
    • 标签分布倾斜：P(x|y)相同，P(y)不同；企鹅在只在南极、北极熊只在北极
    • 标签相同特征不同：P(y)相同，P(x|y)不同；概念飘移。同一个信息代表的含义不同，表示yes是点头/摇头
    • 特征相同标签不同：P_i(x)相同，P(y|x)不同；点头表示Yes / No?
    • 数量不平衡：客户端的数据量

  • 数据偏移：训练集测试集不同分布（训练草丛上的狗，无法识别海里的狗）

  • 非独立：可用节点大多在附近的时区（地理位置）（睡觉时手机的状态容易被选中）

大论文

第一章：

  • 背景和意义

    • 数据孤岛

    • 隐私保护

    • 联邦学习–与分布式的区别

    • 意义：应用

      • 教育–高效评估成绩 FEEDAN Federated Deep Knowledge Tracing（FDKT）

      • 医疗-医学图像 FedMoCo personalized retrogress-resilient framework for real-world medical federated learnin

      • 物联网–减少了上传的数据量和训练所需的通信轮数,区块链

      • 交通–交通流预测

      • 在智慧金融领域中，可以根据多方数据建立更准确的业务模型，从而实现合理定价、定向业务推广、企业风控评定等；

      • 在智慧城市中，实现各政府机构之间、企业与政府之间的联合，实现更准确的实时交通预测，更简化的机关办事步骤，更高效的信息内容查询，更全面的安全防控检测等；

      • 在智慧医疗中，联邦学习可以综合各医院之间的数据，提高医疗影像诊断的准确性，预警病人的身体情况等。

      • 智慧医疗、信贷金融风控、自动驾驶

  • 研究现状
    • 挑战：
      • 数据异构性 fedprox,fednova,fedu,scaffold,fedbn
      • 隐私保护-差分隐私
      • 通信效率
      • 系统异构性
      • 鲁棒性
    • 统计挑战：由于联邦学习中的数据是分散存储在各个客户端上，且数据分布是非独立同分布的（Non-IID），这给模型的训练带来了很大的挑战。不同的客户端数据可能存在偏差或噪声，导致模型在全局范围内的性能下降。
    • 隐私保护：尽管联邦学习通过仅共享模型而非原始数据来减少隐私泄露的风险，但仍存在一些潜在的隐私攻击手段，如梯度泄漏和模型反演等。这些攻击手段可能导致原始数据的敏感信息被泄露，从而威胁到用户的隐私安全。
    • 通信效率：在联邦学习中，各个客户端需要定期上传本地模型的更新信息到服务器进行聚合。然而，由于网络带宽和延迟的限制，频繁的通信可能导致通信成本较高，影响模型的训练效率。
    • 系统异构性：在实际的联邦学习场景中，各个客户端的设备性能、网络连接和电池电量等条件可能存在较大的差异。这种系统异构性可能导致部分客户端无法及时参与模型的训练，从而影响整体模型的性能。
  • 数据集与评价指标 ???
  • 存在问题和研究动机
    • 由联邦学习的数据异构性引出个性化联邦学习
    • 联邦学习存在的问题—尤其是数据异构场景—个性化联邦学习
    • 模型漂移
    • 对应三四章
  • 本文主要内容和组织架构

第二章：

  • 神经网络 cnn resnet

    • （1）卷积层。卷积层是CNN的核心，负责提取输入数据的局部特征。通过卷积操作，卷积层能够捕捉到图像中的边缘、角点、纹理等基础特征。卷积层由多个卷积核组成，从输入数据中提取多种不同的特征。（2）标准化层。标准化层对输入进行规范化处理，有助于缓解梯度消失或爆炸的问题，从而使得网络训练过程更加稳定，加快收敛速度，可以使得网络在不同数据分布之间具有更好的泛化能力。（3）激活层。激活层用于引入非线性因素，使得网络能够学习和表示复杂的函数关系，并提高其泛化能力。最常用的激活函数是ReLU（Rectified Linear Unit）函数，它将所有负值置为零，保留正值不变。（4）池化层。池化层也称为下采样层，用于降低特征图的空间维度，减少参数数量和计算量，同时保持特征的不变性。最常见的池化操作是最大池化（Max Pooling）和平均池化（Average Pooling）。（5）全连接层。全连接层位于CNN的末端，主要功能是将前面层学到的高级特征映射到最终的输出，如分类标签或回归值。（6）输出层。输出层是神经网络的最后一层，根据全连接层的结果给出最终的预测结果。在分类任务中，输出层通常使用softmax函数将全连接层的输出转换为概率分布。
    • 画图
    • resnethttps://blog.csdn.net/m0_64799972/article/details/132753608

  • 深度学习模型训练？？？

  • 联邦学习

    • fl 定义和分类
    • fedavg算法 优化目标

  • 数据异构性

    • 模型漂移
    • 特征分布不平衡与特征不同但标签相同的主要区别在于它们关注的侧重点不同。特征分布不平衡主要关注的是不同类别在特征空间上的分布差异，以及这种差异对模型性能的影响。而特征不同但标签相同则更多关注同一类别内样本的特征变化及其对模型识别能力的影响。

  • 个性化联邦学习

    • 两种策略:全局模型个性化、学习个性化的模型

第四章：

应用？

尤其是在医疗场景下，个性化联邦学习可以使得每个参与联邦学习的医院可以根据自己医院的实际情况获得更加符合自身医院需求的个性化模型[31, 34]。中期

2.1.2 深度学习模型训练

深度学习的训练过程本质上是求解优化问题的过程，它的优化目标是找到一 种最优的模型参数使得预先定义的损失函数达到最小值。损失函数通常被定义为 模型预测值与真实数据标签之间的距离，例如对于一个 N-分类问题，我们可以 将损失函数定义为输出类别概率分布与真实 one-hot 标签向量之间的交叉熵。 深度学习的训练过程主要分为前向传播、反向传播算法和梯度下降算法三个 部分。前向传播是模型由输入数据到输出预测值的计算过程，中间的计算步骤以 计算图的形式记录，用于后续的梯度计算。反向传播算法通过链式求导法则，沿 着模型输出侧到模型输入侧的方向对损失函数进行梯度求解，得到各层参数的梯 度值，其中，求导公式与每层前向计算的定义相关。梯度下降算法则是沿着损失 函数梯度的反方向更新模型参数，

2.2.2联邦学习经典算法fedavg

2.5 伪装目标检测主流数据集与评价指标 2.5.1 典型的伪装目标检测数据集

2.5.2 常用的性能评价指标

存在问题与研究动机

对照论文中的三四章—简单介绍数据异构场景带来的问题

引出联邦学习—引出工作内容

联邦学习存在的问题—尤其是数据异构场景—个性化联邦学习

根据现有的联邦学习的研究[10-12]，数据异构性问题会影响模型的有效性。由于每个客户端的数据分布和全局的数据分布有很大的不同，因此，每个本地客户端的局部最优模型和全局最优模型并不一致。尤其是本地更新比较大的时候，聚合后的平均模型会远离全局最优模型，局部模型和全局模型比集中训练更不稳定。与IID数据的分布式训练相比，FL的局部模型之间存在更严重的分歧[13]，这被称之为客户端漂移[11]。这一现象也说明了数据异构性现象严重损害了联邦学聚合模型的性能和收敛效率。

如图3所示

因此，深入研究并解决联邦学习中的数据异构性问题，对于提升模型性能、实现更为精准和可靠的预测具有重要意义

为了缓解客户端漂移，Wang等人[22]提出需要仔细的调整超参数。例如学习率和局部训练迭代，它直接决定局部模型移动的速度有多快，从而决定它们有多大漂移。然而，太小的学习率也意味着收敛速度较慢。因此，如何同时实现更快的训练速度和更有效缓解客户漂移很重要。为此，许多研究工作试图设计更有效的联邦学习算法来解决客户漂移问题。例如，通过添加正则化来校准局部模型的优化方向，限制局部模型与服务器模型之间的距离[23]。此外，Wang等人[24]提出对本地更新进行归一化，以消除局部和全局优化目标函数之间的不一致，对客户端更新进行纠正，加速和稳定收敛。除此之外由于在高度异构环境下模型收敛性差，并且缺少个性化方案，个性化联邦学习[25]逐渐兴起。个性化联邦学习为每个客户端用户生成一个个性化的客户端模型，而不是使用全局的共享模型，因此可以更加高效的利用本地客户端的局部知识以此来有效的缓解数据异构性的问题，满足参与联邦学习的用户更加个性化的需求。

由于在高度异构环境下模型收敛性差，并且缺少个性化方案，个性化联邦学习[16]逐渐兴起。个性化联邦学习为每个客户端用户生成一个个性化的客户端模型，而不是使用全局的共享模型，因此可以更加高效的利用本地客户端的局部知识以此来有效的缓解数据异构性的问题，满足参与联邦学习的用户更加个性化的需求。

尽管目前已有不少工作对个性化联邦学习进行研究，但是，个性化联邦学习仍然处于未成熟状态。本课题主要针对多源域自适应[17]的场景下进行个性化联邦学习的研究，该场景下多个源域的数据是有标签的，目标域的数据是没有标签的，需要通过迁移学习实现知识迁移。由于数据异构性的问题使得联邦学习聚合过程中遇到了很大的阻碍。简而言之，联邦学习的各个用户之间的数据的非独立同分布性，使得联邦学习在模型迁移方面会产生很大的困难，以及模型聚合方面需要花费更多的时间成本，而多源域自适应的场景下，客户端的数据来源于不同的域，不同域之间的特征不同，这种数据异构性的情况会更加突出[18]。此外，客户端用户加入联邦学习的目的是为了提升自身的收益，但是现有的联邦迁移学习的目标仅仅是为了提升目标域的性能，而忽略了联邦学习的场景下每个客户端的性能[19]。

本课题旨在通过个性化联邦学习的方法来提升数据异构场景下模型的性能，以及模型的收敛速度。基于知识投票的方法来实现对目标域数据的迁移，衡量客户端模型对全局模型的贡献程度来赋予客户端模型不同的权重进行模型聚合，提升模型迁移的性能；基于代理增强转移的方法，旨在提升目标域性能的同时，还可以提升源域的性能，满足每个客户端用户更加个性化的需求，提升每个客户端用户加入联邦学习的收益，以此也能吸引更多的用户加入联邦学习框架中。

三年很短，好像很多“本可以”。然而，时间匆匆如流水。很多事情，不亲身经历，永远不会明白别人的劝诫，即使知道，也不会执行，而是依然我行我素。

所幸，

$$ ( F_i(\theta) ) [ F(\theta) = \sum_{i=1}^{N} w_i F_i(\theta) ] $$