【从零开始学习深度学习】47. Pytorch图片样式迁移实战：将一张图片样式迁移至另一张图片，创作自己喜欢风格的图片【含完整源码】

本文将介绍如何使用卷积神经网络自动将某图像中的样式应用在另一图像之上即样式迁移（style transfer。这里我们需要两张输入图像一张是内容图像另一张是样式图像我们将使用神经网络修改内容图像使其在样式上接近样式图像。下图中的内容图像为雷尼尔山国家公园（Mount Rainier National Park的风景照而样式图像则是一副主题为秋天橡树的油画。最终输出的合成图像在保留了内容图像中物体主体形状的情况下应用了样式图像的油画笔触同时也让整体颜色更加鲜艳。

1. 图片样式迁移的方法介绍

下图用一个例子来阐述基于卷积神经网络的样式迁移方法。首先我们初始化合成图像例如将其初始化成内容图像。该合成图像是样式迁移过程中唯一需要更新的变量即样式迁移所需迭代的模型参数。然后我们选择一个预训练的卷积神经网络来抽取图像的特征其中的模型参数在训练中无须更新。深度卷积神经网络凭借多个层逐级抽取图像的特征。我们可以选择其中某些层的输出作为内容特征或样式特征。以上图为例这里选取的预训练的神经网络含有3个卷积层其中第二层输出图像的内容特征而第一层和第三层的输出被作为图像的样式特征。接下来我们通过正向传播（实线箭头方向计算样式迁移的损失函数并通过反向传播（虚线箭头方向迭代模型参数即不断更新合成图像。样式迁移常用的损失函数由3部分组成内容损失（content loss使合成图像与内容图像在内容特征上接近样式损失（style loss令合成图像与样式图像在样式特征上接近而总变差损失（total variation loss则有助于减少合成图像中的噪点。最后当模型训练结束时我们输出样式迁移的模型参数即得到最终的合成图像。

下面我们通过实验来进一步了解样式迁移的技术细节。实验需要用到一些导入的包或模块。

%matplotlib inline
import time
import torch
import torch.nn.functional as F
import torchvision
import numpy as np
from PIL import Image

import sys
import d2lzh_pytorch as d2l
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

2. 读取内容图像和样式图像

首先我们分别读取内容图像和样式图像。从打印出的图像坐标轴可以看出它们的尺寸并不一样。

关注GZH阿旭算法与机器学习回复“图片样式迁移”即可获取本文数据集与项目文档

d2l.set_figsize()
content_img = Image.open('./img/rainier.jpg')
d2l.plt.imshow(content_img);

d2l.set_figsize()
style_img = Image.open('./img/autumn_oak.jpg')
d2l.plt.imshow(style_img);

3. 图像的预处理和后处理

下面定义图像的预处理函数和后处理函数。预处理函数preprocess先更改输入图像的尺寸然后再将PIL图片转成卷积神经网络接受的输入格式再在RGB三个通道分别做标准化由于预训练模型是在均值为[0.485, 0.456, 0.406]标准差为[0.229, 0.224, 0.225]的图片数据上预训练的所以我们要将图片标准化保持相同的均值和标准差。后处理函数postprocess则将输出图像中的像素值还原回标准化之前的值。由于图像每个像素的浮点数值在0到1之间我们使用clamp函数对小于0和大于1的值分别取0和1。

torchvision.transforms模块有大量现成的转换方法不过需要注意的是有的方法输入的是PIL图像如Resize；有的方法输入的是tensor如Normalize；而还有的是用于二者转换如ToTensor将PIL图像转换成tensor。一定要注意这点使用时看清文档。

rgb_mean = np.array([0.485, 0.456, 0.406])
rgb_std = np.array([0.229, 0.224, 0.225])

def preprocess(PIL_img, image_shape):
    # 预处理函数
    process = torchvision.transforms.Compose([
        torchvision.transforms.Resize(image_shape),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize(mean=rgb_mean, std=rgb_std)])

    return process(PIL_img).unsqueeze(dim = 0) # (batch_size, 3, H, W)

def postprocess(img_tensor):
    # 后处理函数
    inv_normalize = torchvision.transforms.Normalize(
        mean= -rgb_mean / rgb_std,
        std= 1/rgb_std)
    to_PIL_image = torchvision.transforms.ToPILImage()
    return to_PIL_image(inv_normalize(img_tensor[0].cpu()).clamp(0, 1))

4. 图像的抽取特征

我们使用基于ImageNet数据集预训练的VGG-19模型来抽取图像特征 。

PyTorch官方在torchvision.models模块提供了一些常见的预训练好的计算机视觉模型包括图片分类、语义分割、目标检测、实例分割、人关键点检测和视频分类等等。使用时要仔细阅读其文档搞清楚如何使用例如刚刚提到的对图片进行标准化等。

pretrained_net = torchvision.models.vgg19(pretrained=True, progress=True)
# 如果已经下载好了模型则可以用下面方式加载模型参数
# vgg19 = torchvision.models.vgg19(pretrained=False)   #创建一个vgg19模型框架
# vgg19.load_state_dict(torch.load("vgg19_method2.pth"))  #对模型参数进行拷贝

第一次执行上述代码会把预训练好的模型参数下载到环境变量TORCH_HOME指定的位置如果没有该环境变量的话默认位置是.cache/torch。

为了抽取图像的内容特征和样式特征我们可以选择VGG网络中某些层的输出。一般来说越靠近输入层的输出越容易抽取图像的细节信息反之则越容易抽取图像的全局信息。为了避免合成图像过多保留内容图像的细节我们选择VGG较靠近输出的层也称内容层来输出图像的内容特征。我们还从VGG中选择不同层的输出来匹配局部和全局的样式这些层也叫样式层。之前介绍过VGG网络使用了5个卷积块。实验中我们选择第四卷积块的最后一个卷积层作为内容层以及每个卷积块的第一个卷积层作为样式层。这些层的索引可以通过打印pretrained_net实例来获取。

pretrained_net

输出:

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace)
    (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (17): ReLU(inplace)
    (18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace)
    (23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (24): ReLU(inplace)
    (25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (26): ReLU(inplace)
    (27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace)
    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (31): ReLU(inplace)
    (32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (33): ReLU(inplace)
    (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (35): ReLU(inplace)
    (36): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace)
    (2): Dropout(p=0.5)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace)
    (5): Dropout(p=0.5)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

style_layers, content_layers = [0, 5, 10, 19, 28], [25]

在抽取特征时我们只需要用到VGG从输入层到最靠近输出层的内容层或样式层之间的所有层。下面构建一个新的网络net它只保留需要用到的VGG的所有层。我们将使用net来抽取特征。

net_list = []
for i in range(max(content_layers + style_layers) + 1):
    # 0-28层
    net_list.append(pretrained_net.features[i])
net = torch.nn.Sequential(*net_list)

给定输入X如果简单调用前向计算net(X)只能获得最后一层的输出。由于我们还需要中间层的输出因此这里我们逐层计算并保留内容层和样式层的输出。

def extract_features(X, content_layers, style_layers):
    # X为输入的图像
    contents = []
    styles = []
    for i in range(len(net)):
        X = net[i](X)
        if i in style_layers:
            styles.append(X)
        if i in content_layers:
            contents.append(X)
    return contents, styles

下面定义两个函数其中get_contents函数对内容图像抽取内容特征而get_styles函数则对样式图像抽取样式特征。因为在训练时无须改变预训练的VGG的模型参数所以我们可以在训练开始之前就提取出内容图像的内容特征以及样式图像的样式特征。由于合成图像是样式迁移所需迭代的模型参数我们只能在训练过程中通过调用extract_features函数来抽取合成图像的内容特征和样式特征。

def get_contents(image_shape, device):
    content_X = preprocess(content_img, image_shape).to(device)
    contents_Y, _ = extract_features(content_X, content_layers, style_layers)
    # contents_Y为提取出的内容图像的内容特征
    return content_X, contents_Y

def get_styles(image_shape, device):
    style_X = preprocess(style_img, image_shape).to(device)
    _, styles_Y = extract_features(style_X, content_layers, style_layers)
    # styles_Y为提取出的样式图像的样式特征
    return style_X, styles_Y

#5. 定义损失函数

下面我们来描述样式迁移的损失函数。它由内容损失、样式损失和总变差损失3部分组成。

5.1 内容损失

内容损失通过平方误差函数衡量合成图像与内容图像在内容特征上的差异。平方误差函数的两个输入均为extract_features函数计算所得到的内容层的输出。

def content_loss(Y_hat, Y):
    return F.mse_loss(Y_hat, Y)

5.2 样式损失

样式损失也一样通过平方误差函数衡量合成图像与样式图像在样式上的差异。为了表达样式层输出的样式我们先通过extract_features函数计算样式层的输出。假设该输出的样本数为1通道数为$c$高和宽分别为$h$和$w$我们可以把输出变换成$c$行$hw$列的矩阵$\mathbf{X}$。矩阵$\mathbf{X}$可以看作是由$c$个长度为$hw$的向量${\mathbf{x}}_1,\dots ,{\mathbf{x}}_c$组成的。其中向量${\mathbf{x}}_i$代表了通道$i$上的样式特征。这些向量的格拉姆矩阵（Gram matrix$\mathbf{X}{\mathbf{X}}^{\top }\in {\mathbb{R}}^{c\times c}$中$i$行$j$列的元素$x_{ij}$即向量${\mathbf{x}}_i$与${\mathbf{x}}_j$的内积它表达了通道$i$和通道$j$上样式特征的相关性。我们用这样的格拉姆矩阵表达样式层输出的样式。需要注意的是当$hw$的值较大时格拉姆矩阵中的元素容易出现较大的值。此外格拉姆矩阵的高和宽皆为通道数$c$。为了让样式损失不受这些值的大小影响下面定义的gram函数将格拉姆矩阵除以了矩阵中元素的个数即$chw$。

def gram(X):
    num_channels, n = X.shape[1], X.shape[2] * X.shape[3]
    X = X.view(num_channels, n)
    return torch.matmul(X, X.t()) / (num_channels * n)

自然地样式损失的平方误差函数的两个格拉姆矩阵输入分别基于合成图像与样式图像的样式层输出。这里假设基于样式图像的格拉姆矩阵gram_Y已经预先计算好了。

def style_loss(Y_hat, gram_Y):
    return F.mse_loss(gram(Y_hat), gram_Y)

5.3 总变差损失

有时候我们学到的合成图像里面有大量高频噪点即有特别亮或者特别暗的颗粒像素。一种常用的降噪方法是总变差降噪（total variation denoising。假设$x_{i,j}$表示坐标为$(i,j)$的像素值降低总变差损失

$$\sum _{i,j}\left|x_{i,j}-x_{i+1,j}\right|+\left|x_{i,j}-x_{i,j+1}\right|$$

能够尽可能使邻近的像素值相似。

def tv_loss(Y_hat):
    return 0.5 * (F.l1_loss(Y_hat[:, :, 1:, :], Y_hat[:, :, :-1, :]) + 
                  F.l1_loss(Y_hat[:, :, :, 1:], Y_hat[:, :, :, :-1]))

5.4 损失函数

样式迁移的损失函数即内容损失、样式损失和总变差损失的加权和。通过调节这些权值超参数我们可以权衡合成图像在保留内容、迁移样式以及降噪三方面的相对重要性。

content_weight, style_weight, tv_weight = 1, 1e3, 10

def compute_loss(X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram):
    # 分别计算内容损失、样式损失和总变差损失
    contents_l = [content_loss(Y_hat, Y) * content_weight for Y_hat, Y in zip(
        contents_Y_hat, contents_Y)]
    styles_l = [style_loss(Y_hat, Y) * style_weight for Y_hat, Y in zip(
        styles_Y_hat, styles_Y_gram)]
    tv_l = tv_loss(X) * tv_weight
    # 对所有损失求和
    l = sum(styles_l) + sum(contents_l) + tv_l
    return contents_l, styles_l, tv_l, l

6. 创建和初始化合成图像

在样式迁移中合成图像是唯一需要更新的变量。因此我们可以定义一个简单的模型GeneratedImage并将合成图像视为模型参数。模型的前向计算只需返回模型参数即可。

class GeneratedImage(torch.nn.Module):
    def __init__(self, img_shape):
        super(GeneratedImage, self).__init__()
        self.weight = torch.nn.Parameter(torch.rand(*img_shape))

    def forward(self):
        return self.weight

下面我们定义get_inits函数。该函数创建了合成图像的模型实例并将其初始化为图像X。样式图像在各个样式层的格拉姆矩阵styles_Y_gram将在训练前预先计算好。

def get_inits(X, device, lr, styles_Y):
    gen_img = GeneratedImage(X.shape).to(device)
    gen_img.weight.data = X.data
    optimizer = torch.optim.Adam(gen_img.parameters(), lr=lr)
    styles_Y_gram = [gram(Y) for Y in styles_Y]
    return gen_img(), styles_Y_gram, optimizer

7. 训练模型并输出合成图像

在训练模型时我们不断抽取合成图像的内容特征和样式特征并计算损失函数。

def train(X, contents_Y, styles_Y, device, lr, max_epochs, lr_decay_epoch):
    print("training on ", device)
    X, styles_Y_gram, optimizer = get_inits(X, device, lr, styles_Y)
    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, lr_decay_epoch, gamma=0.1)
    for i in range(max_epochs):
        start = time.time()
        
        contents_Y_hat, styles_Y_hat = extract_features(
                X, content_layers, style_layers)
        contents_l, styles_l, tv_l, l = compute_loss(
                X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram)
        
        optimizer.zero_grad()
        l.backward(retain_graph = True)
        optimizer.step()
        scheduler.step()
        
        if i % 50 == 0 and i != 0:
            print('epoch %3d, content loss %.2f, style loss %.2f, '
                  'TV loss %.2f, %.2f sec'
                  % (i, sum(contents_l).item(), sum(styles_l).item(), tv_l.item(),
                     time.time() - start))
    return X.detach()

下面我们开始训练模型。首先将内容图像和样式图像的高和宽分别调整为150和225像素。合成图像将由内容图像来初始化。

image_shape =  (150, 225)
net = net.to(device)
content_X, contents_Y = get_contents(image_shape, device)
style_X, styles_Y = get_styles(image_shape, device)
output = train(content_X, contents_Y, styles_Y, device, 0.01, 500, 200)

输出

training on  cpu
epoch  50, content loss 0.24, style loss 1.11, TV loss 1.33, 1.72 sec
epoch 100, content loss 0.24, style loss 0.81, TV loss 1.20, 1.54 sec
epoch 150, content loss 0.24, style loss 0.73, TV loss 1.12, 1.56 sec
epoch 200, content loss 0.24, style loss 0.68, TV loss 1.06, 1.50 sec
epoch 250, content loss 0.24, style loss 0.68, TV loss 1.05, 1.90 sec
epoch 300, content loss 0.24, style loss 0.67, TV loss 1.04, 1.60 sec
epoch 350, content loss 0.24, style loss 0.67, TV loss 1.04, 1.57 sec
epoch 400, content loss 0.24, style loss 0.67, TV loss 1.03, 1.62 sec
epoch 450, content loss 0.24, style loss 0.67, TV loss 1.03, 1.40 sec

下面我们查看一下训练好的合成图像。可以看到下图中的合成图像保留了内容图像的风景和物体并同时迁移了样式图像的色彩。因为图像尺寸较小所以细节上依然比较模糊。

d2l.plt.imshow(postprocess(output));

为了得到更加清晰的合成图像下面我们在更大的$300\times 450$尺寸上训练。我们将图片的高和宽放大2倍以初始化更大尺寸的合成图像。

image_shape = (300, 450)
_, content_Y = get_contents(image_shape, device)
_, style_Y = get_styles(image_shape, device)
X = preprocess(postprocess(output), image_shape).to(device)
big_output = train(X, content_Y, style_Y, device, 0.01, 500, 200)

输出:

training on  cpu
epoch  50, content loss 0.34, style loss 0.62, TV loss 0.79, 5.00 sec
epoch 100, content loss 0.31, style loss 0.50, TV loss 0.74, 5.39 sec
epoch 150, content loss 0.29, style loss 0.45, TV loss 0.72, 4.91 sec
epoch 200, content loss 0.28, style loss 0.43, TV loss 0.70, 4.99 sec
epoch 250, content loss 0.28, style loss 0.42, TV loss 0.69, 5.59 sec
epoch 300, content loss 0.28, style loss 0.42, TV loss 0.69, 4.96 sec
epoch 350, content loss 0.28, style loss 0.42, TV loss 0.69, 4.42 sec
epoch 400, content loss 0.28, style loss 0.42, TV loss 0.69, 5.81 sec
epoch 450, content loss 0.28, style loss 0.42, TV loss 0.69, 5.10 sec

可以看到由于图像尺寸更大每一次迭代需要花费更多的时间。下面我们查看一下训练好的合成图像。

d2l.set_figsize((7, 5))
d2l.plt.imshow(postprocess(big_output));

从训练得到的图中可以看到此时的合成图像因为尺寸更大所以保留了更多的细节。合成图像里面不仅有大块的类似样式图像的油画色彩块色彩块中甚至出现了细微的纹理。

总结

• 样式迁移常用的损失函数由3部分组成内容损失使合成图像与内容图像在内容特征上接近样式损失令合成图像与样式图像在样式特征上接近而总变差损失则有助于减少合成图像中的噪点。
• 可以通过预训练的卷积神经网络来抽取图像的特征并通过最小化损失函数来不断更新合成图像。
• 用格拉姆矩阵表达样式层输出的样式。

好啦这篇文章的内容就介绍到这里喜欢的小伙伴记得点赞收藏哦~快来一起创作自己喜欢的图片吧