目录
如果你对MindSpore感兴趣，可以关注昇思MindSpore社区
一、环境准备
1.进入ModelArts官网
云平台帮助用户快速创建和部署模型，管理全周期AI工作流，选择下面的云平台以开始使用昇思MindSpore，可以在昇思教程中进入ModelArts官网
选择下方CodeLab立即体验
等待环境搭建完成
2.使用CodeLab体验Notebook实例
下载NoteBook样例代码，.ipynb为样例代码
选择ModelArts Upload Files上传.ipynb文件
选择Kernel环境
在右侧切换规格为GPU架构
进入昇思MindSpore官网，点击上方的安装
获取安装命令
回到Notebook中，在第一块代码前加入三块命令
pip install --upgrade pip
conda install mindspore-gpu=1.9.0 cudatoolkit=10.1 -c mindspore -c conda-forge
pip install mindvision
依次运行即可
二、对抗样本定义
三、攻击方法
快速梯度符号攻击（FGSM）
产生的对抗扰动用公式可以表示为：
| 公式 | 序号 |
|---|---|
| η=εsign(∇xJ(θ)) | (1) |
对抗样本可公式化为：
| 公式 | 序号 |
|---|---|
| x′=x+εsign(∇xJ(θ,x,y)) | (2) |
- x：正确分类为“Pandas”的原始输入图像。
- y：是x的输出。
- θ：模型参数。
- ε：攻击系数。
- J(θ,x,y)：训练网络的损失。
- ∇xJ(θ)：反向传播梯度。
四、数据处理
本案例将使用MNIST训练一个精度达标的LeNet网络，然后运行上文中所提到的FGSM攻击方法，达到欺骗网络模型，让模型实现错误分类的效果。
以下示例代码将数据集下载并解压到指定位置。
from mindvision.dataset import Mnist
# 下载并处理MNIST数据集
download_train = Mnist(path="./mnist", split="train", shuffle=True, download=True)
download_eval = Mnist(path="./mnist", split="test", download=True)
dataset_train = download_train.run()
dataset_eval = download_eval.run()
下载的数据集文件的目录结构如下：
./mnist
├── test
│ ├── t10k-images-idx3-ubyte
│ └── t10k-labels-idx1-ubyte
└── train
├── train-images-idx3-ubyte
└── train-labels-idx1-ubyte
五、训练LeNet网络
实验中使用LeNet作为演示模型完成图像分类，这里先定义网络并使用MNIST数据集进行训练。
定义LeNet网络：
from mindvision.classification.models import lenet
network = lenet(num_classes=10, pretrained=False)
定义优化器与损失函数：
import mindspore.nn as nn
net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)
定义网络参数：
import mindspore as ms
config_ck = ms.CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)
ckpoint = ms.ModelCheckpoint(prefix="checkpoint_lenet", config=config_ck)
训练LeNet网络：
from mindvision.engine.callback import LossMonitor
model = ms.Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'accuracy'})
model.train(5, dataset_train, callbacks=[ckpoint, LossMonitor(0.01, 1875)])
测试此时的网络，可以观察到LeNet已经达到比较高的精度：
acc = model.eval(dataset_eval)
print("{}".format(acc))
六、实现FGSM
在得到精准的LeNet网络之后，下面将会采用FSGM攻击方法，在图像中加载噪声后重新进行测试。
先通过损失函数求取反向梯度：
class WithLossCell(nn.Cell):
"""包装网络与损失函数"""
def __init__(self, network, loss_fn):
super(WithLossCell, self).__init__()
self._network = network
self._loss_fn = loss_fn
def construct(self, data, label):
out = self._network(data)
return self._loss_fn(out, label)
class GradWrapWithLoss(nn.Cell):
"""通过loss求反向梯度"""
def __init__(self, network):
super(GradWrapWithLoss, self).__init__()
self._grad_all = ops.composite.GradOperation(get_all=True, sens_param=False)
self._network = network
def construct(self, inputs, labels):
gout = self._grad_all(self._network)(inputs, labels)
return gout[0]
然后根据公式（2）实现FGSM攻击：
import numpy as np
class FastGradientSignMethod:
"""实现FGSM攻击"""
def __init__(self, network, eps=0.07, loss_fn=None):
# 变量初始化
self._network = network
self._eps = eps
with_loss_cell = WithLossCell(self._network, loss_fn)
self._grad_all = GradWrapWithLoss(with_loss_cell)
self._grad_all.set_train()
def _gradient(self, inputs, labels):
# 求取梯度
out_grad = self._grad_all(inputs, labels)
gradient = out_grad.asnumpy()
gradient = np.sign(gradient)
return gradient
def generate(self, inputs, labels):
# 实现FGSM
inputs_tensor = ms.Tensor(inputs)
labels_tensor = ms.Tensor(labels)
gradient = self._gradient(inputs_tensor, labels_tensor)
# 产生扰动
perturbation = self._eps*gradient
# 生成受到扰动的图片
adv_x = inputs + perturbation
return adv_x
def batch_generate(self, inputs, labels, batch_size=32):
# 对数据集进行处理
arr_x = inputs
arr_y = labels
len_x = len(inputs)
batches = int(len_x / batch_size)
res = []
for i in range(batches):
x_batch = arr_x[i*batch_size: (i + 1)*batch_size]
y_batch = arr_y[i*batch_size: (i + 1)*batch_size]
adv_x = self.generate(x_batch, y_batch)
res.append(adv_x)
adv_x = np.concatenate(res, axis=0)
return adv_x
再次处理MINIST数据集中测试集的图片：
images = []
labels = []
test_images = []
test_labels = []
predict_labels = []
ds_test = dataset_eval.create_dict_iterator(output_numpy=True)
for data in ds_test:
images = data['image'].astype(np.float32)
labels = data['label']
test_images.append(images)
test_labels.append(labels)
pred_labels = np.argmax(model.predict(ms.Tensor(images)).asnumpy(), axis=1)
predict_labels.append(pred_labels)
test_images = np.concatenate(test_images)
predict_labels = np.concatenate(predict_labels)
true_labels = np.concatenate(test_labels)
七、运行攻击
由FGSM攻击公式中可以看出，攻击系数ε越大，对梯度的改变就越大。当ε 为零时则攻击效果不体现。
| 公式 | 序号 |
|---|---|
| η=εsign(∇xJ(θ)) | (3) |
现在先观察当ε为零时的攻击效果：
import mindspore.ops as ops
fgsm = FastGradientSignMethod(network, eps=0.0, loss_fn=net_loss)
advs = fgsm.batch_generate(test_images, true_labels, batch_size=32)
adv_predicts = model.predict(ms.Tensor(advs)).asnumpy()
adv_predicts = np.argmax(adv_predicts, axis=1)
accuracy = np.mean(np.equal(adv_predicts, true_labels))
print(accuracy)
再将ε设定为0.5，尝试运行攻击：
fgsm = FastGradientSignMethod(network, eps=0.5, loss_fn=net_loss)
advs = fgsm.batch_generate(test_images, true_labels, batch_size=32)
adv_predicts = model.predict(ms.Tensor(advs)).asnumpy()
adv_predicts = np.argmax(adv_predicts, axis=1)
accuracy = np.mean(np.equal(adv_predicts, true_labels))
print(accuracy)
从上面的打印结果可以看出，此时LeNet模型的精度大幅降低。
下面演示受攻击照片现在的实际形态，可以看出图片只是发生了很小的变化，然而在精度测试中却严重下降：
import matplotlib.pyplot as plt
%matplotlib inline
adv_examples = np.transpose(advs[:10], [0, 2, 3, 1])
ori_examples = np.transpose(test_images[:10], [0, 2, 3, 1])
plt.figure(figsize=(10, 3), dpi=120)
for i in range(10):
plt.subplot(3, 10, i+1)
plt.axis("off")
plt.imshow(np.squeeze(ori_examples[i]))
plt.subplot(3, 10, i+11)
plt.axis("off")
plt.imshow(np.squeeze(adv_examples[i]))
plt.show()
