Coursera之deeplearning.ai：CNN-Art Generation with Neural Style Transfer

本文主要是介绍Coursera之deeplearning.ai：CNN-Art Generation with Neural Style Transfer，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Deep Learning & Art: Neural Style Transfer

算法为Gatys et al.(2015)提出的(https://arxiv.org/abs/1508.06576).
在本实验中，可以实现neural style transfer algorithm;使用算法生成艺术图像。
很多算法通过优化一个成本函数来获得一组参数值，在Neural Style Transfer中，通过优化一个成本函数来获得像素值。

1-问题陈述

Neural Style Transfer (NST)是在深度学习里一个有趣的技术。如下所示，他合并了两个图像，名为内容图像（C）和风格图像（S），生成图像（G）。G包括图像C的内容和图像S的风格。
在此例中，要将在巴黎拍摄卢浮宫的图片（内容图像C）和一个印象派领袖Claude Monet的画混合在一起。
这里写图片描述

2-迁移学习

Neural Style Transfer (NST)使用预先训练过的卷积神经网络，并在此基础上进行构建。使用在不同任务上训练的网络并将其应用在一个新任务的想法称为迁移学习。
根据原始NST论文(https://arxiv.org/abs/1508.06576)，我们使用VGG网络。使用VGG-19，是VGG网络的19层版本。这个模型已经在非常大的ImageNet数据库上进行了训练，因此已经学习了识别各种低层次的特性（在早期的层次）和高级特性（在更深的层次）。
运行下列代码从VGG模型加载参数，可能需要几秒钟。

model = load_vgg_model("pretrained-model/imagenet-vgg-verydeep-19.mat")
print(model)

该模型存储在python字典里，每个变量名是键，相应的值是包含该变量值的tensor。要在这个网络中运行一个图像，只需要把图像喂给模型。利用TensorFlow，可以使用tf.assign功能。可以使用assign函
model["input"].assign(image)
像作为模型的输入，之后，如果想要访问特定层的激活，比如当网络运行在图像上时的4_2层，可以在正确的tensor conv4_2中运行一个TensorFlow session:

sess.run(model["conv4_2"])

3-Neural Style Transfer

NST算法分三步：

计算内容成本函数 $J_{content}(C,G)$
计算风格成本函数 $J_{style}(C,G)$
计算总成本函数 $J(G)=\alpha J_{content}(C,G)+\beta J_{style}(C,G)$
3.1-计算内容成本
运行实例中，内容图像C是巴黎卢浮宫的图片，运行代码查看卢浮宫图片：

content_image = scipy.misc.imread("images/louvre.jpg")
imshow(content_image)

这里写图片描述
3.1.1-如何确保生成的图像G与图像C的内容相匹配
早期（较浅）层的ConvNet倾向于检测较低层次的特征，如边缘和简单的纹理，后期（更深）层倾向于检测更高级的特征，比如更复杂的纹理和对象类。
我们希望生成的图像G与输入图像C有相似的内容。假设选择了某个层的激活来表示图像的内容。在实践中，如果你选择的层在网络的中间层，你会得到最令人视觉上愉悦的效果。（在完成练习之后，可以自由地回来尝试使用不同的图层，看结果是如何变化的）
假设已经选择了一个特定的隐藏层来使用。现在，将图像C设置为预先训练好的VGG网络的输入，并向前传播。令 $a^{C}$ 为你选择的层中隐藏层激活(hidden layer activations)，是一个 $n_{H}\times n_{W}\times n_{C}$ 的tensor。用图像G重复此过程：设置G为输入，然后进行向前传递。令 $a^{G}$ 是对应的隐藏层激活。我们将内容损失函数定义为：

J c o n t e n t (C, G) = 1 4 \times n H \times n W \times n C \sum all entries (a (C) - a (G)) 2 (1)

$J_{content}(C,G) = \frac{1}{4 \times n_H \times n_W \times n_C}\sum _{ \text{all entries}} (a^{(C)} - a^{(G)})^2\tag{1}$
这里，

nH,nW,nC n H , n W , n C $n_{H},n_{W},n_{C}$ 是选择的隐藏层的高度、宽度和数量，并以成本的标准化项出现。

aC a C $a^{C}$ 和

aG a G $a^{G}$ 是一些volumes对应隐藏层的激活。为计算

Jcontent(C,G) J c o n t e n t ( C , G ) $J_{content}(C,G)$ ，要将这些 3D volumes展开成2D矩阵，如下所示。（从技术上讲，这些unrolling比周不需要计算

Jcontent J c o n t e n t $J_{content}$ ，但是当你以后需要进行类似的操作来计算样式常量

Jstyle J s t y l e $J_{style}$ ，这是个很好的实践。）
这里写图片描述

练习：使用TensorFlow计算内容损失
说明：实现此功能的三个步骤是：
1.从

aG检索维度 a G 检索维度 $a_{G}检索维度$

从tensor X中检索维度，使用：X.get_shape().as_list()
unroll a_C 和 a_G如上图所示
计算内容成本。

# GRADED FUNCTION: compute_content_costdef compute_content_cost(a_C, a_G):"""Computes the content costArguments:a_C -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing content of the image C a_G -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing content of the image GReturns: J_content -- scalar that you compute using equation 1 above."""### START CODE HERE #### Retrieve dimensions from a_G (≈1 line)m, n_H, n_W, n_C = a_G.get_shape().as_list()# Reshape a_C and a_G (≈2 lines)a_C_unrolled = tf.reshape(a_C,shape=[m, n_H*n_W, n_C])a_G_unrolled = tf.reshape(a_G,shape=[m, n_H*n_W, n_C])# compute the cost with tensorflow (≈1 line)J_content = tf.reduce_sum(tf.square(a_C_unrolled - a_G_unrolled))/(4 * n_H * n_W * n_C)### END CODE HERE ###return J_content

tf.reset_default_graph()with tf.Session() as test:tf.set_random_seed(1)a_C = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4)a_G = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4)J_content = compute_content_cost(a_C, a_G)print("J_content = " + str(J_content.eval()))

预期结果为：J_content = 6.76559
3.2-计算风格成本
对于我们的运行案例，我们将使用下面的风格图像：

style_image = scipy.misc.imread("images/monet_800600.jpg")
imshow(style_image)

这里写图片描述
3.2.1-风格矩阵
风格矩阵也成为Gram matrix。在线性代数中，一组向量 $(v_{1},...,v_{n})$ 的Gram matrix G是点积的矩阵， $G_{ij} = v_{i}^T v_{j} = np.dot(v_{i}, v_{j})$ 。换句话说， $G_{ij}$ 计算 $v_i$ 与 $v_j$ 的相似程度：如果它们非常相似，就会期望它们有一个大的点积，因此让 $G_{ij}$ 大。
在NST中，计算风格矩阵通过unrolled过滤矩阵与它们的转置矩阵相乘来计算：
这里写图片描述
结果是一个矩阵的维度（ $n_{C},n_{C}$ ）, $n_{C}$ 是过滤器的数量。 $G_{ij}$ 计算过滤器 $i$ 的activations与过滤器 $j$ 的activations的相似程度。
对角元素 $G_{ii}$ 测量了how active filter $i$ is. 例如，假设过滤器 $i$ 在图像中检测垂直纹理。那么 $G_{ii}$ 是测量在整个图像中垂直纹理的普遍程度：如果 $G_{ii}$ 很大，意味着这个图像有很多垂直的纹理。
通过捕捉不同类型的普遍程度（ $G_{ii}$ ），以及有多少不同特征在一起出现( $G_{ij}$ )，风格矩阵G测量了一个图像的风格。
练习：使用TensorFlow,实现一个计算矩阵A的Gram matrix. 公式是：the gram matrix of A is $G_A = AA^T$ .

# GRADED FUNCTION: gram_matrixdef gram_matrix(A):"""Argument:A -- matrix of shape (n_C, n_H*n_W)Returns:GA -- Gram matrix of A, of shape (n_C, n_C)"""### START CODE HERE ### (≈1 line)GA = tf.matmul(A, tf.transpose(A))### END CODE HERE ###return GA

tf.reset_default_graph()with tf.Session() as test:tf.set_random_seed(1)A = tf.random_normal([3, 2*1], mean=1, stddev=4)GA = gram_matrix(A)print("GA = " + str(GA.eval()))

预期结果：

GA = [[  6.42230511  -4.42912197  -2.09668207][ -4.42912197  19.46583748  19.56387138][ -2.09668207  19.56387138  20.6864624 ]]

3.2.2-风格损失
计算风格矩阵（Gram matrix）后，目标是最小化风格图像S的Gram matrix和生成图像G的Gram matrix之间的距离。现在，只使用一个隐藏层 $a^{[l]}$ ，这一层的对应风格损失定义为

J [l] s t y l e (S, G) = 1 4 \times n C 2 \times ( n H \times n W ) 2 \sum i = 1 n C \sum j = 1 n C (G (S) i j - G (G) i j) 2 (2)

$J_{style}^{[l]}(S,G) = \frac{1}{4 \times {n_C}^2 \times (n_H \times n_W)^2} \sum _{i=1}^{n_C}\sum_{j=1}^{n_C}(G^{(S)}_{ij} - G^{(G)}_{ij})^2\tag{2}$
其中，

GS G S $G^{S}$ 和

GG G G $G^{G}$ 分别是风格图像和生成图像的Gram matrices，使用在网络中一个特定隐藏层的隐藏层激活计算。
练习：计算单个图层的风格成本。
说明：实现功能分三步：

从隐藏层激活a_G检索维度：根据tensor X检索维度: X.get_shape().as_list()
将隐藏层激活a_S 和 s_G unroll为2D矩阵，如上图所示
计算图像S和G的风格矩阵（使用之前写的函数）
计算风格损失

# GRADED FUNCTION: compute_layer_style_costdef compute_layer_style_cost(a_S, a_G):"""Arguments:a_S -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing style of the image S a_G -- tensor of dimension (1, n_H, n_W, n_C), hidden layer activations representing style of the image GReturns: J_style_layer -- tensor representing a scalar value, style cost defined above by equation (2)"""### START CODE HERE #### Retrieve dimensions from a_G (≈1 line)m, n_H, n_W, n_C = a_G.get_shape().as_list()# Reshape the images to have them of shape (n_C, n_H*n_W) (≈2 lines)a_S = tf.reshape(a_S, [n_H*n_W, n_C])a_G = tf.reshape(a_G, [n_H*n_W, n_C])# Computing gram_matrices for both images S and G (≈2 lines)GS = gram_matrix(tf.transpose(a_S))GG = gram_matrix(tf.transpose(a_G))# Computing the loss (≈1 line)J_style_layer = tf.reduce_sum(tf.square(GS-GG))/(4 * n_C**2 * (n_W*n_H)**2)### END CODE HERE ###return J_style_layer

tf.reset_default_graph()with tf.Session() as test:tf.set_random_seed(1)a_S = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4)a_G = tf.random_normal([1, 4, 4, 3], mean=1, stddev=4)J_style_layer = compute_layer_style_cost(a_S, a_G)print("J_style_layer = " + str(J_style_layer.eval()))

期望结果：J_style_layer = 9.19028
（这里注意，题目提示：Reshape the images to have them of shape (n_C, n_H*n_W)，但是这里需要reshape为（n_H*n_W, n_C），不然结果不对）
3.2.3风格权重
现在，已经从一个层捕捉了样式，需要从不同的层合并样式成本，会得到更好的结果。完成训练后，可以自由地返回并尝试不同地权重，看看它是如何改变生成图像G的。就目前为止，这是一个合理的默认值：

STYLE_LAYERS = [('conv1_1', 0.2),('conv2_1', 0.2),('conv3_1', 0.2),('conv4_1', 0.2),('conv5_1', 0.2)]

可以将不同层的样式成本合并在一起：

J s t y l e (S, G) = \sum l λ [l] J [l] s t y l e (S, G)

$J_{style}(S,G) = \sum_{l} \lambda^{[l]} J^{[l]}_{style}(S,G)$
这里，

λ[l] λ [ l ] $\lambda^{[l]}$ 的值在 STYLE_LAYERS 给出.

def compute_style_cost(model, STYLE_LAYERS):"""Computes the overall style cost from several chosen layersArguments:model -- our tensorflow modelSTYLE_LAYERS -- A python list containing:- the names of the layers we would like to extract style from- a coefficient for each of themReturns: J_style -- tensor representing a scalar value, style cost defined above by equation (2)"""# initialize the overall style costJ_style = 0for layer_name, coeff in STYLE_LAYERS:# Select the output tensor of the currently selected layerout = model[layer_name]# Set a_S to be the hidden layer activation from the layer we have selected, by running the session on outa_S = sess.run(out)# Set a_G to be the hidden layer activation from same layer. Here, a_G references model[layer_name] # and isn't evaluated yet. Later in the code, we'll assign the image G as the model input, so that# when we run the session, this will be the activations drawn from the appropriate layer, with G as input.a_G = out# Compute style_cost for the current layerJ_style_layer = compute_layer_style_cost(a_S, a_G)# Add coeff * J_style_layer of this layer to overall style costJ_style += coeff * J_style_layerreturn J_style

注意：在上面的for循环的内部循坏中，a_G是一个tensor，还没有被评估。当我们在model_nn()运行中TensorFlow graph，它将在每次迭代中被评估和更新。
应该记住：
图像样式可以用隐藏层激活的Gram matrix来表示。然后，我将这种表示从多个不同的层组合起来，得到更好的结果。这与内容表示形成了鲜明的对比，在这种情况下通常使用一个隐藏层就足够了。
最小化风格成本可以使图像G遵循图像S的样式。
3.3-确定用于优化的总成本
最后，让我们创建一个成本函数，最小化风格和内容成本。公式是：

J (G) = α J c o n t e n t (C, G) + β J s t y l e (S, G)

$J(G) = \alpha J_{content}(C,G) + \beta J_{style}(S,G)$
练习：实现包含内容成本和风格成本的总成本函数。

 GRADED FUNCTION: total_costdef total_cost(J_content, J_style, alpha = 10, beta = 40):"""Computes the total cost functionArguments:J_content -- content cost coded aboveJ_style -- style cost coded abovealpha -- hyperparameter weighting the importance of the content costbeta -- hyperparameter weighting the importance of the style costReturns:J -- total cost as defined by the formula above."""### START CODE HERE ### (≈1 line)J = alpha * J_content + beta * J_style### END CODE HERE ###return J

tf.reset_default_graph()with tf.Session() as test:np.random.seed(3)J_content = np.random.randn()    J_style = np.random.randn()J = total_cost(J_content, J_style)print("J = " + str(J))

期望输出：J = 35.34667875478276
需要注意：
总成本是内容成本 $J_{content}(C,G)$ 与风格成本 $J_{style}(S,G)$ 的线性组合
$\alpha$ 和 $\beta$ 是控制内容和风格之间的相对权重的超参数

4-解决优化问题

最后，让我们把所有的东西放在一起实现Neural Style Transfer。
这里是程序需要做的：

创建一个Interactive Session
加载内容图像
加载风格图像
随机初始化要生成的图像
加载VGG16模型
运行TensorFlow graph：
通过VGG模型运行内容图像并计算内容成本；
通过VGG模型运行内容图像并计算风格成本；
计算总成本；
定义优化器和学习率。
初始化TensorFlow graph并运行大量的迭代，在每一步更新生成的图像。

之前已经实现了 $J(G)$ 的总体成本。现在我们将设置TensorFlow对于 $G$ 来优化。要做到这一点，程序必须重新设置图表并使用一个“交互式会话”（ “Interactive Session”）。与常规会话不同的是，“交互式会话”将自己安装为构建图表的初始会话。这允许在不需要引用会话对象的情况下运行变量，从而简化了代码。

# Reset the graph
tf.reset_default_graph()# Start interactive session
sess = tf.InteractiveSession()

加载、重塑和规范我们的“内容”形象（卢浮宫的图片）：

content_image = scipy.misc.imread("images/louvre_small.jpg")
content_image = reshape_and_normalize_image(content_image)

加载、重塑和规范我们的“风格”形象（克劳德莫奈的画）：

style_image = scipy.misc.imread("images/monet.jpg")
style_image = reshape_and_normalize_image(style_image)

现在，将“生成”的图像初始化为从内容图像创建的噪声图像。通过初始化生成的图像的像素，主要是噪音，但仍然与内容图像略有关联，这将帮助“生成”图像的内容更快速地匹配“内容”图像的内容。（可以查看 nst_utils.py 中generate_noise_image(…);点击 “File–>Open…” 在笔记本左上角）

generated_image = generate_noise_image(content_image)
imshow(generated_image[0])

这里写图片描述
加载VGG模型：

model = load_vgg_model("pretrained-model/imagenet-vgg-verydeep-19.mat")

为了让程序计算内容成本，我们现在将分配a_C和a_G作为适当的隐藏层激活。我们将使用conv4_2层来计算内容成本。下面的代码如下：

指定内容图像为VGG模型的输入。
将a_C设为一个张量，为conv4_2层提供隐藏层激活。
将a_G设为一个张量，为同一层提供隐藏层激活。
使用a_C和a_G计算内容成本。

# Assign the content image to be the input of the VGG model.  
sess.run(model['input'].assign(content_image))# Select the output tensor of layer conv4_2
out = model['conv4_2']# Set a_C to be the hidden layer activation from the layer we have selected
a_C = sess.run(out)# Set a_G to be the hidden layer activation from same layer. Here, a_G references model['conv4_2'] 
# and isn't evaluated yet. Later in the code, we'll assign the image G as the model input, so that
# when we run the session, this will be the activations drawn from the appropriate layer, with G as input.
a_G = out# Compute the content cost
J_content = compute_content_cost(a_C, a_G)

注意：a_G是一个张量，还没有被评估。当我们在model_nn（）中运行Tensorflow graph时，它将在每次迭代中被评估和更新。

# Assign the input of the model to be the "style" image 
sess.run(model['input'].assign(style_image))# Compute the style cost
J_style = compute_style_cost(model, STYLE_LAYERS)

练习：利用 $J_{content}$ 和 $J_{style}$ ，通过调用totalcost（）来计算总成本 $J$ ，使用 $alpha=10$ 和 $beta=40$ 。

### START CODE HERE ### (1 line)
J = total_cost(J_content, J_style, alpha=10, beta=40)
### END CODE HERE ###

在TensorFlow中设置 Adam optimizer ，学习速率为2.0。

# define optimizer (1 line)
optimizer = tf.train.AdamOptimizer(2.0)# define train_step (1 line)
train_step = optimizer.minimize(J)

练习：实现model_nn（）函数，它初始化tensorflow graph的变量，将输入图像（初始生成的图像）设置为VGG16模型的输入，并为运行train step步。

def model_nn(sess, input_image, num_iterations = 200):# Initialize global variables (you need to run the session on the initializer)### START CODE HERE ### (1 line)sess.run(tf.global_variables_initializer())### END CODE HERE #### Run the noisy input image (initial generated image) through the model. Use assign().### START CODE HERE ### (1 line)sess.run(model["input"].assign(input_image))### END CODE HERE ###for i in range(num_iterations):# Run the session on the train_step to minimize the total cost### START CODE HERE ### (1 line)sess.run(train_step)### END CODE HERE #### Compute the generated image by running the session on the current model['input']### START CODE HERE ### (1 line)generated_image = sess.run(model['input'])### END CODE HERE #### Print every 20 iteration.if i%20 == 0:Jt, Jc, Js = sess.run([J, J_content, J_style])print("Iteration " + str(i) + " :")print("total cost = " + str(Jt))print("content cost = " + str(Jc))print("style cost = " + str(Js))# save current generated image in the "/output" directorysave_image("output/" + str(i) + ".png", generated_image)# save last generated imagesave_image('output/generated_image.jpg', generated_image)return generated_image