深度学习实战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 结构似乎有损害多样性的缺点

1. import torch #使用import语句时,要访问torch模块中的函数或类，你需要使用torch.前缀
2. import torch.nn as nn
3. import torch.nn.functional as F
4. import torch.optim as optim
5. import numpy as np
6. import matplotlib.pyplot as plt#可以提高代码的可读性，因为它直接表明了你正在使用的是来自哪个模块的特定部分
7. import torchvision #torchvision则提供了图像处理和加载数据集的工具
8. from torchvision import transforms#使用from torch import nn后，可以直接使用nn而不需要torch.nn前缀,from也可避免冲突，因为是导入的特定模块
9. #数据归一化，它是数据预处理中的一种常用技术，目的是将数据调整到一个统一的尺度或范围内，以便于不同特征之间的比较和计算
10. transform=transforms.Compose([
11.     transforms.ToTensor(),
12.     transforms.Normalize(0.5,0.5)
13. ])
14. '''这个变换将PIL图像或Numpy数组转换为
15. torch.FloatTensor类型，并将数值范围从[0, 255]压缩到[0.0, 1.0]。
16. 这是将数据从整数格式转换为浮点格式，以便于神经网络处理。'''
17. ''''可能需要调整transforms.Normalize中
18. 的均值和标准差参数,均值0.5，方差0.5，以匹配你的数据的实际范围'''
19. #加载内置数据集
20. train_ds=torchvision.datasets.MNIST('data',
21.                                     train=True,
22.                                     transform=transform,
23.                                     download=True)#PyTorch会从其官方源或者数据集的原始来源下载数据集
24. #创建一个数据加载器，它用于在训练过程中批量地加载数据
25. #每个批次包含64个样本。
26. #shuffle=True: 这个参数决定是否在每个epoch开始时对数据进行打乱（洗牌）。
27. #设置为True可以确保数据在每个epoch中以随机顺序加载，这有助于模型训练的泛化能力。
28. dataloader=torch.utils.data.DataLoader(train_ds,
29.                                        batch_size=64,
30.                                        shuffle=True)
31. #返回一个批次的数据
32. imgs,_=next(iter(dataloader))
33. #生成器
34. #在PyTorch中，nn.Module 的子类需要在构造函数中调用 super().__init__() 来确保正确初始化
35. class Generator(nn.Module):
36.     def __init__ (self):
37.         super(Generator,self).__init__()
38.         self.Linear=nn.Sequential(
39.             nn.Linear(100,256),## 将100维的输入映射到256维
40.             nn.Tanh(),## 使用双曲正切激活函数
41.             nn.Linear(256,512),# 将256维映射到512维
42.             nn.Tanh(),# 再次使用双曲正切激活函数
43.             nn.Linear(512,28*28),# 将512维映射到28*28维，适合MNIST图像
44.             nn.Tanh()
45.         )
46.         #用于指定模型的前向传播过程
47.         '''这一行使用view方法改变了张量x的形状。view方法用于重塑张量而不改变其数据。
48.         这里的-1是一个特殊的参数，表示自动计算该维度的大小以保持总元素数量不变。
49.         因此，view(-1, 28, 28)将x重塑为一个形状为[batch_size, 28, 28]的三维张量，
50.         其中batch_size是输入数据中的批次大小。'''
51.     def forward(self,x):
52.         x=self.Linear(x)## 将输入数据x通过self.linear中的层进行处理
53.         x=x.view(-1,28,28)
54.         return x#方法返回处理后的张量x，它现在是一个具有28x28像素的二维图像张量
55. #辨别器,Discriminator 的类,目的是区分输入数据是真实的还是由生成器生成的
56. class Discriminator(nn.Module):
57.     def __init__(self):
58.         super(Discriminator,  self).__init__()
59.         # 创建了一个 nn.Sequential 容器，这是一个有序的容器，可以包含多个模块，它们将按顺序被应用
60.         #定义了一个线性层，它将输入特征从 28*28（即一个 28x28 的图像展平后的维度）转换为 512 维。
61.         #LeakyReLU 激活函数，它允许负值通过，以解决传统 ReLU 激活函数的“死亡ReLU”问题
62.         #激活函数的某些神经元可能会停止激活，即它们的输入值永远不会变为负数，导致这些神经元的梯度永久为零，从而不再更新。
63.         # 这会导致模型的某些部分不再学习，影响模型的性能。
64.         #定义了一个线性层，它将输入特征从 28*28（即一个 28x28 的图像展平后的维度）转换为 512 维。
65.         #定义了第三个线性层，将特征维度从 256 压缩到 1 维。这个输出通常代表判别器对输入数据是真实还是假数据的判断
66.         #添加了一个 Sigmoid 激活函数，它将线性层的输出压缩到 0 到 1 之间，通常用于二分类问题的概率输出。
67.         self.linear=nn.Sequential(
68.             nn.Linear(28*28,512),
69.             nn.LeakyReLU(),
70.             nn.Linear(512,256),
71.             nn.LeakyReLU(),
72.             nn.Linear(256,1),
73.             nn.Sigmoid()
74.         )
75.     def forward(self, x):
76.         x = x.view(-1, 28*28)
77.         x = self.linear(x)
78.         return x
79. device='cuda' if torch.cuda.is_available() else 'cpu'
80. if device=='cuda':
81.     print('using cuda:',torch.cuda.get_device_name(0))#用于获取第一个CUDA设备的名称
82. Gen=Generator().to(device)#创建了一个 Generator 类的实例，并将其移动到之前定义的 device 上。这个 device 可能是一个 GPU 或cpu设备
83. #使用 .to(device) 是为了确保模型的参数和计算都在指定的设备上进行，这样可以利用 GPU 加速训练过程
84. Dis=Discriminator().to(device)#实例化 Discriminator 类，创建一个判别器对象
85. d_optim=torch.optim.Adam(Dis.parameters(),lr=0.001)#这行代码创建了一个Adam优化器实例，用于更新名为 Dis 的判别器网络的参数。
86. g_optim=torch.optim.Adam(Gen.parameters(),lr=0.001)#这行代码创建了另一个Adam优化器实例，用于更新名为 Gen 的生成器网络的参数。
87. '''学习率的值通常表示为一个介于0和1之间的小数
88. 如果学习率设置得太高，可能会导致模型在训练过程中不稳定，甚至发散，因为每次更新的步长太大，可能会越过损失函数的最小点
89. 如果学习率设置得太低，模型的收敛速度会很慢，因为每次更新的步长太小，需要更多的迭代次数才能达到最小点
90. '''
91. loss_function=torch.nn.BCELoss()#用来定义二元交叉熵损失函数
92. def gen_img_plot(model,test_input):
93.     prediction=np.squeeze(model(test_input).detach().cpu().numpy())#生成器模型 model(test_input) 生成图像，通过 .detach().cpu().numpy()
94.     #将生成的PyTorch张量转换为NumPy数组并移至CPU，然后使用 np.squeeze() 移除单维度以简化数组形状，为绘图准备数据。
95.     fig=plt.figure(figsize=(4,4))#创建一个新的matplotlib图形对象，设置图形的大小为4x4英寸
96.     for i in range(prediction.shape[0]):#prediction.shape[0] 表示生成的图像数量
97.         plt.subplot(4,4,i+1)
98.         plt.imshow((prediction[i]+1)/2)#显示当前图像。由于生成的图像数据可能在 [-1, 1] 范围内
99.         #这里通过 (prediction[i]+1)/2 将其规范化到 [0, 1] 范围
100.         plt.axis('off')#用于关闭matplotlib图表中的坐标轴的函数
101.     plt.show()
102. test_input=torch.randn(16,100,device=device)
103. D_loss=[]#用于存储判别器（Discriminator）在训练过程中的损失值
104. G_loss=[]
105. for epoch in range(20):#每次迭代称为一个epoch
106.     d_epoch_loss=0#初始化判别器的累积损失
107.     g_epoch_loss=0#初始化生成器的累积损失
108.     count=len(dataloader)#计算数据加载器（dataloader）中的批次数量。
109.     for step,(img,_) in enumerate(dataloader):# 遍历数据加载器中的每个批次
110.         img=img.to(device)#将图像数据移动到指定的设备（例如GPU）
111.         size=img.size(0)#获取当前批次的大小
112.         random_noise=torch.randn(size,100,device=device)#生成随机噪声，用作生成器的输入,"噪声"通常指的是随机生成的数据
113.         d_optim.zero_grad()#清除判别器的梯度
114.         real_output=Dis(img)#使用判别器对真实图像进行判断
115.         d_real_loss=loss_function(real_output,torch.ones_like(real_output))#计算判别器对真实图像的损失。
116.         d_real_loss.backward()#对真实图像的损失进行反向传播
117.         gen_img=Gen(random_noise)#使用生成器生成假图像
118.         fake_output=Dis(gen_img.detach())#使用判别器对生成的假图像进行判断
119.         d_fake_loss=loss_function(fake_output,  #计算判别器对假图像的损失
120.                                   torch.zeros_like(fake_output))
121.         d_fake_loss.backward()#对假图像的损失进行反向传播
122.         d_loss=d_real_loss+d_fake_loss#计算判别器的总损失
123.         d_optim.step()# 更新判别器的参数
126.         g_optim.zero_grad()#清除生成器的优化器中的梯度。这是每次参数更新前的标准步骤，用于防止梯度累加。
127.         fake_output=Dis(gen_img)#将生成器生成的图像（gen_img）传递给判别器（Dis），以获取判别器对假图像的判断结果。
128.         g_loss=loss_function(fake_output,torch.ones_like(fake_output))#生成器的损失计算是至关重要的，因为它指导生成器如何改进以生成更逼真的图像
129.         g_loss.backward()#计算生成器损失的反向传播
130.         g_optim.step()#更新生成器的参数。这一步使用优化器（如SGD或Adam）根据反向传播计算得到的梯度来更新生成器的权重
131.         with torch.no_grad():
132.             d_epoch_loss+=d_loss#累加判别器的损失
133.             g_epoch_loss+= g_loss#累加生成器的损失
134.     with torch.no_grad():#这个上下文管理器指示 PyTorch 在这个代码块中不计算梯度。
135.         #这通常用于推理或评估阶段，以减少内存使用并提高性能
136.             d_epoch_loss/=count# 将判别器的累积损失除以批次数量 count，以计算整个epoch的平均损失。
137.             g_epoch_loss/=count#将生成器的累积损失除以批次数量 count，以计算整个epoch的平均损失。
138.             D_loss.append(d_epoch_loss)#将计算得到的判别器平均损失添加到 D_loss 列表中，用于记录每个epoch的损失。
139.             G_loss.append(g_epoch_loss)#将计算得到的生成器平均损失添加到 G_loss 列表中，用于记录每个epoch的损失。
140.             print('Epoch:',epoch+1)# 打印当前的epoch编号，epoch+1 因为 epoch 从0开始计数，而通常人们习惯从1开始计数。
141.             gen_img_plot(Gen,test_input)#绘制生成器的输出图像

复制代码

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。