PFL联邦学习框架是基于pytorch开发的集成了多种联邦学习算法的联邦学习框架。

使用PFL框架可以通过简单的代码编写，和参数设置来完成一个联邦学习模型训练任务。

PFL框架优势

  • PFL目前集成了传统的FedAvg联邦学习算法和基于知识蒸馏的联邦学习算法。
  • 即将提供基于区块链的通信支持，结合知识蒸馏的联邦学习算法，为用户提供去中心化的联邦学习服务

PFL框架设计

在prepare_job阶段，模型方需要制定各种策略，设计好联邦学习任务。在run_time阶段，使用模型方生成的job协调fl_client客户端和fl_server服务端进行联邦学习训练。如图，PFL框架支持多对多的server和client通信模式。

prepare job：模型方准备联邦学习任务阶段

  • FederateSrategy:联邦学习算法策略选择，目前提供FED_AVG和FED_DISTILLATION两种选项
  • WorkModeStrategy:工作模式选择，目前可以选择单机模式和集群模式
  • TrainStrategy:训练策略，定义联邦学习任务的迭代次数
  • User-Defined-Model:定义好一个运行需要的模型类，用户自定义的模型类

FL Run-Time:使用模型方生成的job协调FLClient客户端和FLServer服务端进行联邦学习训练

  • FLClient:根据FederateStrategy来执行客户端对应的操作
  • FLServer:根据FederateStrategy来执行不同的启动策略

演示

使用单例模式进行演示

服务端的pfl_model,pfl_server和客户端的pfl_client

pfl_model.py

 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

# pfl_model:模型文件，定义训练时使用的模型，并且生成相应的联邦学习任务
from torch import nn
import torch.nn.functional as F
# pfl的核心策略包，包含pfl的工作模式策略，联邦学习算法策略和训练策略
import gfl.core.strategy as strategy
# pfl的任务管理包
from gfl.core.job_manager import JobManager


# 定义了一个简单的模型类net
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5, 1)
        self.conv2 = nn.Conv2d(20, 50, 5, 1)
        self.fc1 = nn.Linear(4 * 4 * 50, 500)
        self.fc2 = nn.Linear(500, 10)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2, 2)
        x = x.view(-1, 4 * 4 * 50)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)

        return x


if __name__ == "__main__":
    # 实例化模型model，和任务管理器job_manager
    model = Net()
    job_manager = JobManager()
    # 定义一个联邦学习任务job，工作模式设为单例模式，（也可以使用集群模式），联邦学习算法策略为联邦平均法，（也可以使用联邦蒸馏算法），epoch为3，模型类型为net
    job = job_manager.generate_job(work_mode=strategy.WorkModeStrategy.WORKMODE_STANDALONE,
                                   fed_strategy=strategy.FederateStrategy.FED_AVG, epoch=3, model=Net)
    # 向job_manager传入定义好的job和model
    job_manager.submit_job(job, model)

pfl_server.py

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

# 根据在pfl_model文件中设置的job参数
# 从server包中导入了FLStandaloneServer，再从strategy中导入的联邦学习策略算法FederateStrategy
from gfl.core.server import FLStandaloneServer
from gfl.core.strategy import FederateStrategy

FEDERATE_STRATEGY = FederateStrategy.FED_AVG

if __name__ == "__main__":
    # 定义好server的联邦学习方法策略为FederateStrategy,并启动server
    FLStandaloneServer(FEDERATE_STRATEGY).start()

# 运行后日志提示聚合开始

pfl_client.py

 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

import torch
from torchvision import datasets, transforms
# 导入pfl的相关包，包括客户端包，策略包，训练控制器
from gfl.core.client import FLClient
from gfl.core.strategy import WorkModeStrategy, TrainStrategy, LossStrategy
from gfl.core.trainer_controller import TrainerController

CLIENT_ID = 0

if __name__ == "__main__":
    # CLIENT_ID = int(sys.argv[1])
    # 数据集mnist的导入
    #手写数字数据集
    mnist_data = datasets.MNIST("D:\Python\PycharmProjects\pflttt\mnist_data", download=True, train=True, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.13066062,), (0.30810776,))
    ]))
    # 实例化一个客户端
    client = FLClient()
    # 获得服务器端的模型pfl
    gfl_models = client.get_remote_gfl_models()

    # 由于一个flclient可以参与多个job，所以获得的pflmodels也有可能是多个
    # 循环遍历这些模型
    for gfl_model in gfl_models:
        # 对于每个模型，要定义好优化集，optimize，和训练策略，train_strategy
        optimizer = torch.optim.SGD(gfl_model.get_model().parameters(), lr=0.01, momentum=0.5)
        train_strategy = TrainStrategy(optimizer=optimizer, batch_size=32, loss_function=LossStrategy.NLL_LOSS)
        # 并将策略传入到对应的pfl_model中，(不同的模型也可以设置不同的训练策略)
        gfl_model.set_train_strategy(train_strategy)

    # 调用TrainerController设置工作模式为单例模式，模型为pfl_models,数据为mnist数据集
    # 客户端id为0，curve设置本地是否显示训练曲线，concurrent_num为本地线程数
    # 启动TrainerController
    TrainerController(work_mode=WorkModeStrategy.WORKMODE_STANDALONE, models=gfl_models, data=mnist_data, client_id=CLIENT_ID,
                      curve=True, concurrent_num=3).start()

流程分析

运行pfl_model后可以看到，job已经生成并添加成功了。同时在日志文件中也有了相应的记录。 编写pfl_server以及pfl_client 先运行pfl_server，运行后日志提示聚合开始 然后运行pfl_client,可以看到client已经获取到了job，载入模型开始进行训练 等client完成一轮训练后，可以在server端看到第一轮的参数聚合在server端完成了。 训练完成后，会产生一个模型文件

当然pfl框架也可以使用集群模式进行训练 只需要在client和server文件中声明地址，并选择工作模式为集群模式即可 https://galaxylearning.github.io/quickstart/

GFL

A Decentralized Federated Learning Framework Based On Blockchain

GFL:一个基于区块链的去中心化联邦学习框架

Abstract：

当前的FL框架在恶意节点攻击下如何提高通信性能、保持安全性和鲁棒性是一个巨大的挑战。本文提出了一种基于区块链的去中心化的FL学习框架——银河联邦学习框架(Galaxy Federated Learning Framework, GFL)。GFL引入了一致哈希算法来提高通信性能，并提出了一种新的环形去中心化FL算法(RDFL)来提高分散FL性能和带宽利用率。此外，GFL还引入了星际文件系统(InterPlanetary File System, IPFS)和区块链，进一步提高了通信效率和FL的安全性。在恶意节点和非独立同分布（非IID）数据集的数据中毒情况下，提高通信性能和分散FL性能。

Introduction：

传统的FL框架使用中心化的体系结构，中心结点收集梯度或模型参数来更新全局模型。传统的压力和挑战：中心结点的通信压力和通信带宽瓶颈以及通信压力带来的中心结点的稳定性挑战。

提出了去中心化的FL框架：移除了中心结点，并在数据结点之间同步FL更新，然后执行聚合。在突破通信瓶颈和提高FL稳定性方面取得了一些进展，但是仍面临通信压力、分散FL性能和安全方面的挑战。用于同步FL更新的去中心化FL框架会造成更大的通信压力。由于数据节点中恶意节点的数据中毒以及非独立同分布（非IID）问题，现有去中心化FL框架中使用的聚合算法无法实现竞争性能。此外，现有去中心化FL框架的更新过程存在被篡改的安全风险，并且由于缺乏共识（协商一致）机制，无法追踪FL更新的来源。

为了解决上述问题，本文提出了一种基于区块链的去中心化FL框架——银河联邦学习框架（GFL）。GFL采用一致性哈希算法构建数据节点的环形拓扑，旨在降低通信压力，提高拓扑稳定性。此外，本文还设计了一种新颖的环形去中心化FL算法（RDFL）。在RDFL中引入了RingAllReduce算法和知识蒸馏，以提高带宽利用率和去中心化FL性能。此外，还引入了星际文件系统（IPFS）和区块链，以进一步提高分散FL的通信效率和安全性。

Consistent Hashing Algorithm:一致性哈希算法(Consistent Hashing Algorithm)。是一种分布式算法，常用于负载均衡。Memcached client也选择这种算法，解决将key-value均匀分配到众多cahce server上的问题。它可以取代传统的取模操作，解决了取模操作无法应对增删cached Server的问题 (增删server会导致同一个key,在get操作时分配不到数据真正存储的server，命中率会急剧下降)。简单来说，是将整个哈希值空间组织成一个虚拟的圆环，整个空间按顺时针方向组织。将各个服务器使用Hash进行一个哈希，具体可以选择服务器的ip或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置。将数据key使用相同的函数Hash计算出哈希值，并确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器。

RingAllReduce:ring allreduce是一种算法，其通信成本是恒定的并且与系统中GPU的数量无关，并且仅由系统中GPU之间的最慢连接确定; 事实上，如果你只考虑带宽作为通信成本的一个因素（并忽略延迟），那么ring allreduce是一种最佳的通信算法。（当您的模型很大时，这是对通信成本的一个很好的预估，并且您只需要较少数次数发送大量数据。）Ring allreduce中的GPU排列在一个逻辑环中。 每个GPU应该有一个左邻居和一个右邻居; 它只会向其右邻居发送数据，并从其左邻居接收数据。该算法分两步进行：第一步是scatter-reduce，然后是all-gather。 在scatter-reduce步骤中，GPU将交换数据，使得每个GPU最终得到最终结果的一部分。 在all-gather步骤中，GPU将交换这些块，以便所有GPU最终得到完整的最终结果。

IPFS:IPFS（InterPlanetary File System）叫星际文件传输系统，本质是一个基于点对点的分布式超媒体分发协议，它整合了分布式系统，为所有人提供全球统一的可寻址空间，因为他具有良好的安全性、较高的传输速度等特点，被认为是最有可能取代HTTP的新一代互联网协议。IPFS用基于内容的寻址替代传统的基于域名的寻址。用户不需要关心服务器的位置，不用考虑文件存储的名字和路径。我们将一个文件放到IPFS节点中，将会得到基于其内容计算出的唯一加密哈希值。哈希值直接反映文件的内容，哪怕只修改1比特，哈希值也会完全不同。当IPFS被请求一个文件哈希时，它会使用一个分布式哈希表找到文件所在的节点，取回文件并验证文件的哈希值，如果哈希值不符合，说明内容被篡改了。将传统的基于内容的地址替代基于域名的地址，也就是用户寻找的不是某个地址而是储存在某个地方的内容，不需要验证发送者的身份，而只需要验证内容的哈希，通过这样可以让网页的速度更快、更安全、更健壮、更持久。大文件会被切分成小的分块，下载的时候可以从多个服务器同时获取。IPFS的网络是不固定的、细粒度的、分布式的网络，可以很好的适应内容分发网络的要求。

Knowledge Distillation：知识蒸馏,培养一个能很好表现和概括的大模型。这就是所谓的教师模式。取你所有的数据，计算教师模型的预测值。包含这些预测的总数据集称为知识，而预测本身通常称为软目标。这就是知识提炼的步骤。利用之前获得的知识来训练较小的网络，称为学生模型。

blockchain:区块链(Blockchain)是分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式。”所谓共识机制是区块链系统中实现不同节点之间建立信任、获取权益的数学算法。区块链就是一种网络技术，通过程序员敲代码形成的网络，各方相互合作交易均可直接对接完成，不需要靠第三方平台，也就省去了中间的一些程序和费用(省时省力还省钱)，但为了合作或交易的安全，系统会将每一个参与者的动作广播给所有参与者，保障了整个过程的安全、透明，解决了信任问题。区块链准确的说就是“全中心”体系，就是链上的每个节点都是中心。不可删除，不可更改，这就是区块链技术。

contributions

  • 设计了一种新的去中心化FL数据节点拓扑机制，采用了一致性哈希算法。该机制能够显著降低通信压力，提高拓扑稳定性。据我们所知，这是第一次尝试在去中心化FL框架中为数据节点拓扑设计引入一致性哈希算法。
  • 提出了一种新的环分散联邦学习（RDFL）算法，旨在提高训练中的带宽利用率和分散联邦学习性能。
  • 为了提高去中心化的FL框架的通信性能和安全性，我们引入IPFS技术来降低系统通信压力，并引入区块链来提高FL的安全性。

  • 中心化FL：存在通信瓶颈和稳定性问题

  • 去中心化FL：基于八卦算法和模型分割的去中心化FL算法，点对点的去中心化FL算法，完全分散的FL算法，基于区块链的分散FL框架。在分散的FL性能和安全性方面面临挑战。

  • 解决通信问题：主要集中在研究新的通信压缩或模型压缩技术来降低通信压力。利用八卦算法提高带宽利用率，并通过模型分割降低通信压力。降低沟通压力的模型量化方法。通信压缩方法，以降低通信压力。

  • 提高Non-IID数据集上的FL性能：现有研究主要集中在集中式FL上，共享数据集，知识蒸馏。

    在分散FL场景中，为了提高非IID数据集上的分散FL性能和恶意数据节点的数据中毒，Li提出了一个分散FL框架，但在没有数据中毒的情况下，没有实现比联邦平均（FedAvg）更好的性能。

  • 保护数据隐私：现有的研究集中在新的防御方法上，如差分隐私和多方安全计算。也有研究将区块链技术应用于分散FL，以提高安全性。

The Proposed Framework

  • 描述了GFL中设计的拓扑机制如何利用一致性哈希算法为数据节点构建环形分散FL拓扑
  • 在GFL中描述了RDFL算法
  • 描述了GFL如何利用IPFS和区块链来降低通信压力和提高FL安全性

  1. Ring Decentralized FL Topology 环分散FL拓扑

    n个数据结点，可信任结点为m个，不可信任结点为n-m个。数据结点记作D={DP1,DP2,…,DPn}。GFL利用一致性散列算法构造了n个数据节点的环形拓扑。一致哈希值Hk=Hash(DPk^ip)。DPkip表示DPk的ip。数据节点分布在环上，根据一致的哈希值其值范围为[0,2^32−1] 。

    不受信任的数据节点将以顺时针方向将本地模型发送到环拓扑上最近的受信任数据节点。绿色数据节点表示受信任的数据节点，灰色数据节点表示不受信任的数据节点。在一致性哈希算法的帮助下，不同的不可信数据节点向不同的可信节点发送模型，有效降低了可信节点的通信压力。为了使可信节点在环上的分布更加均匀，GFL在环拓扑中引入可信节点的虚拟节点，进一步降低通信压力。带有红色虚线的绿色节点表示虚拟节点，如果不受信任的数据节点发现最近的受信任节点是顺时针方向的虚拟节点，它们将直接将模型发送到虚拟节点对应的受信任节点。

  2. RDFL Algorithm

    GFL基于一致性哈希算法构建的环形分散拓扑结构，开始执行RDFL算法。

    为了提高可信节点之间的带宽利用率，RDFL算法在一致性哈希算法中引入了RingAllReduce算法和顺时针原理来执行模型同步。

    • Train and Synchronize Model 每个数据节点加载用于本地训练的全局模型，并按顺时针方向同步其模型

      1. 每个数据节点DPk首先加载上一次迭代生成的全局模型GM进行局部训练，并获得一个新的局部模型MK。

      2. 非信任节点根据顺时针原则将本地模型发送到最近的信任节点。

      3. 受信任节点同步模型,以便所有受信任节点获得其余受信任节点的模型。

      4. m-1之后轮同步（r=m−1） ，所有受信任节点都具有其他受信任节点的模型

        ???：已经知道是不受信任结点的模型，为何还要发给信任结点，并全部同步？

    • Knowledge Distillation 利用知识蒸馏将可信节点拥有的其他模型的dark knowledge收敛到本地模型，并在可信节点之间同步本地模型

      1. 由于同步，每个受信任节点从其余受信任数据节点获取模型。
      2. 每个受信任节点在本地进行知识蒸馏
      3. teacher模型中的 dark knowledge 转移到知识较少的student模型中
      4. 可信节点利用RingAllReduce算法和顺时针规则同步可信节点的局部模型
      5. 同步后，所有受信任节点都具有其他受信任节点的本地模型。
      6. 在RDFL算法的知识蒸馏步骤中，每个可信节点DPk使用本地模型Mk作为学生，DPk拥有的剩余模型将用作教师，以将dark knowledge提取到Mk。RDFL利用KL散度来衡量模型之间的分布差异。为了避免恶意节点在不可信节点中的数据中毒，RDFL只允许前30%的模型与Mk的KL差异最小的模型作为教师模型。
      7. dark knowledge

    • Federated Averaging 每个受信任节点执行联合平均（FedAvg）以生成新的全局模型并开始下一次迭代

      1. 每个受信任节点DPK执行 FedAvg以获得新的全局模型。
      2. 然后，每个受信任节点根据环形拓扑将新的全局模型逆时针发送给不受信任的节点，并开始下一次迭代。

  3. IPFS and Blockchain

    数据节点之间的模型传输占用大量通信开销，并造成严重的通信压力。通信存在被篡改的安全风险，并且无法追踪模型的来源。

    • Communication Pressure：引入IPFS作为模型存储系统。IPFS由GFL中的可信节点组成。IPFS中的文件将被分成多个存储在不同节点上的片段，IPFS将生成与该文件对应的IPFS hash值。IPFS hash是一个46字节的字符串，可以通过IPFS hash从IPFS获取相应的文件。由于模型文件以片段形式存储在受信任节点中，因此数据隐私泄漏的风险进一步降低。
    • Communication Security：引入区块链作为通信系统。数据节点发送的IPFS hash以区块链交易的形式传输。每个交易都通过一致性算法进行验证，以降低篡改风险。由于区块链记录每个交易信息，GFL可以根据交易信息追溯到恶意节点。由于区块链的开放性，区块链上的任何节点都可以获取区块链中的交易信息。为了避免IPFS hash的泄漏，GFL对IPFS hash进行加密以保护数据节点的隐私。

Framework Design

  1. Architecture(架构)：GFL的架构由IPFS和区块链组成。对于区块链，GFL利用Ethereum作为区块链的实施平台。在GFL中，区块链由所有数据节点组成，IPFS由可信节点组成。可信数据节点是构成IPFS和区块链的节点，而不可信节点只是构成区块链的节点。

    智能合约(一种旨在以信息化方式传播、验证或执行合同的计算机协议)是部署在区块链上的协议，通过该协议，区块链可以执行比数字交易更多的功能。数据节点通过使用智能合约，将模型的IPFS hash以交易的形式发送到区块链。区块链首先执行共识机制，验证交易是否被篡改，如果验证通过，交易将打包到区块中。智能合约是以太坊生态系统搭建的关键角色。 当有人想要在以太坊完成某项任务时，他们会与一个或多个人发起一个智能合约。 这个合约其实是一系列的指令，使用编程语言“solidity”编写，这些语言在IFTTT逻辑（也就是IF-THIS-THEN-THAT逻辑）的基础上工作。 基本上，如果第一组指令已经完成，那么执行下一个功能，然后继续下一个功能，直到达到合同结束。

    GFL中有两种类型的智能合约。控制器合约负责控制所有FL任务的流程。存储合约负责存储模型的IPFS hash，每个FL任务都有一个独立的存储合约。

  2. Encryption Mechanism(加密机制)：由于区块链的可见性，区块链上的节点可以访问任何区块中的交易信息，不可信数据节点中存在恶意节点可能导致数据隐私泄露。为了解决数据隐私泄露问题，GFL采用RSA非对称加密算法和AES对称加密算法对交易信息进行加密。通过GFL的加密机制，对每个区块链交易中模型的IPFS hash进行加密，防止数据隐私泄露。

    如果DPh和DPk是第一次通信，DPk将生成AES密钥，并使用DPh的公钥对其进行加密，并在通信之前将其发送给DPh。DPh在收到AES密钥后利用其私钥对其进行解密。然后，DPh和DPk之间传输的IPFS hash将使用AES密钥加密。A将明文使用AES密钥加密，然后使用RSA公钥将密钥加密，发送给B；B接收到后用私钥打开获取到AES的密钥。保证了密钥的安全性，之后便可以通过AES通信。

视频

项目地址

galaxylearning官方网站

论文