隐私计算实践6|联邦学习在水平场景的开发实践

leeyayai_xixihah

已于 2024-07-31 15:35:53 修改

阅读量607

点赞数 18

分类专栏：隐私计算文章标签： neo4j

于 2024-07-31 15:33:45 首次发布

本文链接：https://blog.csdn.net/leeyayai_xixihah/article/details/140821126

版权

隐私计算专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.设置多方安全计算环境--部署节点PYU

一：隐语水平联邦框架

树模型与网络模型

二：隐语 FLModel实战讲解

构建联邦数据集

定义模型--Flmodel

三：隐语水平XGB实战讲解

明文xgboost

密文xgboost

创建联邦数据

构造SFXgboost

四：上手实践

任务：花卉图片分类

1.设置多方安全计算环境--部署节点PYU

import secretflow as sf

# Check the version of your SecretFlow
print('The version of SecretFlow: {}'.format(sf.__version__))

# In case you have a running secretflow runtime already.
sf.shutdown()
sf.init(['alice', 'bob', 'charlie'], address="local", log_to_driver=False)
alice, bob, charlie = sf.PYU('alice'), sf.PYU('bob'), sf.PYU('charlie')

2.下载数据并提取

# The TensorFlow interface is reused to download images , and the output is a folder, as shown in the following figure.
import tempfile
import tensorflow as tf

_temp_dir = tempfile.mkdtemp()
path_to_flower_dataset = tf.keras.utils.get_file(
    "flower_photos",
    "https://secretflow-data.oss-accelerate.aliyuncs.com/datasets/tf_flowers/flower_photos.tgz",
    untar=True,
    cache_dir=_temp_dir,
)

3.数据加载与处理

定义了一个创建数据集构建器的函数 create_dataset_builder，它接受一些参数来设置数据加载器的行为，并返回一个 dataset_builder 函数，这个内部函数用于创建和返回训练和评估（验证）的数据加载器。

def create_dataset_builder(
    batch_size=32,
    train_split=0.8,
    shuffle=True,
    random_seed=1234,
):
    def dataset_builder(x, stage="train"):
        """ """
        import math

        import numpy as np
        from torch.utils.data import DataLoader
        from torch.utils.data.sampler import SubsetRandomSampler
        from torchvision import datasets, transforms

        # Define dataset
        flower_transform = transforms.Compose(
            [
                transforms.Resize((180, 180)),
                transforms.ToTensor(),
            ]
        )
        flower_dataset = datasets.ImageFolder(x, transform=flower_transform)
        dataset_size = len(flower_dataset)
        # Define sampler

        indices = list(range(dataset_size))
        if shuffle:
            np.random.seed(random_seed)
            np.random.shuffle(indices)
        split = int(np.floor(train_split * dataset_size))
        train_indices, val_indices = indices[:split], indices[split:]
        train_sampler = SubsetRandomSampler(train_indices)
        valid_sampler = SubsetRandomSampler(val_indices)

        # Define databuilder
        train_loader = DataLoader(
            flower_dataset, batch_size=batch_size, sampler=train_sampler
        )
        valid_loader = DataLoader(
            flower_dataset, batch_size=batch_size, sampler=valid_sampler
        )

        # Return
        if stage == "train":
            train_step_per_epoch = math.ceil(split / batch_size)

            return train_loader, train_step_per_epoch
        elif stage == "eval":
            eval_step_per_epoch = math.ceil((dataset_size - split) / batch_size)
            return valid_loader, eval_step_per_epoch

    return dataset_builder

4.切分，构建联邦数据

创建一个名为 data_builder_dict 的字典，其中的键是不同的参与方（在这个例子中是 alice 和 bob），而值是使用 create_dataset_builder 函数创建的数据集构建器。这个字典可以用于根据每个参与方的特定配置初始化数据加载器。
# prepare dataset dict
data_builder_dict = {
    alice: create_dataset_builder(
        batch_size=32,
        train_split=0.8,
        shuffle=False,
        random_seed=1234,
    ),
    bob: create_dataset_builder(
        batch_size=32,
        train_split=0.8,
        shuffle=False,
        random_seed=1234,
    ),
}

5. 定义 FLModel模型进行训练

定义了一个使用PyTorch构建的简单的卷积神经网络（CNN）类ConvRGBNet，它继承自secretflow.ml.nn.core.torch.BaseModule。这个网络设计用于处理彩色图像（RGB），并且可以用于分类任务。
from torch import nn

from secretflow.ml.nn.core.torch import BaseModule


class ConvRGBNet(BaseModule):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.network = nn.Sequential(
            nn.Conv2d(
                in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Flatten(),
            nn.Linear(16 * 45 * 45, 128),
            nn.ReLU(),
            nn.Linear(128, 5),
        )

    def forward(self, xb):
        return self.network(xb)
网络结构包括：

两个卷积层（nn.Conv2d），使用3x3的卷积核，第一个卷积层的输入通道是3（RGB图像），输出通道是16。
激活函数使用ReLU（nn.ReLU）。
池化层（nn.MaxPool2d），使用2x2的最大池化。
一个展平层（nn.Flatten），将多维的输入一维化，以便于全连接层处理。
两个全连接层（nn.Linear），第一个全连接层的输入特征数量是根据卷积层输出的尺寸计算得到的，输出特征数量是128；第二个全连接层将128维的特征映射到5个输出类别。

6.训练模型

使用 SecretFlow 框架构建一个基于 PyTorch 的联邦学习模型。代码展示了如何设置模型、损失函数、优化器、评估指标，并创建一个联邦学习模型实例。

device_list = [alice, bob]
aggregator = SecureAggregator(charlie, [alice, bob])
# prepare model
num_classes = 5

input_shape = (180, 180, 3)
# torch model
loss_fn = nn.CrossEntropyLoss
optim_fn = optim_wrapper(optim.Adam, lr=1e-3)
model_def = TorchModel(
    model_fn=ConvRGBNet,
    loss_fn=loss_fn,
    optim_fn=optim_fn,
    metrics=[
        metric_wrapper(
            Accuracy, task="multiclass", num_classes=num_classes, average='micro'
        ),
        metric_wrapper(
            Precision, task="multiclass", num_classes=num_classes, average='micro'
        ),
    ],
)

fed_model = FLModel(
    device_list=device_list,
    model=model_def,
    aggregator=aggregator,
    backend="torch",
    strategy="fed_avg_w",
    random_seed=1234,
)

定义设备列表:

device_list = [alice, bob]

这里定义了一个设备列表，包含了参与联邦学习的各方（在这个例子中是 alice 和 bob）。

创建安全聚合器:

aggregator = SecureAggregator(charlie, [alice, bob])

使用 SecureAggregator 类创建一个聚合器实例，这个聚合器由 charlie 管理，负责聚合来自 alice 和 bob 的模型更新。

准备模型参数:

num_classes = 5: 设置类别数为5，这通常对应于多分类问题中的类别数量。
input_shape = (180, 180, 3): 设置输入图像的尺寸和通道数，这里是180x180像素的RGB图像。

定义 PyTorch 模型:

model_def = TorchModel( model_fn=ConvRGBNet, loss_fn=loss_fn, optim_fn=optim_fn, metrics=[ # 评估指标... ], )

使用 TorchModel 类定义了一个 PyTorch 模型，其中包括：

model_fn=ConvRGBNet: 指定模型函数为之前定义的 ConvRGBNet 类。
loss_fn=nn.CrossEntropyLoss: 指定损失函数为交叉熵损失，适用于分类问题。
optim_fn=optim_wrapper(optim.Adam, lr=1e-3): 指定优化器为使用 optim.Adam 并包装成 SecretFlow 支持的优化器，学习率为1e-3。

定义评估指标:

metrics=[ metric_wrapper( Accuracy, task="multiclass", num_classes=num_classes, average='micro' ), metric_wrapper( Precision, task="multiclass", num_classes=num_classes, average='micro' ), ]

定义了评估模型性能的指标，包括准确率和精确率，都设置为多分类任务，并使用微平均（micro-average）方式。

创建联邦学习模型:

fed_model = FLModel( device_list=device_list, model=model_def, aggregator=aggregator, backend="torch", strategy="fed_avg_w", random_seed=1234, )

使用 FLModel 类创建一个联邦学习模型实例，其中包括：

device_list: 参与联邦学习的设备列表。
model: 定义好的模型。
aggregator: 安全聚合器实例。
backend="torch": 指定后端为 PyTorch。
strategy="fed_avg_w": 指定联邦学习策略为加权平均（可能指加权联邦平均算法）。
random_seed=1234: 设置随机种子以确保结果的可复现性。

leeyayai_xixihah

关注

18
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
隐私计算实践6|联邦学习在水平场景的开发实践

定义了一个使用PyTorch构建的简单的卷积神经网络（CNN）类ConvRGBNet，它继承自。这个网络设计用于处理彩色图像（RGB），并且可以用于分类任务。nn.Conv2d(),nn.ReLU(),nn.ReLU(),nn.ReLU(),两个卷积层（nn.Conv2d），使用3x3的卷积核，第一个卷积层的输入通道是3（RGB图像），输出通道是16。激活函数使用ReLU（nn.ReLU池化层（），使用2x2的最大池化。一个展平层（nn.Flatten。
复制链接

扫一扫

专栏目录