深度学习实战3--GAN：基础手写数字对抗生成

本节目标

1.看懂GAN  基础架构的代码；

2.重点是GAN  的损失函数的构成；

3.理解如何从 GAN 修改成CGAN;

4.尝试复现本章实战任务

任务描述

        GAN 的任务是生成，用两个模型相互对抗，来增强生成模型的效果。此处准备的数据集是MNIST手写数字，希望生成类似的手写数字的图像。

判别器和生成器：生成器 G 是创造者，负责生成新的数据实例，而判别器 D 是鉴别者，负责评估数据实例的真伪。两者相互竞争，推动对方不断进步，从而提高生成数据的质量。

注意：BCE 是Binary_Cross_Entropy的缩写，可以理解为二分类问题。GAN 的任务是生成，用两个模型相互对抗，来增强生成模型的效果。那么 CGAN  就是 给定条件进行指定数字的生成。

以下内容是重点：

(1)GAN 的损失函数与BCE之间的转换；

(2)GAN 的判别器D 和生成器G 模型的输入输出；

(3)GAN 如何转化成CGAN;

(4)CGAN 中窥视到GAN 结构似乎有损害多样性的缺点

import torch #使用import语句时,要访问torch模块中的函数或类，你需要使用torch.前缀
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt#可以提高代码的可读性，因为它直接表明了你正在使用的是来自哪个模块的特定部分
import torchvision #torchvision则提供了图像处理和加载数据集的工具
from torchvision import transforms#使用from torch import nn后，可以直接使用nn而不需要torch.nn前缀,from也可避免冲突，因为是导入的特定模块
#数据归一化，它是数据预处理中的一种常用技术，目的是将数据调整到一个统一的尺度或范围内，以便于不同特征之间的比较和计算
transform=transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(0.5,0.5)
])
'''这个变换将PIL图像或Numpy数组转换为
torch.FloatTensor类型，并将数值范围从[0, 255]压缩到[0.0, 1.0]。
这是将数据从整数格式转换为浮点格式，以便于神经网络处理。'''
''''可能需要调整transforms.Normalize中
的均值和标准差参数,均值0.5，方差0.5，以匹配你的数据的实际范围'''
#加载内置数据集
train_ds=torchvision.datasets.MNIST('data',
                                    train=True,
                                    transform=transform,
                                    download=True)#PyTorch会从其官方源或者数据集的原始来源下载数据集
#创建一个数据加载器，它用于在训练过程中批量地加载数据
#每个批次包含64个样本。
#shuffle=True: 这个参数决定是否在每个epoch开始时对数据进行打乱（洗牌）。
#设置为True可以确保数据在每个epoch中以随机顺序加载，这有助于模型训练的泛化能力。
dataloader=torch.utils.data.DataLoader(train_ds,
                                       batch_size=64,
                                       shuffle=True)
#返回一个批次的数据
imgs,_=next(iter(dataloader))
#生成器
#在PyTorch中，nn.Module 的子类需要在构造函数中调用 super().__init__() 来确保正确初始化
class Generator(nn.Module):
    def __init__ (self):
        super(Generator,self).__init__()
        self.Linear=nn.Sequential(
            nn.Linear(100,256),## 将100维的输入映射到256维
            nn.Tanh(),## 使用双曲正切激活函数
            nn.Linear(256,512),# 将256维映射到512维
            nn.Tanh(),# 再次使用双曲正切激活函数
            nn.Linear(512,28*28),# 将512维映射到28*28维，适合MNIST图像
            nn.Tanh()
        )
        #用于指定模型的前向传播过程
        '''这一行使用view方法改变了张量x的形状。view方法用于重塑张量而不改变其数据。
        这里的-1是一个特殊的参数，表示自动计算该维度的大小以保持总元素数量不变。
        因此，view(-1, 28, 28)将x重塑为一个形状为[batch_size, 28, 28]的三维张量，
        其中batch_size是输入数据中的批次大小。'''
    def forward(self,x):
        x=self.Linear(x)## 将输入数据x通过self.linear中的层进行处理
        x=x.view(-1,28,28)
        return x#方法返回处理后的张量x，它现在是一个具有28x28像素的二维图像张量
#辨别器,Discriminator 的类,目的是区分输入数据是真实的还是由生成器生成的
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator,  self).__init__()
        # 创建了一个 nn.Sequential 容器，这是一个有序的容器，可以包含多个模块，它们将按顺序被应用
        #定义了一个线性层，它将输入特征从 28*28（即一个 28x28 的图像展平后的维度）转换为 512 维。
        #LeakyReLU 激活函数，它允许负值通过，以解决传统 ReLU 激活函数的“死亡ReLU”问题
        #激活函数的某些神经元可能会停止激活，即它们的输入值永远不会变为负数，导致这些神经元的梯度永久为零，从而不再更新。
        # 这会导致模型的某些部分不再学习，影响模型的性能。
        #定义了一个线性层，它将输入特征从 28*28（即一个 28x28 的图像展平后的维度）转换为 512 维。
        #定义了第三个线性层，将特征维度从 256 压缩到 1 维。这个输出通常代表判别器对输入数据是真实还是假数据的判断
        #添加了一个 Sigmoid 激活函数，它将线性层的输出压缩到 0 到 1 之间，通常用于二分类问题的概率输出。
        self.linear=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.linear(x)
        return x
device='cuda' if torch.cuda.is_available() else 'cpu'
if device=='cuda':
    print('using cuda:',torch.cuda.get_device_name(0))#用于获取第一个CUDA设备的名称
Gen=Generator().to(device)#创建了一个 Generator 类的实例，并将其移动到之前定义的 device 上。这个 device 可能是一个 GPU 或cpu设备
#使用 .to(device) 是为了确保模型的参数和计算都在指定的设备上进行，这样可以利用 GPU 加速训练过程
Dis=Discriminator().to(device)#实例化 Discriminator 类，创建一个判别器对象
d_optim=torch.optim.Adam(Dis.parameters(),lr=0.001)#这行代码创建了一个Adam优化器实例，用于更新名为 Dis 的判别器网络的参数。
g_optim=torch.optim.Adam(Gen.parameters(),lr=0.001)#这行代码创建了另一个Adam优化器实例，用于更新名为 Gen 的生成器网络的参数。
'''学习率的值通常表示为一个介于0和1之间的小数
如果学习率设置得太高，可能会导致模型在训练过程中不稳定，甚至发散，因为每次更新的步长太大，可能会越过损失函数的最小点
如果学习率设置得太低，模型的收敛速度会很慢，因为每次更新的步长太小，需要更多的迭代次数才能达到最小点
'''
loss_function=torch.nn.BCELoss()#用来定义二元交叉熵损失函数
def gen_img_plot(model,test_input):
    prediction=np.squeeze(model(test_input).detach().cpu().numpy())#生成器模型 model(test_input) 生成图像，通过 .detach().cpu().numpy() 
    #将生成的PyTorch张量转换为NumPy数组并移至CPU，然后使用 np.squeeze() 移除单维度以简化数组形状，为绘图准备数据。
    fig=plt.figure(figsize=(4,4))#创建一个新的matplotlib图形对象，设置图形的大小为4x4英寸
    for i in range(prediction.shape[0]):#prediction.shape[0] 表示生成的图像数量
        plt.subplot(4,4,i+1)
        plt.imshow((prediction[i]+1)/2)#显示当前图像。由于生成的图像数据可能在 [-1, 1] 范围内
        #这里通过 (prediction[i]+1)/2 将其规范化到 [0, 1] 范围
        plt.axis('off')#用于关闭matplotlib图表中的坐标轴的函数
    plt.show()
test_input=torch.randn(16,100,device=device)
D_loss=[]#用于存储判别器（Discriminator）在训练过程中的损失值
G_loss=[]
for epoch in range(20):#每次迭代称为一个epoch
    d_epoch_loss=0#初始化判别器的累积损失
    g_epoch_loss=0#初始化生成器的累积损失
    count=len(dataloader)#计算数据加载器（dataloader）中的批次数量。
    for step,(img,_) in enumerate(dataloader):# 遍历数据加载器中的每个批次
        img=img.to(device)#将图像数据移动到指定的设备（例如GPU）
        size=img.size(0)#获取当前批次的大小
        random_noise=torch.randn(size,100,device=device)#生成随机噪声，用作生成器的输入,"噪声"通常指的是随机生成的数据
        d_optim.zero_grad()#清除判别器的梯度
        real_output=Dis(img)#使用判别器对真实图像进行判断
        d_real_loss=loss_function(real_output,torch.ones_like(real_output))#计算判别器对真实图像的损失。
        d_real_loss.backward()#对真实图像的损失进行反向传播
        gen_img=Gen(random_noise)#使用生成器生成假图像
        fake_output=Dis(gen_img.detach())#使用判别器对生成的假图像进行判断
        d_fake_loss=loss_function(fake_output,  #计算判别器对假图像的损失
                                  torch.zeros_like(fake_output))
        d_fake_loss.backward()#对假图像的损失进行反向传播
        d_loss=d_real_loss+d_fake_loss#计算判别器的总损失
        d_optim.step()# 更新判别器的参数


        g_optim.zero_grad()#清除生成器的优化器中的梯度。这是每次参数更新前的标准步骤，用于防止梯度累加。
        fake_output=Dis(gen_img)#将生成器生成的图像（gen_img）传递给判别器（Dis），以获取判别器对假图像的判断结果。
        g_loss=loss_function(fake_output,torch.ones_like(fake_output))#生成器的损失计算是至关重要的，因为它指导生成器如何改进以生成更逼真的图像
        g_loss.backward()#计算生成器损失的反向传播
        g_optim.step()#更新生成器的参数。这一步使用优化器（如SGD或Adam）根据反向传播计算得到的梯度来更新生成器的权重
        with torch.no_grad():
            d_epoch_loss+=d_loss#累加判别器的损失
            g_epoch_loss+= g_loss#累加生成器的损失
    with torch.no_grad():#这个上下文管理器指示 PyTorch 在这个代码块中不计算梯度。
        #这通常用于推理或评估阶段，以减少内存使用并提高性能
            d_epoch_loss/=count# 将判别器的累积损失除以批次数量 count，以计算整个epoch的平均损失。
            g_epoch_loss/=count#将生成器的累积损失除以批次数量 count，以计算整个epoch的平均损失。
            D_loss.append(d_epoch_loss)#将计算得到的判别器平均损失添加到 D_loss 列表中，用于记录每个epoch的损失。
            G_loss.append(g_epoch_loss)#将计算得到的生成器平均损失添加到 G_loss 列表中，用于记录每个epoch的损失。
            print('Epoch:',epoch+1)# 打印当前的epoch编号，epoch+1 因为 epoch 从0开始计数，而通常人们习惯从1开始计数。
            gen_img_plot(Gen,test_input)#绘制生成器的输出图像

缩进错误很难分清，代码又一样，写的时候需要仔细看清，找了好久才发现这个错误。