图像风格迁移试玩

风格迁移

• 图像风格迁移原理

• 内容损失函数
• 风格损失函数

• 现成工具：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$：第 u 层，每个卷积层都有自己对应的风格矩阵
• $k、k$：第 k、k’ 通道之间的风格关系
• $S$：风格矩阵是关于风格图像
• $n_{h}$：激活矩阵的高
• $n_{w}$：激活矩阵的宽

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

• $G_{kk$

风格损失函数：

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

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

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

除此之外，因为每层都有风格损失函数，我们引入一个超参数 $\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'] = False

import numpy as np
import PIL.Image
import time
import functools

def load_img(path_to_img):
  max_dim = 512
  img = 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_dim
  new_shape = tf.cast(shape * scale, tf.int32)
  img = tf.image.resize(img, new_shape)
  img = img[tf.newaxis, :]
  return img

def 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 * 255
  tensor = np.array(tensor, dtype=np.uint8)
  if np.ndim(tensor) > 3:
    assert tensor.shape[0] == 1
    tensor = 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 = False

  outputs = [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_layers
    self.content_layers = content_layers
    self.num_style_layers = len(style_layers)
    self.vgg.trainable = False 

  def call(self, inputs):
    inputs = inputs*255.0
    preprocessed_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: value
                    for content_name, value
                    in zip(self.content_layers, content_outputs)}

    style_dict = {style_name: value
                  for style_name, value
                  in 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_layers
    
    content_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_layers
    loss = style_loss + content_loss
    return 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_image
  opt.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 += 1
    train_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))
'''

输出：

从结果可以看出，图片已经有了一点点风格图片的感觉了。

 

---

我们对风格有失恭敬

风格，是一种非常人性化的东西，它的反义词是机械化。

同样一个笑话，或者一句特别经典的话，奥巴马说一遍可能效果就非常好，而你如果接下来照着他学一遍，那就完全不好使 —— 你就是机械化的模仿，你没有自己的个人风格。

说服别人，不能用写学术论文的方法，期待用一大堆数字图表去碾压别人，那样别人只会反感，当你是个机器人。

没人愿意听机器人的，人们喜欢有风格的人。

我喜欢你的风格 — 这简直就是对人最高级的评价。

得有自己的风格，甚至哲学。

任何时候都要真诚，不要模仿任何人，永远做最真实的自己 — 而且你也不必为此道歉。

如果你的真实自我是一个很怪异的人，那你就做这样一个很怪异的人。

我所喜欢的风格 — 惜字如金，一语惊人。

能打动别人，说服别人，的确是个本事。但是我们周围人写的文章里诗歌实在太多，中文世界里有太多感情充沛气势磅礴，而又言之无物的东西。

含金量高的书，第一言之有物，传达了独特的思想或感受，第二文字凝练，赋予了这些思想或感受以最简洁的形式。

所谓文字凝练，倒不在于刻意少写，而在于不管写多写少，都力求货真价实（站得住脚，而不是好看）。

这一要求见之于修辞，就是剪除一切可有可无的词句，达于文风的简洁。

由于惜墨如金，所以果然就落笔成金，字字都掷地有声。