0
0

自回归模型 - PixelCNN

点击上方“Deephub Imba”,关注公众号,好文章不错过 !

介绍

生成模型是近年来受到广泛关注的无监督学习中的一类重要模型。可以将它们定义为一类模型，其目标是学习如何生成与训练数据来自同一数据集的新样本。在训练阶段，生成模型试图解决密度估计的核心任务。在密度估计中，我们的模型学习构建一个估计——pmodel(x)——尽可能类似于不可观察的概率密度函数——pdata(x)。需要说明的是，生成模型应该能够从分布中生成新样本，而不仅仅是复制和粘贴现有样本。一旦我们成功地训练了我们的模型，它就可以用于各种各样的应用，从各种形式的重建，如图像填充、着色和超分辨率到生成艺术品。

我们可以使用几种不同的方法来执行这种概率密度估计，例如：

  1. 生成对抗网络 (GAN) 使用模型执行隐式密度估计的方法。在这种情况下，我们训练了一个模型，该模型可以从 pmodel(x) 创建样本，而无需明确定义 pmodel(x)；该模型学习一个随机过程，并使用该过程生成数据，但不提供观测概率的知识，或指定一个条件对数似然函数;
  2. 变分自编码器 (VAE) 使用显式密度估计，但定义了一个带有潜在变量的难以处理的密度函数。因此为了训练模型，我们导出并优化似然的下界（近似密度）；我们通过最大化证据下界(ELBO)优化数据的对数似然(log-likelihood)；
  3. 自回归 (AR) 模型创建了一个显式密度模型，该模型易于处理以最大化训练数据的可能性（可处理密度）。出于这个原因，使用这些方法，很容易计算数据观察的可能性并获得生成模型的评估指标。

正如上面提到的自回归是一种实用的方法，它提供了似然函数的显式建模。但是要对具有多个维度/特征的数据进行建模，自回归模型需要有一些附加条件。首先，输入空间 X 需要对其特征进行确定排序。这就是为什么自回归模型通常用于具有内在时间步长序列的时间序列。它们可以通过定义例如左侧的像素在右侧的像素之前，顶部的像素在底部的像素之前来用于图像。其次，为了在数据观察 (p(x)) 中对特征的联合分布进行易处理的建模，自回归方法将p(x)视为条件分布的乘积。给定先前特征的值，自回归模型使用每个特征的条件定义联合分布。例如，图像中某个像素具有特定强度值的概率取决于所有先前像素的值；而一幅图像的概率（所有像素的联合分布）是它所有像素的概率的组合。因此，自回归模型使用链式法则将数据样本 x 的似然分解为一维分布的乘积（以下方程）。分解将联合建模问题转化为序列问题，在给定所有先前生成的像素的情况下，学习预测下一个像素。

这些条件（即确定条件分布的顺序和乘积）就是定义自回归模型的主要条件。

现在，最大的挑战是计算这些条件似然 p(x ᵢ| x₁, …, x ᵢ ₋ ₁)。我们如何在一个易于处理和可扩展的表达模型中定义这些复杂的分布？一种解决方案是使用通用逼近器，比如深度神经网络。

PixelCNN

DeepMind在2016年引入了PixelCNN (Oord et al.， 2016)，该模型开启了最有前途的自回归生成模型家族。从那时起，它就被用于生成语音、视频和高分辨率图片。

PixelCNN 是一种深度神经网络，它在其参数中捕获像素之间的依赖关系分布。它沿两个空间维度在图像中一次顺序生成一个像素。

像素 i（红色）由所有先前的像素（蓝色）定义。PixelCNN 可以使用沿深度神经网络的卷积层对它们的关联进行建模。

使用卷积操作，PixelCNN 可以并行学习图像中所有像素的分布。然而，在确定特定像素的概率时，标准卷积层的感受野违反了自回归模型的顺序预测。在处理一个中心像素的信息时，卷积滤波器会考虑它周围的所有像素来计算输出特征图，而不仅仅是前面的像素。所以这里需要采用掩码来阻止来自尚未预测的像素的信息流。

带掩码的卷积层

掩码可以通过将所有不应考虑的像素归零来完成。在我们的实现中，创建了一个与卷积滤波器大小相同、值为 1 和 0 的掩码。在进行卷积运算之前，这个掩码与权重张量相乘。在 PixelCNN 中，有两种类型的掩码：

掩码类型 A：此掩码仅应用于第一个卷积层。它通过将掩码中的中心像素归零来限制对像素的访问。这样，我们保证模型不会访问它即将预测的像素（下图中的红色部分）。

掩码类型 B：此掩码应用于所有后续卷积层，并通过允许从像素到自身的连接来放宽掩码 A 的限制。这对于解释第一层的像素预测很重要。

掩码 A 仅用于第一个卷积层。掩码 B 用于所有其他层，以允许以像素为中心的卷积操作的信息沿网络传播。

在这里，我们展示了使用 Tensorflow 2.0 框架实现掩码的片段。

class MaskedConv2D(keras.layers.Layer):
    """Convolutional layers with masks.

    Convolutional layers with simple implementation of masks type A and B for
    autoregressive models.

    Arguments:
    mask_type: one of `"A"` or `"B".`
    filters: Integer, the dimensionality of the output space
        (i.e. the number of output filters in the convolution).
    kernel_size: An integer or tuple/list of 2 integers, specifying the
        height and width of the 2D convolution window.
        Can be a single integer to specify the same value for
        all spatial dimensions.
    strides: An integer or tuple/list of 2 integers,
        specifying the strides of the convolution along the height and width.
        Can be a single integer to specify the same value for
        all spatial dimensions.
        Specifying any stride value != 1 is incompatible with specifying
        any `dilation_rate` value != 1.
    padding: one of `"valid"` or `"same"` (case-insensitive).
    kernel_initializer: Initializer for the `kernel` weights matrix.
    bias_initializer: Initializer for the bias vector.
    """

    def __init__(self,
                 mask_type,
                 filters,
                 kernel_size,
                 strides=1,
                 padding='same',
                 kernel_initializer='glorot_uniform',
                 bias_initializer='zeros'):
        super(MaskedConv2D, self).__init__()

        assert mask_type in {'A', 'B'}
        self.mask_type = mask_type

        self.filters = filters
        self.kernel_size = kernel_size
        self.strides = strides
        self.padding = padding.upper()
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.bias_initializer = initializers.get(bias_initializer)

    def build(self, input_shape):
        self.kernel = self.add_weight('kernel',
                                      shape=(self.kernel_size,
                                             self.kernel_size,
                                             int(input_shape[-1]),
                                             self.filters),
                                      initializer=self.kernel_initializer,
                                      trainable=True)

        self.bias = self.add_weight('bias',
                                    shape=(self.filters,),
                                    initializer=self.bias_initializer,
                                    trainable=True)

        center = self.kernel_size // 2

        mask = np.ones(self.kernel.shape, dtype=np.float32)
        mask[center, center + (self.mask_type == 'B'):, :, :] = 0.
        mask[center + 1:, :, :, :] = 0.

        self.mask = tf.constant(mask, dtype=tf.float32, name='mask')

    def call(self, input):
        masked_kernel = tf.math.multiply(self.mask, self.kernel)
        x = nn.conv2d(input,
                      masked_kernel,
                      strides=[1, self.strides, self.strides, 1],
                      padding=self.padding)
        x = nn.bias_add(x, self.bias)
        return x

模型架构

PixelCNN 使用以下架构：第一层是带有 7x7 过滤器的掩码卷积（A 型）。然后，使用了 15 个残差块。每个块使用掩码类型 B 的 3x3 卷积层和标准 1x1 卷积层的组合处理数据。在每个卷积层之间，都有一个非线性 ReLU。

在序列块之后为RELU-CONV-RELU-CONV 层，其中CONV是使用带有1x1 滤波器标准卷积。然后，输出层是一个 softmax 层，它预测像素的所有可能值。模型的输出具有与输入图像大小相同的格式（因为我们想要每个像素的输出值）乘以可能值的数量（根据强度级别进行分类，例如256 个强度级别）。

class ResidualBlock(keras.Model):
    """Residual blocks that compose pixelCNN

    Blocks of layers with 3 convolutional layers and one residual connection.
    Based on Figure 5 from [1] where h indicates number of filters.

    Refs:
    [1] - Oord, A. V. D., Kalchbrenner, N., & Kavukcuoglu, K. (2016). Pixel
     recurrent neural networks. arXiv preprint arXiv:1601.06759.
    """

    def __init__(self, h):
        super(ResidualBlock, self).__init__(name='')

        self.conv2a = keras.layers.Conv2D(filters=h, kernel_size=1, strides=1)
        self.conv2b = MaskedConv2D(mask_type='B', filters=h, kernel_size=3, strides=1)
        self.conv2c = keras.layers.Conv2D(filters=2 * h, kernel_size=1, strides=1)

    def call(self, input_tensor):
        x = nn.relu(input_tensor)
        x = self.conv2a(x)

        x = nn.relu(x)
        x = self.conv2b(x)

        x = nn.relu(x)
        x = self.conv2c(x)

        x += input_tensor
        return x
        
# Create PixelCNN model
inputs = keras.layers.Input(shape=(height, width, n_channel))
x = MaskedConv2D(mask_type='A', filters=128, kernel_size=7, strides=1)(inputs)

for i in range(15):
    x = ResidualBlock(h=64)(x)

x = keras.layers.Activation(activation='relu')(x)
x = keras.layers.Conv2D(filters=128, kernel_size=1, strides=1)(x)
x = keras.layers.Activation(activation='relu')(x)
x = keras.layers.Conv2D(filters=128, kernel_size=1, strides=1)(x)
x = keras.layers.Conv2D(filters=q_levels, kernel_size=1, strides=1)(x)

pixelcnn = keras.Model(inputs=inputs, outputs=x)

预处理

PixelCNN 的输入值被缩放到 [0, 1] 的范围内。通过量化输入值，可以达到快速收敛的目的。

输出目标对应于指示像素强度的分类（整数）值。

模型评价指标

PixelCNN也是一个分类问题，所以模型通过最大化目标的可能性来训练其参数。

大多数优化问题都可以被定义为最小化问题，因此常用的技巧是将训练目标转换为负对数似然 (NLL) 的最小化。

由于 p(xᵢ|θ) 对应于 softmax 层输出的概率，因此 NLL 相当于交叉熵损失函数——监督学习中常用的损失函数。此外，NLL 是用于比较生成方法（使用NAT单位或每像素单位）之间的性能的指标。

推理

由于PixelCNN是一个自回归模型，推理是顺序的——我们必须逐个像素地生成。首先，我们通过向模型传递0来生成图像。它不应该影响第一个像素，因为它的值被建模为独立于所有其他像素。我们执行前向传播并获得其分布。给定分布后我们从多项式概率分布中抽取一个值。然后我们用采样的像素值更新我们的图像，我们重复这个过程，直到我们生成了所有的像素值。这里的 PixelCNN 使用 MNIST 数据集在 150 个训练轮次后生成样本。每个生成的图像都有四个像素强度级别。

同样的采样过程可以用部分遮挡的图像作为起始点。

现在，我们也尝试训练或建模，以产生具有256级像素强度的图像。

以下是部分遮挡的图像作为起始点的256级像素强度的图像

与其他生成模型(VAE和gan)相比，这种采样过程相对较慢，因为其他模型中所有像素都是一次性生成的。不过最近的研究使得速度有了很大的进步，例如可以使用缓存值来减少采样时间(例如Fast pixelcnn++)

总结

PixelCNN 模型的优点是联合概率学习技术是非常容易处理的；我们只是尝试在给定所有先前像素值的情况下预测后面的每个像素值。由于 PixelCNN 是通过最小化负对数似然来训练的，因此与其他方法（例如 GAN——需要找到纳什均衡）相比它的训练更加稳定。但是由于样本的生成是顺序的（逐像素），原始的 PixelCNN 在可扩展性方面存在困难。

引用

作者：Walter Hugo Lopez Pinaya, Pedro F. da Costa, and Jessica Dafflon

喜欢就关注一下吧：

点个 在看 你最好看！********** **********

标签：
登录后发布评论

“自回归模型 - PixelCNN”的评论:

还没有评论
关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

循环编码:时间序列中周期性特征的一种常用编码方式

LSTM时间序列预测中的一个常见错误以及如何修正

LLM2Vec介绍和将Llama 3转换为嵌入模型代码示例

BiTCN：基于卷积网络的多元时间序列预测

整合文本和知识图谱嵌入提升RAG的性能

Gradformer: 通过图结构归纳偏差提升自注意力机制的图Transformer

10个使用NumPy就可以进行的图像处理步骤

文章导航