Pysyft学习笔记，11安全深度学习分类

您的数据很重要，您的模型也很重要

数据是机器学习的推动力 创建和收集数据的组织能够构建和训练自己的机器学习模型。这使他们能够向外部组织提供此类模型即服务（MLaaS）的使用。这对于某些组织很有用——他们无法自行创建这些模型，但仍希望使用此模型对自己的数据进行预测。

但是，托管在云中的模型仍然存在隐私/ IP问题。 为了让外部组织使用它——他们必须上传输入数据（例如要分类的图像）或下载模型。从隐私的角度来看，上传输入数据可能会出现问题，但是如果创建/拥有模型的组织不愿意，则下载模型可能不是一个选择。

计算加密数据

在这种情况下，一种潜在的解决方案是以一种方式对模型和数据进行加密，以允许一个组织使用另一组织拥有的模型，而无需将其IP彼此公开。存在几种允许对加密数据进行计算的加密方案，其中最为人熟知的类型是安全多方计算（SMPC），同态加密（FHE / SHE）和功能加密（FE）。我们将在这里集中讨论安全的多方计算（[在教程5的此处详细介绍](https://github.com/OpenMined/PySyft/blob/dev/examples/tutorials/Part%205%20-%20Intro% 20to％20Encrypted％20Programs.ipynb)），其中包含私有添加共享。它依赖于SecureNN和SPDZ等加密协议，[在此出色的博客文章中给出了详细信息](Private Image Analysis with MPC - Cryptography and Machine Learning /)。

这些协议在加密数据上实现了卓越的性能，并且在过去的几个月中，我们一直在努力使这些协议易于使用。具体来说，我们正在构建工具，使您可以使用这些协议，而不必自己重新实现协议（甚至不必知道其工作原理背后的加密方法）。让我们进去看看。

设定

本教程中的确切设置如下：考虑您是服务器，并且有一些数据。首先，您使用此私人训练数据定义和训练模型。然后，您与拥有自己的一些数据的客户联系，该客户希望访问您的模型以做出一些预测。

您对模型（神经网络）进行加密。客户端加密其数据。然后，您都使用这两个加密资产来使用模型对数据进行分类。 最后，预测结果以加密方式发送回客户端，以便服务器（即您）对客户端数据一无所知（您既不了解输入也不了解预测）。

理想情况下，我们将在“服务器”与“客户端”之间共享输入，对模型亦然。为了简单起见，共享将由另外两个工作机“alice”和“ bob”持有。 如果您认为alice由客户端拥有，而bob由服务器拥有，也是一样的。

该计算在许多MPC框架中是标准的半诚实（译者注：honest-but-curious，指的是遵循协议但会试图窃取隐私信息的敌手）敌手模型中是安全的。

万事俱备, 我们开始吧！

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms

'''
我们还需要执行特定于导入/启动PySyft的命令。
我们创建了一些工作程序（分别命名为“client”，“bob”和“ alice”）。 
最后，我们定义crypto_provider，它提供我们可能需要的所有加密原语（[请参阅我们在SMPC上的教程以了解更多详细信息]
(https://github.com/OpenMined/PySyft/blob/master/examples/tutorials/Part ％2009％20-％20Intro％20to％20Encrypted％20Programs.ipynb)。
'''

import syft as sy
hook = sy.TorchHook(torch)
client = sy.VirtualWorker(hook, id="client")
bob = sy.VirtualWorker(hook, id="bob")
alice = sy.VirtualWorker(hook, id="alice")
crypto_provider = sy.VirtualWorker(hook, id="crypto_provider")

epochs = 20

#我们定义学习任务的设置
class Arguments():
    def __init__(self):
        self.batch_size = 64
        self.test_batch_size = 50
        self.epochs = epochs
        self.lr = 0.001
        self.log_interval = 100

args = Arguments()

'''
数据加载并发送给工作人员
在我们的设置中，我们假设服务器有权访问某些数据以首先训练其模型。这是MNIST训练集。
'''

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.batch_size, shuffle=True)

#其次，客户端具有一些数据，并且希望使用服务器的模型对其进行预测。
# 该客户端通过在两个工作人员“alice”和“ bob”之间共享共享数据来加密其数据。
'''
SMPC使用要求在整数上工作的加密协议。
我们在这里利用PySyft张量抽象来使用.fix_precision()将PyTorch浮点张量转换为固定精度张量。例如，精度为2的0.123在第二个十进制数字处进行舍入，因此存储的数字为整数12。
'''

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.test_batch_size, shuffle=True)

private_test_loader = []
for data, target in test_loader:
    private_test_loader.append((
        data.fix_precision().share(alice, bob, crypto_provider=crypto_provider),
        target.fix_precision().share(alice, bob, crypto_provider=crypto_provider)
    ))

#前馈神经网络规范
#这是服务器使用的网络规范

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 500)
        self.fc2 = nn.Linear(500, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        return x

'''
启动训练
训练是在本地进行的，所以这是纯粹的本地PyTorch训练，这里没有什么特别的！
'''

def train(args, model, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        output = F.log_softmax(output, dim=1)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * args.batch_size, len(train_loader) * args.batch_size,
                100. * batch_idx / len(train_loader), loss.item()))
model = Net()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)

for epoch in range(1, args.epochs + 1):
    train(args, model, train_loader, optimizer, epoch)
def test(args, model, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            output = F.log_softmax(output, dim=1)
            test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss
            pred = output.argmax(1, keepdim=True) # get the index of the max log-probability
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)

    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))
test(args, model, test_loader)

#现在我们的模型已经过训练，可以随时提供服务！

'''
安全评估
现在，作为服务器，我们将模型发送给持有数据的工作人员。
由于模型是敏感信息（您已经花了很多时间优化它！），因此您不想透露其权重，因此像我们之前对数据集所做的那样，秘密共享模型。
'''

model.fix_precision().share(alice, bob, crypto_provider=crypto_provider)

'''
这个测试函数执行加密的评估。模型权重，数据输入，预测和用于评分的目标均已加密！
但是，语法与模型的纯PyTorch测试非常相似，不是很好吗？
我们从服务器端解密的唯一一件事是最后的最终分数，以验证预测的平均水平。
'''


def test(args, model, test_loader):
    model.eval()
    n_correct_priv = 0
    n_total = 0
    with torch.no_grad():
        for data, target in test_loader[:n_test_batches]:
            output = model(data)
            pred = output.argmax(dim=1)
            n_correct_priv += pred.eq(target.view_as(pred)).sum()
            n_total += args.test_batch_size
            # 此“测试”功能执行加密的评估。 模型权重，数据输入，预测和评分目标均已加密！
            # 但是，您可以看到，语法与普通的PyTorch测试非常相似！ 真好！

            # 我们从服务器端解密的唯一一件事是在200批次数据的末尾最终得分，以验证预测的平均水平。
            n_correct = n_correct_priv.copy().get().float_precision().long().item()

            print('Test set: Accuracy: {}/{} ({:.0f}%)'.format(
                n_correct, n_total,
                100. * n_correct / n_total))


# 在调用test函数之前定义n_test_batches
n_test_batches = 10  # 例如，设置为10个批次进行测试
test(args, model, private_test_loader)