这里，系数 λ 控制两个损失之间的相对重要性。CycleGAN 旨在解决以下极小极大目标：

        ​​​​​​​        ​​​​​​​        

实施 CycleGAN

此示例包含位于Advanced-Deep-Learning-with-Python/Chapter05/cyclegan at master · PacktPublishing/Advanced-Deep-Learning-with-Python · GitHub的几个源文件。除了TF，代码还依赖tensorflow_addons和imageio包。您可以使用pip软件包安装程序安装它们。我们将为多个训练数据集实现 CycleGAN，所有这些数据集均由论文作者提供。在运行示例之前，您必须借助download_dataset.sh可执行脚本下载相关数据集，该脚本使用数据集名称作为参数。可用数据集的列表包含在文件中。一旦你下载了这个，你可以在类的帮助下访问图像，DataLoader该类位于data_loader.py模块（我们不会在这里包含它的源代码）。可以说，该类可以将标准化图像的小批量和整个数据集加载为数组。我们还将省略通常的导入。 numpy

构建生成器和判别器

首先，我们将实现该build_generator功能。到目前为止，我们看到的 GAN 模型都是从某种潜在向量开始的。但是在这里，生成器的输入是来自其中一个域的图像，输出是来自相反域的图像。按照论文的指导，生成器是一个 U-Net 风格的网络。它有一个下采样编码器、一个上采样解码器以及相应编码器/解码器块之间的快捷连接。我们将从build_generator定义开始：

def build_generator(img: Input) -> Model:

U-Net 下采样编码器由许多带有LeakyReLU激活的卷积层组成，然后是InstanceNormalization. 批量和实例规范化之间的区别在于批量规范化在整个小批量中计算其参数，而实例规范化为小批量的每个图像分别计算它们。为清楚起见，我们将实现一个名为 的单独子例程downsampling2d，它定义了一个这样的层。当我们构建网络编码器时，我们将使用这个函数来构建必要的层数（请注意这里的缩进；downsampling2d是定义在 中的子程序build_generator）：

    def downsampling2d(layer_input, filters: int):
        """Layers used in the encoder"""
        d = Conv2D(filters=filters,
                   kernel_size=4,
                   strides=2,
                   padding='same')(layer_input)
        d = LeakyReLU(alpha=0.2)(d)
        d = InstanceNormalization()(d)
        return d

接下来，让我们关注解码器，它不是用转置卷积实现的。相反，输入数据通过该操作进行上采样，该UpSampling2D操作只是将每个输入像素复制为 2 × 2 补丁。接下来是常规卷积以平滑补丁。此平滑输出与skip_input来自相应编码器块的快捷方式（或 ）连接相连接。解码器由许多这样的上采样块组成。为清楚起见，我们将实现一个名为 的单独子例程upsampling2d，它定义了一个这样的块。我们将使用它为网络解码器构建必要数量的块（请注意此处的缩进；upsampling2d是定义在 中的子例程build_generator）：

    def upsampling2d(layer_input, skip_input, filters: int):
        """
        Layers used in the decoder
        :param layer_input: input layer
        :param skip_input: another input from the corresponding encoder block
        :param filters: number of filters
        """
        u = UpSampling2D(size=2)(layer_input)
        u = Conv2D(filters=filters,
                   kernel_size=4,
                   strides=1,
                   padding='same',
                   activation='relu')(u)
        u = InstanceNormalization()(u)
        u = Concatenate()([u, skip_input])
        return u

接下来，我们将使用我们刚刚定义的子例程来实现 U-Net 的完整定义（请注意此处的缩进；代码是 的一部分build_generator）：

    # Encoder
    gf = 32
    d1 = downsampling2d(img, gf)
    d2 = downsampling2d(d1, gf * 2)
    d3 = downsampling2d(d2, gf * 4)
    d4 = downsampling2d(d3, gf * 8)

    # Decoder
    # Note that we concatenate each upsampling2d block with
    # its corresponding downsampling2d block, as per U-Net
    u1 = upsampling2d(d4, d3, gf * 4)
    u2 = upsampling2d(u1, d2, gf * 2)
    u3 = upsampling2d(u2, d1, gf)

    u4 = UpSampling2D(size=2)(u3)
    output_img = Conv2D(3, kernel_size=4, strides=1, padding='same',
    activation='tanh')(u4)

    model = Model(img, output_img)

    model.summary()

    return model

然后，我们应该实现该build_discriminator功能。我们将在这里省略实现，因为它是一个相当简单的 CNN，类似于前面示例中显示的那些（你可以在本书的 GitHub 存储库中找到它）。唯一的区别是，它不是使用批量规范化，而是使用实例规范化。

把它们放在一起

此时，我们通常会实现该train方法，但由于 CycleGAN 的组件较多，我们将向您展示如何构建整个模型。首先，我们实例化data_loader对象，您可以在其中指定训练集的名称（随意尝试不同的数据集）。所有图像都将调整img_res=(IMG_SIZE, IMG_SIZE)为网络输入的大小，其中IMG_SIZE = 256（您也可以尝试128加快训练过程）：

# Input shape
img_shape = (IMG_SIZE, IMG_SIZE, 3)

# Configure data loader
data_loader = DataLoader(dataset_name='facades',
                         img_res=(IMG_SIZE, IMG_SIZE))

然后，我们将定义优化器和损失权重：

lambda_cycle = 10.0  # Cycle-consistency loss
lambda_id = 0.1 * lambda_cycle  # Identity loss

optimizer = Adam(0.0002, 0.5)

接下来，我们将创建两个生成器g_XY和g_YX，以及它们对应的鉴别器d_Y和d_X。我们还将创建combined模型来同时训练两个生成器。然后，我们将创建复合损失函数，其中包含一个附加的恒等映射项。您可以在相应的论文中阅读更多相关信息，但简而言之，当将图像从绘画域转换为照片域时，它有助于保持输入和输出之间的颜色组合：

# Build and compile the discriminators
d_X = build_discriminator(Input(shape=img_shape))
d_Y = build_discriminator(Input(shape=img_shape))
d_X.compile(loss='mse', optimizer=optimizer, metrics=['accuracy'])
d_Y.compile(loss='mse', optimizer=optimizer, metrics=['accuracy'])

# Build the generators
img_X = Input(shape=img_shape)
g_XY = build_generator(img_X)

img_Y = Input(shape=img_shape)
g_YX = build_generator(img_Y)

# Translate images to the other domain
fake_Y = g_XY(img_X)
fake_X = g_YX(img_Y)

# Translate images back to original domain
reconstr_X = g_YX(fake_Y)
reconstr_Y = g_XY(fake_X)

# Identity mapping of images
img_X_id = g_YX(img_X)
img_Y_id = g_XY(img_Y)

# For the combined model we will only train the generators
d_X.trainable = False
d_Y.trainable = False

# Discriminators determines validity of translated images
valid_X = d_X(fake_X)
valid_Y = d_Y(fake_Y)

# Combined model trains both generators to fool the two discriminators
combined = Model(inputs=[img_X, img_Y],
                 outputs=[valid_X, valid_Y,
                          reconstr_X, reconstr_Y,
                          img_X_id, img_Y_id])

接下来，让我们配置combined模型进行训练：

combined.compile(loss=['mse', 'mse',
                       'mae', 'mae',
                       'mae', 'mae'],
                 loss_weights=[1, 1,
                               lambda_cycle, lambda_cycle,
                               lambda_id, lambda_id],
                 optimizer=optimizer)

模型准备好后，我们使用该train函数启动训练过程。根据论文的指南，我们将使用大小为 1 的 mini-batch：

train(epochs=200, batch_size=1, data_loader=data_loader,
      g_XY=g_XY,
      g_YX=g_YX,
      d_X=d_X,
      d_Y=d_Y,
      combined=combined,
      sample_interval=200)

最后，我们将实现该train功能。它与之前的 GAN 模型有些相似，但它也考虑了两对生成器和判别器：

def train(epochs: int, data_loader: DataLoader,
          g_XY: Model, g_YX: Model, d_X: Model, d_Y: Model, 
          combined:Model, batch_size=1, sample_interval=50):
    start_time = datetime.datetime.now()

    # Calculate output shape of D (PatchGAN)
    patch = int(IMG_SIZE / 2 ** 4)
    disc_patch = (patch, patch, 1)

    # GAN loss ground truths
    valid = np.ones((batch_size,) + disc_patch)
    fake = np.zeros((batch_size,) + disc_patch)

    for epoch in range(epochs):
        for batch_i, (imgs_X, imgs_Y) in
        enumerate(data_loader.load_batch(batch_size)):
            # Train the discriminators

            # Translate images to opposite domain
            fake_Y = g_XY.predict(imgs_X)
            fake_X = g_YX.predict(imgs_Y)

            # Train the discriminators (original images = real /
            translated = Fake)
            dX_loss_real = d_X.train_on_batch(imgs_X, valid)
            dX_loss_fake = d_X.train_on_batch(fake_X, fake)
            dX_loss = 0.5 * np.add(dX_loss_real, dX_loss_fake)

            dY_loss_real = d_Y.train_on_batch(imgs_Y, valid)
            dY_loss_fake = d_Y.train_on_batch(fake_Y, fake)
            dY_loss = 0.5 * np.add(dY_loss_real, dY_loss_fake)

            # Total discriminator loss
            d_loss = 0.5 * np.add(dX_loss, dY_loss)

            # Train the generators
            g_loss = combined.train_on_batch([imgs_X, imgs_Y],
                                             [valid, valid,
                                              imgs_X, imgs_Y,
                                              imgs_X, imgs_Y])

            elapsed_time = datetime.datetime.now() - start_time

            # Plot the progress
            print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f, acc: %3d%%]
            [G loss: %05f, adv: %05f, recon: %05f, id: %05f] time: %s " \ 
            % (epoch, epochs, batch_i, data_loader.n_batches, d_loss[0], 
            100 * d_loss[1], g_loss[0], np.mean(g_loss[1:3]),
            np.mean(g_loss[3:5]), np.mean(g_loss[5:6]), elapsed_time))

            # If at save interval => save generated image samples
            if batch_i % sample_interval == 0:
                sample_images(epoch, batch_i, g_XY, g_YX, data_loader)

训练可能需要一段时间才能完成，但该过程将在sample_interval每批之后生成图像。以下显示了由机器感知中心外观数据库 ( CMP Facade Database ) 生成的一些图像示例。它包含建筑立面，其中每个像素都被标记为多个与立面相关的类别之一，例如窗户、门、阳台等：

我们对 GAN 的讨论到此结束。接下来，我们将关注一种不同类型的生成模型，称为艺术风格迁移。

引入艺术风格转移

在最后一节中，我们将讨论艺术风格的转移。与 CycleGAN 的一种应用类似，它允许我们使用一张图像的风格（或纹理）来再现另一张图像的语义内容。尽管它可以用不同的算法实现，但最流行的方法是在 2015 年的A Neural Algorithm of Artistic Style论文 ( https://arxiv.org/abs/1508.06576 ) 中介绍的。它也被称为神经风格迁移，它使用（你猜对了！）CNN。基本算法在过去几年中得到了改进和调整，但在本节中，我们将探索其原始形式，因为这将为我们理解最新版本提供良好的基础。

该算法将两个图像作为输入：

• 我们要重绘的内容图像( C )
• 我们将使用其样式（纹理）重绘C的样式图像( I )

算法的结果是一个新图像：G = C + S。下面是一个神经风格迁移的例子：

神经风格迁移的一个例子

要了解神经风格迁移的工作原理，让我们回顾一下 CNN 学习其特征的分层表示。我们知道初始卷积层学习基本特征，例如边缘和线条。相反，更深的层学习更复杂的特征，例如人脸、汽车和树木。知道了这一点，我们再来看看算法本身：

1.与许多其他任务（例如，第 3 章，对象检测和图像分割）一样，该算法从预训练的 VGG 网络开始。

2.向网络提供内容图像C。提取并存储网络中间的一个或多个隐藏卷积层的输出激活（或特征图或切片）。让我们用Acl表示这些激活，其中l是层的索引。我们对中间层感兴趣，因为其中编码的特征抽象级别最适合这项任务。

3.对样式图像S执行相同操作。这一次，用A s l表示l层的风格激活。我们为内容和样式选择的图层不一定相同。

4.生成单个随机图像（白噪声）G。这个随机图像会逐渐变成算法的最终结果。我们将重复此操作进行多次迭代：

1. 通过网络传播G。这是我们将在整个过程中使用的唯一图像。就像我们之前所做的那样，我们将存储所有l层的激活（这里，l是我们用于内容和样式图像的所有层的组合）。让我们用A g l表示这些激活。
2. 一方面计算随机噪声激活A g l与另一方面A c l和A s l之间的差异。这些将是我们损失函数 的两个组成部分：
   • ，称为内容损失：这只是所有l层的两次激活之间元素差异的MSE 。
   • ，称为样式损失：这类似于内容损失，但我们将比较它们的gram 矩阵而不是原始激活（我们不会详细讨论）。

1. 使用内容损失和风格损失来计算总损失 ，这只是两者的加权和。α 和 β 系数决定了哪些分量将具有更大的权重。 
2. 将梯度反向传播到网络的起点并更新生成的图像。通过这种方式，我们使G更类似于内容和风格图像，因为损失函数是两者的组合。 

该算法使我们能够利用 CNN 的强大表现力进行艺术风格的迁移。它通过新颖的损失函数和反向传播的智能使用来做到这一点。

如果您对实现神经风格迁移感兴趣，请查看Neural Transfer Using PyTorch — PyTorch Tutorials 1.12.1+cu102 documentation上的官方 PyTorch 教程。或者，转到https://www.tensorflow.org/beta/tutorials/generation/style_transfer了解 TF 2.0 实施。

该算法的一个缺点是它相对较慢。通常，我们必须重复这个伪训练过程几百次迭代才能产生视觉上吸引人的结果。幸运的是，论文Perceptual Losses for Real-Time Style Transfer and Super-Resolution ( https://arxiv.org/abs/1603.08155 ) 建立在原始算法之上，提供了一个解决方案，速度提高了三个数量级。 

概括

在本章中，我们讨论了如何使用生成模型创建新图像，这是目前最令人兴奋的深度学习领域之一。我们了解了 VAE 的理论基础，然后我们实现了一个简单的 VAE来生成新的MNIST 数字。然后，我们描述了 GAN 框架，并讨论并实现了多种类型的 GAN，包括 DCGAN、CGAN、WGAN 和 CycleGAN。最后，我们提到了神经风格迁移算法。本章结束了专门介绍计算机视觉的四章系列，我真的希望你喜欢它们。

在接下来的几章中，我们将讨论自然语言处理和循环网络。

文章出处登录后可见！

立即登录

已经登录？立即刷新

提交评分

共计人评分，平均分

到目前为止还没有投票！成为第一位评论此文章。

赞 (0)

社会演员多普通用户

0

生成海报