【源码解析】SwapAutoEncoder(一)

已于 2022-05-07 16:51:45 修改
阅读量585 收藏 2
点赞数 1
分类专栏： 源码解析 文章标签： cnn 深度学习 人工智能
于 2022-05-07 16:16:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hua_happy_/article/details/124621029
版权
本文详细解析了StyleGAN2中的关键组件，包括EqualConv2d、ResBlock和编码器（Encoder）的实现。EqualConv2d通过自定义学习率调整权重，保证尺度一致性；ResBlock结合了下采样、卷积和残差连接；编码器通过多层下采样获取空间和全局编码。这些技术在生成高质量图像中起到关键作用。
摘要由CSDN通过智能技术生成

[SwapAutoEncoder 源码解析] Baselayer & Encoder

文章目录

一、StyleGAN2_layer 部分

EqualConv2d

EqualConv2d与nn.conv2d有细微的差别，增加了对卷积核权重的调整和学习率的自定义

class EqualConv2d(nn.Module):
    def __init__(
            self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True, lr_mul=1.0,
    ):
        super().__init__()

        self.weight = nn.Parameter(
            torch.randn(out_channel, in_channel, kernel_size, kernel_size)
        )
        self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2) * lr_mul

        self.stride = stride
        self.padding = padding

        if bias:
            self.bias = nn.Parameter(torch.zeros(out_channel))

        else:
            self.bias = None

    def forward(self, input):
        out = F.conv2d(
            input,
            self.weight * self.scale,
            bias=self.bias,
            stride=self.stride,
            padding=self.padding,
        )

        return out

    def __repr__(self):
        return (
            f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},'
            f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})'
        )
  1. lr_mul
    参数更新的过程中，针对卷积核参数自定义设置参数更新的速度，反向传播求导的过程中会增加一个倍数
  2. self.scale
    参考 https://blog.csdn.net/weixin_41943311/article/details/105657139
    为了保证在训练过程中尺度的度量标准一致，避免不同大小的卷积核产生不同的影响，因此要对卷积的计算结果求平均值，反应在参数上就是权重除以每个输出通道下卷积核中参数的个数

upfirdn2d

def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
    global use_custom_kernel
    if use_custom_kernel:
        out = UpFirDn2d.apply(
            input, kernel, (up, up), (down, down), (pad[0], pad[1], pad[0], pad[1])
        )
    else:
        out = upfirdn2d_native(input, kernel, up, up, down, down, pad[0], pad[1], pad[0], pad[1])

    return out

用默认的kernel,upfirdn2d_native 函数

def upfirdn2d_native(
    input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1
):
    bs, ch, in_h, in_w = input.shape
    minor = 1
    kernel_h, kernel_w = kernel.shape

    #assert kernel_h == 1 and kernel_w == 1

    #print("original shape ", input.shape, up_x, down_x, pad_x0, pad_x1)

    out = input.view(-1, in_h, 1, in_w, 1, minor)
    if up_x > 1 or up_y > 1:
        out = F.pad(out, [0, 0, 0, up_x - 1, 0, 0, 0, up_y - 1])

    #print("after padding ", out.shape)
    out = out.view(-1, in_h * up_y, in_w * up_x, minor)

    #print("after reshaping ", out.shape)

    if pad_x0 > 0 or pad_x1 > 0 or pad_y0 > 0 or pad_y1 > 0:
        out = F.pad(out, [0, 0, max(pad_x0, 0), max(pad_x1, 0), max(pad_y0, 0), max(pad_y1, 0)])

    #print("after second padding ", out.shape)
    out = out[
        :,
        max(-pad_y0, 0) : out.shape[1] - max(-pad_y1, 0),
        max(-pad_x0, 0) : out.shape[2] - max(-pad_x1, 0),
        :,
    ]

    #print("after trimming ", out.shape)

    out = out.permute(0, 3, 1, 2)
    out = out.reshape(
        [-1, 1, in_h * up_y + pad_y0 + pad_y1, in_w * up_x + pad_x0 + pad_x1]
    )

    #print("after reshaping", out.shape)
    w = torch.flip(kernel, [0, 1]).view(1, 1, kernel_h, kernel_w)
    out = F.conv2d(out, w)

    #print("after conv ", out.shape)
    out = out.reshape(
        -1,
        minor,
        in_h * up_y + pad_y0 + pad_y1 - kernel_h + 1,
        in_w * up_x + pad_x0 + pad_x1 - kernel_w + 1,
    )

    out = out.permute(0, 2, 3, 1)

    #print("after permuting ", out.shape)

    out = out[:, ::down_y, ::down_x, :]

    out = out.view(bs, ch, out.size(1), out.size(2))

    #print("final shape ", out.shape)

    return out
  1. F.pad() https://blog.csdn.net/binbinczsohu/article/details/106359426 对每个维度的开头和结尾进行填充
  2. 第一次填充：利用填充操作，扩充feature map的大小，为上采样做准备，在宽和高上做倍数的增加
out = input.view(-1, in_h, 1, in_w, 1, minor)
 if up_x > 1 or up_y > 1:
     out = F.pad(out, [0, 0, 0, up_x - 1, 0, 0, 0, up_y - 1])
out = out.view(-1, in_h * up_y, in_w * up_x, minor)

在这里插入图片描述
3. 第二次填充：单纯在宽和高上填充，不做倍数变换
4. 卷积操作：根据给定的卷积核进行卷积操作，近似blur
5. 下采样：按照下采样倍数，间隔取出元素作为最后的结果
至此 近似完成Blur操作

Blur

def make_kernel(k):
    k = torch.tensor(k, dtype=torch.float32)

    if k.dim() == 1:
        k = k[None, :] * k[:, None]

    k /= k.sum()

    return k

根据输入构造核

# If antialiasing is used, create a very lightweight Gaussian kernel.
blur_kernel = [1, 2, 1] if self.opt.use_antialias else [1]

class Blur(nn.Module):
    def __init__(self, kernel, pad, upsample_factor=1, reflection_pad=False):
        super().__init__()

        kernel = make_kernel(kernel)

        if upsample_factor > 1:
            kernel = kernel * (upsample_factor ** 2)

        self.register_buffer('kernel', kernel)

        self.pad = pad
        self.reflection = reflection_pad
        if self.reflection:
            self.reflection_pad = nn.ReflectionPad2d((pad[0], pad[1], pad[0], pad[1]))
            self.pad = (0, 0)

    def forward(self, input):
        if self.reflection:
            input = self.reflection_pad(input)
        out = upfirdn2d(input, self.kernel, pad=self.pad)

        return out

Blur的作用是通过blur kernel对图片的上下采样
nn.ReflectionPad2d https://zhuanlan.zhihu.com/p/351958361
先进行reflectionpad，
再进行upfirdn2d

解释为什么self.pad归零？
如果已经填充后，在upfirdn2d中不再进行填充，否则仍需填充

ConvLayer

class ConvLayer(nn.Sequential):
    def __init__(
        self,
        in_channel,
        out_channel,
        kernel_size,
        downsample=False,
        blur_kernel=[1, 3, 3, 1],
        bias=True,
        activate=True,
        pad=None,
        reflection_pad=False,
    ):
        layers = []

        if downsample:
            factor = 2
            if pad is None:
                pad = (len(blur_kernel) - factor) + (kernel_size - 1)
            pad0 = (pad + 1) // 2
            pad1 = pad // 2

            layers.append(("Blur", Blur(blur_kernel, pad=(pad0, pad1), reflection_pad=reflection_pad)))

            stride = 2
            self.padding = 0
        else:
            stride = 1
            self.padding = kernel_size // 2 if pad is None else pad
            if reflection_pad:
                layers.append(("RefPad", nn.ReflectionPad2d(self.padding)))
                self.padding = 0


        layers.append(("Conv",
                       EqualConv2d(
                           in_channel,
                           out_channel,
                           kernel_size,
                           padding=self.padding,
                           stride=stride,
                           bias=bias and not activate,
                       ))
        )

        if activate:
            if bias:
                layers.append(("Act", FusedLeakyReLU(out_channel)))

            else:
                layers.append(("Act", ScaledLeakyReLU(0.2)))

        super().__init__(OrderedDict(layers))

    def forward(self, x):
        out = super().forward(x)
        return out

继承自nn.Sequential
带有特殊参数
downsample :bool 卷积过程中是否需要下采样(缩小feature map的大小)
blur_kernel : list 在下采样的过程中使用的核
activate:bool 选择激活函数
reflection_pad:bool 是否使用nn.ReflectionPad2d()

  1. 使用下采样
    stride=2 加入Blur层
  2. 不使用下采样
    stride=1 加入RefPad层
  3. 卷积层
    EqualConv2d
  4. 激活函数
    bias FusedleakyRelu
    not bias ScaledLeakyReLU(0.2)

FusedleakyRelu

class FusedLeakyReLU(nn.Module):
    def __init__(self, channel, negative_slope=0.2, scale=2 ** 0.5):
        super().__init__()

        self.bias = nn.Parameter(torch.zeros(channel))
        self.negative_slope = negative_slope
        self.scale = scale

    def forward(self, input):
        return fused_leaky_relu(input, self.bias, self.negative_slope, self.scale)


def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
    global use_custom_kernel
    if use_custom_kernel:
        return FusedLeakyReLUFunction.apply(input, bias, negative_slope, scale)
    else:
        dims = [1, -1] + [1] * (input.dim() - 2)
        bias = bias.view(*dims)
        return F.leaky_relu(input + bias, negative_slope) * scale

在算leaky relu之前手动加了一个bias

ScaledLeakyReLU

class ScaledLeakyReLU(nn.Module):
    def __init__(self, negative_slope=0.2):
        super().__init__()

        self.negative_slope = negative_slope

    def forward(self, input):
        out = F.leaky_relu(input, negative_slope=self.negative_slope)

        return out * math.sqrt(2)

leaky relu https://zhuanlan.zhihu.com/p/172254089

ResBlock

class ResBlock(nn.Module):
    def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1], reflection_pad=False, pad=None, downsample=True):
        super().__init__()

        self.conv1 = ConvLayer(in_channel, in_channel, 3, reflection_pad=reflection_pad, pad=pad)
        self.conv2 = ConvLayer(in_channel, out_channel, 3, downsample=downsample, blur_kernel=blur_kernel, reflection_pad=reflection_pad, pad=pad)

        self.skip = ConvLayer(
            in_channel, out_channel, 1, downsample=downsample, blur_kernel=blur_kernel, activate=False, bias=False
        )

    def forward(self, input):
        #print("before first resnet layeer, ", input.shape)
        out = self.conv1(input)
        #print("after first resnet layer, ", out.shape)
        out = self.conv2(out)
        #print("after second resnet layer, ", out.shape)

        skip = self.skip(input)
        out = (out + skip) / math.sqrt(2)

        return out

两个卷积层以及skip layer 使用ConvLayer
在skip和conv结果相加后，方差加倍，为了消除方差变化的影响需要除以根号2，在一般的resnet中通过batchnormalization来消除这种影响（StyleGAN2论文中有解释）
StyleGAN2
目的是为了避免texture code中编码了位置信息，使用reflectpad
在这里插入图片描述

EqualLinear

class EqualLinear(nn.Module):
    def __init__(
        self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None
    ):
        super().__init__()

        self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul))

        if bias:
            self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init))

        else:
            self.bias = None

        self.activation = activation

        self.scale = (1 / math.sqrt(in_dim)) * lr_mul
        self.lr_mul = lr_mul

    def forward(self, input):
        if self.activation:
            if input.dim() > 2:
                out = F.conv2d(input, self.weight[:, :, None, None] * self.scale)
            else:
                out = F.linear(input, self.weight * self.scale)
            out = fused_leaky_relu(out, self.bias * self.lr_mul)

        else:
            if input.dim() > 2:
                out = F.conv2d(input, self.weight[:, :, None, None] * self.scale,
                               bias=self.bias * self.lr_mul
                )
            else:
                out = F.linear(
                    input, self.weight * self.scale, bias=self.bias * self.lr_mul
                )

        return out

    def __repr__(self):
        return (
            f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})'
        )

和nn.Linear()区别

  1. 处理高维数据、二维数据：高维数据使用1×1卷积，不改变feature map大小，只改变通道的数量
  2. 设置是否使用激活函数
  3. 设置参数更新的速度lr_mul
  4. 对权重进行尺度的缩放

二、StyleGAN2ResnetEncoder 部分

FromRGB layer

self.add_module("FromRGB", ConvLayer(3, self.nc(0), 1))

对输入图像的第一次卷积，增加通道的数量，不改变大小
本质 EqualConv2D
in_channel 3 out_channel 32 padding 0 stride 1 kernel size 1*1
input B*3*H*W output B*32*H*W

DownToSpatialCode

self.DownToSpatialCode = nn.Sequential()
for i in range(self.opt.netE_num_downsampling_sp):
    self.DownToSpatialCode.add_module(
        "ResBlockDownBy%d" % (2 ** i),
        ResBlock(self.nc(i), self.nc(i + 1), blur_kernel,
                 reflection_pad=True)
    )

四组下采样的残差块进行下采样
本质 nn.Sequential([ResBlock1, ResBlock2, ResBlock3, ResBlock4])
每个resblock都是带下采样的，feature map的大小减半，通道数翻倍
input B*32*H*W output B*512*H/16*W /16

ToSpatialCode

nchannels = self.nc(self.opt.netE_num_downsampling_sp)
self.add_module(
    "ToSpatialCode",
    nn.Sequential(
        ConvLayer(nchannels, nchannels, 1, activate=True, bias=True),
        ConvLayer(nchannels, self.opt.spatial_code_ch, kernel_size=1,
                  activate=False, bias=True)
    )
)

获得structrue code
两个卷积核大小为1*1的卷积层
改变通道的大小为空间特征最后的数目，不改变feature map的大小
本质 nn.Sequential([Conv1, Conv2])
input B*512*H/16*W /16 output B*8*H/16*W /16

DownToGlobalCode

self.DownToGlobalCode = nn.Sequential()
for i in range(self.opt.netE_num_downsampling_gl):
     idx_from_beginning = self.opt.netE_num_downsampling_sp + i
     self.DownToGlobalCode.add_module(
         "ConvLayerDownBy%d" % (2 ** idx_from_beginning),
         ConvLayer(self.nc(idx_from_beginning),
                   self.nc(idx_from_beginning + 1), kernel_size=3,
                   blur_kernel=[1], downsample=True, pad=0)
     )

本质 nn.Sequential([Conv1, Conv2])
input B*512*H/16*W /16 output B*2048*H/64*W /64
使用两个卷积核大小为3*3的卷积层，通道翻倍，feature map大小减半
因为填充和卷积运算的原因，此处不能严格整除64

ToGlobalCode

nchannels = self.nc(self.opt.netE_num_downsampling_sp +  self.opt.netE_num_downsampling_gl)
self.add_module(
    "ToGlobalCode",
    nn.Sequential(
        EqualLinear(nchannels, self.opt.global_code_ch)
    )
)

获得texture_code
本质 EqualLinear
input B*in_dim output B*out_dim
相当于一个全连接层 dense layer

normalize

def normalize(v):
    if type(v) == list:
        return [normalize(vv) for vv in v]

    return v * torch.rsqrt((torch.sum(v ** 2, dim=1, keepdim=True) + 1e-8))

StyleGAN2ResnetEncoder总体流程

  1. FromRGB
  2. DownToSpatialCode
  3. ToSpatialCode -> 获得空间编码信息(structure code->sp)
  4. DownToGlobalCode -> 获得全局编码信息(texture code->gl)
  5. 在texture code后两个维度上取均值
    input B*2048*H/64*W /64 output B*2048
  6. ToGlobalCode 全连接层
  7. sp和gl分别通过normalize获得最后的编码结果(除以对应的L2范数)
    在这里插入图片描述
hua_happy_
关注
专栏目录
[占坑] Equalized learning rate implementation
qq_38712865的博客
01-15 1252
本文主要挖一个关于「Equalized Learning Rate」的坑，后续再填。
swapping-autoencoder-pytorch:交换自动编码器用于深层图像处理的非官方实现（https
03-20
交换自动编码器火炬 在PyTorch中非自动实现用于深层图像处理的交换自动编码器（ ） 用法 首先创建lmdb数据集： python prepare_data.py --out LMDB_PATH --n_worker N_WORKER --size SIZE1，SIZE2，SIZE3，... DATASET_PATH 这会将图像转换为jpeg并预先调整其大小。此实现不使用渐进式增长，但是对于以后要尝试其他分辨率的情况，可以使用带有逗号分隔列表的大小参数来创建多个分辨率数据集。 然后您可以在分布式设置中训练模型 python -m torch.distributed.launch --nproc_per_node = N_GPU --master_port = PORT train.py --batch BATCH_SIZE LMDB_PATH train.py支持权重和偏差记录。如
【源码解析】SwapAutoEncoder(二)
hua_happy_的博客
05-09 250
[SwapAutoEncoder 源码解析] Generator/Decoder 文章目录[SwapAutoEncoder 源码解析] Generator/Decoder1. Base ModuleGeneratorModulation2. Generator模块结构SpatialCodeModulation 1. Base Module GeneratorModulation class GeneratorModulation(torch.nn.Module): def __init__(se
论文学习笔记-Swapping Autoencoder
lzj50002801的博客
11-09 813
GAN相关网络用什么归一化方法：BatchNorm？Weight Norm？Layer Norm？
qq_36561737的博客
09-11 2051
神经网络中各种归一化方法分析与介绍
Flink源码解析.zip
06-04
1、Flink 源码解析 —— 源码编译运行 2、Flink 源码解析 —— 项目结构一览 3、Flink 源码解析—— local 模式启动流程 4、Flink 源码解析 —— standalonesession 模式启动流程 5、Flink 源码解析 —— ...
一次解析源码
10-01
一次解析源码，部分需要更新COOKIE。自己下载后更具里面内容样式抓取吧！
Andorid项目源码 飞鸽传书 源码解析 参考示例
最新发布
03-24
Andorid项目源码 飞鸽传书 源码解析 参考示例Andorid项目源码 飞鸽传书 源码解析 参考示例Andorid项目源码 飞鸽传书 源码解析 参考示例Andorid项目源码 飞鸽传书 源码解析 参考示例Andorid项目源码 飞鸽传书 源码...
一次解析源码外面俗称3500元一套
12-24
【标题】"一次解析源码"通常指的是在软件开发中，对原始的编程代码进行一次性编译或解析，形成可以直接运行或使用的程序。这个过程不涉及对已有的编译结果进行再次解析，而是直接处理源代码，使得用户能够更深入地...
backbone源码解析
09-25
backbone源码解析,写得非常好,下载了你不后悔
自编码 （Autoencoder） - 自己总结的PPT
04-11
自编码 （Autoencoder） - 自己总结的PPT
CV入门（1）——权重初始化
REstrat的博客
10-09 600
到此，我们的初步网络已经可以手工了，但是在现实中，我们真正使用神经网络的时候，我们还需要应用到激活函数，从而达到非线性的映射关系。然而，我们的期望是什么，我们希望网咯的输出分布还是能够保持在正态分布中，那么，在这100层矩阵乘法中，我们怎么保证我们的输出最终还是符合标准正态分布勒？我们可以证明，在给定的层，我们从标准正态分布初始化的输入x和权重矩阵a的矩阵乘积，平均而言，标准偏差非常接近输入通道的平方根，在这个例子中是。此外，我们假设我们的输入经过了100层的简单网络，每一层都包含一个权重矩阵a。
ICCV2021 频域图像翻译 Frequency Domain Image Translation: More Photo-realistic, Better Identity-preserving
u014546828的博客
11-27 3385
本文提出了一种新的频域图像翻译(FDIT) 框架，利用频率信息增强图像生成过程（研究方法）。本文的主要想法是将图像分解为低频和高频成分，其中高频特征捕获类似于 identity 的对象结构（核心思想）。本文的训练目标有利于在像素空间和傅里叶频谱空间中保持频率信息（方法优/特点）。
（学习笔记）Chest Radiograph Disentanglementfor COVID-19 Outcome Prediction
jtup1253的博客
06-21 351
学习笔记
重磅推荐：2020年人工智能最精彩的25篇论文（附下载）
fengdu78的博客
12-25 6477
本文推荐整理的2020年人工智能最新突破的25篇论文，包含论文下载、视频说明、代码下载。这是今年最精彩的人工智能方向的研究论文，本文帮您整理了。简而言之，这是一份精心策划人工智能和数据科...
Autoencoder
chuange6363的博客
09-10 195
自编码器 Autoencoder 稀疏自编码器 Sparse Autoencoder 降噪自编码器 Denoising Autoencoder 堆叠自编码器 Stacked Autoencoder 本博客是从梁斌博士的博客上面复制过来的，本人利用 Tens...
conv2d 公式_Pytorch 从0开始学（6）——Conv2d 详解
weixin_33110093的博客
01-26 937
您是否在使用Conv2d时遇见问题了呢？您是否还在以Conv2d(128， 256， 3)的方式简单使用这个最具魅力的layer呢？想更了解Conv2d么？让我们一起来深入看看它的真容吧，让我们触到它更高端的用法。在第5节中，我们已经使用了Linear层来构建模型。其来自于torch.nn中首先，我们先对torch.nn 来个整体的认识。官方链接：可以看到，在torch.nn下包含了我们模型的概念...
Pytorch中的Conv2d的认识
baidu_38634017的博客
08-19 6768
转载自：https://www.aiuai.cn/aifarm618.html  首页 正文   分享到： ...
神经网络——Conv2d的使用
热门推荐
m0_51816252的博客
06-01 2万+
在Convolution Layers 卷积层中有很多函数，像：nn.Conv1d 表示1维的；nn.Conv2d 表示2维的，如图片，等。其中Conv2d使用最多，故本文重点讲下nn.Conv2d的使用。
深入理解PostgreSQL：源码解析
"该文档是一份详尽的PostgreSQL源码解读资料，共计4500页，专门针对PostgreSQL数据库系统的核心功能进行了深入解析。文档涵盖了从数据插入到查询处理的全过程，通过一系列章节逐步剖析了PostgreSQL的内部工作原理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值