【深度学习】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.Compose 是用于定义一系列数据变换的类，ToTensor() 将图像转换为PyTorch张量，Normalize(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() 激活函数生成大小为28x28的图像。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
这一部分定义了判别器的神经网络模型。判别器的输入是28x28大小的图像，通过多个线性层和激活函数（LeakyReLU），最后通过 nn.Sigmoid() 激活函数输出一个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)
1.设置 test_input 作为模型的输入，并初始化用于存储判别器（D）和生成器（G）的损失值的列表。
2.开始 30 轮次的训练循环。在每一轮中：
3.对数据集进行遍历。每次迭代，加载一批图像数据 (img)。
4.将图像数据移动到设备（device）上，并获取批次大小。
5.生成随机噪声，作为输入给生成器。
6.训练判别器（D）：
- 对真实图像计算判别器的损失 (d_real_loss)，并反向传播计算梯度。
- 生成生成器产生的图像，并计算判别器的对这些生成图像的损失 (d_fake_loss)，再反向传播计算梯度。
- 计算总的判别器损失 d_loss，并更新判别器的参数。
7.训练生成器（G）：
- 生成器生成图像，并将其输入到判别器中，计算生成器的损失 (g_loss)，并反向传播计算梯度。
- 更新生成器的参数。
这个过程是 GAN 中交替训练生成器和判别器的典型过程，目的是让生成器生成逼真的图像，同时让判别器能够准确区分真假图像。
