Neo Sun


What's past is prologue

Deep Dream:理解深度神经网络结构及应用

  • ~10.64K words
  1. 1. 导入模型
  2. 2. Dream图像生成（以噪声为起点）
  3. 3. 完整程序

Deep Dream 项目简介

Deep Dream技术原理
Deep Dream 技术原理
最大化输出层输出的某一类别概率
最大化卷积层某一通道激活值
导入ImageNet图像分类模型
经典CNN
经典CNN———AlexNet
主要贡献：
— 防止过拟合：数据增强（data augmentation）, Dropout
— GPU实现：将网络分布在两个GPU上，且GPU之间在某些层能够互相通信。
— 非线性激活：ReLU
— 大数据训练：120万ImageNet图像数据集
经典CNN——AlexNet
dropout
经典CNN——VGGNet
经典CNN——GoogleNet
经典CNN——ResNet
经典CNN——ResNet
模型的加载
Tensorflow提供了以下两种方式来存储和加载模型：
生成检查点文件（checkpoint file）, 扩展名一般为.ckpt，通过在tf.train.Saver对象上调用Saver.save()生成，通过saver.restore()来加载。
生成图协议文件（graph proto file），这是一个二进制文件，扩展名一般为.bp，用tf.train.write_graph()保存，然后使用tf.import_graph_def()来加载图。

图的保存与加载
图像预处理——增加维度
• 使用的图像数据格式通常是（height,width,channel），只能表示一张图像；
• 而Inception模型要求的输入格式却是（batch，height， width, channel），
即同时将多张图像送入网络
tf.expand_dims(input, dim, name=None)
Returns:
A Tensor. Has the same type as input. Contains the same data as input, but itsshape has an additional dimension of size 1 added.
向tensor中插入维度1，插入位置就是参数代表的位置（维度从0开始）
图的基本操作
⚫ 建立图、获得默认图、重置默认图
(tf.Graph()，tf.get_default_graph()，tf.reset_default_graph())
⚫ 获取张量
⚫ 获取节点操作

在图像保存的过程中，我遇到一个问题：
引用全局变量提示：local variable referenced before assignment.
症结归因：
在网上查了python3使用toimage()函数的场景，发现这个函数已经弃用（deprecated），很多教程推荐降低第三方scipy的版本来配合toimage()函数的使用，无法从根本上解决问题，况且技术更新迭代是不可避免的，我们需要顺势而为。
解决方案：
使用matplotlib模块中image下的.imsave()函数，将numpy数组转成图片保存。具体代码如下：

1
2
from matplotlib import image
image.imsave(filename,image_array,cmap='gray')  # cmap常用于改变绘制风格，如黑白gray

导入模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from __future__ import print_function
import os
from io import BytesIO
import numpy as np
from functools import partial
import PIL.Image 
import scipy.misc
import tensorflow as tf
#创建图和会话
graph = tf.Graph()
sess = tf.InteractiveSession(graph=graph)
#导入模型
model_fn = 'tensorflow_inception_graph.pb'#导入Inception网络
# tensorflow_inception_graph.pb文件的下载：
# https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip
 
#with tf.gfile.FastGFile(model_fn, 'rb') as f:
with tf.gfile.GFile(model_fn, 'rb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())

# 定义输入图像的占位符
t_input = tf.placeholder(np.float32, name='input')
 
#图像预处理——减均值
imagenet_mean = 117.0 #在训练Inception模型时做了减均值预处理，此处也需减同样的均值以保持一致
 
#图像预处理——增加维度
# 图像数据格式一般是（height，width，channels），为同时将多张图片输入网络而在前面增加一维
# 变为（batch,height,width,channel）
t_preprocessed = tf.expand_dims(t_input - imagenet_mean, 0) 
 
# 导入模型并将经预处理的图像送入网络中
tf.import_graph_def(graph_def, {'input': t_preprocessed})

layers = [op.name for op in graph.get_operations() if op.type == 'Conv2D']
# 输出卷积层层数
print('Number of layers', len(layers))
 
# 输出所有卷积层名称
print(layers)
 
# 还可输出指定卷积层的参数
name1 = 'mixed4d_3x3_bottleneck_pre_relu'
print('shape of %s: %s' % (name1, str(graph.get_tensor_by_name('import/' + name1 + ':0').get_shape())))
 
name2 = 'mixed4e_5x5_bottleneck_pre_relu'
print('shape of %s: %s' % (name2, str(graph.get_tensor_by_name('import/' + name2 + ':0').get_shape())))

Dream图像生成（以噪声为起点）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 把一个numpy.ndarray保存成图像文件
def savearray(img_array, img_name):
    scipy.misc.toimage(img_array).save(img_name)
    print('img saved: %s' % img_name)
 
# 渲染函数
def render_naive(t_obj, img0, iter_n=20, step=1.0):
    # t_obj：是layer_output[:, :, :, channel]，即卷积层某个通道的值
    # img0：初始图像（噪声图像）
    # iter_n：迭代次数
    # step：用于控制每次迭代步长，可以看作学习率   
 
    t_score = tf.reduce_mean(t_obj)
    # t_score是t_obj的平均值
    # 由于我们的目标是调整输入图像使卷积层激活值尽可能大
    # 即最大化t_score
    # 为达到此目标，可使用梯度下降
    # 计算t_score对t_input的梯度
    t_grad = tf.gradients(t_score, t_input)[0]
    
    img = img0.copy()#复制新图像可避免影响原图像的值
    for i in range(iter_n):
        # 在sess中计算梯度，以及当前的t_score
        g, score = sess.run([t_grad, t_score], {t_input: img})
        # 对img应用梯度
        # 首先对梯度进行归一化处理
        g /= g.std() + 1e-8
        # 将正规化处理后的梯度应用在图像上，step用于控制每次迭代步长，此处为1.0
        img += g * step
        #print('score(mean)=%f' % (score))
        print('iter:%d' %(i+1), 'score(mean)=%f' % score)
    # 保存图片
    savearray(img, 'naive_deepdream.jpg')

单通道特征生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 定义卷积层、通道数，并取出对应的tensor
name = 'mixed4d_3x3_bottleneck_pre_relu'# (?, ?, ?, 144)
channel = 139 
# 'mixed4d_3x3_bottleneck_pre_relu'共144个通道
# 此处可选任意通道（0~143之间任意整数）进行最大化
 
layer_output = graph.get_tensor_by_name("import/%s:0" % name)
# layer_output[:, :, :, channel]即可表示该卷积层的第140个通道
 
# 定义图像噪声
img_noise = np.random.uniform(size=(224, 224, 3)) + 100.0
 
# 调用render_naive函数渲染
render_naive(layer_output[:, :, :, channel], img_noise, iter_n=20)
 
# 保存并显示图片
im = PIL.Image.open('naive_deepdream.jpg')
im.show()
im.save('naive_single_chn.jpg')

较低层单通道生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义卷积层、通道数，并取出对应的tensor
name3 = 'mixed3a_3x3_bottleneck_pre_relu'
layer_output = graph.get_tensor_by_name("import/%s:0" % name3)
print('shape of %s: %s' % (name3, str(graph.get_tensor_by_name('import/' + name3 + ':0').get_shape())))
 
# 定义噪声图像
img_noise = np.random.uniform(size=(224, 224, 3)) + 100.0
 
# 调用render_naive函数渲染
channel = 86 # (?, ?, ?, 96)
render_naive(layer_output[:, :, :, channel], img_noise, iter_n=20)
 
# 保存并显示图片
im = PIL.Image.open('naive_deepdream.jpg')
im.show()
im.save('shallow_single_chn.jpg')

较高层单通道生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义卷积层、通道数，并取出对应的tensor
name4 = 'mixed5b_5x5_pre_relu'
layer_output = graph.get_tensor_by_name("import/%s:0" % name4)
print('shape of %s: %s' % (name4, str(graph.get_tensor_by_name('import/' + name4 + ':0').get_shape())))
 
# 定义噪声图像
img_noise = np.random.uniform(size=(224, 224, 3)) + 100.0
 
# 调用render_naive函数渲染
channel =118 # (?, ?, ?, 128)
render_naive(layer_output[:, :, :, channel], img_noise, iter_n=20)
 
# 保存并显示图片
im = PIL.Image.open('naive_deepdream.jpg')
im.show()
im.save('deep_single_chn.jpg')

多通道生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 定义卷积层、通道数，并取出对应的tensor
name1 = 'mixed4d_3x3_bottleneck_pre_relu' #(?, ?, ?, 144)
name2= 'mixed4e_5x5_bottleneck_pre_relu' # (?, ?, ?, 32)
channel1 = 139 #因为共144通道，此处可选择0~143之间任意整数
channel2 = 28 # 因为共32通道，此处可选择0~31之间任意整数
 
layer_output1= graph.get_tensor_by_name("import/%s:0" % name1)
layer_output2= graph.get_tensor_by_name("import/%s:0" % name2)
 
# 定义噪声图像
img_noise = np.random.uniform(size=(224, 224, 3)) + 100.0
 
# 调用render_naive函数渲染
render_naive(layer_output1[:, :, :, channel1]+layer_output2[:, :, :, channel2], img_noise, iter_n=20)
 
# 保存并显示图片
im = PIL.Image.open('naive_deepdream.jpg')
im.show()
im.save('multi_chn.jpg')

所有通道生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义卷积层，并取出对应的tensor
name = 'mixed4d_3x3_bottleneck_pre_relu' 
layer_output= graph.get_tensor_by_name("import/%s:0" % name)
 
# 定义噪声图像
img_noise = np.random.uniform(size=(224, 224, 3)) + 100.0
 
# 调用render_naive函数渲染
render_naive(layer_output, img_noise, iter_n=20) # 不指定特定通道，即表示利用所有通道特征
# 单通道时：layer_output[:, :, :, channel]
 
# 保存并显示图片
im = PIL.Image.open('naive_deepdream.jpg')
#im = PIL.Image.open('deepdream.jpg')
im.show()
im.save('all_chn.jpg')

生成原始Deep Dream图像
通过最大化某一通道的平均值能够得到有意义的图像
从浅层到高层越来越抽象
从单通道到多通道到所有通道

如何提高生成图像的质量
提高图像质量
在图像算法中，有高频成分和低频成分的概念。简单的说，高频成分就是图像中灰度、颜色、明度变化比较大的地方，比如图像的边缘和细节部分。低频成分就是图像中变化不大的地方，比如大块色块、整体风格。因此，对于生成的Deep Dream图像，它的高频成分太多，颜色、明度变化都比较剧烈。 而理想是图像的低频成分更多，这样生成的图像才能够更加柔和。
在图像分解时，是从金字塔底层开始的，比如从level0 （原图）开始，分解出 level1 高频成分，把当时的低频成分留作level2 ，然后再把level2 分解成高频成分和更低频成分的level3 ，逐步分解，来得到更加低频的信息。
在图像生成时，是从金字塔顶层开始的。首先生成低频的图像，把低频成分（level4）放大成跟level3一样的尺寸后，加到level3，得到比较高频的成分，然后再把合成之后的level3’放大，加到level2，逐层相加，得到最后的最大尺寸图像，即合成图像。

完整程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
from __future__ import print_function
import os
from io import BytesIO
import numpy as np
from functools import partial
import PIL.Image
import scipy.misc
import tensorflow as tf
 
 
graph = tf.Graph()
model_fn = 'tensorflow_inception_graph.pb'
sess = tf.InteractiveSession(graph=graph)
with tf.gfile.FastGFile(model_fn, 'rb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())
t_input = tf.placeholder(np.float32, name='input')  
imagenet_mean = 117.0
t_preprocessed = tf.expand_dims(t_input - imagenet_mean, 0)
tf.import_graph_def(graph_def, {'input': t_preprocessed})

# 保存图像
def savearray(img_array, img_name):
    scipy.misc.toimage(img_array).save(img_name)
    print('img saved: %s' % img_name)
 
# 将图像放大ratio倍
def resize_ratio(img, ratio):
    min = img.min()
    max = img.max()
    img = (img - min) / (max - min) * 255
    img = np.float32(scipy.misc.imresize(img, ratio))
    img = img / 255 * (max - min) + min
    return img
 
# 调整图像尺寸
def resize(img, hw):
    min = img.min()
    max = img.max()
    img = (img - min) / (max - min) * 255
    img = np.float32(scipy.misc.imresize(img, hw))
    img = img / 255 * (max - min) + min
    return img
 
# 原始图像尺寸可能很大，从而导致内存耗尽问题 
# 每次只对 tile_size * tile_size 大小的图像计算梯度，避免内存问题
def calc_grad_tiled(img, t_grad, tile_size=512):
    sz = tile_size
    h, w = img.shape[:2]
    sx, sy = np.random.randint(sz, size=2)
    img_shift = np.roll(np.roll(img, sx, 1), sy, 0)  # 先在行上做整体移动，再在列上做整体移动
    grad = np.zeros_like(img)
    for y in range(0, max(h - sz // 2, sz), sz):
        for x in range(0, max(w - sz // 2, sz), sz):
            sub = img_shift[y:y + sz, x:x + sz]
            g = sess.run(t_grad, {t_input: sub})
            grad[y:y + sz, x:x + sz] = g
    return np.roll(np.roll(grad, -sx, 1), -sy, 0)
 
def render_deepdream(t_obj, img0,
                     iter_n=10, step=1.5, octave_n=4, octave_scale=1.4):
    t_score = tf.reduce_mean(t_obj)
    t_grad = tf.gradients(t_score, t_input)[0]
    img = img0.copy()
    
    # 将图像进行金字塔分解
    # 从而分为高频、低频部分
    octaves = []
    for i in range(octave_n - 1):
        hw = img.shape[:2]
        lo = resize(img, np.int32(np.float32(hw) / octave_scale))
        hi = img - resize(lo, hw)
        img = lo
        octaves.append(hi)
 
    # 首先生成低频的图像，再依次放大并加上高频
    for octave in range(octave_n):
        if octave > 0:
            hi = octaves[-octave]
            img = resize(img, hi.shape[:2]) + hi
        for i in range(iter_n):
            g = calc_grad_tiled(img, t_grad)
            img += g * (step / (np.abs(g).mean() + 1e-7))
           
    img = img.clip(0, 255)
    savearray(img, 'mountain_deepdream.jpg')
    im = PIL.Image.open('mountain_deepdream.jpg').show()

    name = 'mixed4c'
layer_output = graph.get_tensor_by_name("import/%s:0" % name)
 
img0 = PIL.Image.open('cat.png') # 自己找一张图片
img0 = np.float32(img0)
render_deepdream(tf.square(layer_output), img0)
This work is licensed under Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)