cycleGAN代碼實作（附詳細代碼注釋）

最近剛剛入門深度學習，試著復現cycleGAN代碼，看了一個YouTube博主的cycleGAN代碼，自己跟著寫了一遍，同時加上了代碼注釋，希望能幫到同樣的入門伙伴

下面的github地址
https://github.com/RRRRRBL/CycleGAN-Detailed-notes-
在這里給出一個生成器的代碼

import torch.nn as nn



class ConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels, down=True, use_act=True, **kwargs):  # down：下采樣，act：激活，**kwargs字典引數
        super().__init__()
        self.conv = nn.Sequential(  # 卷積塊，可以完成下采樣卷積或者保持原size卷積
            nn.Conv2d(in_channels, out_channels, padding_mode='reflect', **kwargs)
            if down
            else nn.ConvTranspose2d(in_channels, out_channels, **kwargs),
            nn.InstanceNorm2d(out_channels),  # 標準化
            nn.ReLU(inplace=True) if use_act else nn.Identity()  # identity不會做任何操作
        )

    def forward(self, x):
        return self.conv(x)


class ResidualBlock(nn.Module):  # 殘差塊，不改變size
    def __init__(self, channels):
        super().__init__()
        self.block = nn.Sequential(
            ConvBlock(channels, channels, kernel_size=3, padding=1),
            ConvBlock(channels, channels, use_act=False, kernel_size=3, padding=1)
        )

    def forward(self, x):
        return x + self.block(x)  # 殘差塊兒


class Generator(nn.Module):
    def __init__(self, img_channels, num_features=64, num_residuals=9, ):  # num_features是通道數的一個公約數,num_residuals殘差層數
        super(Generator, self).__init__()
        self.initial = nn.Sequential(  # 初始化
            nn.Conv2d(img_channels, num_features, kernel_size=7, stride=1, padding=3, padding_mode='reflect'),
            nn.InstanceNorm2d(num_features),
            nn.ReLU(inplace=True),  # 原地激活
        )
        self.down_blocks = nn.ModuleList(  # 下采樣（增加通道數，減小img尺寸
            [
                ConvBlock(num_features, num_features * 2, kernel_size=3, stride=2, padding=1),
                ConvBlock(num_features * 2, num_features * 4, kernel_size=3, stride=2, padding=1),

            ]
        )
        self.residual_block = nn.Sequential(  # 殘差塊兒（不改變大小
            *[ResidualBlock(num_features * 4) for _ in range(num_residuals)]
            # *4是因為之前的各類操作得到的變數channel已經是4
            # 是4*num_featurs了，這里呼叫了九次殘差塊兒，進行訓練，大小一直不變
        )
        self.up_blocks = nn.ModuleList(  # 上采樣block channels減小，img變大
            [
                ConvBlock(num_features * 4, num_features * 2, down=False, kernel_size=3, stride=2, padding=1,
                          output_padding=1),
                ConvBlock(num_features * 2, num_features * 1, down=False, kernel_size=3, stride=2, padding=1,
                          output_padding=1),

            ]
        )
        self.last = nn.Conv2d(num_features * 1, img_channels, kernel_size=7, stride=1, padding=3,
                              padding_mode='reflect')

    def forward(self, x):
        x = self.initial(x)  # 初始化
        for layer in self.down_blocks:
            x = layer(x)
        x = self.residual_block(x)
        for layer in self.up_blocks:
            x = layer(x)
        return torch.tanh(self.last(x)) ```



'''觀察代碼不難發現，在整個生成器的生成程序中，用到的還是簡單基礎的知識，只是在一些處理選擇上比較特殊
代碼利用了殘差神經網路 和卷積神經網路集合的方式進行訓練
測驗代碼如下
>def test():
    img_channels = 3
    img_size = 256
    x = torch.randn((2, img_channels, img_size, img_size))
    gen = Generator(img_channels, 9)
    print(gen(x).shape)

>if __name__ == "__main__":
    test()'''

標籤：其他

上一篇：openssh-淺談openssl和openssh的升級

下一篇：一個免殺專案分享