使用成员推理测试模型安全性

使用成员推理测试模型安全性 - 图1

概述

成员推理是一种推测用户隐私数据的方法。隐私指的是单个用户的某些属性，一旦泄露可能会造成人身损害、名誉损害等后果。通常情况下，用户的隐私数据会作保密处理，但我们可以利用非敏感信息来进行推测。如果我们知道了某个私人俱乐部的成员都喜欢戴紫色墨镜、穿红色皮鞋，那么我们遇到一个戴紫色墨镜且穿红色皮鞋（非敏感信息）的人，就可以推断他/她很可能是这个私人俱乐部的成员（敏感信息）。这就是成员推理。

机器学习/深度学习的成员推理(MembershipInference)，指的是攻击者拥有模型的部分访问权限(黑盒、灰盒或白盒)，能够获取到模型的输出、结构或参数等部分或全部信息，并基于这些信息推断某个样本是否属于模型的训练集。利用成员推理，我们可以评估机器学习/深度学习模型的隐私数据安全。如果在成员推理下能正确识别出60%+的样本，那么我们认为该模型存在隐私数据泄露风险。

这里以VGG16模型，CIFAR-100数据集为例，说明如何使用MembershipInference进行模型隐私安全评估。本教程使用预训练的模型参数进行演示，这里仅给出模型结构、参数设置和数据集预处理方式。

本例面向Ascend 910处理器，您可以在这里下载完整的样例代码：

https://gitee.com/mindspore/mindarmour/blob/r1.0/examples/privacy/membership_inference/example_vgg_cifar.py

实现阶段

导入需要的库文件

引入相关包

下面是我们需要的公共模块、MindSpore相关模块和MembershipInference特性模块，以及配置日志标签和日志等级。

  1. import argparse
  2. import sys
  3. import math
  4. import os
  6. import numpy as np
  8. import mindspore.nn as nn
  9. from mindspore.train import Model
  10. from mindspore.train.serialization import load_param_into_net, load_checkpoint
  11. import mindspore.common.dtype as mstype
  12. from mindspore.common import initializer as init
  13. from mindspore.common.initializer import initializer
  14. import mindspore.dataset as de
  15. import mindspore.dataset.transforms.c_transforms as C
  16. import mindspore.dataset.vision.c_transforms as vision
  17. from mindarmour import MembershipInference
  18. from mindarmour.utils import LogUtil
  20. LOGGER = LogUtil.get_instance()
  21. TAG = "MembershipInference_test"
  22. LOGGER.set_level("INFO")

加载数据集

这里采用的是CIFAR-100数据集，您也可以采用自己的数据集，但要保证传入的数据仅有两项属性”image”和”label”。

  1. # Generate CIFAR-100 data.
  2. def vgg_create_dataset100(data_home, image_size, batch_size, rank_id=0, rank_size=1, repeat_num=1,
  3.                           training=True, num_samples=None, shuffle=True):
  4.     """Data operations."""
  5.     de.config.set_seed(1)
  6.     data_dir = os.path.join(data_home, "train")
  7.     if not training:
  8.         data_dir = os.path.join(data_home, "test")
  10.     if num_samples is not None:
  11.         data_set = de.Cifar100Dataset(data_dir, num_shards=rank_size, shard_id=rank_id,
  12.                                       num_samples=num_samples, shuffle=shuffle)
  13.     else:
  14.         data_set = de.Cifar100Dataset(data_dir, num_shards=rank_size, shard_id=rank_id)
  16.     input_columns = ["fine_label"]
  17.     output_columns = ["label"]
  18.     data_set = data_set.rename(input_columns=input_columns, output_columns=output_columns)
  19.     data_set = data_set.project(["image", "label"])
  21.     rescale = 1.0 / 255.0
  22.     shift = 0.0
  24.     # Define map operations.
  25.     random_crop_op = vision.RandomCrop((32, 32), (4, 4, 4, 4))  # padding_mode default CONSTANT.
  26.     random_horizontal_op = vision.RandomHorizontalFlip()
  27.     resize_op = vision.Resize(image_size)  # interpolation default BILINEAR.
  28.     rescale_op = vision.Rescale(rescale, shift)
  29.     normalize_op = vision.Normalize((0.4465, 0.4822, 0.4914), (0.2010, 0.1994, 0.2023))
  30.     changeswap_op = vision.HWC2CHW()
  31.     type_cast_op = C.TypeCast(mstype.int32)
  33.     c_trans = []
  34.     if training:
  35.         c_trans = [random_crop_op, random_horizontal_op]
  36.     c_trans += [resize_op, rescale_op, normalize_op,
  37.                 changeswap_op]
  39.     # Apply map operations on images.
  40.     data_set = data_set.map(operations=type_cast_op, input_columns="label")
  41.     data_set = data_set.map(operations=c_trans, input_columns="image")
  43.     # Apply repeat operations.
  44.     data_set = data_set.repeat(repeat_num)
  46.     # Apply batch operations.
  47.     data_set = data_set.batch(batch_size=batch_size, drop_remainder=True)
  49.     return data_set

建立模型

这里以VGG16模型为例，您也可以替换为自己的模型。

  1. def _make_layer(base, args, batch_norm):
  2.     """Make stage network of VGG."""
  3.     layers = []
  4.     in_channels = 3
  5.     for v in base:
  6.         if v == 'M':
  7.             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
  8.         else:
  9.             weight_shape = (v, in_channels, 3, 3)
  10.             weight = initializer('XavierUniform', shape=weight_shape, dtype=mstype.float32).to_tensor()
  11.             conv2d = nn.Conv2d(in_channels=in_channels,
  12.                                out_channels=v,
  13.                                kernel_size=3,
  14.                                padding=args.padding,
  15.                                pad_mode=args.pad_mode,
  16.                                has_bias=args.has_bias,
  17.                                weight_init=weight)
  18.             if batch_norm:
  19.                 layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU()]
  20.             else:
  21.                 layers += [conv2d, nn.ReLU()]
  22.             in_channels = v
  23.     return nn.SequentialCell(layers)
  26. class Vgg(nn.Cell):
  27.     """
  28.     VGG network definition.
  29.     """
  31.     def __init__(self, base, num_classes=1000, batch_norm=False, batch_size=1, args=None, phase="train"):
  32.         super(Vgg, self).__init__()
  33.         _ = batch_size
  34.         self.layers = _make_layer(base, args, batch_norm=batch_norm)
  35.         self.flatten = nn.Flatten()
  36.         dropout_ratio = 0.5
  37.         if not args.has_dropout or phase == "test":
  38.             dropout_ratio = 1.0
  39.         self.classifier = nn.SequentialCell([
  40.             nn.Dense(512*7*7, 4096),
  41.             nn.ReLU(),
  42.             nn.Dropout(dropout_ratio),
  43.             nn.Dense(4096, 4096),
  44.             nn.ReLU(),
  45.             nn.Dropout(dropout_ratio),
  46.             nn.Dense(4096, num_classes)])
  48.     def construct(self, x):
  49.         x = self.layers(x)
  50.         x = self.flatten(x)
  51.         x = self.classifier(x)
  52.         return x
  55. base16 = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M']
  58. def vgg16(num_classes=1000, args=None, phase="train"):
  59.     net = Vgg(base16, num_classes=num_classes, args=args, batch_norm=args.batch_norm, phase=phase)
  60.     return net

运用MembershipInference进行隐私安全评估

  1. 构建VGG16模型并加载参数文件。

    这里直接加载预训练完成的VGG16参数配置，您也可以使用如上的网络自行训练。

    1. ...
    2. # load parameter
    3. parser = argparse.ArgumentParser("main case arg parser.")
    4. parser.add_argument("--data_path", type=str, required=True, help="Data home path for dataset")
    5. parser.add_argument("--pre_trained", type=str, required=True, help="Checkpoint path")
    6. args = parser.parse_args()
    7. args.batch_norm = True
    8. args.has_dropout = False
    9. args.has_bias = False
    10. args.padding = 0
    11. args.pad_mode = "same"
    12. args.weight_decay = 5e-4
    13. args.loss_scale = 1.0 
    15. # Load the pretrained model.
    16. net = vgg16(num_classes=100, args=args)
    17. loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
    18. opt = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9,
    19.                   weight_decay=args.weight_decay, loss_scale=args.loss_scale)
    20. load_param_into_net(net, load_checkpoint(args.pre_trained))
    21. model = Model(network=net, loss_fn=loss, optimizer=opt)

  2. 加载CIFAR-100数据集，按8:2分割为成员推理模型的训练集和测试集。

    1. # Load and split dataset.
    2. train_dataset = vgg_create_dataset100(data_home=args.data_path, image_size=(224, 224),
    3.                                       batch_size=64, num_samples=5000, shuffle=False)
    4. test_dataset = vgg_create_dataset100(data_home=args.data_path, image_size=(224, 224),
    5.                                      batch_size=64, num_samples=5000, shuffle=False, training=False)
    6. train_train, eval_train = train_dataset.split([0.8, 0.2])
    7. train_test, eval_test = test_dataset.split([0.8, 0.2])
    8. msg = "Data loading completed."
    9. LOGGER.info(TAG, msg)

  3. 配置推理参数和评估参数

    设置用于成员推理的方法和参数。目前支持的推理方法有：KNN、LR、MLPClassifier和RandomForestClassifier。推理参数数据类型使用list，各个方法使用key为”method”和”params”的字典表示。

    1. config = [
    2.         {
    3.             "method": "lr",
    4.             "params": {
    5.                 "C": np.logspace(-4, 2, 10)
    6.             }
    7.         },
    8.         {
    9.             "method": "knn",
    10.             "params": {
    11.                 "n_neighbors": [3, 5, 7]
    12.             }
    13.         },
    14.         {
    15.             "method": "mlp",
    16.             "params": {
    17.                 "hidden_layer_sizes": [(64,), (32, 32)],
    18.                 "solver": ["adam"],
    19.                 "alpha": [0.0001, 0.001, 0.01]
    20.             }
    21.         },
    22.         {
    23.             "method": "rf",
    24.             "params": {
    25.                 "n_estimators": [100],
    26.                 "max_features": ["auto", "sqrt"],
    27.                 "max_depth": [5, 10, 20, None],
    28.                 "min_samples_split": [2, 5, 10],
    29.                 "min_samples_leaf": [1, 2, 4]
    30.             }
    31.         }
    32.     ]

    我们约定标签为数据集的是正类，标签为测试集的是负类。设置评价指标，目前支持3种评价指标。包括：

    • 准确率：accuracy，正确推理的数量占全体样本中的比例。

    • 精确率：precision，正确推理的正类样本占所有推理为正类中的比例。

    • 召回率：recall，正确推理的正类样本占全体正类样本的比例。 在样本数量足够大时，如果上述指标均大于0.6，我们认为目标模型就存在隐私泄露的风险。

    1.     metrics = ["precision", "accuracy", "recall"]

  4. 训练成员推理模型，并给出评估结果。

    1. inference = MembershipInference(model)                  # Get inference model.
    3. inference.train(train_train, train_test, config)        # Train inference model.
    4. msg = "Membership inference model training completed."
    5. LOGGER.info(TAG, msg)
    7. result = inference.eval(eval_train, eval_test, metrics) # Eval metrics.
    8. count = len(config)
    9. for i in range(count):
    10.     print("Method: {}, {}".format(config[i]["method"], result[i]))

  5. 实验结果。 执行如下指令,开始成员推理训练和评估：

    1. python example_vgg_cifar.py --data_path ./cifar-100-binary/ --pre_trained ./VGG16-100_781.ckpt

    成员推理的指标如下所示，各数值均保留至小数点后四位。

    以第一行结果为例：在使用lr（逻辑回归分类）进行成员推理时，推理的准确率（accuracy）为0.7132，推理精确率（precision）为0.6596，正类样本召回率为0.8810，说明lr有71.32%的概率能正确分辨一个数据样本是否属于目标模型的训练数据集。在二分类任务下，指标表明成员推理是有效的，即该模型存在隐私泄露的风险。

    1. Method: lr, {'recall': 0.8810,'precision': 0.6596,'accuracy': 0.7132}
    2. Method: knn, {'recall': 0.7082,'precision': 0.5613,'accuracy': 0.5774}
    3. Method: mlp, {'recall': 0.6729,'precision': 0.6462,'accuracy': 0.6522}
    4. Method: rf, {'recall': 0.8513, 'precision': 0.6655, 'accuracy': 0.7117}

参考文献

[1] Shokri R , Stronati M , Song C , et al. Membership Inference Attacks against Machine Learning Models[J].