Pytorch编写生成对抗网络生成MNIST手写图片

作者学习记录

之前在训练过程中，生成器的输入仅有随机数，这次将真实图片同样作为输入给予生成器。
相比之前增加生成器复杂度，降低了判别器复杂度，网络如下所示，简单的使用了卷积与反卷积：

class Generator(torch.nn.Module):
    def __init__(self, channels):
        super().__init__()
        # Output_dim = C (number of channels)
        self.conv1 = nn.Sequential(
            # Z latent vector 100
            nn.Conv2d(in_channels=channels, out_channels=32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=32),
            nn.ReLU(True),

            )
        self.conv2 = nn.Sequential(
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=64),
            nn.ReLU(True),

            )
        self.conv3 = nn.Sequential(
            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=128),
            nn.ReLU(True),

            )
        self.conv4 = nn.Sequential(
            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=256),
            nn.ReLU(True),

            )
        self.conv5 = nn.Sequential(
            nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=128),
            nn.ReLU(True),

            )
        self.conv6 = nn.Sequential(
            nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=64),
            nn.ReLU(True),

            )
        self.conv7 = nn.Sequential(
            nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(num_features=32),
            nn.ReLU(True),

            )
        self.conv8 = nn.Sequential(
            nn.ConvTranspose2d(in_channels=32, out_channels=channels, kernel_size=3, stride=1, padding=1))
            # output of main module --> Image (Cx28x28)

        self.output = nn.Tanh()

    def forward(self, x, z):
        x = x + z
        q = self.conv1(x)
        w = self.conv2(q)
        e = self.conv3(w)
        r = self.conv4(e)
        t = self.conv5(r)
        y = self.conv6(t)
        u = self.conv7(y)
        i = self.conv8(u)
        return self.output(i)


class Discriminator(torch.nn.Module):
    def __init__(self, channels):
        super().__init__()
        # Input_dim = channels (Cx64x64)
        # Output_dim = 1
        self.main_module = nn.Sequential(
            # Image (Cx28x28)
            nn.Conv2d(in_channels=channels, out_channels=32, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),

            # State (32x16x16)
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.2, inplace=True),

            # State (64x8x8)
            nn.Conv2d(in_channels=64, out_channels=32, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.2, inplace=True))
            # outptut of main module --> State (128x4x4)

        self.output = nn.Sequential(
            nn.Conv2d(in_channels=32, out_channels=1, kernel_size=3, stride=1, padding=0),
            # Output 1
            nn.Sigmoid())

生成图片效果
文件名为训练轮次：

手动输入噪音生成图像：

同一个真实图像随机输入正态分布生成的图片：