Python深度学习（8）：DeepDream

算法简介

DeepDream是Google在2015年发出的一个比较好玩的算法。它的本意是去可视化神经网络。其思想简介就是，对于深度学习，以图片分类为例，我们最终的网络可以识别图像，是因为在训练过程中不断改变网络的参数值。那么我们能不能用已经训练好的网络去改变图片，使得网络相信该图片属于哪一类。听上去好像是可行的。
最终的效果就是，输入图片有点像某类的特征的地方会越来越明显。

Tips

1.需要将多层的过滤器激活同时最大化
具体做法：对一组靠近顶部的层激活的L2范数进行加权求和
2.输入图像在不同的尺度上进行处理
具体做法：每次在当前尺寸运行梯度上升后，将得到的图像放大40%

代码

from keras.applications import inception_v3
from keras import backend as K
import numpy as np
import scipy
from keras.preprocessing import image

K.set_learning_phase(0) #禁止所有与训练有关的操作
model = inception_v3.InceptionV3(weights = 'imagenet', include_top = False)
#构建不包含全连接层的Inception V3网络，使用在ImageNet权重上预训练的模型

#选择哪些层将其激活最大化，将他们的影响设一个权重值，靠近底部的层生成内容抽象，靠近顶部的层生成内容具体
layer_contributions = {'mixed2' : 0.2, 'mixed3' : 3., 'mixed4' : 2., 'mixed5' : 1.5}

layer_dict = dict([(layer.name, layer) for layer in model.layers]) #将层的名字映射为层的实例

loss = K.variable(0.) #定义损失函数的Variable

for layer_name in layer_contributions:
    coeff = layer_contributions[layer_name] #该层对应的影响系数
    activation = layer_dict[layer_name].output #该层的输出
    scaling = K.prod(K.cast(K.shape(activation), 'float32'))
    #将该层输出的L2范数添加到Loss去
    loss += coeff * K.sum(K.square(activation[:, 2 : -2, 2 : -2, :])) / scaling

dream = model.input #用于保存梦境图像
grads = K.gradients(loss, dream)[0] #计算损失相对于梦境图像的梯度
grads /= K.maximum(K.mean(K.abs(grads)), 1e-7) #梯度标准化，除以梯度绝对值的平均值

#设置函数，输入图片可以获取损失值和梯度值
outputs = [loss, grads]
fetch_loss_and_grads = K.function([dream], outputs)
#返回损失值和梯度值
def eval_loss_and_grads(x):
    outs = fetch_loss_and_grads([x])
    loss_value = outs[0]
    grad_values = outs[1]
    return loss_value, grad_values
#梯度上升算法
def gradient_ascent(x, iterations, step, max_loss = None):
    for i in range(iterations):
        loss_value, grad_values = eval_loss_and_grads(x)
        if max_loss is not None and loss_value > max_loss:
            break
        print('...Loss value as', i, ':', loss_value)
        x += step * grad_values
    return x

#修改图片大小
def resize_img(img, size):
    img = np.copy(img)
    factors = (1, float(size[0]) / img.shape[1], float(size[1]) / img.shape[2], 1)
    return scipy.ndimage.zoom(img, factors, order=1)
#保存图片
def save_img(img, fname):
    pil_img = deprocess_image(np.copy(img))
    scipy.misc.imsave(fname, pil_img)
#转换为Inception V3能够处理的张量
def preprocess_image(image_path):
    img = image.load_img(image_path)
    img = image.img_to_array(img)
    img = np.expand_dims(img, axis=0)
    img = inception_v3.preprocess_input(img)
    return img
#将张量转为图像
def deprocess_image(x):
    if K.image_data_format() == 'channels_first':
        x = x.reshape((3, x.shape[2], x.shape[3]))
        x = x.transpose((1, 2, 0))
    else:
        x = x.reshape((x.shape[1], x.shape[2], 3))
    x /= 2.
    x += 0.5
    x *= 255.
    x = np.clip(x, 0, 255).astype('uint8')
    return x

step = 0.1 #梯度上升的步长
num_octave = 3 #运行梯度上升的尺度个数
octave_scale = 1.4 #两个尺度之间大小比例
iterations = 20 #在每个尺度上运行梯度上升的步数

max_loss = 10 #损失最大范围，避免丑陋伪影

base_image_path = 'original.png'

img = preprocess_image(base_image_path) #图像转为numpy格式
original_shapes = img.shape[1:3] #存放原始图片的大小
successive_shapes = [original_shapes]#形状列表存放运行梯度上升时不同的图片尺度（每次是上一次的octave_scale倍）
for i in range(1, num_octave):
    shape = tuple([int(dim / (octave_scale ** i)) for dim in original_shapes])
    successive_shapes.append(shape)

successive_shapes = successive_shapes[::-1] #形状列表反转，变为升序
original_img = np.copy(img)
shrunk_original_img = resize_img(img, successive_shapes[0]) #将图像numpy数组大小缩放到最小尺寸

for shape in successive_shapes:
    print('Processing image shape', shape)
    img = resize_img(img, shape)
    img = gradient_ascent(img, iterations=iterations, step=step, max_loss=max_loss) #运行梯度上升，改变梦境图像
    upscaled_shrunk_original_img = resize_img(shrunk_original_img, shape) #将原始图像较小版本放大
    same_size_original = resize_img(original_img, shape) #在这个尺寸上计算原始图像的高质量版本
    lost_detail = same_size_original - upscaled_shrunk_original_img #丢失的细节

    img += lost_detail #将丢失的细节重新注入到梦境图像中
    shrunk_original_img = resize_img(original_img, shape) #把放大后的图像缩小为原大小
    save_img(img, fname = 'drean_at_scale_' + str(shape) + '.png') #保存图片

save_img(img, fname='final_dream.png')

最终效果：


改了一下层，使用更偏顶部的层后，大型车祸现场。
有兴趣的可以多试几个。

layer_contributions = {'conv2d_85' : 0.2, 'mixed9_0' : 3., 'mixed9' : 2., 'mixed9_1' : 1.5}

参考

Tensorflow实现