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

如何让自己的网站被搜索引擎收录,学习网站建设的书,行业网站建设费用明细,哪些公司做外贸网站GAN(Generative Adversarial Nets) 引言 GAN由Ian J. Goodfellow等人提出#xff0c;是Ian J. Goodfellow的代表作之一#xff0c;他还出版了大家耳熟能详的花书#xff08;Deep Learning深度学习#xff09;#xff0c;GAN主要的思想是同时训练两个模型#xff0c;生成…GAN(Generative Adversarial Nets) 引言 GAN由Ian J. Goodfellow等人提出是Ian J. Goodfellow的代表作之一他还出版了大家耳熟能详的花书Deep Learning深度学习GAN主要的思想是同时训练两个模型生成模型G用于获取数据分布判别模型D用于估计样本来自训练数据而不是G的概率。G的训练过程是最大化D犯错误的概率。这个过程对应于一个极小极大两人博弈。在任意函数G和D的空间中存在唯一解其中G恢复训练数据分布并且D处处等于1/2。 用一个警察与小偷的故事来阐述假设一个城市里有许多小偷在这些小偷中部分是技艺高超的偷窃高手另一部分则是毫无技术的新手。警察开始进行对小偷的抓捕其中一批“学艺不精”的小偷就被捉住了。这些小偷被抓住或许是因为识别他们毫无难度警察不需要特殊本领但是剩下的“偷窃高手”警察就很难抓捕。于是警察们开始继续训练自己的破案技术开始抓住那些技艺高超的小偷。随着这些他们的落网警察们也练就了特别的本事他们能很快能从一群人中识别终逮捕嫌犯随着警察们的水平大大提高为了避免被捕小偷们努力表现得不那么“可疑”而魔高一尺、道高一丈警察也在不断提高自己的水平争取将小偷和无辜的普通群众区分开。随着警察和小偷之间的这种“交流”与“切磋”小偷们都变得非常谨慎他们有着极高的偷窃技巧表现得跟普通群众一模一样而警察们都练就了“火眼金睛”一旦发现可疑人员就能马上发现并及时控制——最终我们同时得到了最强的小偷和最强的警察。其中小偷就可以视作生成模型G警察可以视作判别模型D通过G和D的对抗能够获得效果较好的生成模型判别模型也是如此参考链接 主要架构 根据引言一个GAN主要包含两个基础模型生成器(G)与判别器(D)。其中生成器用于生成新数据其生成数据的基础往往是一组噪音或者随机数而判别器用于判断生成的数据和真实数据哪个才是真的。生成器执行无监督任务而判别器执行有监督任务用于二分类其label是“假与真”0与1。
生成器的目标是生成尽量真实的数据这也是我们对生成对抗网络的要求最好能够以假乱真、让判别器判断不出来因此生成器的学习目标是让判别器上的判断准确性越来越低相反判别器的目标是尽量判别出真伪因此判别器的学习目标是让自己的判断准确性越来越高。 当生成器生成的数据越来越真时判别器为维持住自己的准确性就必须向判别能力越来越强的方向迭代。当判别器越来越强大时生成器为了降低判别器的判断准确性就必须生成越来越真的数据。在这个奇妙的关系中判别器与生成器同时训练、相互内卷对损失函数的影响此消彼长。参考链接 理论支撑 m i n G m a x D V ( D , G ) E x ∼ p d a t a ( x ) [ l o g D ( x ) ] E z ∼ p z ( z ) [ l o g ( 1 − D ( G ( z ) ) ) ] \underset{G}{min}\underset{D}{max}V(D,G) {\mathbb E{x \sim{p}{data}(x)} [logD(x)]} {\mathbb E {z \sim{p}{z}(z)}[{log(1-D({G(z)}))}]} Gmin​Dmax​V(D,G)Ex∼pdata​(x)​[logD(x)]Ez∼pz​(z)​[log(1−D(G(z)))] V V V是一个值函数损失函数 x x x表示真实数据 p d a t a p_{data} pdata​表示数据的真实分布 z z z是与真实数据相同分布的随机数据, G ( z ) G(z) G(z)是生成器中基于 z z z生成的数据 D ( x ) D(x) D(x)是判别器在真实数据 x x x上判断的结果, D ( G ( x ) ) D(G(x)) D(G(x))表示判别器在生成器生成的数据 G ( z ) G(z) G(z)上判断出的结果。 那么需要做的就是

1. 对于判别器D来说尽可能找到生成器生成的数据

2. 对于生成器G来说尽可能让生成的数据接近真实数据使得判别器D无法判别出来 上面表达式需要做的是首先固定G在D的层面使得值最大即让判别器能够精确区分真实数据和生成数据然后固定D在G的层面使得值最小即在判别器能够精确区分数据的情况下让生成器能够生成更接近真实的数据使得判别器无法区分从而实现了D和G的对抗如此可以找到最好的生成器生成模型。
   图(a)中展示了生成器G、判别器D以及真实数据初始状态此时真实数据与生成数据分布明显不同判别器此时也只是初始状态图(b)展示了判别器经过训练后能够进行区分真实数据和生成数据图©展示了生成器经过训练后能够更加接近真实分布图(d)展示了经过多次循环之后生成器和判别器的状态此时生成数据已经无限接近真实数据分布同时判别器难以区分出真实数据和生成数据导致判别答案始终为1/2。 算法 算法存在的一个问题是需要选择一个较好的k在算法中要保证不能一次性让判别器就能够准确的识别出所有生成数据这会导致生成器没有办法继续提升生成更加接近真实分布的数据同时也不能让生成模型一下子生成非常接近真实分布的数据这会导致判别器难以进行识别能力的提升。 公式分析 对于判别器D 判别器的作用是尽可能找出生成器生成的数据与真实数据分布之间的差异这是一个二分类的问题将G固定后公式就变为 m a x D V ( D , G ) E x ∼ p d a t a ( x ) [ l o g D ( x ) ] E z ∼ p z ( z ) [ l o g ( 1 − D ( G ( z ) ) ) ] \underset{D}{max}V(D,G) {\mathbb E{x \sim{p}{data}(x)} [logD(x)]} {\mathbb E {z \sim{p}{z}(z)}[{log(1-D({G(z)}))}]} Dmax​V(D,G)Ex∼pdata​(x)​[logD(x)]Ez∼pz​(z)​[log(1−D(G(z)))] 该公式等价于交叉熵只不过交叉熵是取负的对数。这个函数的输入一部分是真实数据分布为 p d a t a {p{data}} pdata​,一部分是生成器的数据噪声数据,生成器接收的数据 z z z服从分布 p ( z ) p(z) p(z)输入 z z z经过生成器的计算生产的数据分布设为 p G ( x ) {p{G}}(x) pG​(x)这个函数要取得最大值必然是对于真实数据 D ( x ) 1 D(x)1 D(x)1,对于生成数据 D ( x ) 0 D(x)0 D(x)0,这一步用于优化D因此可以简写为 D G ∗ m a x D V ( G , D ) D_G^* \underset D {max}V(G,D) DG∗​Dmax​V(G,D) 此时这是D的一元函数进行求导得到 取导数为0算最优点得到
   对于生成器G 当且仅当 P G ( x ) P d a t a ( x ) {PG}(x) {P{data}}(x) PG​(x)Pdata​(x)时有 D G ∗ P d a t a ( x ) P G ( x ) P d a t a ( x ) 1 2 DG^* \frac{{{P{data}}(x)}}{{{PG}(x) {P{data}}(x)}} \frac{1}{2} DG∗​PG​(x)Pdata​(x)Pdata​(x)​21​ 此时生成器无法判别数据是真实数据或者生成数据。 我们假设 P G ( x ) P d a t a ( x ) {PG}(x) {P{data}}(x) PG​(x)Pdata​(x)可以反向推出 V ( G , D G ∗ ) ∫ x P d a t a ( x ) l o g 1 2 P G ( x ) l o g ( 1 − 1 2 ) d x {V(G,D_G^) \intx {{P{data}}(x)log\frac{1}{2}} {P_G}(x)log(1 - \frac{1}{2})dx} V(G,DG∗​)∫x​Pdata​(x)log21​PG​(x)log(1−21​)dx ⇔ V ( G , D G ∗ ) − log ⁡ 2 ∫ x P G ( x ) d x − log ⁡ 2 ∫ x P d a t a ( x ) d x − 2 log ⁡ 2 − log ⁡ 4 \Leftrightarrow {V(G,D_G^) - \log 2\int\limits_x {{P_G}(x)} dx - \log 2\int\limitsx {{P{data}}(x)} dx - 2\log 2 - \log 4} ⇔V(G,DG∗​)−log2x∫​PG​(x)dx−log2x∫​Pdata​(x)dx−2log2−log4 该值是全局最小值的候选因为它只有在 P G ( x ) P d a t a ( x ) {PG}(x) {P{data}}(x) PG​(x)Pdata​(x) 的时候才出现。 对于任意一个G将 D ∗ {D^*} D∗带入到 V ( G , D ) V(G,D) V(G,D)中:
   结合KL散度得到 − 2 l o g 2 K L ( P d a t a ( x ) ∣ ∣ P d a t a ( x ) P G ( x ) 2 ) K L ( P G ( x ) ∣ ∣ P d a t a ( x ) P G ( x ) 2 ) { - 2log2 KL({P{data}}(x)||\frac{{{P{data}}(x) {P_G}(x)}}{2}) KL({PG}(x)||\frac{{{P{data}}(x) {PG}(x)}}{2})} −2log2KL(Pdata​(x)∣∣2Pdata​(x)PG​(x)​)KL(PG​(x)∣∣2Pdata​(x)PG​(x)​) 最后根据JS散度得到 V ( G , D ) − log ⁡ 4 2 ∗ J S D ( P d a t a ( x ) ∣ P G ( x ) ) V(G,D) - \log 4 2*JSD({P{data}}(x)|{P_G}(x)) V(G,D)−log42∗JSD(Pdata​(x)∣PG​(x)) 根据他的属性当 P G ( x ) P d a t a ( x ) {PG}(x) {P{data}}(x) PG​(x)Pdata​(x) 时 为0。综上所述生成分布当前仅当等于真实数据分布式时我们可以取得最优生成器。前后逻辑自洽。 注 对于判别器D的优化这是一个二分类满足 y l o g q ( 1 − y ) l o g ( 1 − q ) ylogq(1-y)log(1-q) ylogq(1−y)log(1−q)对于x标签只会为1因此只有log(D(x))这一项对于g(z其标签只会为0因此只有log(1-D(G(z)))这一项因此可以有损失函数 l o s s c r o s s E n t r o p y L o s s ( D ( x ) , 1 ) c r o s s E n t r o p y L o s s ( D ( x ) , 0 ) loss crossEntropyLoss(D(x),1)crossEntropyLoss(D(x),0) losscrossEntropyLoss(D(x),1)crossEntropyLoss(D(x),0) 对于生成器G的优化因为D(x)这一项并不包含生成器的优化参数因此在求梯度的时候D(x)这一项为0因此只有log(1-D(G(z)))这一项损失函数 l o s s c r o s s E n t r o p y L o s s ( D ( G ( z ) ) , 1 ) loss crossEntropyLoss(D(G(z)),1) losscrossEntropyLoss(D(G(z)),1) 代码 import argparse import os import numpy as np import mathimport 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 torchos.makedirs(images, exist_okTrue)parser argparse.ArgumentParser() parser.add_argument(–n_epochs, typeint, default50, helpnumber of epochs of training) parser.add_argument(–batch_size, typeint, default64, helpsize of the batches) parser.add_argument(–lr, typefloat, default0.0002, helpadam: learning rate) parser.add_argument(–b1, typefloat, default0.5, helpadam: decay of first order momentum of gradient) parser.add_argument(–b2, typefloat, default0.999, helpadam: decay of first order momentum of gradient) parser.add_argument(–n_cpu, typeint, default8, helpnumber of cpu threads to use during batch generation) parser.add_argument(–latent_dim, typeint, default100, helpdimensionality of the latent space) parser.add_argument(–img_size, typeint, default28, helpsize of each image dimension) parser.add_argument(–channels, typeint, default1, helpnumber of image channels) parser.add_argument(–sample_interval, typeint, default400, helpinterval betwen image samples) #使用jupyter时需要传入list opt parser.parse_args(args[]) #opt parser.parse_args() #print(opt)#图像形状为:1*28*28图像大小为784 img_shape (opt.channels, opt.img_size, opt.img_size)#这里提前做了一下cuda的判断 device torch.device(cuda if torch.cuda.is_available() else cpu)#生成器G用于进行数据的生成 class Generator(nn.Module):def init(self):super(Generator, self).init()#定义模型的中间块def block(in_feat, out_feat, normalizeTrue):layers [nn.Linear(in_feat, out_feat)] #多个线性层的组合if normalize:layers.append(nn.BatchNorm1d(out_feat, 0.8)) #进行正则化layers.append(nn.LeakyReLU(0.2, inplaceTrue)) #激活函数return layers#多个模型块进行组合MLP输入维度的映射过程为input_dim-128-256-512-1024-1*28*28self.model nn.Sequential(*block(opt.latent_dim, 128, normalizeFalse),*block(128, 256),*block(256, 512),*block(512, 1024),nn.Linear(1024, int(np.prod(img_shape))),nn.Tanh() #Tanh取值范围为-1,1即将输出映射到-1,1)def forward(self, z):img self.model(z) #对噪声数据处理进行数据生成img img.view(img.size(0), *img_shape) #生成数据为(batch_size,1,28,28)return img#判别器D用于区分真实数据和生成数据 class Discriminator(nn.Module):def init(self):super(Discriminator, self).init()#维度映射过程1*28*28-512-256-1使用sigmoid进行二分类激活映射为0,1之间的数self.model nn.Sequential(nn.Linear(int(np.prod(img_shape)), 512),nn.LeakyReLU(0.2, inplaceTrue),nn.Linear(512, 256),nn.LeakyReLU(0.2, inplaceTrue),nn.Linear(256, 1),nn.Sigmoid(),)def forward(self, img):img_flat img.view(img.size(0), -1) #将输入展平validity self.model(img_flat) #进行判别return validity# Loss function adversarial_loss torch.nn.BCELoss() #损失函数使用BCE二分类交叉熵# Initialize generator and discriminator generator Generator() discriminator Discriminator()if cuda:generator.to(device)discriminator.to(device)adversarial_loss.to(device)# Configure data loader os.makedirs(./data/mnist, exist_okTrue) #数据集加载 dataloader torch.utils.data.DataLoader(datasets.MNIST(./data/mnist,trainTrue,downloadTrue,transformtransforms.Compose([transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]),),batch_sizeopt.batch_size,shuffleTrue, )# Optimizers optimizer_G torch.optim.Adam(generator.parameters(), lropt.lr, betas(opt.b1, opt.b2)) optimizer_D torch.optim.Adam(discriminator.parameters(), lropt.lr, betas(opt.b1, opt.b2))# ———-

   Training

   ———-for epoch in range(opt.n_epochs):for i, (imgs, _) in enumerate(dataloader):# Adversarial ground truthsvalid torch.tensor([[1.0]] * imgs.size(0), requires_gradFalse).to(device) #定义真实数据标号为1fake torch.tensor([[0.0]] * imgs.size(0), requires_gradFalse).to(device) #定义虚假数据标号为0# Configure inputreal_imgs torch.tensor(imgs.type(torch.Tensor)).to(device)# —————–# Train Generator# —————–optimizer_G.zero_grad()# Sample noise as generator inputz torch.tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim)), dtypetorch.float32).to(device) #随机生成噪声# Generate a batch of imagesgen_imgs generator(z) #生成数据# Loss measures generators ability to fool the discriminatorg_loss adversarial_loss(discriminator(gen_imgs), valid)g_loss.backward()optimizer_G.step()# ———————# Train Discriminator# ———————optimizer_D.zero_grad()# Measure discriminators ability to classify real from generated samplesreal_loss adversarial_loss(discriminator(real_imgs), valid)fake_loss adversarial_loss(discriminator(gen_imgs.detach()), fake)d_loss (real_loss fake_loss) / 2d_loss.backward()optimizer_D.step()print([Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]% (epoch, opt.n_epochs, i, len(dataloader), d_loss.item(), g_loss.item()))batches_done epoch * len(dataloader) iif batches_done % opt.sample_interval 0:save_image(gen_imgs.data[:25], images/%d.png % batches_done, nrow5, normalizeTrue)参考

   参考 文章1 文章2 文章3 代码