图像风格迁移试玩

风格迁移

图像风格迁移原理
内容损失函数
风格损失函数

现成工具：tensorflow hub
手工实现风格迁移
我们对风格有失恭敬

神经风格转换是深度学习领域中一个很有趣的技术。它可以改变图像的风格。

如下图所示，根据一张内容图片和一张风格图片，生成一张新图片，这张图片结合了第一张图像的内容和第二张图像的风格。

图像风格迁移原理

我们用卷积神经网络来实现风格迁移，需要准备俩张图：

输入图：内容图 $C$
输入图：风格图 $S$

目标，是将内容图（真人）变成某种风格（二次元）的内容图（二次元风格的真人）。

生成图：某种风格的内容图 $G$

在机器学习、深度学习里，只需要知道数据格式、损失函数，一个问题就变成了优化算法，不断迭代去调参即可。

风格转换网络的损失函数，是由俩个子损失函数组成的。

$J_{c}(C,~G)$ ：计算内容图片、生成图片之间的损失，即内容损失函数
$J_{s}(S,~G)$ ：计算风格图片、生成图片之间的损失，即风格损失函数
$J(G)=J_{c}(C,~G)+J_{s}(S,~G)$ ，风格转化损失函数 = 内容损失函数 + 风格损失函数

当然，这样写俩者就是等比例的，我们想实现不同的风格效果，需要添加俩个参数 $\alpha、\beta$ ，用于调整内容与风格之间的占比：

$J(G)=\alpha*J_{c}(C,~G)+\beta*J_{s}(S,~G)$
$\alpha$ 大，侧重于生成内容
$\beta$ 大，侧重于生成风格

清楚损失函数就可以训练神经网络，过程模拟如下。

输入内容图片（编号1）、风格图片（编号2）图片：

最开始，随机初始化生成图（编号3）。

通过损失函数计算得出，当前生成图与内容图、风格图之间的损失都很大。

梯度下降算法开始最小化代价函数 $J (G)$ ，逐步处理像素，这样慢慢得到一个生成图片（编号4、5），越来越像用风格图片的风格画出来的内容图片（编号6）。

内容损失函数

不同层的神经网络学到的特征不同，学习过程从点 -> 线 -> 面，前面的是抽象的，后面的是具象的。

而风格转换既不能太抽象，也不能太具象，所以计算内容损失函数用中间层的神经网络。

内容损失函数，如何计算呢？

计算内容图像与生成图像在某一层的激活值的差异程度。

假设是第 u 层的激活值计算损失：

-求俩个激活值向量的差异： $a^{[u](C)} - a^{[u](G)} ||^{2}$

$a^{[u](C)}$ ：内容图像第 u 层激活值
$^{[u](G)}$ ：生成图像第 u 层激活值

如果结果小，说明生成图像在内容上与内容图像很相似。

内容损失函数： $J^{u}_{content}(C,~G)=\frac{1}{(2n_{h}^{[u]}n_{w}^{[u]}n_{c}^{[u]})^{2}}\sum\limits_{j=1}^{n_{h}^{[u]}}\sum\limits_{j=1}^{n_{w}^{[u]}}(a^{[u](C)} - a^{[u](G)})^{2}$

风格损失函数

在风格损失函数之前，风格上什么？

从创作角度来看，一种带有综合性的总体特点，包含笔触、纹理、用色等等，比如一些画派追求眼睛所见的真实，对颜色、光影的掌控无敌的好。一些画派凭主观印象来画，对空间、设计的掌控无敌的好。
从神经网络的角度来说，风格是激活值矩阵中不同深度的互相关系，是通道的不同相同位置的激活值之间的关系。

在这里插入图片描述
以 conv1_1 为例，共包含 64 个通道，这 64 个通道可以类比成 64 个人对一幅画的不同理解。

一些人喜欢眼睛所见之真实
一些人喜欢抽象代表的内涵

这 64 个人之间理解的差异，可用 64 个通道的互相关（喜好差异）表示：

如果输入的图片的风格和生成图片一样，互相关的结果也就是相同的
如果输入的图片的风格和生成图片不一样，互相关的结果也就是差异化的

怎么计算呢？

第 1、2 个通道的第 1 个激活值相乘，第 1、2 个通道的第 2 个激活值相乘，······，相乘后的结果相加，结果就是俩个通道的风格关系。

通过这样一一相乘再相加（内积），会得到一个新矩阵。

生成图像的风格矩阵，用 G 表示：

$G_{kk'}^{[u](s)}=\sum\limits_{i=1}^{n_{h}^{[u]}}\sum\limits_{j=1}^{n_{w}^{[u]}}a_{ij_{k}^{[u](s)}}a_{ij_{k'}^{[u](s)}}$

解释：

$u$ ：第 u 层，每个卷积层都有自己对应的风格矩阵
$k 、 k^{'}$ ：第 k、k’ 通道之间的风格关系
$S$ ：风格矩阵是关于风格图像
$n_{h}$ ：激活矩阵的高
$n_{w}$ ：激活矩阵的宽

同理，生成矩阵图像的风格矩阵（三个 s 改成 G 即可）：

$G_{kk'}^{[u](G)}=\sum\limits_{i=1}^{n_{h}^{[u]}}\sum\limits_{j=1}^{n_{w}^{[u]}}a_{ij_{k}^{[u](G)}}a_{ij_{k'}^{[u](G)}}$

风格损失函数：

$J_{style}^{[u]}(S,~G)=\frac{1}{(2n_{h}^{[u]}n_{w}^{[u]}n_{c}^{[u]})^{2}}\sum\limits_{k}\sum\limits_{k'}(G_{kk'}^{[u](s)}-G_{kk'}^{[u](G)})$

风格图像的风格矩阵 - 生成图像的风格矩阵，如果风格差异大，那相减的结果就很大，就是损失很大。

那神经网络就会改变参数让损失变小，让俩张图像的风格越来越靠近。

除此之外，因为每层都有风格损失函数，我们引入一个超参数 $\lambda$ ，控制对不同卷积层的重视程度，或是低层次风格特征（纹理、边缘），或是高层次风格特征（复杂对象）。

完整的风格损失函数：

$J_{style}(S,~G)=\sum\limits_{1}\lambda^{u}·J_{style}^{[u]}(S,~G)$

现成工具：tensorflow hub

在 tensorflow hub 中已经有现成的风格转换模型可以被免费调用了。

除了风格转换模型外，hub 中还包含了很多常见的模型，很强大很可怕！！

https://hub.tensorflow.google.cn/

我们将下面俩张图合成吧。

以下代码，除了图片路径需要修改，其他都是通用的：

content_path = tf.keras.utils.get_file('ebcf732904a54911be5967c5b072a8e4.jpeg', 'https://img-blog.csdnimg.cn/ebcf732904a54911be5967c5b072a8e4.jpg')
# 内容图
style_path = tf.keras.utils.get_file('b275d4b95c33488e93a829bb1e7da6c9.jpeg', 'https://img-blog.csdnimg.cn/b275d4b95c33488e93a829bb1e7da6c9.jpg')
# 风格图

import os
import tensorflow as tf
os.environ['TFHUB_MODEL_LOAD_FORMAT'] = 'COMPRESSED'
import IPython.display as display
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['figure.figsize'] = (12, 12)
mpl.rcParams['axes.grid'] = Falseimport numpy as np
import PIL.Image
import time
import functoolsdef load_img(path_to_img):max_dim = 512img = tf.io.read_file(path_to_img)img = tf.image.decode_image(img, channels=3)img = tf.image.convert_image_dtype(img, tf.float32)shape = tf.cast(tf.shape(img)[:-1], tf.float32)long_dim = max(shape)scale = max_dim / long_dimnew_shape = tf.cast(shape * scale, tf.int32)img = tf.image.resize(img, new_shape)img = img[tf.newaxis, :]return imgdef imshow(image, title=None):if len(image.shape) > 3:image = tf.squeeze(image, axis=0)plt.imshow(image)if title:plt.title(title)# 修改内容图、风格图地址即可
content_path = tf.keras.utils.get_file('ebcf732904a54911be5967c5b072a8e4.jpeg', 'https://img-blog.csdnimg.cn/ebcf732904a54911be5967c5b072a8e4.jpg')
style_path = tf.keras.utils.get_file('b275d4b95c33488e93a829bb1e7da6c9.jpeg', 'https://img-blog.csdnimg.cn/b275d4b95c33488e93a829bb1e7da6c9.jpg')content_image = load_img(content_path)
style_image = load_img(style_path)
plt.subplot(1, 2, 1)
imshow(content_image, 'Content Image')
plt.subplot(1, 2, 2)
imshow(style_image, 'Style Image')def tensor_to_image(tensor):tensor = tensor * 255tensor = np.array(tensor, dtype=np.uint8)if np.ndim(tensor) > 3:assert tensor.shape[0] == 1tensor = tensor[0]return PIL.Image.fromarray(tensor)import tensorflow_hub as hub
hub_model = hub.load('https://hub.tensorflow.google.cn/google/magenta/arbitrary-image-stylization-v1-256/2')
stylized_image = hub_model(tf.constant(content_image), tf.constant(style_image))[0]
tensor_to_image(stylized_image)

输出：

手工实现风格迁移

迁移学习其实就是利用已经训练好的模型来实现另一个任务，我们借用一个训练好了的 VGG-19 模型。

vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')
# vgg就代表了一个训练好了的VGG19模型，include_top=False 代表不需要最后一层。风格转换不需要最后一层，最后一层是用来识别图片的。# 风格转换产生的图片既要有内容图片的内容又要有风格图片的风格
content_layers = ['block5_conv2'] 
# VGG 的 block5_conv2 层来生成最终图像的内容
style_layers = ['block1_conv1','block2_conv1','block3_conv1', 'block4_conv1', 'block5_conv1']
# VGG 的 block1_conv1，block2_conv1，block3_conv1，block4_conv1，block5_conv1 来生成最终图片的风格num_content_layers = len(content_layers)
num_style_layers = len(style_layers)# 创建一个自定义的模型，在输入vgg.input后（一张图片后），这个函数会返回上面定义的那些网络层的激活值，就能获取代表内容和风格的网络层的激活值
def vgg_layers(layer_names):vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')vgg.trainable = Falseoutputs = [vgg.get_layer(name).output for name in layer_names]model = tf.keras.Model([vgg.input], outputs)return model# 将激活值矩阵转换成风格矩阵，将激活值矩阵转换成风格矩阵，然后才能通过对比风格矩阵来判断两张图片的风格是否相同
def gram_matrix(input_tensor):result = tf.linalg.einsum('bijc,bijd->bcd', input_tensor, input_tensor)input_shape = tf.shape(input_tensor)num_locations = tf.cast(input_shape[1]*input_shape[2], tf.float32)return result/(num_locations)# 这个类整合了上面那些工具函数，当将一张图片输入后，这个类会返回这个图片的内容激活值矩阵以及风格矩阵。
class StyleContentModel(tf.keras.models.Model):def __init__(self, style_layers, content_layers):super(StyleContentModel, self).__init__()self.vgg = vgg_layers(style_layers + content_layers)self.style_layers = style_layersself.content_layers = content_layersself.num_style_layers = len(style_layers)self.vgg.trainable = False def call(self, inputs):inputs = inputs*255.0preprocessed_input = tf.keras.applications.vgg19.preprocess_input(inputs)outputs = self.vgg(preprocessed_input)style_outputs, content_outputs = (outputs[:self.num_style_layers],outputs[self.num_style_layers:])style_outputs = [gram_matrix(style_output)for style_output in style_outputs]content_dict = {content_name: valuefor content_name, valuein zip(self.content_layers, content_outputs)}style_dict = {style_name: valuefor style_name, valuein zip(self.style_layers, style_outputs)}return {'content': content_dict, 'style': style_dict}extractor = StyleContentModel(style_layers, content_layers)
style_targets = extractor(style_image)['style']          
# 获取风格图片的风格矩阵
content_targets = extractor(content_image)['content'] 
# 获取内容图片的内容激活值矩阵
image = tf.Variable(content_image)
# 复制内容图片到image，后面会不断的根据content_image和style_image来改变image，时image的风格越来越像style_image# 一个工具函数，用来修剪图片的数值
def clip_0_1(image):return tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0)opt = tf.optimizers.Adam(learning_rate=0.02, beta_1=0.99, epsilon=1e-1)
style_weight = 1e-2  
# 可以通过这个值来控制风格化到什么程度
content_weight = 1e4
# 控制内容保留的程度# 损失函数，用这个函数来对比最终图片image与内容图片content_image风格图片style_image的差别，差别越大损失就越大。
# 当iamge的内容越来越像content_image，风格越来越像style_image，那么损失就会越来越小。
def style_content_loss(outputs):style_outputs = outputs['style']      # image当前的风格矩阵content_outputs = outputs['content']  # image当前的内容激活值矩阵# 计算风格损失style_loss = tf.add_n([tf.reduce_mean((style_outputs[name]-style_targets[name])**2) for name in style_outputs.keys()])# 计算内容损失style_loss *= style_weight / num_style_layerscontent_loss = tf.add_n([tf.reduce_mean((content_outputs[name]-content_targets[name])**2) for name in content_outputs.keys()])content_loss *= content_weight / num_content_layersloss = style_loss + content_lossreturn loss@tf.function()
def train_step(image):# tape会记录下前向传播的每一个步骤，后面好自动执行反向传播with tf.GradientTape() as tape:outputs = extractor(image) # 获取当前image的内容激活值矩阵和风格矩阵loss = style_content_loss(outputs) # 计算损失，即与内容图片content_image风格图片style_image的差距# 获取image相对于loss的梯度。这里的image就相当于w和b参数一样grad = tape.gradient(loss, image)# 使用梯度来改变image，也即是说image会变得越来越像content_image风格图片style_imageopt.apply_gradients([(grad, image)]) image.assign(clip_0_1(image))import time
start = time.time()epochs = 10
steps_per_epoch = 100# 只训练了三步，图片风格会稍稍变化
train_step(image)
train_step(image)
train_step(image)
tensor_to_image(image)'''
真正训练的话，是要很多步的。会花很长时间，以下代码电脑配置不好的可能要花几个小时
step = 0
for n in range(epochs):for m in range(steps_per_epoch):step += 1train_step(image)print(".", end='', flush=True)display.clear_output(wait=True)display.display(tensor_to_image(image))print("Train step: {}".format(step))end = time.time()
print("Total time: {:.1f}".format(end-start))
'''