<jupyter_start><jupyter_text>Part 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等加密协议，[在此出色的博客文章中给出了详细信息](https://mortendahl.github.io/2017/09/19/private-image-analysis-with-mpc /)。这些协议在加密数据上实现了卓越的性能，并且在过去的几个月中，我们一直在努力使这些协议易于使用。具体来说，我们正在构建工具，使您可以使用这些协议，而不必自己重新实现协议（甚至不必知道其工作原理背后的加密方法）。让我们进去看看。 设定本教程中的确切设置如下：考虑您是服务器，并且有一些数据。首先，您使用此私人训练数据定义和训练模型。然后，您与拥有自己的一些数据的客户联系，该客户希望访问您的模型以做出一些预测。您对模型（神经网络）进行加密。客户端加密其数据。然后，您都使用这两个加密资产来使用模型对数据进行分类。 最后，预测结果以加密方式发送回客户端，以便服务器（即您）对客户端数据一无所知（您既不了解输入也不了解预测）。理想情况下，我们将在“服务器”与“客户端”之间共享输入，对模型亦然。为了简单起见，共享将由另外两个工作机“alice”和“ bob”持有。 如果您认为alice由客户端拥有，而bob由服务器拥有，也是一样的。该计算在[许多MPC框架](https://arxiv.org/pdf/1801.03239.pdf)中是标准的半诚实（译者注：honest-but-curious，指的是遵循协议但会试图窃取隐私信息的敌手）敌手模型中是安全的。**万事俱备, 我们开始吧！**作者:- <NAME> - Twitter: [@theoryffel](https://twitter.com/theoryffel) · GitHub: [@LaRiffle](https://github.com/LaRiffle)中文版译者：- <NAME> - github：[@dljgs1](https://github.com/dljgs1)**Let's get started!**  导包以及模型规格<jupyter_code>import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms<jupyter_output><empty_output><jupyter_text>我们还需要执行特定于导入/启动PySyft的命令。我们创建了一些工作程序（分别命名为“client”，“bob”和“ alice”）。 最后，我们定义`crypto_provider`，它提供我们可能需要的所有加密原语（[请参阅我们在SMPC上的教程以了解更多详细信息](https://github.com/OpenMined/PySyft/blob/master/examples/tutorials/Part ％2009％20-％20Intro％20to％20Encrypted％20Programs.ipynb)。<jupyter_code>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")<jupyter_output><empty_output><jupyter_text>我们定义学习任务的设置<jupyter_code>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()<jupyter_output><empty_output><jupyter_text>数据加载并发送给工作人员在我们的设置中，我们假设服务器有权访问某些数据以首先训练其模型。这是MNIST训练集。<jupyter_code>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)<jupyter_output><empty_output><jupyter_text>其次，客户端具有一些数据，并且希望使用服务器的模型对其进行预测。该客户端通过在两个工作人员“alice”和“ bob”之间共享共享数据来加密其数据。> SMPC使用要求在整数上工作的加密协议。我们在这里利用PySyft张量抽象来使用.fix_precisio你（）将PyTorch浮点张量转换为固定精度张量。例如，精度为2的0.123在第二个十进制数字处进行舍入，因此存储的数字为整数12。<jupyter_code>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)
    ))<jupyter_output><empty_output><jupyter_text>前馈神经网络规范这是服务器使用的网络规范<jupyter_code>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<jupyter_output><empty_output><jupyter_text>启动训练训练是在本地进行的，所以这是纯粹的本地PyTorch训练，这里没有什么特别的！<jupyter_code>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)<jupyter_output><empty_output><jupyter_text>现在我们的模型已经过训练，可以随时提供服务！  安全评估 现在，作为服务器，我们将模型发送给持有数据的工作人员。由于模型是敏感信息（您已经花了很多时间优化它！），因此您不想透露其权重，因此像我们之前对数据集所做的那样，秘密共享模型。<jupyter_code>model.fix_precision().share(alice, bob, crypto_provider=crypto_provider)<jupyter_output><empty_output><jupyter_text>这个测试函数执行加密的评估。模型权重，数据输入，预测和用于评分的目标均已加密！但是，语法与模型的纯PyTorch测试非常相似，不是很好吗？我们从服务器端解密的唯一一件事是最后的最终分数，以验证预测的平均水平。<jupyter_code>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(args, model, private_test_loader)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13415685147945994, 'fraction_numerical': 0.019247342717609882, 'mean_word_length': 4.548207171314741, 'pattern_counts': {'":': 0, '<': 39, '<?xml version=': 0, '>': 40, 'https://': 7, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '151198', 'license': 'Apache-2.0', 'n_tokens_mistral': 3602, 'n_tokens_neox': 3783, 'n_words': 301, 'path': 'examples/tutorials/translations/chinese/Part 11 - Secure Deep Learning Classification.ipynb', 'repo_name': 'Bingyy/PySyft', 'size': '6968'}