GAN  的问题主要有两点：Loss 等于0的梯度消失问题和梯度不稳定以及多样性受损。 前者是因为选择的分布函数使用JS 距离，这个距离不能衡量两个不相交的分布的距离；后者是因为Loss  函数要求KL 距离最小，JS 距离最大，所以梯度不稳定，而且 Loss 函数对正确率要求太大，多样性要求小，所以会造成模型选择大量生成“安全”的“数字1”来降低Loss函数。

        WGAN 使用了EM  距离，保证了多样 性，并且解决了梯度消失的问题，从实验结果来看，多样性是有保证的，但是生成图片的效果 并不好，较难收敛。

        WGAN-GP 的效果好，在第100代的时候，就可以生成多样化、图片清晰的手写数字。 该实验证明了以下两点：

(1)WGAN解决了多样性问题，这也说明，之前原理部分分析的多样性受损确实是由Loss 函数造成的；

(2)WGAN-GP 比 WGAN 效果好，梯度惩罚的效果比 Weight Clipping强，收敛速度快。

WGAN(2017)关于WGAN 的 Loss 函数的图

class discriminator(nn.Module):
    def __init __(self):
    super(discriminator,self).init__()
    self.dis=nn.Sequential(
        nn.Linear(784,256),
        nn.LeakyReLU(0.2),
        nn.Linear(256,256),
        nn.LeakyReLU(0.2),
        nn.Linear(256,1))
    def forward(self,x):
        x=self.dis(x)
        return x

         对于判别器 D 来说，若要使V(G,D)   最大，那么它的Loss  函数就要使-V(G,D) 最小

注释掉GAN判别器D的loss函数，在合适位置写下Loss的新函数

d_loss=torch.mean(fake_out)-torch.mean(real_out)

同理在合适的位置下写下G的新的Loss函数

g_loss=torch.mean(-output)

最后，增加上Weight  Clipping (权重剪裁).Weight  Clipping将所有的参数都变到[一c,c]  内，这里 截断值c=0.05。 截断值c 要根据具体任务具体设置，如果c 过小，会造成梯度消失；如果 c 过大，会造成梯度爆炸。

        梯度消失（Vanishing Gradients）是深度学习中常见的一个问题，特别是在训练深层神经网络时。当网络层数较多时，反向传播过程中梯度会通过多层权重进行连乘，这可能导致梯度变得非常小，以至于网络中的权重更新非常缓慢，从而使得训练过程非常缓慢甚至停滞.

梯度爆炸则是指在训练过程中，梯度随着层数的增加而指数级增长，导致权重更新过大，从而使模型训练变得不稳定。这通常与权重的初始化值过大、学习率过高或网络结构设计不合理有关。

for layer in D.dis:
    if(layer. __class __.__name__=='Linear'):
        layer.weight.requires_grad=False#关闭梯度
        layer.weight.clamp_(-c,c)
        layer.weight.requires_grad=True#打开梯度

        D是判别器，layer 就一个PyTorch  的网络层。layer.__class     .    name__     为 Linear   表 示全连接层，为Conv2d 表示卷积层。在该 MNIST  案例中，都是线性层。

 由于截断操作是一个突变的过程，无法计算梯度，如果不关闭梯度，将会报错。因此要 先关闭这一层的参数的梯度下降，否则无法进行截断。截断之后再打开梯度下降。

WGAN-GP(2017)

        WGAN-GP 是 WGAN 的改进版本。WGAN的问题是截断值的取值问题和大量参数被截断成截断值而导致的泛化能力的丢失。WGAN-GP取 消 了 Weight    Clipping,使用 Gradient   Penalty(梯度惩罚)优化损失函数。梯度惩罚（Gradient Penalty）是在使用Wasserstein GAN（WGAN）进行训练时引入的一种技术，旨在强制判别器（critic）满足Lipschitz连续的约束。

        神经网络的最大的优点在于泛化能力，理论上足够大的神经网络可以拟合各种函数，而这泛化能力正是神经网络中成千上万的大小不一、自动调整的参数凝聚而成的。假设这些参数一大半都是同一个常数(截断值),那泛化能力不久就下降了。

如何从WGAN  改成WGAN-GP

1.注释掉weight clipping

#for layer in D.dis:
   # if(layer. __class __.__name__=='Linear'):
      # layer.weight.requires_grad=False
       # layer.weight.clamp_(-c,c)
        #layer.weight.requires_grad=True

2.计算Gradient     Penalty

'''创建一个形状为 (num_img, 1, 1, 1) 的张量 alpha，其中 num_img 是图像的数量。
张量中的每个元素都是从均匀分布 [0, 1) 中随机采样的。
然后将 alpha 移动到指定的设备（如 GPU）上'''
alpha=torch.rand((num_img,1,1,1)).to(device)
'''
    通过线性插值的方式，将真实图像 real_img 和假图像 fake_img 组合起来，生成新的图像 x_hat。
    alpha 用于控制真实图像和假图像的混合比例。
'''
#使用判别器 D 评估混合图像 x_hat，得到预测结果 pred_hat
x_hat=alpha*real_img+(1-alpha)*fake_img
pred_hat=D(x_hat)
#使用 torch.autograd.grad 计算 pred_hat 相对于 x_hat 的梯度
gradients=torch.autograd.grad(outputs=pred_hat,#outputs=pred_hat 指定了需要计算梯度的输出
                              inputs=x_hat,#inputs=x_hat 指定了需要计算梯度的输入
                              grad_outputs=torch.ones(pred_hat.size()).to(device),#创建一个与 pred_hat 形状相同、所有元素为 1 的张量，用于梯度计算。
                                create_graph=True,#允许梯度的梯度计算，这对于二阶导数（如在梯度惩罚中）是必要的
                                retain_graph=True,#表示在一次backward之后不释放计算图，这对于再次进行backward是必要的。
                                only_inputs=True)[0]#表示只计算对输入的梯度，而不计算对权重的梯度
gradient_penalty=lambda_*((gradients.view(gradients.size()[0],-1).norm(2,1)-1)**2).mean()
#lambda_ 是梯度惩罚的权重，是一个超参数,超参数是机器学习模型训练过程中的参数，它们在开始学习过程之前设置，并且在学习过程中不发生变化。
#将梯度张量重新塑形，以便每个样本的梯度都在一个向量中。
#norm(2, 1) 计算每个样本梯度的 L2 范数,L2 范数（欧几里得范数）：向量元素的平方和的平方根
#计算梯度范数与 1 的差的平方，这是梯度惩罚的核心部分，用于惩罚梯度范数偏离 1 的情况。
#.mean() 计算所有样本的平均梯度惩罚
#这段代码的目的是为了在 WGAN 训练过程中添加梯度惩罚项，以确保判别器满足 Lipschitz 连续的约束，从而提高训练的稳定性和生成模型的质量

        代码中的gradients  与 V₂D(x)   有关联，V₂D(x)的倒三角“梯度算子”表示对D(x)求 x的偏导。考虑函数 torch.autograd.grad,相关代码如下。

#x是一个tensor变量,变量是多维数组的一个泛化，它可以包含标量、向量、矩阵或更高维度的数据
x=torch.tensor([1,2,3],[2,3,4]]).float()
#开启x的梯度下降功能
x.requires_grad=True#PyTorch 会跟踪所有对 x 的操作，以便在反向传播时计算梯度。这对于模型的参数（如权重和偏置）通常是必需的，因为我们需要更新这些参数来最小化损失函数
print(x)
#对x进行计算，相当于函数y=2*x
y=2*x#求x的导数
print(y)
grad=torch.autograd.grad(outputs=y,#指定了需要计算梯度的输出张量 y。这通常是某个损失函数或神经网络的输出
                         inputs=x,#指定了需要计算梯度的输入张量 x。这通常是网络的输入或任何你想要计算梯度的张量。
                         grad_outputs=torch.ones(x.shape))#创建了一个与 y 形状相同、所有元素为1的张量，用于作为 grad 函数的 grad_outputs 参数。这个参数代表了 y 相对于 x 的外部梯度，通常在计算损失函数相对于网络输出的梯度时使用。
print(grad)

计算图是用来计算梯度的一个方法 

#x是一个tensor变量
xtorch.tensor([1,2,3],[2,3,4]]).float()
#开启梯度下降功能
x.requires_grad=True
#对x进行计算，相当于函数y=2*x
x1=2*x
y+3*x1
#对y=2*x求x的导数
#"grad" 通常是指梯度
grad=torch.autograd.grad(outputs=y,inputs=x,
                         grad_outputs=torch.one(x.shape),
                         retain_graph=True#用于指定是否需要保留计算图
                         )

        参数grad 没有计算图，不支持梯度计算，需要引入另外一个参数“create_graph= True”,  为返回值创建一个计算图。

grad=torch.autograd(outputs=y,inputs=x,
                    grad_outputs=torch.ones(x.shape),
                    retain_graph=True,
                    create_graph=True)
grad=torch.autograd(outs=grad[0],inputs=x,
                    grad_outputs=torch.ones(x.shape))
print(grad)

WGANGP

gradients=torch.autograd.grad(outputs=pred_hat,#torch.autograd.grad 是 PyTorch 中用于自动计算梯度的函数
                              inputs=x_hat,#outputs=pred_hat 指定了要计算梯度的输出张量,inputs=x_hat 指定了相对于哪个输入张量计算梯度
                              grad_outputs=torch.ones(pred_hat.size()).to(device),#.to(device) 创建了一个与 pred_hat 相同形状的张量，并且将其所有元素初始化为1。这个张量用于梯度计算中的外导数项。.to(device) 确保这个张量被移到了与 pred_hat 相同的设备上（例如 CPU 或 GPU）。
                              create_graph=True,#表示在计算梯度时，要保留计算图，这样你可以对梯度进行进一步的梯度计算（即高阶导数）。
                              retain_graph=True,#表示在计算梯度后，不立即释放计算图
                              only_inputs=True)[0]# 表示只计算输入张量的梯度，不计算任何其他可能影响输出的参数的梯度
#总结：这段代码通常用于神经网络训练过程中的反向传播，用于计算损失函数相对于网络输入的梯度。

DCGAN,即判别器D 和生成器G 加上了卷积层的GAN, 故先 把基础GAN 的判别器D和生成器G改写成如下模型：

class discriminator(nn.Module):
    def __init __(self):
            super(Discriminator,self). __init__()#调用了父类 nn.Module 的构造函数，以确保正确初始化 nn.Module 的所有属性。
            self.dis=nn.Sequential(#创建了一个 nn.Sequential 容器，用于按顺序包含一系列层。self.dis 将存储这些层
                  nn.Conv2d(1,32,3,Stride=1,padding=1),#添加了一个 2D 卷积层，它将输入的 1 个通道转换为 32 个通道，卷积核大小为 3x3，步长为 1，边缘填充为 1 像素
                  nn.LeakyReLU(0.2,True),#添加了一个 LeakyReLU 激活层，负斜率为 0.2，inplace=True 表示在原地进行计算，以节省内存
                  nn.MaxPool2d((2,2)),#添加了一个最大池化层，池化窗口大小为 2x2，步长默认为 2。
                  nn.Conv2d(32,64,3,Stride=1,padding=1),#添加了第二个卷积层，它将 32 个通道转换为 64 个通道，卷积核大小为 3x3，步长为 1，边缘填充为 1 像素。
                  nn.LeakyReLU(0.2,True)#再次添加了一个 LeakyReLU 激活层，参数与第一个相同
                  nn.MaxPool2d((2,2))
            )
    self.fc=nn.Sequential(#创建了另一个 nn.Sequential 容器，self.fc 将用于包含全连接层。
          nn.Linear(7*7*64,1024),#添加了一个全连接层，它将卷积层输出的特征图展平后的特征数量（在这种情况下是 7x7x64）转换为 1024 个特征。
          nn.LeakyReLU(0.2,True),
          nn.Linear(1024,1),#添加了另一个全连接层，将 1024 个特征转换为 1 个特征。
          nn.Sigmoid()  #用于将输出转换为 0 到 1 之间的值，通常用于二分类任务     
    )

再将生成器G 改成如下模型

class generator(nn.Module):#定义了一个名为 generator 的类，它继承自 nn.Module
    def __init__(self,input_size,num_feature):#它接受两个参数：input_size 表示输入噪声向量的维度，num_feature 表示生成器网络中第一个全连接层输出的特征数量
        super(generator,self). __init __()#确保正确初始化 nn.Module 的所有属性
        #fc 通常代表 "Fully Connected"，即全连接层
        self.fc=nn.Linear(input_size,num_feature)#创建了一个全连接层，将输入的噪声向量（维度为 input_size）转换为具有 num_feature 个特征的向量。
        self.br=nn.Sequential(#创建了一个 nn.Sequential 容器，用于包含批量归一化层和 ReLU 激活层
            nn.BatchNorm2d(1),#这里 BatchNorm2d 的参数 1 表示输入通道数为 1。
            nn.ReLU(True),
        )
        #然后使用3个卷积层将1×56×56的图片，转换为1×28×28的图片
        #创建了另一个 nn.Sequential 容器，用于包含生成器网络中的卷积层。
        self.gen=nn.Sequential(
            nn.Conv2d(1,64,3,Stride=1,padding=1),#添加了一个 2D 卷积层，它将输入的 1 个通道转换为 64 个通道，卷积核大小为 3x3，步长为 1，边缘填充为 1 像素
            nn.BatchNorm2d(64),#添加了一个批量归一化层，参数 64 表示输入通道数为 64
            nn.ReLU(True),#添加了一个 ReLU 激活层
            nn.Conv2d(32,1,3,Stride=2,padding=1),
            nn.Tanh(),#添加了一个 Tanh 激活层，用于将输出值归一化到 [-1, 1] 范围内
        )
    def forward(self,x):
        x=self.fc(x)#定义了 forward 方法，它是模型的前向传播函数，x 是输入数据。
        x=x.view(x.shape[0],1,56,56)#全连接层的输出 x 重塑为一个四维张量，其中批次大小保持不变，通道数为 1，空间维度为 56x56
        x=self.br(x)#将重塑后的张量 x 通过批量归一化和 ReLU 激活层 self.br 进行处理。
        x=self.gen(x)
        return x#返回卷积层的输出 x，这是生成器的最终输出图像

         从 DCGAN到 WDCGAN再到 WDCGAN-GP的过程与GAN到WGAN 到 WGAN- GP 类似

  CVAE-GAN

#VAE模型结构,VAE是一种生成模型，它通过编码器将输入数据映射到一个潜在空间，然后通过解码器从潜在空间重构输入数据。
class VAE(nn.Module):#定义了一个名为VAE的类，它继承自nn.Module，这是PyTorch中所有神经网络模型的基类。
    def __init __(self):#定义了类的初始化函数
    super(VAE,self).__init__()
    #定义编码器
    self.encoder_conv=nn.Sequential(#是一个卷积层序列，用于特征提取
        nn.Conv2d(1,16,kernel_size=3,Stride=2,padding=1),#一个输入通道为1、输出通道为16的卷积层，核大小为3，步长为2，填充为1
        nn.BatchNorm2d(16),
        nn.LeakyReLU(0.2,inplace=True),
                     nn.Conv2d(16,32,kernel_size=3,Stride=2,padding=1),
                     nn.BatchNorm2d(32),
                     nn.LeakyReLU(0.2,inplace=True),
                     nn.Conv2d(32,32,kernel_size=3,Stride=1,padding=1),
                     nn.BatchNorm2d(32),
                     nn.LeakyReLU(0.2,inplace=True)
    )
    self.encoder_fc1=nn.Linear(32*7*7,nz)#两个全连接层，用于将卷积层的输出映射到潜在空间的均值和方差。
    self.encoder_fc2=nn.Linear(32*7*7,nz)
    self.decoder_fc=nn.Linear(nz+10,32*7*7)
    self.decoder_deconv=nn.Sequential(#self.decoder_fc 是一个全连接层，将潜在空间的向量映射回卷积层的输出维度。self.decoder_deconv 是一个反卷积层序列，用于将特征图映射回原始输入空间。
        nn.ConvTranspose2d(32,16,4,2,1),
        nn.ReLU(inplace=True),
        nn.ConvTranspose2d(16,1,4,2,1),
        nn.Sigmoid(),
    )
    def noise_reparameterize(self,mean,logvar):#是一个辅助函数，用于在训练过程中引入随机性。它通过重参数化技巧来生成潜在空间的样本。
    eps=torch.randn(mean.shape).to(device)
    z=mean+eps*torch.exp(logvar)
    return z
    def encoder(self,x):#定义了编码器的前向传播过程。它首先通过卷积层提取特征，然后通过两个全连接层计算潜在空间的均值和方差。最后，使用noise_reparameterize函数生成潜在空间的样本。
        out1,out2=self.encoder_conv(x),self.encoder_conv(x)
        mean=self.encoder_fc1(out1.view(out1.shape[0],-1))#这行代码将 out1 的输出展平（view 方法），然后通过一个全连接层 self.encoder_fc1 来计算潜在空间的均值向量 mean。
        logstd=self.encoder_fc2(out2.view(out2.shape[0],-1))#类似地，这行代码将 out2 的输出展平，然后通过另一个全连接层 self.encoder_fc2 来计算潜在空间的标准差对数 logstd。在VAE中，方差通常通过对数方差来参数化，以便确保方差始终为正。
        z=self.noise_reparameterize(mean,logstd)#该方法使用均值 mean 和对数方差 logstd 来生成潜在空间的样本 z。这是通过添加噪声到均值上实现的，噪声的大小由对数方差决定
        return z,mean,logstd#这行代码返回生成的潜在空间样本 z 以及用于生成它的均值和对数方差
    def decoder(self,z)#这行代码将潜在空间样本 z 通过一个全连接层 self.decoder_fc 来扩展其维度，准备进行反卷积操作。
        out3=self.decoder_fc(z)
        out3=out3.view(out3.shape[0],32,7,7)#这行代码将 out3 的输出重新塑形为适合反卷积操作的形状，即 [batch_size, channels, height, width]
        out3=self.decoder_deconv(out3)#这行代码将重新塑形后的 out3 通过反卷积层序列 self.decoder_deconv 进行处理，以生成重构的输出
        return out3#这行代码返回解码器的输出，即从潜在空间重构的输入数据
        

        在训练过程中，跟GAN  一样，每个模型轮着训练，这里先训练分类器C, 再训练判别器 D, 最后训练生成器G

#分类器C训练
for i,(data,label) in enumerate(dataloader,0):#这是一个循环，遍历 dataloader 中的所有数据。dataloader 是一个迭代器，它每次提供一批数据和对应的标签。enumerate 函数用于获取当前批次的索引 i 和数据 data 与标签 label
    #先处理一下数据
    data=data.to(device)#这行代码将数据移动到指定的设备（如CPU或GPU）上。device 是一个字符串或设备对象，指定了数据应该被发送到的设备
    label_onehot=torch.zeros((data.shape[0],10)).to(device)#创建一个零矩阵，其形状为 [batch_size, 10]，其中 batch_size 是当前批次数据的数量，10 是类别的数量。这个矩阵用于存储一个独热编码的标签。
    label_onehot[torch.arange(data.shape[0]),label]=1
    batch_size=data.shape[0]#这行代码获取当前批次的大小，并将其存储在变量 batch_size 中
    output=C(data)#这行代码将数据传递给分类器 C，得到模型的输出
    real_label=label_onehot.to(device)#这行代码确保独热编码的标签也被移动到指定的设备上。
    errC=criterion(output,real_label)#这行代码计算模型输出和真实标签之间的损失。criterion 是一个损失函数，例如交叉熵损失
    C.zero_grad()#在反向传播之前，需要将模型参数的梯度清零。这是因为默认情况下，梯度是累加的
    errC.backward()#这行代码执行反向传播，计算损失函数关于模型参数的梯度
    optimzerC.step()#这行代码根据计算出的梯度更新模型的参数。optimizerC 是一个优化器对象，负责在训练过程中调整参数。
    #独热编码（One-Hot Encoding）是一种将分类变量转换为机器学习算法可以更好处理的形式的方法。在独热编码中，每个类别被表示为一个二进制向量，其中只有一个元素是1，其余元素都是0。这个1的位置对应于类别的索引

判别器D训练过程

#判别器D训练代码,判别器的作用就是判断真假
output=D(data)#这行代码将真实数据 data 传递给判别器 D，得到判别器对真实数据的输出
#创建一个包含全1的向量，其长度等于当前批次的大小 batch_size，并将这个向量移动到指定的设备上。
# 这个向量代表真实数据的标签，在二分类问题中，1通常表示正类，也就是真，负类也就是假
real_label=torch.ones(batch_size).to(device)
fake_label=torch.zeros(batch_size).to(device)
errD_real=criterion(output,real_label)#计算判别器对真实数据输出和真实标签之间的损失。criterion 是一个损失函数，例如二元交叉熵损失
z=torch.randn(batch_size,nz+10).to(device)#创建一个随机噪声向量 z，其形状为 [batch_size, nz + 10]，并将这个向量移动到指定的设备上。这里的 nz 是潜在空间的维度，10 可能是附加信息的维度
fake_data=vae.decoder(z)
output=D(fake_data)#将生成的假数据 fake_data 传递给判别器 D，得到判别器对假数据的输出
errD_fake=criterion(output,fake_label)#计算判别器对假数据输出和假标签之间的损失
errD=errD_real+errD_fake#将判别器在真实数据和假数据上的损失相加，得到总损失 errD
errD.backward()#这行代码执行反向传播，计算损失函数关于判别器参数的梯度
optimizerD.step()#optimizerD 是一个优化器对象，负责在训练过程中调整判别器 D 的参数。

        判别器D 的训练方式和GAN  的训练方式没有差别，即希望判别器可以把真实图片都 归类为1,生成图片都归类为0。至于生成器G 的损失函数，由三部分组成：

(1)生成图像更接近原始图像，而且生成的mean 和 logstd 也应该满足标准分布； (2)生成图像可以被Discriminator  判断成是真实的图像；

(3)生成图像可以被Classifier 判断出对应的类别。

分别对应下面代码中的1、2、3部分：

#更新VAE(G)1，损失函数就是传统VAE的损失函数
z,mean,logstd=vae.encoder(data)#使用VAE的编码器对输入数据进行编码，得到潜在空间的表示z，以及均值mean和对数标准差logstd
z=torch.cat([z,label_onehot],1)#z和标签的one-hot编码label_onehot拼接在一起，以便在解码器中使用
recon_data=vae.decoder(z)
vae_loss1=loss_function(recon_data)#计算重构损失，这是传统VAE损失函数的一部分，通常包括重构误差和KL散度。
#更新VAE(G)2,损失函数是传统GAN的损失函数，希望生成器G可以生成以假乱真的图片
output=D(recon_data)
##使用VAE的解码器对拼接后的潜在表示进行解码，得到重构的数据。
#衡量解码器输出的数据与原始输入数据之间的相似度。它通常使用某种距离度量（如均方误差）来计算，目的是使解码器能够尽可能准确地重建输入数据
#衡量编码器输出的潜在空间分布与先验分布（通常是标准正态分布）之间的差异
real_label=torch.ones(batch_size).to(device)#创建一个与批次大小相同，所有元素为1的张量，表示真实数据的标签。
vae_loss2=criterion(output,real_label)#计算GAN损失，这是希望生成器生成的数据能够被判别器认为是真实的。
#更新VAE(3),是一个类别的损失函数，希望生成器G可以生成分类器C得出分类的图片
output=C(recon_data)#将重构的数据输入到分类器C中，得到分类器的输出
real_label=label_onehot#使用原始的标签one-hot编码作为真实标签
vae_loss3=criterion(output,real_label)#计算分类损失，这是希望生成器生成的数据能够被分类器正确分类。
#三个部分损失函数梯度下降
vae.zero_grad()#清除VAE模型的梯度
vae_loss=vae_loss1+vae_loss2+vae_loss3#将三个部分的损失相加，得到总的损失
vae_loss.backward()#对总损失进行反向传播，计算梯度
optimizerVAE.step()#使用优化器更新VAE模型的参数
vae=VAE().to(device)#重新初始化VAE模型并将其移动到指定的设备（如GPU）