第G7周：Semi-Supervised GAN 理论与实战
>- **🍨 本文为[🔗365天深度学习训练营]中的学习记录博客**
>- **🍖 原作者：[K同学啊]**
本人往期文章可查阅： 深度学习总结
🏡 我的环境：
- 语言环境：Python3.11
- 编译器：PyCharm
- 深度学习环境：Pytorch
-
- torch==2.0.0+cu118
-
- torchvision==0.18.1+cu118
- 显卡：NVIDIA GeForce GTX 1660
论文原文：Semi-Supervised Learning with Generative Adversarial Networks
在学习GAN的时候你有没有想过这样一个问题呢，如果我们生成的图像是带有标签的，例如数字0~9，那为什么要鉴别器判断输入图像为真假，而不直接判断图像是0~9中的哪一个数字呢，这样的鉴别效果不是更好吗？今天要讲解的SGAN将解答你的疑惑。
1. 理论知识讲解
该算法将产生对抗网络（GAN）拓展到半监督学习，通过强制 判别器D 来输出类别标签。我们在一个数据集上训练一个 生成器G 以及一个 判别器D ，输入是N类当中的一个。在训练的时候， 判别器D 被用于预测输入是属于N+1类中的哪一个，这个N+1是对应了 生成器G 的输出，这里的 判别器D 同时也充当起了 分类器C 的效果。这种方法可以用于训练效果更好的 判别器D，并且可以比普通的GAN产生更加高质量的样本。Semi-Supervised GAN有如下优点：
- 1. 作者对GANs做了一个新的扩展，允许他同时学习一个生成模型和一个分类器。我们把这个扩展叫做半监督GAN或SGAN。
- 2. 论文实验结果表明，SGAN在有限数据集上比没有生成部分的基准分类器提升了分类性能。
- 3. 论文实验结果表明，SGAN可以显著地提升生成样本的质量并降低生成器的训练时间。
通过生成的效果图可以明显发现普通DCGAN算法与SGAN算法性能优劣
项目代码： 已将.py 文件上传至本项目，页面最顶端可以直接下载。
2. 代码实现
2.1 配置代码
import argparse,os,math
import numpy as np
import torchvision.transforms as transforms
from torchvision.utils import save_image
from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch
# 创建保存生成图像的文件夹
os.makedirs("images",exist_ok=True)
# 模拟命令行参数
import sys
sys.argv=[
'script.py', # 脚本名称
'--n_epochs', '50',
'--batch_size', '64',
'--lr', '0.0002',
'--b1', '0.5',
'--b2', '0.999',
'--n_cpu', '8',
'--latent_dim', '100',
'--num_classes', '10',
'--img_size', '32',
'--channels', '1',
'--sample_interval', '400'
]
# 使用 argparse 解析命令行参数
parser=argparse.ArgumentParser()
parser.add_argument("--n_epochs",type=int,default=50,help="训练的轮数")
parser.add_argument("--batch_size",type=int,default=64,help="每个批次的样本数量")
parser.add_argument("--lr",type=float,default=0.0002,help="Adam 优化器的学习率")
parser.add_argument("--b1",type=float,default=0.5,help="Adam 优化器的第一个动量衰减参数")
parser.add_argument("--b2",type=float,default=0.999,help="Adam 优化器的第二个动量衰减参数")
parser.add_argument("--n_cpu",type=int,default=8,help="用于批次生成的 CPU 线程数")
parser.add_argument("--latent_dim",type=int,default=100,help="潜在空间的维度")
parser.add_argument("--num_classes",type=int,default=10,help="数据集的书类别数")
parser.add_argument("--img_size",type=int,default=32,help="每个图像的尺寸（高度和宽度相等）")
parser.add_argument("--channels",type=int,default=1,help="图像的通道数（灰度图像通道数为1）")
parser.add_argument("--sample_interval",type=int,default=400,help="图像采样间隔")
opt=parser.parse_args()
print(opt)
# 如果GPU可用，则使用CUDA加速
cuda=True if torch.cuda.is_available() else False此段代码与.py文件中的稍有区别，因运行原代码后出现错误，发现是由于在 Jupyter Notebook 环境中使用了 argparse 来解析命令行参数。Jupyter Notebook 并不提供一个真正的命令行环境，因此 argparse 会尝试解析 Jupyter Notebook 启动时传递给内核的参数，而不是你期望的自定义参数。这导致了 unrecognized arguments 错误，因为 Jupyter Notebook 传递了一些它自己的参数，比如 -f 后面跟着的 JSON 文件路径。
故使用 sys.argv 模拟命令行参数
2.2 初始化权重
def weights_init_normal(m):
classname=m.__class__.__name__
if classname.find("Conv")!=-1:
torch.nn.init.normal_(m.weight.data,0.0,0.02)
elif classname.find("BatchNorm")!=-1:
torch.nn.init.normal_(m.weight.data,1.0,0.02)
torch.nn.init.constant_(m.bias.data,0.0)2.3 定义算法模型
import torch.nn as nn
class Generator(nn.Module):
def __init__(self):
super(Generator,self).__init__()
# 创建一个标签嵌入层，用于将条件标签映射到潜在空间
self.label_emb=nn.Embedding(opt.num_classes,opt.latent_dim)
# 初始化图像尺寸，用于上采样之前
self.init_size=opt.img_size//4 # Initial size before upsampling
# 第一个全连接层，将随机噪声映射到合适的维度
self.l1=nn.Sequential(nn.Linear(opt.latent_dim,128*self.init_size**2))
# 生成器的卷积块
self.conv_blocks=nn.Sequential(
nn.BatchNorm2d(128),
nn.Upsample(scale_factor=2),
nn.Conv2d(128,128,3,stride=1,padding=1),
nn.BatchNorm2d(128,0.8),
nn.LeakyReLU(0.2,inplace=True),
nn.Upsample(scale_factor=2),
nn.Conv2d(128,64,3,stride=1,padding=1),
nn.BatchNorm2d(64,0.8),
nn.LeakyReLU(0.2,inplace=True),
nn.Conv2d(64,opt.channels,3,stride=1,padding=1),
nn.Tanh(),
)
def forward(self,noise):
out=self.l1(noise)
out=out.view(out.shape[0],128,self.init_size,self.init_size)
img=self.conv_blocks(out)
return img
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator,self).__init__()
def discriminator_block(in_filters,out_filters,bn=True):
# 返回每个鉴别器块的层
block=[nn.Conv2d(in_filters,out_filters,3,2,1),nn.LeakyReLU(0.2,inplace=True),nn.Dropout2d(0.25)]
if bn:
block.append(nn.BatchNorm2d(out_filters,0.8))
return block
# 鉴别器的卷积块
self.conv_blocks=nn.Sequential(
*discriminator_block(opt.channels,16,bn=False),
*discriminator_block(16,32),
*discriminator_block(32,64),
*discriminator_block(64,128),
)
# 下采样图像的高度和宽度
ds_size=opt.img_size//2**4
# 输出层
"""用于鉴别真假的输出层"""
self.adv_layer=nn.Sequential(nn.Linear(128*ds_size**2,1),nn.Sigmoid())
"""用于鉴别类别的输出层"""
self.aux_layer=nn.Sequential(nn.Linear(128*ds_size**2,opt.num_classes+1),nn.Softmax(dim=1))
def forward(self,img):
out=self.conv_blocks(img)
out=out.view(out.shape[0],-1)
validity=self.adv_layer(out)
label=self.aux_layer(out)
return validity,label2.4 配置模型
# 定义损失函数
adversarial_loss=torch.nn.BCELoss() # 二元交叉熵损失，用于对抗训练
auxiliary_loss=torch.nn.CrossEntropyLoss() #交叉熵损失，用于辅助分类
# 初始化生成器和鉴别器
generator=Generator() # 创建生成器实例
discriminator=Discriminator() # 创建鉴别器实例
# 如果使用GPU，将模型和损失函数移至GPU上
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
auxiliary_loss.cuda()
# 初始化模型权重
generator.apply(weights_init_normal) # 初始化生成器的权重
discriminator.apply(weights_init_normal) # 初始化鉴别器的权重
# 配置数据加载器
os.makedirs("../5、GAN入门实践/G7/data",exist_ok=True) # 创建存储MNIST数据集的文件
dataloader=torch.utils.data.DataLoader(
datasets.MNIST(
"../5、GAN入门实践/G7/data/",
train=True,
download=False,transform=transforms.Compose(
[transforms.Resize(opt.img_size),transforms.ToTensor(),transforms.Normalize([0.5],[0.5])]
),
),
batch_size=opt.batch_size,
shuffle=True,
)
# 优化器
optimizer_G=torch.optim.Adam(generator.parameters(),lr=opt.lr,betas=(opt.b1,opt.b2)) # 生成器的优化器
optimizer_D=torch.optim.Adam(discriminator.parameters(),lr=opt.lr,betas=(opt.b1,opt.b2)) # 鉴别器的优化器
# 根据是否使用GPU选择数据类型
FloatTensor=torch.cuda.FloatTensor if cuda else torch.FloatTensor
LongTensor=torch.cuda.LongTensor if cuda else torch.LongTensor2.5 训练模型
G_losses=[] # 用于存储生成器的损失列表
D_losses=[] # 用于存储判别器的损失列表
for epoch in range(opt.n_epochs):
for i,(imgs,labels) in enumerate(dataloader):
batch_size=imgs.shape[0]
# 定义对抗训练的标签
valid=Variable(FloatTensor(batch_size,1).fill_(1.0),requires_grad=False) # 用于真实样本
fake=Variable(FloatTensor(batch_size,1).fill_(0.0),requires_grad=False) # 用于生成样本
fake_aux_gt=Variable(LongTensor(batch_size).fill_(opt.num_classes),requires_grad=False) # 用于生成样本的类别标签
# 配置输入数据
real_imgs=Variable(imgs.type(FloatTensor)) # 真实图像
labels=Variable(labels.type(LongTensor)) # 真实类别标签
# -----------
# 训练生成器
# -----------
optimizer_G.zero_grad()
# 采样噪声和类别标签作为生成器的输入
z=Variable(FloatTensor(np.random.normal(0,1,(batch_size,opt.latent_dim))))
# 生成一批图像
gen_imgs=generator(z)
# 计算生成器的损失，衡量生成器欺骗鉴别器的能力
validity,_=discriminator(gen_imgs)
g_loss=adversarial_loss(validity,valid)
g_loss.backward()
optimizer_G.step()
# -----------
# 训练鉴别器
# -----------
optimizer_D.zero_grad()
# 真实图像的损失
real_pred,real_aux=discriminator(real_imgs)
d_real_loss=(adversarial_loss(real_pred,valid)+auxiliary_loss(real_aux,labels))/2
# 生成图像的损失
fake_pred,fake_aux=discriminator(gen_imgs.detach())
d_fake_loss=(adversarial_loss(fake_pred,fake)+auxiliary_loss(fake_aux,fake_aux_gt))/2
# 总的鉴别器损失
d_loss=(d_real_loss+d_fake_loss)/2
# 计算鉴别器准确率
pred=np.concatenate([real_aux.data.cpu().numpy(),fake_aux.data.cpu().numpy()],axis=0)
gt=np.concatenate([labels.data.cpu().numpy(),fake_aux_gt.data.cpu().numpy()],axis=0)
d_acc=np.mean(np.argmax(pred,axis=1)==gt)
d_loss.backward()
optimizer_D.step()
batches_done=epoch*len(dataloader)+i
if batches_done % opt.sample_interval==0:
save_image(gen_imgs.data[:25],"images/%d.png"%batches_done,nrow=5,normalize=True)
# 将损失值存储到列表中
G_losses.append(g_loss.item())
D_losses.append(d_loss.item())
print(
"[Epoch %d/%d] [Batch %d/%d] [D loss:%f,acc:%d%%] [G loss:%f]"
% (epoch,opt.n_epochs,i,len(dataloader),d_loss.item(),100*d_acc,g_loss.item())
)运行结果：
[Epoch 0/50] [Batch 937/938] [D loss:1.359054,acc:50%] [G loss:0.658630]
[Epoch 1/50] [Batch 937/938] [D loss:1.369362,acc:50%] [G loss:0.715378]
[Epoch 2/50] [Batch 937/938] [D loss:1.339417,acc:50%] [G loss:0.754641]
[Epoch 3/50] [Batch 937/938] [D loss:1.375170,acc:50%] [G loss:0.738586]
[Epoch 4/50] [Batch 937/938] [D loss:1.329984,acc:50%] [G loss:0.890041]
[Epoch 5/50] [Batch 937/938] [D loss:1.372990,acc:50%] [G loss:0.804013]
[Epoch 6/50] [Batch 937/938] [D loss:1.332207,acc:50%] [G loss:0.846153]
[Epoch 7/50] [Batch 937/938] [D loss:1.351278,acc:50%] [G loss:1.045990]
[Epoch 8/50] [Batch 937/938] [D loss:1.345362,acc:50%] [G loss:0.703861]
[Epoch 9/50] [Batch 937/938] [D loss:1.360350,acc:50%] [G loss:0.565309]
[Epoch 10/50] [Batch 937/938] [D loss:1.361928,acc:50%] [G loss:0.838291]
[Epoch 11/50] [Batch 937/938] [D loss:1.331936,acc:50%] [G loss:0.717057]
[Epoch 12/50] [Batch 937/938] [D loss:1.274163,acc:50%] [G loss:0.969151]
[Epoch 13/50] [Batch 937/938] [D loss:1.282497,acc:50%] [G loss:1.057411]
[Epoch 14/50] [Batch 937/938] [D loss:1.238691,acc:50%] [G loss:0.770747]
[Epoch 15/50] [Batch 937/938] [D loss:1.404710,acc:50%] [G loss:1.073111]
[Epoch 16/50] [Batch 937/938] [D loss:1.218316,acc:50%] [G loss:0.808461]
[Epoch 17/50] [Batch 937/938] [D loss:1.281859,acc:50%] [G loss:0.982794]
[Epoch 18/50] [Batch 937/938] [D loss:1.317131,acc:50%] [G loss:1.579549]
[Epoch 19/50] [Batch 937/938] [D loss:1.211256,acc:50%] [G loss:0.981205]
[Epoch 20/50] [Batch 937/938] [D loss:1.352305,acc:50%] [G loss:1.411370]
[Epoch 21/50] [Batch 937/938] [D loss:1.335480,acc:50%] [G loss:1.149625]
[Epoch 22/50] [Batch 937/938] [D loss:1.519487,acc:50%] [G loss:0.631097]
[Epoch 23/50] [Batch 937/938] [D loss:1.261408,acc:50%] [G loss:1.005546]
[Epoch 24/50] [Batch 937/938] [D loss:1.357080,acc:50%] [G loss:1.608805]
[Epoch 25/50] [Batch 937/938] [D loss:1.126652,acc:50%] [G loss:0.821136]
[Epoch 26/50] [Batch 937/938] [D loss:1.250515,acc:50%] [G loss:1.322052]
[Epoch 27/50] [Batch 937/938] [D loss:1.289688,acc:50%] [G loss:1.163337]
[Epoch 28/50] [Batch 937/938] [D loss:1.251256,acc:50%] [G loss:1.163154]
[Epoch 29/50] [Batch 937/938] [D loss:1.372620,acc:50%] [G loss:2.401432]
[Epoch 30/50] [Batch 937/938] [D loss:1.435972,acc:50%] [G loss:2.662034]
[Epoch 31/50] [Batch 937/938] [D loss:1.229758,acc:50%] [G loss:0.980402]
[Epoch 32/50] [Batch 937/938] [D loss:1.474208,acc:50%] [G loss:1.439286]
[Epoch 33/50] [Batch 937/938] [D loss:1.267647,acc:50%] [G loss:1.945136]
[Epoch 34/50] [Batch 937/938] [D loss:1.241629,acc:50%] [G loss:0.390739]
[Epoch 35/50] [Batch 937/938] [D loss:1.349249,acc:50%] [G loss:0.406453]
[Epoch 36/50] [Batch 937/938] [D loss:1.199789,acc:50%] [G loss:0.611880]
[Epoch 37/50] [Batch 937/938] [D loss:1.141212,acc:50%] [G loss:1.199799]
[Epoch 38/50] [Batch 937/938] [D loss:1.243011,acc:50%] [G loss:1.736397]
[Epoch 39/50] [Batch 937/938] [D loss:1.184355,acc:50%] [G loss:0.866000]
[Epoch 40/50] [Batch 937/938] [D loss:1.314039,acc:50%] [G loss:1.424341]
[Epoch 41/50] [Batch 937/938] [D loss:1.602049,acc:50%] [G loss:1.359957]
[Epoch 42/50] [Batch 937/938] [D loss:1.140057,acc:50%] [G loss:2.062046]
[Epoch 43/50] [Batch 937/938] [D loss:1.141948,acc:50%] [G loss:1.213121]
[Epoch 44/50] [Batch 937/938] [D loss:1.249625,acc:50%] [G loss:1.836994]
[Epoch 45/50] [Batch 937/938] [D loss:1.598727,acc:50%] [G loss:1.668386]
[Epoch 46/50] [Batch 937/938] [D loss:1.265866,acc:50%] [G loss:0.504183]
[Epoch 47/50] [Batch 937/938] [D loss:1.205068,acc:50%] [G loss:1.233357]
[Epoch 48/50] [Batch 937/938] [D loss:1.075509,acc:50%] [G loss:2.143309]
[Epoch 49/50] [Batch 937/938] [D loss:1.378439,acc:50%] [G loss:2.828498]2.6 生成图片效果
3. 心得体会
通过本项目的学习，充分了解了SGAN的运行过程，发现SGAN精度与以往有所提升。