当前位置：首页 > wzjs >正文

银川网站建设哪家优质外贸获客软件

wzjs 2025/7/27 19:24:21

银川网站建设哪家优质,外贸获客软件,如何让百度搜到网站,企业网站做优化>- **🍨 本文为[🔗365天深度学习训练营]中的学习记录博客** >- **🍖 原作者：[K同学啊]** 本人往期文章可查阅： 深度学习总结 🏡 我的环境： 语言环境：Python3.11 编译器&…

>- **🍨 本文为[🔗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 npimport torchvision.transforms as transforms
from torchvision.utils import save_imagefrom torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variableimport 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 nnclass 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 imgclass 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,label

2.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.LongTensor

2.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)+iif 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]