【深度学习】gan网络原理生成对抗网络

本文介绍: 这一部分设置了设备（GPU或CPU）、初始化了生成器和判别器的实例，并定义了优化器（Ad a m 优化器）和损失函数（二分类交叉熵损失）。将生成器和判别器移动到设备上进行加速计算。plt.show()

【深度 学习】gan 网络 原理 生成 对抗 网络

GAN的基本思想源自博弈论你的二人零和博弈，由一个生成器和一个判别器构成，通过对抗学习的方式训练，目的是估测数据样本的潜在分布并生成新的数据样本。
在这里插入图片描述

1.下载 数据并对数据进行规范

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(0.5 , 0.5)
])
train_ds = torchvision.datasets.MNIST('data', train=True, transform=transform, download=True)
dataloader = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)

下载MNIST数据集，并对数据进行规范化。transforms.Com pose 是用于定义一系列数据变换的类，ToTensor() 将图像转换为PyTorch 张量，Norm a lize(0.5, 0.5) 对张量进行归一化。然后，创建一个 DataLoader，它将数据集划分成小批次，使得在训练时更容易处理。

2.生成器的代码

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
               nn.Linear(100, 256),
               nn.ReLU(),
               nn.Linear(256, 512),
               nn.ReLU(),
               nn.Linear(512, 28*28),
               nn.Tanh()
           )

    def forward(self, x):
        img = self.main(x)
        img = img.reshape(-1, 28, 28)
        return img

这一部分定义了生成器的神经网络模型。生成器的输入是一个大小为100的随机向量，通过多个线性层和激活函数（ReLU），最后通过 nn.Tanh() 激活函数生成大小为28×28的图像。forward 方法定义了前向传播的过程。

3.判别器的代码

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
                    nn.Linear(28*28, 512),
                    nn.LeakyReLU(),
                    nn.Linear(512, 256),
                    nn.LeakyReLU(),
                    nn.Linear(256, 1),
                    nn.Sigmoid()
        )

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = self.main(x)
        return x

这一部分定义了判别器的神经网络模型。判别器的输入是28×28大小的图像，通过多个线性层和激活函数（LeakyReLU），最后通过 nn.Si gmoid() 激活函数输出一个0到1之间的值，表示输入图像是真实图像的概率。

4. 定义损失函数和优化 函数

device = 'cuda' if torch.cuda.is_available() else 'cpu'
gen = Generator().to(device)
dis = Discriminator().to(device)
gen_opt = optim.Adam(gen.parameters(), lr=0.0001)
dis_opt = optim.Adam(dis.parameters(), lr=0.0001)
loss_fn = torch.nn.BCELoss()

这一部分设置了设备（GPU或CPU）、初始化了生成器和判别器的实例，并定义了优化器（Adam优化器）和损失函数（二分类交叉熵损失）。将生成器和判别器移动到设备上进行加速计算。

5.定义绘图 函数

def gen_img_plot(model,test_input):
    prediction = np.squeeze(model(test_input).detach().cpu().numpy())
    fig = plt.figure(figsize=(4, 4))
    for i in range(16):
        plt.subplot(4, 4, i+1)
        plt.imshow((prediction[i]+1)/2)
        plt.axis('off')
    plt.show()

6. 开始训练，并显示出生成器所产生的图像

test_input = torch.randn(16, 100, device=device)
D_loss = []
G_loss = []
for epoch in range(30):
    d_epoch_loss = 0
    g_epoch_loss = 0
    count = len(dataloader)
    for step, (img, _) in enumerate(dataloader):
        img = img.to(device)               # 获得用于训练的mnist图像
        size = img.size(0)                 # 获得1批次数据量大小
        
    # 随机生成size个100维的向量样本值，也即是噪声，用于输入生成器 生成 和mnist一样的图像数据
    random_noise = torch.randn(size, 100, device=device)

    ########################### 先训练判别器 #############################
    dis_opt.zero_grad()
    real_output = dis(img)
    d_real_loss = loss_fn(real_output, torch.ones_like(real_output))  # 真实值的loss，也即是真图片与1标签的损失
    d_real_loss.backward()

    gen_img = gen(random_noise)
    fake_output = dis(gen_img.detach())
    d_fake_loss = loss_fn(fake_output, torch.zeros_like(fake_output)) # 假的值的loss，也即是生成的图像与0标签的损失
    d_fake_loss.backward()

    d_loss = d_real_loss + d_fake_loss
    dis_opt.step()

    ########################### 下面再训练生成器 #############################
    gen_opt.zero_grad()
    fake_output = dis(gen_img)
    g_loss = loss_fn(fake_output, torch.ones_like(fake_output))
    g_loss.backward()
    gen_opt.step()
    #########################################################################
   with torch.no_grad():
        d_epoch_loss += d_loss
        g_epoch_loss += g_loss
with torch.no_grad():
    d_epoch_loss /= count
    g_epoch_loss /= count
    D_loss.append(d_epoch_loss)
    G_loss.append(g_epoch_loss)
    print('epoch:', epoch)
    gen_img_plot(gen, test_input)