風(fēng)格遷移

本節(jié)將介紹如何使用卷積神經(jīng)網(wǎng)絡(luò)，自動將一個圖像中的風(fēng)格應(yīng)用在另一圖像之上，即風(fēng)格遷移（style transfer） (Gatys et al., 2016)。 這里我們需要兩張輸入圖像：一張是內(nèi)容圖像，另一張是風(fēng)格圖像。 我們將使用神經(jīng)網(wǎng)絡(luò)修改內(nèi)容圖像，使其在風(fēng)格上接近風(fēng)格圖像。 例如， 圖中的內(nèi)容圖像為本書作者在西雅圖郊區(qū)的雷尼爾山國家公園拍攝的風(fēng)景照，而風(fēng)格圖像則是一幅主題為秋天橡樹的油畫。 最終輸出的合成圖像應(yīng)用了風(fēng)格圖像的油畫筆觸讓整體顏色更加鮮艷，同時保留了內(nèi)容圖像中物體主體的形狀。

方法

首先，我們初始化合成圖像，例如將其初始化為內(nèi)容圖像。 該合成圖像是風(fēng)格遷移過程中唯一需要更新的變量，即風(fēng)格遷移所需迭代的模型參數(shù)。 然后，我們選擇一個預(yù)訓(xùn)練的卷積神經(jīng)網(wǎng)絡(luò)來抽取圖像的特征，其中的模型參數(shù)在訓(xùn)練中無須更新。 這個深度卷積神經(jīng)網(wǎng)絡(luò)憑借多個層逐級抽取圖像的特征，我們可以選擇其中某些層的輸出作為內(nèi)容特征或風(fēng)格特征。 以下圖為例，這里選取的預(yù)訓(xùn)練的神經(jīng)網(wǎng)絡(luò)含有3個卷積層，其中第二層輸出內(nèi)容特征，第一層和第三層輸出風(fēng)格特征。

接下來，我們通過前向傳播（實線箭頭方向）計算風(fēng)格遷移的損失函數(shù)，并通過反向傳播（虛線箭頭方向）迭代模型參數(shù)，即不斷更新合成圖像。 風(fēng)格遷移常用的損失函數(shù)由3部分組成：

1. 內(nèi)容損失使合成圖像與內(nèi)容圖像在內(nèi)容特征上接近；

2. 風(fēng)格損失使合成圖像與風(fēng)格圖像在風(fēng)格特征上接近；

3. 全變分損失則有助于減少合成圖像中的噪點。

最后，當(dāng)模型訓(xùn)練結(jié)束時，我們輸出風(fēng)格遷移的模型參數(shù)，即得到最終的合成圖像。

在下面，我們將通過代碼來進(jìn)一步了解風(fēng)格遷移的技術(shù)細(xì)節(jié)。

閱讀內(nèi)容和風(fēng)格圖像

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

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

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

預(yù)處理和后處理

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

def preprocess(img, image_shape):
    transforms = torchvision.transforms.Compose([
        torchvision.transforms.Resize(image_shape),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize(mean=rgb_mean, std=rgb_std)])
    return transforms(img).unsqueeze(0)

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))

preprocess 函數(shù)接受一個輸入圖像 img 和一個 image_shape 參數(shù)作為輸入。它使用 torchvision.transforms.Resize 將圖像大小調(diào)整為指定的大小，使用 torchvision.transforms.ToTensor 將圖像轉(zhuǎn)換為張量，并使用 torchvision.transforms.Normalize 對張量進(jìn)行歸一化，其中的均值和標(biāo)準(zhǔn)差值分別由 rgb_mean 和 rgb_std 定義。最后，它使用 unsqueeze(0) 添加了一個額外的維度，以創(chuàng)建一個批次維度，然后返回預(yù)處理后的張量。

postprocess 函數(shù)接受一個張量 img 作為輸入。它通過使用索引 [0] 移除批次維度，使用 .to(rgb_std.device) 將張量移動到 rgb_std 所在的設(shè)備上，然后使用 torch.clamp 和 * 操作對張量進(jìn)行反歸一化。torch.clamp 函數(shù)用于確保像素值在 0 和 1 之間，因為歸一化可能導(dǎo)致某些值超出此范圍。最后，它使用 torchvision.transforms.ToPILImage() 將張量轉(zhuǎn)換回 PIL 圖像，并使用 .permute(2, 0, 1) 對維度進(jìn)行排列，以便通道成為最后一個維度，然后返回圖像。

歸一化是將數(shù)據(jù)轉(zhuǎn)換為特定范圍內(nèi)的值的過程。在計算機(jī)視覺中，通常使用均值和標(biāo)準(zhǔn)差來對圖像進(jìn)行歸一化。這是因為圖像中的每個像素都可以視為一組數(shù)字，每個數(shù)字的值在 0 到 255 之間。因此，對圖像進(jìn)行歸一化可以將像素值縮放到 0 到 1 之間，使它們更易于處理和比較。在本代碼中，torchvision.transforms.Normalize 函數(shù)用于對圖像進(jìn)行歸一化，其中 rgb_mean 和 rgb_std 定義了用于標(biāo)準(zhǔn)化圖像的均值和標(biāo)準(zhǔn)差值。

反歸一化是將數(shù)據(jù)從歸一化范圍內(nèi)的值轉(zhuǎn)換為原始值的過程。在計算機(jī)視覺中，反歸一化通常用于將模型輸出轉(zhuǎn)換回原始圖像的像素值范圍。在本代碼中，postprocess 函數(shù)中的 torch.clamp 和 * 操作用于對張量進(jìn)行反歸一化，以將像素值從歸一化范圍內(nèi)的值轉(zhuǎn)換為原始圖像像素值。

抽取圖像特征

pretrained_net = torchvision.models.vgg19(pretrained=True)
print(pretrained_net)

結(jié)構(gòu)為：

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (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=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (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=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (17): ReLU(inplace=True)
    (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=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (24): ReLU(inplace=True)
    (25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (26): ReLU(inplace=True)
    (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=True)
    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (31): ReLU(inplace=True)
    (32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (33): ReLU(inplace=True)
    (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (35): ReLU(inplace=True)
    (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=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

為了抽取圖像的內(nèi)容特征和風(fēng)格特征，我們可以選擇VGG網(wǎng)絡(luò)中某些層的輸出。 一般來說，越靠近輸入層，越容易抽取圖像的細(xì)節(jié)信息；反之，則越容易抽取圖像的全局信息。 為了避免合成圖像過多保留內(nèi)容圖像的細(xì)節(jié)，我們選擇VGG較靠近輸出的層，即內(nèi)容層，來輸出圖像的內(nèi)容特征。 我們還從VGG中選擇不同層的輸出來匹配局部和全局的風(fēng)格，這些圖層也稱為風(fēng)格層。 VGG網(wǎng)絡(luò)使用了5個卷積塊。 實驗中，我們選擇第四卷積塊的最后一個卷積層作為內(nèi)容層，選擇每個卷積塊的第一個卷積層作為風(fēng)格層。 這些層的索引可以通過打印pretrained_net實例獲取。

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

使用VGG層抽取特征時，我們只需要用到從輸入層到最靠近輸出層的內(nèi)容層或風(fēng)格層之間的所有層。 下面構(gòu)建一個新的網(wǎng)絡(luò)net，它只保留需要用到的VGG的所有層。

net = nn.Sequential(*[pretrained_net.features[i] for i in
                      range(max(content_layers + style_layers) + 1)])

這些層的選擇是由 content_layers 和 style_layers 兩個列表決定的。content_layers 列表包含用于內(nèi)容提取的層的索引，而 style_layers 列表包含用于風(fēng)格提取的層的索引。這些層的索引是根據(jù) VGG19 的結(jié)構(gòu)確定的，因為在該模型的特定層中提取的特征已被證明對于內(nèi)容和風(fēng)格的捕捉非常有用。

給定輸入X，如果我們簡單地調(diào)用前向傳播net(X)，只能獲得最后一層的輸出。 由于我們還需要中間層的輸出，因此這里我們逐層計算，并保留內(nèi)容層和風(fēng)格層的輸出。

def extract_features(X, content_layers, style_layers):
    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

這段代碼定義了一個函數(shù) extract_features，它接受輸入圖像 X，以及用于內(nèi)容提取和風(fēng)格提取的層索引列表 content_layers 和 style_layers。

函數(shù)中的 for 循環(huán)逐層遍歷了神經(jīng)網(wǎng)絡(luò) net，并應(yīng)用了輸入圖像 X，以獲取每一層的輸出。如果當(dāng)前層的索引在 style_layers 中，則將該層的輸出添加到 styles 列表中。如果當(dāng)前層的索引在 content_layers 中，則將該層的輸出添加到 contents 列表中。最后，函數(shù)返回 contents 和 styles 兩個列表，分別包含了用于內(nèi)容和風(fēng)格提取的層的輸出。

這個函數(shù)的目的是使用神經(jīng)網(wǎng)絡(luò) net 中的層來提取輸入圖像的內(nèi)容和風(fēng)格特征。特別地，contents 列表包含了用于表示輸入圖像內(nèi)容的特征，而 styles 列表包含了用于表示輸入圖像風(fēng)格的特征。這些特征將用于計算損失函數(shù)，進(jìn)而用于訓(xùn)練風(fēng)格遷移模型。

下面定義兩個函數(shù)：get_contents函數(shù)對內(nèi)容圖像抽取內(nèi)容特征； get_styles函數(shù)對風(fēng)格圖像抽取風(fēng)格特征。 因為在訓(xùn)練時無須改變預(yù)訓(xùn)練的VGG的模型參數(shù)，所以我們可以在訓(xùn)練開始之前就提取出內(nèi)容特征和風(fēng)格特征。 由于合成圖像是風(fēng)格遷移所需迭代的模型參數(shù)，我們只能在訓(xùn)練過程中通過調(diào)用extract_features函數(shù)來抽取合成圖像的內(nèi)容特征和風(fēng)格特征。

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

損失函數(shù)

下面我們來描述風(fēng)格遷移的損失函數(shù)。 它由內(nèi)容損失、風(fēng)格損失和全變分損失3部分組成。

內(nèi)容損失

與線性回歸中的損失函數(shù)類似，內(nèi)容損失通過平方誤差函數(shù)衡量合成圖像與內(nèi)容圖像在內(nèi)容特征上的差異。 平方誤差函數(shù)的兩個輸入均為extract_features函數(shù)計算所得到的內(nèi)容層的輸出。

def content_loss(Y_hat, Y):
    # 我們從動態(tài)計算梯度的樹中分離目標(biāo)：
    # 這是一個規(guī)定的值，而不是一個變量。
    return torch.square(Y_hat - Y.detach()).mean()

風(fēng)格損失

風(fēng)格損失與內(nèi)容損失類似，也通過平方誤差函數(shù)衡量合成圖像與風(fēng)格圖像在風(fēng)格上的差異。了表達(dá)風(fēng)格層輸出的風(fēng)格，我們先通過extract_features函數(shù)計算風(fēng)格層的輸出。 假設(shè)該輸出的樣本數(shù)為$1$,通道數(shù)為$c$，高和寬分別為$h$和$w$，我們可以將此輸出轉(zhuǎn)換為矩陣$X$，其有$c$行和$wh$列。 這個矩陣可以被看作由$c$個長度為$wh$的向量$x_1,...,x_c$組合而成的。其中向量$x_i$代表了通道$i$上的風(fēng)格特征。

在這些向量的格拉姆矩陣$X{X}^T\in R^{c\times c}$中，$i$行$j$列的元素$x_{ij}$即向量$x_i$和$x_j$的內(nèi)積。它表達(dá)了通道$i$和通道$j$上風(fēng)格特征的相關(guān)性。我們用這樣的格拉姆矩陣來表達(dá)風(fēng)格層輸出的風(fēng)格。 需要注意的是，當(dāng)$hw$的值較大時，格拉姆矩陣中的元素容易出現(xiàn)較大的值。 此外，格拉姆矩陣的高和寬皆為通道數(shù)$c$。 為了讓風(fēng)格損失不受這些值的大小影響，下面定義的gram函數(shù)將格拉姆矩陣除以了矩陣中元素的個數(shù)，即$chw$

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)

這段代碼定義了一個函數(shù) gram，它接受一個張量 X 作為輸入，并返回 X 的 Gram 矩陣。Gram 矩陣是一種用于描述特征之間相關(guān)性的矩陣，通常用于計算輸入圖像的風(fēng)格特征。

具體來說，這個函數(shù)首先獲取輸入張量 X 的通道數(shù)和像素數(shù)量，并將其重塑為一個形狀為 (num_channels, n) 的矩陣，其中 num_channels 是通道數(shù)，n 是像素數(shù)量。然后，函數(shù)計算矩陣乘積 X @ X.T，并將結(jié)果除以 (num_channels * n)，以歸一化 Gram 矩陣的值。最后，函數(shù)返回歸一化的 Gram 矩陣。

自然地，風(fēng)格損失的平方誤差函數(shù)的兩個格拉姆矩陣輸入分別基于合成圖像與風(fēng)格圖像的風(fēng)格層輸出。這里假設(shè)基于風(fēng)格圖像的格拉姆矩陣gram_Y已經(jīng)預(yù)先計算好了

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

全變分損失

有時候，我們學(xué)到的合成圖像里面有大量高頻噪點，即有特別亮或者特別暗的顆粒像素。 一種常見的去噪方法是全變分去噪（total variation denoising）： 假設(shè)$x_{i,j}$表示坐標(biāo)$(i,j)$處的像素值，降低全變分損失
$$\sum _{i,j}|x_{i,j}?x_{i+1,j}|+|x_{i,j}?x_{i,j+1}|$$
能夠盡可能使鄰近的像素值相似。

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())

總損失函數(shù)

風(fēng)格轉(zhuǎn)移的損失函數(shù)是內(nèi)容損失、風(fēng)格損失和總變化損失的加權(quán)和。 通過調(diào)節(jié)這些權(quán)重超參數(shù)，我們可以權(quán)衡合成圖像在保留內(nèi)容、遷移風(fēng)格以及去噪三方面的相對重要性。

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

def compute_loss(X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram):
    # 分別計算內(nèi)容損失、風(fēng)格損失和全變分損失
    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(10 * styles_l + contents_l + [tv_l])
    return contents_l, styles_l, tv_l, l

初始化合成圖像

在風(fēng)格遷移中，合成的圖像是訓(xùn)練期間唯一需要更新的變量。因此，我們可以定義一個簡單的模型SynthesizedImage，并將合成的圖像視為模型參數(shù)。模型的前向傳播只需返回模型參數(shù)即可。

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

下面，我們定義get_inits函數(shù)。該函數(shù)創(chuàng)建了合成圖像的模型實例，并將其初始化為圖像X。風(fēng)格圖像在各個風(fēng)格層的格拉姆矩陣styles_Y_gram將在訓(xùn)練前預(yù)先計算好。

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

訓(xùn)練模型

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

現(xiàn)在我們訓(xùn)練模型： 首先將內(nèi)容圖像和風(fēng)格圖像的高和寬分別調(diào)整為300和450像素，用內(nèi)容圖像來初始化合成圖像。

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)

文章來源地址http://www.zghlxwxcb.cn/news/detail-635575.html

到了這里，關(guān)于計算機(jī)視覺：風(fēng)格遷移的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！