使用CNN在MNIST上实现简单的攻击样本

王 茂南
王 茂南
王 茂南
2826
文章
75
评论
2019年5月28日07:14:18
评论 12840字阅读42分48秒
摘要关于测试MNIST，并且生成一些攻击样本。尝试一下这个方法。

简单原理

其实这个的原理和CNN可视化Convolutional Features很相似，简单来说，要看某个filter在检测什么，我们让通过其后的输出激活值较大。想要一些样本，有一个简单的想法就是让最后结果中是某一类的概率值变大，接着进行反向传播(固定住网络的参数)，去修改input. 下面有一个简单的图示：

使用CNN在MNIST上实现简单的攻击样本

下面看一下具体的实验.

具体实现

训练一个分类网络

下面的方法是一套比较通用的写法，训练别的网络的时候也是可以加以参考的。

首先我们训练一个CNN网络，可以用于手写数字的分类。首先导入需要使用的库。

  1. import time
  2. import csv, os
  3. import numpy as np
  4. import pandas as pd
  5. import matplotlib.pyplot as plt
  6. import cv2
  7. from cv2 import resize
  9. import torch
  10. import torch.nn as nn
  11. import torch.nn.functional as F
  12. from torch.utils.data.sampler import SubsetRandomSampler
  13. from torch.autograd import Variable
  14. import torch.utils.data as Data
  15. from sklearn import preprocessing
  16. import copycopy
  17. import torchvision
  18. import torchvision.transforms as transforms

接着定义绘制loss图像的函数。

  1. # ---------------
  2. # Visual The Loss
  3. # ---------------
  4. def draw_loss_acc(train_list,validation_list,mode='Loss'):
  5.     plt.style.use('seaborn')
  6.     fig = plt.figure(figsize=(10,5))
  7.     ax = fig.add_subplot(1, 1, 1)
  8.     # 设置间隔
  9.     data_len = len(train_list)
  10.     x_ticks = np.arange(1,data_len+1)
  11.     plt.xticks(x_ticks)
  12.     if mode == 'Loss':
  13.         plt.plot(x_ticks,train_list,label='Train Loss')
  14.         plt.plot(x_ticks,validation_list,label='Validation Loss')
  15.         plt.xlabel('Epoch')
  16.         plt.ylabel('Loss')
  17.         plt.legend()
  18.         plt.savefig('Epoch_loss.jpg')
  19.     elif mode == 'Accuracy':
  20.         plt.plot(x_ticks,train_list,label='Train Accuracy')
  21.         plt.plot(x_ticks,validation_list,label='Validation Accuracy')
  22.         plt.xlabel('Epoch')
  23.         plt.ylabel('Accuracy')
  24.         plt.legend()
  25.         plt.savefig('Epoch_Accuracy.jpg')

接着定义训练时需要使用的函数。

  1. # ----------------
  2. # Train the model
  3. # ----------------
  4. def train_model(model, criterion, optimizer, dataloaders, train_datalengths, scheduler=None, num_epochs=2):
  5.     """传入的参数分别是:
  6.     1. model:定义的模型结构
  7.     2. criterion:损失函数
  8.     3. optimizer:优化器
  9.     4. dataloaders:training dataset
  10.     5. train_datalengths:train set和validation set的大小, 为了计算准确率
  11.     6. scheduler:lr的更新策略
  12.     7. num_epochs:训练的epochs
  13.     """
  14.     since = time.time()
  15.     # 保存最好一次的模型参数和最好的准确率
  16.     best_model_wts = copycopy.deepcopy(model.state_dict())
  17.     best_acc = 0.0
  18.     train_loss = [] # 记录每一个epoch后的train的loss
  19.     train_acc = []
  20.     validation_loss = []
  21.     validation_acc = []
  22.     for epoch in range(num_epochs):
  23.         print('Epoch [{}/{}]'.format(epoch+1, num_epochs))
  24.         print('-' * 10)
  26.         # Each epoch has a training and validation phase
  27.         for phase in ['train', 'val']:
  28.             if phase == 'train':
  29.                 if scheduler != None:
  30.                     scheduler.step()
  31.                 model.train()  # Set model to training mode
  32.             else:
  33.                 model.eval()   # Set model to evaluate mode
  35.             running_loss = 0.0 # 这个是一个epoch积累一次
  36.             running_corrects = 0 # 这个是一个epoch积累一次
  38.             # Iterate over data.
  39.             total_step = len(dataloaders[phase])
  40.             for i, (inputs, labels) in enumerate(dataloaders[phase]):
  41.                 # inputs = inputs.reshape(-1, 28*28).to(device)
  42.                 inputs = inputs.to(device)
  43.                 labels = labels.to(device)
  44.                 # zero the parameter gradients
  45.                 optimizer.zero_grad()
  47.                 # forward
  48.                 # track history if only in train
  49.                 with torch.set_grad_enabled(phase == 'train'):
  50.                     outputs = model(inputs)
  51.                     _, preds = torch.max(outputs, 1) # 使用output(概率)得到预测
  53.                     loss = criterion(outputs, labels) # 使用output计算误差
  55.                     # backward + optimize only if in training phase
  56.                     if phase == 'train':
  57.                         loss.backward()
  58.                         optimizer.step()
  60.                 # statistics
  61.                 running_loss += loss.item() * inputs.size(0)
  62.                 running_corrects += torch.sum(preds == labels.data)
  63.                 if (i+1)%100==0:
  64.                     # 这里相当于是i*batch_size的样本个数打印一次, i*100
  65.                     iteration_loss = loss.item()/inputs.size(0)
  66.                     iteration_acc = 100*torch.sum(preds == labels.data).item() / len(preds)
  67.                     print ('Mode {}, Epoch [{}/{}], Step [{}/{}], Accuracy: {}, Loss: {:.4f}'.format(phase, epoch+1, num_epochs, i+1, total_step, iteration_acc, iteration_loss))
  69.             epoch_loss = running_loss / train_datalengths[phase]
  70.             epoch_acc = running_corrects.double() / train_datalengths[phase]
  71.             if phase == 'train':
  72.                 train_loss.append(epoch_loss)
  73.                 train_acc.append(epoch_acc)
  74.             else:
  75.                 validation_loss.append(epoch_loss)
  76.                 validation_acc.append(epoch_acc)
  77.             print('*'*10)
  78.             print('Mode: [{}], Loss: {:.4f}, Acc: {:.4f}'.format(
  79.                 phase, epoch_loss, epoch_acc))
  80.             print('*'*10)
  81.             # deep copy the model
  82.             if phase == 'val' and epoch_acc > best_acc:
  83.                 best_acc = epoch_acc
  84.                 best_model_wts = copycopy.deepcopy(model.state_dict())
  86.         print()
  88.     time_elapsed = time.time() - since
  89.     print('*'*10)
  90.     print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
  91.     print('Best val Acc: {:4f}'.format(best_acc))
  92.     print('*'*10)
  93.     # load best model weights
  94.     final_model = copycopy.deepcopy(model) # 最后得到的model
  95.     model.load_state_dict(best_model_wts) # 在验证集上最好的model
  96.     draw_loss_acc(train_list=train_loss,validation_list=validation_loss,mode='Loss') # 绘制Loss图像
  97.     draw_loss_acc(train_list=train_acc,validation_list=validation_acc,mode='Accuracy') # 绘制准确率图像
  98.     return (model,final_model)

定义全局变量，learning_rate与num_epochs等.

  1. # --------------------
  2. # Device configuration
  3. # --------------------
  4. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  6. # ----------------
  7. # Hyper-parameters 
  8. # ----------------
  9. num_classes = 10
  10. num_epochs = 3
  11. batch_size = 100
  12. validation_split = 0.05 # 每次训练集中选出10%作为
  13. learning_rate = 0.001

接着我们进行加载数据.

  1. # -------------
  2. # MNIST dataset 
  3. # -------------
  4. train_dataset = torchvision.datasets.MNIST(root='./',
  5.                                         train=True,
  6.                                         transform=transforms.ToTensor(),
  7.                                         download=True)
  9. test_dataset = torchvision.datasets.MNIST(root='./',
  10.                                         train=False,
  11.                                         transform=transforms.ToTensor())
  12. # -----------
  13. # Data loader
  14. # -----------
  15. test_len = len(test_dataset) # 计算测试集的个数
  16. test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
  17.                                         batch_size=batch_size,
  18.                                         shuffle=False)
  20. for (inputs,labels) in test_loader:
  21.     print(inputs.size())
  22.     print(labels.size())
  23.     break
  24. # ------------------
  25. # 下面切分validation
  26. # ------------------
  27. dataset_len = len(train_dataset)
  28. indices = list(range(dataset_len))
  29. # Randomly splitting indices:
  30. val_len = int(np.floor(validation_split * dataset_len)) # validation的长度
  31. validation_idx = np.random.choice(indices, size=val_len, replace=False) # validatiuon的index
  32. train_idx = list(set(indices) - set(validation_idx)) # train的index
  33. ## Defining the samplers for each phase based on the random indices:
  34. train_sampler = SubsetRandomSampler(train_idx)
  35. validation_sampler = SubsetRandomSampler(validation_idx)
  36. train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
  37.                                             sampler=train_sampler,
  38.                                             batch_size=batch_size)
  39. validation_loader = torch.utils.data.DataLoader(train_dataset,
  40.                                             sampler=validation_sampler,
  41.                                             batch_size=batch_size)
  42. train_dataloaders = {"train": train_loader, "val": validation_loader} # 使用字典的方式进行保存
  43. train_datalengths = {"train": len(train_idx), "val": val_len} # 保存train和validation的长度

模型的定义与模型的初始化.

  1. # -------------------------------------------------------
  2. # Convolutional neural network (two convolutional layers)
  3. # -------------------------------------------------------
  4. class ConvNet(nn.Module):
  5.     def __init__(self, num_classes=10):
  6.         super(ConvNet, self).__init__()
  7.         self.layer1 = nn.Sequential(
  8.             nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=2),
  9.             nn.BatchNorm2d(16),
  10.             nn.ReLU(),
  11.             nn.MaxPool2d(kernel_size=2, stride=2))
  12.         self.layer2 = nn.Sequential(
  13.             nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=2),
  14.             nn.BatchNorm2d(32),
  15.             nn.ReLU(),
  16.             nn.MaxPool2d(kernel_size=2, stride=2))
  17.         self.fc = nn.Linear(7*7*32, num_classes)
  19.     def forward(self, x):
  20.         out = self.layer1(x)
  21.         out = self.layer2(out)
  22.         out = out.reshape(out.size(0), -1)
  23.         out = self.fc(out)
  24.         return out
  26. # 模型初始化
  27. model = ConvNet(num_classes=num_classes).to(device)

定义损失函数与优化器，进行训练

  1. # -------------------
  2. # Loss and optimizer
  3. # ------------------
  4. criterion = nn.CrossEntropyLoss()
  5. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
  7. # -------------
  8. # 进行模型的训练
  9. # -------------
  10. (best_model,final_model) = train_model(model=model,criterion=criterion,optimizer=optimizer,dataloaders=train_dataloaders,train_datalengths=train_datalengths,num_epochs=num_epochs)
使用CNN在MNIST上实现简单的攻击样本

我们测试一下模型的效果。选取test中的第一个数据，为7.

使用CNN在MNIST上实现简单的攻击样本

接着带入模型进行预测，查看模型的结果。

  1. # 带入模型进行预测
  2. inputdata = test_dataset.data[0].view(1,1,28,28).float()/255
  3. inputdata = inputdata.to(device)
  4. outputs = model(inputdata)
  5. outputs
使用CNN在MNIST上实现简单的攻击样本
  1. # 查看预测结果
  2. torch.max(outputs, 1)
使用CNN在MNIST上实现简单的攻击样本

控制输出的概率, 看输出是什么

这里我们希望做的是：

  1. 初始随机一张图片
  2. 我们希望让分类中某个数的概率最大
  3. 最后看一下这个网络认为什么样的图像是这个数字

所以最终的步骤大概如下所示：

  1. 初始化一张图片, 28*28
  2. 使用上面训练好的网络，固定网络参数；
  3. 最后一层因为是10个输出(相当于是概率), 我们loss设置为某个的负的概率值
  4. 梯度下降, 使负的概率下降，即相对应的概率值上升，我们最终修改的是初始的图片
  1. # hook住模型
  2. layer = 2
  3. activations = SaveFeatures(list(model.children())[layer])
  5. # 超参数
  6. lr = 0.05 # 学习率
  7. opt_steps = 100 # 迭代次数
  8. upscaling_factor = 10 # 放大的倍数(为了最后图像的保存)
  10. # 保存迭代后的数字
  11. true_nums = []
  14. # 带入网络进行迭代
  15. for true_num in range(0,10):
  16.     # 初始化随机图片(数据定义和优化器一定要在一起)
  17.     # 定义数据
  18.     sz = 28
  19.     img = np.uint8(np.random.uniform(0, 255, (1, sz, sz)))/255
  20.     img = torch.from_numpy(img[None]).float().to(device)
  21.     img_var = Variable(img, requires_grad=True)
  22.     # 定义优化器
  23.     optimizer = torch.optim.Adam([img_var], lr=lr, weight_decay=1e-6)
  24.     for n in range(opt_steps):  # optimize pixel values for opt_steps times
  25.         optimizer.zero_grad()
  26.         model(img_var) # 正向传播
  27.         loss = -(activations.features[0, true_num]-activations.features[0].mean()) # loss相当于最大该层的激活的值
  28.         # loss = -activations.features[0, true_num]
  29.         loss.backward()
  30.         optimizer.step()
  31.     # 打印最后的img的样子
  32.     print(activations.features[0, true_num])
  33.     print(activations.features[0])
  34.     print('========')
  35.     img = img_var.cpu().clone()
  36.     img = img.squeeze(0)
  37.     # 图像的裁剪(确保像素值的范围)
  38.     img=1
  39.     img=0
  40.     true_nums.append(img)
  41.     unloader = transforms.ToPILImage()
  42.     img = unloader(img)
  43.     img = cv2.cvtColor(np.asarray(img),cv2.COLOR_RGB2BGR)
  44.     sz = int(upscaling_factor * sz)  # calculate new image size
  45.     img = cv2.resize(img, (sz, sz), interpolation = cv2.INTER_CUBIC)  # scale image up
  46.     cv2.imwrite('num_{}.jpg'.format(true_num),img)
  48. # 移除hook
  49. activations.close()

我们看最后输出的两个的效果，分别如下所示。

使用CNN在MNIST上实现简单的攻击样本

我们将生成的图片，重新放回进行预测，查看预测的结果：

使用CNN在MNIST上实现简单的攻击样本

可以看到，除了第一个数字0会预测错误，其他都是能正确分类。关于第一个分类错误的原因，是由于我们进行了像素的裁剪(小于0的等于0，大于1的等于1)

让正确的图片分类错误

这里的步骤基本是和上面相同的，除了初始化的步骤不相同。上面使用随机图片进行初始化，这里使用特定数字的图片进行初始化。

  1. 使用特定数字的图片，如数字7(初始化方式与前面的不一样)
  2. 使用上面训练好的网络，固定网络参数；
  3. 最后一层因为是10个输出(相当于是概率), 我们loss设置为某个的负的概率值
  4. 梯度下降, 使负的概率下降，即相对应的概率值上升，我们最终修改的是初始的图片
  5. 这样使得网络认为这张图片识别的数字的概率增加
  1. # hook住模型
  2. layer = 2
  3. activations = SaveFeatures(list(model.children())[layer])
  5. # 超参数
  6. lr = 0.005 # 学习率
  7. opt_steps = 70 # 迭代次数
  8. upscaling_factor = 10 # 放大的倍数(为了最后图像的保存)
  10. # 保存迭代后的数字
  11. true_nums = []
  13. # 带入网络进行迭代
  14. for true_num in range(0,10):
  15.     # 初始化随机图片(数据定义和优化器一定要在一起)
  16.     # 定义数据
  17.     sz = 28
  18.     # 将7变成0,1,2,3,4,5,6,7,8,9
  19.     img = test_dataset.data[0].view(1,1,28,28).float()/255
  20.     img = img.to(device)
  21.     img_var = Variable(img, requires_grad=True)
  22.     # 定义优化器
  23.     optimizer = torch.optim.Adam([img_var], lr=lr, weight_decay=1e-6)
  24.     for n in range(opt_steps):  # optimize pixel values for opt_steps times
  25.         optimizer.zero_grad()
  26.         model(img_var) # 正向传播
  27.         # 这里的loss确保某个值的输出大, 并且与原图不会相差很多
  28.         loss = -activations.features[0, true_num] + F.mse_loss(img_var,img)
  29.         loss.backward()
  30.         optimizer.step()
  31.     # 打印最后的img的样子
  32.     print(activations.features[0, true_num])
  33.     print(activations.features[0])
  34.     print('========')
  35.     img = img_var.cpu().clone()
  36.     img = img.squeeze(0)
  37.     # 图像的裁剪(确保像素值的范围)
  38.     img=1
  39.     img=0
  40.     true_nums.append(img)
  41.     unloader = transforms.ToPILImage()
  42.     img = unloader(img)
  43.     img = cv2.cvtColor(np.asarray(img),cv2.COLOR_RGB2BGR)
  44.     sz = int(upscaling_factor * sz)  # calculate new image size
  45.     img = cv2.resize(img, (sz, sz), interpolation = cv2.INTER_CUBIC)  # scale image up
  46.     cv2.imwrite('real7_regonize{}.jpg'.format(true_num),img)
  48. # 移除hook
  49. activations.close()

我们看一下最终的效果，最终会在原始的7的图片上进行修改，得到下面的图片，使得网络分类错误。

使用CNN在MNIST上实现简单的攻击样本

其实大致的思想都是类似的，都是固定网络参数，希望输出的某个概率最大，于是进行反向传播，更改输入的值，达到想要的效果。

代码仓库 : MNIST攻击样本

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南
  • 本文由 发表于 2019年5月28日07:14:18
  • 转载请务必保留本文链接：https://mathpretty.com/10499.html
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: