如何使用TensorFlow生成对抗样本

如果说卷积神经网络是昔日影帝的话,那么生成对抗已然成为深度学习研究领域中一颗新晋的耀眼新星,它将彻底地改变我们认知世界的方式。对抗学习训练为指导人工智能完成复杂任务提供了一个全新的思路,生成对抗图片能够非常轻松的愚弄之前训练好的分类器,因此如何利用生成对抗图片提高系统的鲁棒性是一个很有研究的热点问题。 神经网络合成的对抗样本很容易让人大吃一惊,这是因为对输入进行小巧精心制作的扰动就可能导致神经网络以任意选择的方式对输入进行错误地分类。鉴于对抗样本转移到物质世界,可以使其变得非常强大,因此这是一个值得关注的安全问题。比如说人脸识别,若一张对抗图像也被识别为真人的话,就会出现一些安全隐患及之后带来的巨大损失。对生成对抗图像感兴趣的读者可以关注一下最近的Kaggle挑战赛NIPS。

在这篇文章中,将手把手带领读者利用TensorFlow实现一个简单的算法来合成对抗样本,之后使用这种技术建立一个鲁棒的对抗性例子。

import tensorflow as tf
import tensorflow.contrib.slim as slim
import tensorflow.contrib.slim.nets as nets

tf.logging.set_verbosity(tf.logging.ERROR)
sess = tf.InteractiveSession()

首先,设置输入图像。使用tf.Variable而不是使用tf.placeholder,这是因为要确保它是可训练的。当我们需要时,仍然可以输入它。

image = tf.Variable(tf.zeros((299, 299, 3)))

接下来,加载Inception v3模型。

def inception(image, reuse):
    preprocessed = tf.multiply(tf.subtract(tf.expand_dims(image, 0), 0.5), 2.0)
    arg_scope = nets.inception.inception_v3_arg_scope(weight_decay=0.0)
    with slim.arg_scope(arg_scope):
        logits, _ = nets.inception.inception_v3(
            preprocessed, 1001, is_training=False, reuse=reuse)
        logits = logits[:,1:] # ignore background class
        probs = tf.nn.softmax(logits) # probabilities
    return logits, probs

logits, probs = inception(image, reuse=False)

接下来,加载预训练的权重。这个Inception v3的top-5的准确率为93.9%。

import tempfile
from urllib.request import urlretrieve
import tarfile
import os

data_dir = tempfile.mkdtemp()
inception_tarball, _ = urlretrieve(
    'http://download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz')
tarfile.open(inception_tarball, 'r:gz').extractall(data_dir)

restore_vars = [
    var for var in tf.global_variables()
    if var.name.startswith('InceptionV3/')
]

saver = tf.train.Saver(restore_vars)
saver.restore(sess, os.path.join(data_dir, 'inception_v3.ckpt'))

接下来,编写一些代码来显示图像,并对它进行分类及显示分类结果。

import json
import matplotlib.pyplot as plt

imagenet_json, _ = urlretrieve(
    'http://www.anishathalye.com/media/2017/07/25/imagenet.json')
    
with open(imagenet_json) as f:
    imagenet_labels = json.load(f)
    
def classify(img, correct_class=None, target_class=None):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 8))
    fig.sca(ax1)
    p = sess.run(probs, feed_dict={image: img})[0]
    ax1.imshow(img)
    fig.sca(ax1)
    
    topk = list(p.argsort()[-10:][::-1])
    topprobs = p[topk]
    barlist = ax2.bar(range(10), topprobs)
    
    if target_class in topk:
        barlist[topk.index(target_class)].set_color('r')
    if correct_class in topk:
        barlist[topk.index(correct_class)].set_color('g')
        
    plt.sca(ax2)
    plt.ylim([0, 1.1])
    plt.xticks(range(10),
               [imagenet_labels[i][:15] for i in topk],
               rotation='vertical')
    fig.subplots_adjust(bottom=0.2)
    plt.show()

示例图像

加载示例图像,并确保它已被正确分类。

import PIL
import numpy as np

img_path, _ = urlretrieve('http://www.anishathalye.com/media/2017/07/25/cat.jpg')
img_class = 281
img = PIL.Image.open(img_path)
big_dim = max(img.width, img.height)

wide = img.width > img.height
new_w = 299 if not wide else int(img.width * 299 / img.height)
new_h = 299 if wide else int(img.height * 299 / img.width)
img = img.resize((new_w, new_h)).crop((0, 0, 299, 299))
img = (np.asarray(img) / 255.0).astype(np.float32)

classify(img, correct_class=img_class)

对抗样本

给定一个图像X,神经网络输出标签上的概率分布为P(y|X)。当手工制作对抗输入时,我们想要找到一个X',使得logP(y'|X')被最大化为目标标签y',即输入将被错误分类为目标类。通过约束一些ℓ∞半径为ε的箱,要求‖X- X'‖∞≤ε,我们可以确保X'与原始X看起来不太一样。 在这个框架中,对抗样本是解决一个约束优化的问题,可以使用反向传播和投影梯度下降来解决,基本上也是用与训练网络本身相同的技术。算法很简单: 首先将对抗样本初始化为X'←X。然后,重复以下过程直到收敛:

1. X'←X^+α⋅∇logP(y'|X')

2. X'←clip(X',X - ε,X+ε)

初始化

首先从最简单的部分开始:编写一个TensorFlow op进行相应的初始化。

x = tf.placeholder(tf.float32, (299, 299, 3))

x_hat = image # our trainable adversarial input
assign_op = tf.assign(x_hat, x)

梯度下降步骤

接下来,编写梯度下降步骤以最大化目标类的对数概率(或最小化交叉熵)。

learning_rate = tf.placeholder(tf.float32, ())
y_hat = tf.placeholder(tf.int32, ())

labels = tf.one_hot(y_hat, 1000)
loss = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=[labels])
optim_step = tf.train.GradientDescentOptimizer(
    learning_rate).minimize(loss, var_list=[x_hat])

投影步骤

最后,编写投影步骤,使得对抗样本在视觉上与原始图像相似。另外,将其限定为[0,1]范围内保持有效的图像。

epsilon = tf.placeholder(tf.float32, ())

below = x - epsilon
above = x + epsilon
projected = tf.clip_by_value(tf.clip_by_value(x_hat, below, above), 0, 1)
with tf.control_dependencies([projected]):
    project_step = tf.assign(x_hat, projected)

执行

最后,准备合成一个对抗样本。我们任意选择“鳄梨酱”(imagenet class 924)作为我们的目标类。

demo_epsilon = 2.0/255.0 # a really small perturbation
demo_lr = 1e-1
demo_steps = 100
demo_target = 924 # "guacamole"

# initialization step
sess.run(assign_op, feed_dict={x: img})

# projected gradient descent
for i in range(demo_steps):
    # gradient descent step
    _, loss_value = sess.run(
        [optim_step, loss],
        feed_dict={learning_rate: demo_lr, y_hat: demo_target})
    # project step
    sess.run(project_step, feed_dict={x: img, epsilon: demo_epsilon})
    if (i+1) % 10 == 0:
        print('step %d, loss=%g' % (i+1, loss_value))
    

adv = x_hat.eval() # retrieve the adversarial example
step 10, loss=4.18923
step 20, loss=0.580237
step 30, loss=0.0322334
step 40, loss=0.0209522
step 50, loss=0.0159688
step 60, loss=0.0134457
step 70, loss=0.0117799
step 80, loss=0.0105757
step 90, loss=0.00962179
step 100, loss=0.00886694

这种对抗图像与原始图像在视觉上无法区分,没有可见的人为加工。但是它会以很高的概率分类为“鳄梨酱”。

classify(adv, correct_class=img_class, target_class=demo_target)

[图片上传失败...(image-7a063e-1515921665436)]

鲁棒的对抗样本

现在来看一个更高级的例子。遵循我们的方法来合成稳健的对抗样本,以找到对猫图像的单一扰动,这在某些选择的变换分布下同时对抗,可以选择任何可微分变换的分布;在这篇文章中,我们将合成一个单一的对抗输入,设置θ∈[- π/4,π/4],这对旋转是鲁棒的。 在继续下面的工作之前,检查一下之前的例子是否能对抗旋转,比如说设置角度为θ=π/8。

ex_angle = np.pi/8

angle = tf.placeholder(tf.float32, ())
rotated_image = tf.contrib.image.rotate(image, angle)
rotated_example = rotated_image.eval(feed_dict={image: adv, angle: ex_angle})
classify(rotated_example, correct_class=img_class, target_class=demo_target)

看起来我们之前生成的对抗样本不是旋转不变的! 那么,如何使得一个对抗样本对变换的分布是鲁棒的呢?给定一些变换分布T,我们可以最大化Et~TlogP(y'|t(X')),约束条件为‖X- X'‖∞≤ε。可以通过投影梯度下降法来解决这个优化问题,注意到∇EtTlogP(y'|t(X'))与EtT∇logP(y'|t(X'))相等,并在每个梯度下降步骤中来逼近样本。 可以使用一个技巧让TensorFlow为我们做到这一点,而不是通过手动实现梯度采样得到:我们可以模拟基于采样的梯度下降,作为随机分类器的集合中的梯度下降,随机分类器从分布中随机抽取并在分类之前变换输入。

num_samples = 10
average_loss = 0
for i in range(num_samples):
    rotated = tf.contrib.image.rotate(
        image, tf.random_uniform((), minval=-np.pi/4, maxval=np.pi/4))
    rotated_logits, _ = inception(rotated, reuse=True)
    average_loss += tf.nn.softmax_cross_entropy_with_logits(
        logits=rotated_logits, labels=labels) / num_samples

我们可以重复使用assign_op和project_step,但为了这个新目标,必须写一个新的optim_step。

optim_step = tf.train.GradientDescentOptimizer(
    learning_rate).minimize(average_loss, var_list=[x_hat])

最后,我们准备运行PGD来产生对抗输入。和前面的例子一样,选择“鳄梨酱”作为我们的目标类。

demo_epsilon = 8.0/255.0 # still a pretty small perturbation
demo_lr = 2e-1
demo_steps = 300
demo_target = 924 # "guacamole"

# initialization step
sess.run(assign_op, feed_dict={x: img})

# projected gradient descent
for i in range(demo_steps):
    # gradient descent step
    _, loss_value = sess.run(
        [optim_step, average_loss],
        feed_dict={learning_rate: demo_lr, y_hat: demo_target})
    # project step
    sess.run(project_step, feed_dict={x: img, epsilon: demo_epsilon})
    if (i+1) % 50 == 0:
        print('step %d, loss=%g' % (i+1, loss_value))
    

adv_robust = x_hat.eval() # retrieve the adversarial example
step 50, loss=0.0804289
step 100, loss=0.0270499
step 150, loss=0.00771527
step 200, loss=0.00350717
step 250, loss=0.00656128
step 300, loss=0.00226182

这种对抗图像被高度信任地归类为“鳄梨酱”,即使是旋转的情况下!

rotated_example = rotated_image.eval(feed_dict={image: adv_robust, angle: ex_angle})
classify(rotated_example, correct_class=img_class, target_class=demo_target)

[图片上传失败...(image-c6194d-1515921665436)]

下面来看一下在整个角度范围内产生的鲁棒对抗样本的旋转不变性,看P(y'|x')在θ∈[- π/4,π/4]。

thetas = np.linspace(-np.pi/4, np.pi/4, 301)

p_naive = []
p_robust = []
for theta in thetas:
    rotated = rotated_image.eval(feed_dict={image: adv_robust, angle: theta})
    p_robust.append(probs.eval(feed_dict={image: rotated})[0][demo_target])
    
    rotated = rotated_image.eval(feed_dict={image: adv, angle: theta})
    p_naive.append(probs.eval(feed_dict={image: rotated})[0][demo_target])

robust_line, = plt.plot(thetas, p_robust, color='b', linewidth=2, label='robust')
naive_line, = plt.plot(thetas, p_naive, color='r', linewidth=2, label='naive')
plt.ylim([0, 1.05])
plt.xlabel('rotation angle')
plt.ylabel('target class probability')
plt.legend(handles=[robust_line, naive_line], loc='lower right')
plt.show()

[图片上传失败...(image-90a84f-1515921665436)]

从图中蓝色曲线可以看到,生成的对抗样本是超级有效的。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏TensorFlow从0到N

TensorFlow从1到2 - 4 - 深入拆解CNN架构

本篇将拆开CNN架构,一探究竟。 ? 基于空间映射的架构 全连接网络架构存在一个“硬”伤:网络中各层神经元的一维排布方式,丢弃了图像的空间结构信息。 以MN...

48470
来自专栏人工智能

神经网络与反向传播算法

1、前言 先简单的说下神经网络吧。 简单来说就是模拟大脑的神经元。 前端会有一大批数据输入,例如,前端输入了一张图像的所有像素点。 中间层会有成千上万个网络数据...

21260
来自专栏CreateAMind

PPGN即插即用GAN:Ian Goodfellow推荐的最新模型 视频+多图

PPGN 整合了对抗训练、cnn特征匹配、降噪自编码、Langevin采样;在NIPS2016得到了Ian Goodfellow的介绍.

12310
来自专栏人工智能LeadAI

TensorFlow从1到2 | 第四章: 拆解CNN架构

上一篇 《TensorFlow从1到2 | 第三章: 深度学习革命的开端:卷积神经网络》 快速回顾了CNN的前世今生。 本篇将拆开CNN架构,一探究竟。 ? 基...

37970
来自专栏AI研习社

从编程实现角度学习 Faster R-CNN(附极简实现)

Faster R-CNN 的极简实现: github: simple-faster-rcnn-pytorch(http://t.cn/RHCDoPv ) 本文插...

1.2K50
来自专栏和蔼的张星的图像处理专栏

6. RCNN--Fast-RCNN--Faster-RCNN技术演进

分类已经学习过了四大网络(AlexNet,VGG,InceptionNer,ResNet),对于一个分类问题,数据量足够的话,根据分类复杂性搭建不同深度的卷积神...

19230
来自专栏技术随笔

[译] 基于R-FCN的物体检测题目:基于R-FCN的物体检测摘要简介方法相关工作实验总结与展望Reference

37660
来自专栏应兆康的专栏

机器学习概念:梯度下降

机器学习中大部分都是优化问题,大多数的优化问题都可以使用梯度下降/上升法处理,所以,搞清楚梯度算法就非常重要。

42890
来自专栏ATYUN订阅号

【教程】估算一个最佳学习速率,以更好地训练深度神经网络

对于训练深度神经网络来说,学习速率是调优的最重要的超参数之一。在这篇文章中,我将描述一个简单而有力的方法来找到一个合理的学习速率。这种方法是我从Fast AI网...

33460
来自专栏林欣哲

图像扩张

机器视觉中的图像识别问题,常常需要大量的数据,而带标签的数据需要人工标注,很难得到较多的数据。因此,我们需要使用图像扩张的方法,人工生成各种变换后的数据,扩大我...

383100

扫码关注云+社区

领取腾讯云代金券