样式迁移（neural style）

作者: 小黄不头秃 | 来源:发表于2022-09-25 10:39 被阅读0次

(一)样式迁移(neural style)

就是有两张图片，例如一张人像，一张油画，你想把优化的风格迁移到人像上。生成一张油画版的新的人像。

（1）基于CNN的样式迁移

从图中看出似乎有三个神经网络，实际上是只有一个神经网络。这图的意思是，我们希望输出值是左右两张图片的结合，但是具体怎么结合呢？就是让有些层能够和左边网络的某些层匹配。还有些曾能够和右边的样式的某些层匹配。左边的层主要是抽取图片的内容信息。右边的层主要抽取图片的纹理信息。两者结合在一起，就能生成我们想要的图片。

我们以前所使用的网络都是更新网络中层的参数，但是这里不同，由于是需要对输入的图片进行改变而不是进行参数的权重更新，那么我们将网络层的参数固定，将输入做成可以更新的，然后在生成我们所需要的样式图片。

（2）基于CNN的样式迁移怎么训练

这和前面我们的神经网络在技术上没有什么区别，但是他的训练方式比较奇特。他的目标是生成一张带有风格样式的图片。

我们知道神经网络层的作用是使用不同的卷积核能提取特征信息，经过训练的网络的卷积核往往能够将图片的纹理信息，空间信息提取出来。于是基于CNN的样式迁移就使用了已经训练好的VGG模型，利用训练好的卷积核分别提取两张图片的内容和样式信息，共同作用出一张样式图像。

第一个区别，一般的网络是更新网络里的参数，然而在这个网络中，我们是相当于修改输入，而网络中的参数是固定不变的。
第二个大区别是，loss函数的定义，这个网络总共由三个部分的loss组成，

内容损失，生成的x和原图之间的差距
风格损失，生成的x和风格图片之间的差距
全变分损失，让图片没那么多噪点。

缺点，每张图片我们都需要重新训练。
具体实现可以参考代码。

（二）代码实现

%matplotlib inline
import torch 
import torchvision 
from torch import nn 
from d2l import torch as d2l

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

原图

style_img = d2l.Image.open('../img/autumn-oak.jpg')
d2l.plt.imshow(style_img)

风格图

rgb_mean = torch.tensor([0.485, 0.456, 0.406])
rgb_std = torch.tensor([0.229, 0.224, 0.225])

# 将图片处理成一个tensor
def preprocess(img, image_shape):
    transforms = torchvision.transforms.Compose([
        torchvision.transforms.Resize(image_shape),
        torchvision.transforms.ToTensor(), # 会除以255
        torchvision.transforms.Normalize(mean=rgb_mean, std=rgb_std)])
    return transforms(img).unsqueeze(0)

# 将一个tensor输出成一张图片
def postprocess(img):
    img = img[0].to(rgb_std.device)
    img = torch.clamp(img.permute(1, 2, 0) * rgb_std + rgb_mean, 0, 1)
    return torchvision.transforms.ToPILImage()(img.permute(2, 0, 1))

# 使用CGG作为预训练模型
pretrained_net = torchvision.models.vgg19(weights=torchvision.models.VGG19_Weights.IMAGENET1K_V1)

# 层的下标
style_layers, content_layers = [0,5,10,19,28], [26]

# 抽取对应的层
net = nn.Sequential(*[pretrained_net.features[i] for i in range(max(style_layers+content_layers))])

# 抽取特征
def extract_features(x, content_layers, style_layers):
    contents = []
    styles = []
    for i in range(len(net)):
        # 前向传播，获取featuremap
        x = net[i](x)
        if i in style_layers:
            styles.append(x)
        if i in content_layers:
            contents.append(x)
    return contents, styles

# 图片预处理
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)
    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)
    return style_X, styles_Y

（1）内容损失

就直接可以使用均方损失，计算对应像素的均方损失。

（2）风格损失

风格损失与内容损失类似，也通过平方误差函数衡量合成图像与风格图像在风格上的差异。
为了表达风格层输出的风格，我们先通过extract_features函数计算风格层的输出。
假设该输出的样本数为1，通道数为 $c$ ，高和宽分别为 $h$ 和 $w$ ，我们可以将此输出转换为矩阵 $\mathbf{X}$ ，其有 $c$ 行和 $hw$ 列。
这个矩阵可以被看作是由 $c$ 个长度为 $hw$ 的向量 $\mathbf{x}_1, \ldots, \mathbf{x}_c$ 组合而成的。其中向量 $\mathbf{x}_i$ 代表了通道 $i$ 上的风格特征。

在这些向量的格拉姆矩阵 $\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$ 。

（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 content_loss(y_hat, y):
    return torch.square(y_hat - y.detach()).mean()

def gram(X):
    num_channels, n = X.shape[1], X.numel() // X.shape[1]
    X = X.reshape((num_channels, n))
    return torch.matmul(X, X.T) / (num_channels * n)

def style_loss(Y_hat, gram_Y):
    return torch.square(gram(Y_hat) - gram_Y.detach()).mean()

# tv降噪，就是让像素较为平均
def tv_loss(Y_hat):
    return 0.5 * (torch.abs(Y_hat[:, :, 1:, :] - Y_hat[:, :, :-1, :]).mean() +
                  torch.abs(Y_hat[:, :, :, 1:] - Y_hat[:, :, :, :-1]).mean())

# 三个loss之间的权重
content_weight, style_weight, tv_weight = 1, 10 * 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 + contents_l + [tv_l])
    return contents_l, styles_l, tv_l, l

# 这是一个特殊的结构，生成一个和输入图片一样大小的weight，用于更新图片
class SynthesizedImage(nn.Module):
    def __init__(self, img_shape, **kwargs):
        super(SynthesizedImage, self).__init__(**kwargs)
        self.weight = nn.Parameter(torch.rand(*img_shape))

    def forward(self):
        return self.weight

# 初始化函数
def get_inits(X, device, lr, styles_Y):
    gen_img = SynthesizedImage(X.shape).to(device)
    gen_img.weight.data.copy_(X.data)
    trainer = torch.optim.Adam(gen_img.parameters(), lr=lr)
    styles_Y_gram = [gram(Y) for Y in styles_Y]
    return gen_img(), styles_Y_gram, trainer

# 训练函数
def train(X, contents_Y, styles_Y, device, lr, num_epochs, lr_decay_epoch):
    X, styles_Y_gram, trainer = get_inits(X, device, lr, styles_Y)
    scheduler = torch.optim.lr_scheduler.StepLR(trainer, lr_decay_epoch, 0.8)
    animator = d2l.Animator(xlabel='epoch', ylabel='loss',
                            xlim=[10, num_epochs],
                            legend=['content', 'style', 'TV'],
                            ncols=2, figsize=(7, 2.5))
    for epoch in range(num_epochs):
        trainer.zero_grad()
        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)
        l.backward()
        trainer.step()
        scheduler.step()
        if (epoch + 1) % 10 == 0:
            animator.axes[1].imshow(postprocess(X))
            animator.add(epoch + 1, [float(sum(contents_l)),
                                     float(sum(styles_l)), float(tv_l)])
    return X

device, image_shape = d2l.try_gpu(), (300, 450)
net = net.to(device)
content_X, contents_Y = get_contents(image_shape, device)
_, styles_Y = get_styles(image_shape, device)
output = train(content_X, contents_Y, styles_Y, device, 0.3, 500, 50)

结果图

样式迁移（neural style）

(一)样式迁移(neural style)

（1）基于CNN的样式迁移

（2）基于CNN的样式迁移怎么训练

（二）代码实现

（1）内容损失

（2）风格损失

（3）全变分损失

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读