精华内容
下载资源
问答
  • gan训练

    2019-05-15 17:11:31
    gan对mnist数据集训练

    gan对mnist数据集训练

    使用非卷积神经网络,对1维数据模拟,卷积是对2维数据模拟

    import torch
    import torchvision
    import torch.nn as nn
    import torch.nn.functional as F
    from torchvision import datasets
    from torchvision import transforms
    from torchvision.utils import save_image
    from torch.autograd import Variable
    import os
     
    if not os.path.exists('./img'):
        os.mkdir('./img')
     
     
    def to_img(x):
        out = 0.5 * (x + 1)
        out = out.clamp(0, 1)
        out = out.view(-1, 1, 28, 28)
        return out
     
     
    batch_size = 128
    num_epoch = 100
    z_dimension = 100
     
    # Image processing
    img_transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize([0.5], [0.5])            #可能时mnist数据集数据更新过,以前使用的[0.5,0.5,0.5]会报错
    ])
    # MNIST dataset
    mnist = datasets.MNIST(
        root='./tensorflow/data_gan/', train=True, transform=img_transform, download=True)
    # Data loader
    dataloader = torch.utils.data.DataLoader(
        dataset=mnist, batch_size=batch_size, shuffle=True)
     
     
    # Discriminator
    class discriminator(nn.Module):
        def __init__(self):
            super(discriminator, self).__init__()
            self.dis = nn.Sequential(
                nn.Linear(784, 256),
                nn.LeakyReLU(0.2),
                nn.Linear(256, 256),
                nn.LeakyReLU(0.2),
                nn.Linear(256, 1), 
                nn.Sigmoid())
     
        def forward(self, x):
            x = self.dis(x)
            return x
     
     
    # Generator
    class generator(nn.Module):
        def __init__(self):
            super(generator, self).__init__()
            self.gen = nn.Sequential(
                nn.Linear(100, 256),
                nn.ReLU(True),
                nn.Linear(256, 256), 
                nn.ReLU(True), 
                nn.Linear(256, 784), 
                nn.Tanh())
     
        def forward(self, x):
            x = self.gen(x)
            return x
     
     
    D = discriminator()
    G = generator()
    if torch.cuda.is_available():
        D = D.cuda()
        G = G.cuda()
    # Binary cross entropy loss and optimizer
    criterion = nn.BCELoss()
    d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0003)
    g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0003)
     
    # Start training
    for epoch in range(num_epoch):
        for i, (img, _) in enumerate(dataloader):
            num_img = img.size(0)
            # =================train discriminator
            img = img.view(num_img, -1)
            real_img = Variable(img)
            real_label = Variable(torch.ones(num_img))
            fake_label = Variable(torch.zeros(num_img))
     
            # compute loss of real_img
            real_out = D(real_img)
            d_loss_real = criterion(real_out, real_label)
            real_scores = real_out  # closer to 1 means better
     
            # compute loss of fake_img
            z = Variable(torch.randn(num_img, z_dimension))
            fake_img = G(z)
            fake_out = D(fake_img)
            d_loss_fake = criterion(fake_out, fake_label)
            fake_scores = fake_out  # closer to 0 means better
     
            # bp and optimize
            d_loss = d_loss_real + d_loss_fake
            d_optimizer.zero_grad()
            d_loss.backward()
            d_optimizer.step()
     
            # ===============train generator
            # compute loss of fake_img
            z = Variable(torch.randn(num_img, z_dimension))
            fake_img = G(z)
            output = D(fake_img)
            g_loss = criterion(output, real_label)
     
            # bp and optimize
            g_optimizer.zero_grad()
            g_loss.backward()
            g_optimizer.step()
     
            if (i + 1) % 100 == 0:
                print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} '
                      'D real: {:.6f}, D fake: {:.6f}'.format(
                          epoch, num_epoch, d_loss.item(), g_loss.item(),
                          real_scores.data.mean(), fake_scores.data.mean()))
        if epoch == 0:
            real_images = to_img(real_img.cpu().data)
            save_image(real_images, './img/real_images.png')
     
        fake_images = to_img(fake_img.cpu().data)
        save_image(fake_images, './img/fake_images-{}.png'.format(epoch + 1))
     
    torch.save(G.state_dict(), './generator.pth')
    torch.save(D.state_dict(), './discriminator.pth')
    

    单个图片训练(训练使用一张图片中的每个小图片)

    import torch
    from torch import nn
    from torch import autograd
    from PIL import Image
    from torchvision import transforms,utils
    
    class discriminator(nn.Module):
        def __init__(self,inputsize,outputsize):
            super(discriminator, self).__init__()
            self.dis = nn.Sequential(
                nn.Linear(inputsize, outputsize),
                nn.LeakyReLU(0.2),
                nn.Linear(outputsize, outputsize),
                nn.LeakyReLU(0.2),
                nn.Linear(outputsize, 1),
                nn.Sigmoid()
            )
     
        def forward(self, x):
            x = self.dis(x)
            return x
    
    class generator(nn.Module):
        def __init__(self,gsize,inputsize,outputsize):
            super(generator, self).__init__()
            self.gen = nn.Sequential(
                nn.Linear(gsize, outputsize),
                nn.ReLU(True),
                nn.Linear(outputsize, outputsize),
                nn.ReLU(True),
                nn.Linear(outputsize, inputsize),
                nn.Tanh()
            )
     
        def forward(self, x):
            x = self.gen(x)
            return x
    
    width = 240
    height = 360
    x = width//8
    y = height//12
    z_dimension = 96
    
    def to_img(img):
        out = 0.5 * (img + 1)
        out = out.clamp(0, 1)
        out = out.view(-1, 1, x, y)
        return out
    
    image = Image.open('./tensorflow/jpg/text.png')
    img = transforms.Compose([transforms.Resize((height,width)),
            transforms.Grayscale(),
            transforms.ToTensor(),
            transforms.Normalize([0.5], [0.5])])(image)
    
    print(img.shape)
    img = torch.cat(img.chunk(12,1))#图像数据分割
    img = torch.cat(img.chunk(8,2))#图像数据分割
    img = img.view(12*8, -1)  # 将格子中图片展开
    print(img.shape)
    
    D = discriminator(x*y,8*12)
    G = generator(z_dimension,x*y,8*12)
    
    criterion = nn.BCELoss()
    d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0003)
    g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0003)
    
    
    epoch = 1000
    for i in range(epoch*100):
        num_img = img.size(0)
        real_img = autograd.Variable(img)  # 将tensor变成Variable放入计算图中
        real_label = autograd.Variable(torch.ones(num_img))  # 定义真实label为1
        fake_label = autograd.Variable(torch.zeros(num_img))  # 定义假的label为0
    
        if i==0:
            utils.save_image(to_img(real_img.data), './tensorflow/gan-png/real_images.png')
    
        # compute loss of real_img
        real_out = D(real_img)  # 将真实的图片放入判别器中
        d_loss_real = criterion(real_out, real_label)  # 得到真实图片的loss  
        real_scores = real_out  # 真实图片放入判别器输出越接近1越好
    
        # compute loss of fake_img
        z = autograd.Variable(torch.randn(num_img, z_dimension))  # 随机生成一些噪声
        fake_img = G(z)  # 放入生成网络生成一张假的图片
        fake_out = D(fake_img)  # 判别器判断假的图片
        d_loss_fake = criterion(fake_out, fake_label)  # 得到假的图片的loss
        fake_scores = fake_out  # 假的图片放入判别器越接近0越好
    
        # bp and optimize
        d_loss = d_loss_real+d_loss_fake  # 将真假图片的loss加起来
        d_optimizer.zero_grad()  # 归0梯度
        d_loss.backward()  # 反向传播
        d_optimizer.step()  # 更新参数
    
        # compute loss of fake_img
        z = autograd.Variable(torch.randn(num_img, z_dimension))  # 得到随机噪声
        fake_img = G(z)  # 生成假的图片
        output = D(fake_img)  # 经过判别器得到结果
        g_loss = criterion(output, real_label)  # 得到假的图片与真实图片label的loss
    
        # bp and optimize
        g_optimizer.zero_grad()  # 归0梯度
        g_loss.backward()  # 反向传播
        g_optimizer.step()  # 更新生成网络的参数
    
        if i%(epoch) == 0:
            print("real_scores:%f,fake_scores:%f,d_loss:%f,g_loss:%f"%(real_scores.data.mean().item(),
            fake_scores.data.mean().item(),d_loss_fake.item(),g_loss.item()))
            print("-------------------------%d"%i)
            utils.save_image(to_img(fake_img.data), './tensorflow/gan-png/fake_images_{}.png'.format(i//epoch))
    
    

    原图

    在这里插入图片描述

    生成图片

    在这里插入图片描述

    展开全文
  • GAN训练心得

    万次阅读 热门讨论 2018-11-24 20:54:52
    先抱怨一句,GAN训练真不容易… 一开始GAN总是训练效果很差,使用的是CNN去训练generator和discriminator,但是出来的总是“晶体图”,找到了一些技巧,然后自己实践了一下,也遇到了一些蠢哭的事情。 我换了一个...

    先抱怨一句,GAN训练真不容易…
    一开始GAN总是训练效果很差,使用的是CNN去训练generator和discriminator,但是出来的总是“晶体图”,找到了一些技巧,然后自己实践了一下,也遇到了一些蠢哭的事情。
    我换了一个网络,即调整了原来CNN的参数,或者多加入了一些层,结果出来的效果非常可观,看来首先要找到一个对的网络。

    我尝试了用TensorFlow去实现GAN,一开始是用的Keras。实现第一遍的时候,其实还不错,使用的是全连接网络,没有使用CNN。
    第二次想尝试WGAN,就跟着一位博主的文章开始了练习,但是敲完之后,结果非常糟糕,后来检查发现没有控制trainable_variables,在训练generator的时候,把discriminator的参数也更新了。
    后来发现生成的图片都非常暗,感觉哪里有问题,但是有没发现,后来在看别人代码的时候才发现,我将图片的RGB值由(0,225)缩放到 (-1,1)的时候,我缩放错了,直接除以了255,结果缩放成了(0,1)。

    下面是我觉得很不错的技巧:

    1. 输入的图片经过处理,将0-255的值变为-1到1的值。
      images = (images/255.0)*2 - 1

    2. 在generator输出层使用tanh激励函数,使得输出范围在 (-1,1)

    3. 保存生成的图片时,将矩阵值缩放到[0,1]之间
      gen_image = (gen_image+1) / 2

    4. 使用leaky_relu激励函数,使得负值可以有一定的比重

    5. 使用BatchNormalization,使分布更均匀,最后一层不要使用。

    6. 在训练generator和discriminator的时候,一定要保证另外一个的参数是不变的,不能同时更新两个网络的参数。

    7. 如果训练很容易卡住,可以考虑使用WGAN

    8. 可以选择使用RMSprop optimizer

    更多有用的技巧:
    GAN训练技巧
    Tips on train GAN

    展开全文
  • 提升GAN训练 特征匹配 给生成器一个新的训练目标,避免生成器过拟合当前的判别器。即使用判别器的中间层的特征来匹配图像的真伪,并将其作为一个监督信号来训练生成器。 通过这种方式,我们训练的生成器会匹配真实...


    1、计数
    2、角度
    3、全局结构

    提升GAN训练

    特征匹配

    给生成器一个新的训练目标,避免生成器过拟合当前的判别器。即使用判别器的中间层的特征来匹配图像的真伪,并将其作为一个监督信号来训练生成器。
    通过这种方式,我们训练的生成器会匹配真实数据以及判别器中间层的预期特征值,在判别器的训练过程中,我们让判别器去寻找那些能很好判别真实数据的特征,不是那些生成模型生成数据的特征。

    小批量

    小批量整体来说表现更实际,可以保证不同样本之间在空间上有合适的距离。

    历史平均

    加入一个惩罚项来惩罚那些和历史平均权重相差过多的权重,具体来说,代价函数是当前参数值和历史上最近t批该参数平均值的距离

    单侧标签平滑

    我们使用标签0代表图像是真实的,1代表图像是伪造的,使用平滑标签例如0.1,0.9可以使得在一些对抗例子中更加健壮

    输入规范化

    大多数情况下最好将图像规范化到-1和1的范围之间并使用tanh作为生成器最后一层的激发函数

    批规范化

    针对真实数据和伪造数据构造不同的小批,每一个小批

    使用ReLU和MaxPool避免稀疏梯度

    优化器和噪声

    针对生成器用ADMA作为优化器,针对判别器使用SGD作为优化器,在生成去器的不同层中去除输入层来作为噪声的来源

    不要根据损失来统计信息平衡损失

    while lossD>A
    train D
    while lossG>B
    train G

    展开全文
  • RealFakeAugment 用于GAN训练的图像增强功能
  • 预测优化器(稳定GAN训练) 介绍 这是以下论文中介绍的“预测方法”的PyTorch实现... Abhay Yadav等人,《使用预测方法稳定对抗网络》,ICLR 2018, (为澄清起见,我不是本文的作者。 ) 作者提出了一种简单(但...
  • DRAGAN, 一种稳定的GAN训练 Analytic Generative Generative Adversarial Adversarial链接到我们的纸张- https://arxiv.org/abs/1705.07215Pytorch实现( 致谢) - https
  • 【飞桨】【Paddlepaddle】【论文复现】BigGAN用于高保真自然图像合成的大规模 GAN 训练LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS1、BiagGAN的贡献2.1背景2.2具体措施与改变2.2.1规模...

    用于高保真自然图像合成的大规模 GAN 训练

    LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS

    生成对抗网络(GANs, Goodfellow et al. (2014))能够训练输入的图片生成出新的样本图片(Generator),但传统的GANs在生成图片是会出现一些问题,例如模式崩塌,难以收敛等。并且传统GANs生成的图片不具备足够的精度和分辨率。BigGAN(A.Brock, et al 2018) 以最大规模培训了生成对抗网络,并研究了这种规模所特有的不稳定性。它将正交正则化应用于生成器使得它适用于简单的“截断技巧”,允许通过截断潜在空间来精确控制样本保真度和变化之间的权衡。BigGAN的 Inception Score(IS)为 166.3,Fréchet Inception Distance(FID)为 9.6,相比之前的最佳 (指论文发表时)IS 为 52.52,FID 为 18.65。
    Paper链接:BigGAN.
    Github:BigGAN-Pytorch.
    在这里插入图片描述
    Alt

    1、BiagGAN的贡献

    1. 证明了 GAN 从缩放中获益匪浅,并且与现有技术相比,训练模型的参数为 2 到 4 倍,batch size达到 8 倍。 我们介绍了两种简单的通用体系结构更改,可以提高可伸缩性,并修改正则化方案不断调节,从而显著提升性能;
    2. 作为我们修改的副作用,BIgGAn模型变得适合“截断技巧”,这是一种简单的采样技术,可以对样本种类和保真度之间的权衡进行明确、细粒度的控制;
    3. 我们发现特定于大规模 GAN 的不稳定性,并根据经验表征它们。 利用此分析的见解,我们证明新颖技术和现有技术的结合可以减少这些不稳定性,但完全的训练稳定性只能以极高的性能成本实现。

    2.1背景

    生成对抗网络(GAN)涉及生成器(G)和鉴别器(D)网络,其目的分别是将随机噪声映射到样本并区分实际和生成的样本。正式地,GAN 目标,其原始形式表述为以下两个玩家最小 - 最大问题(minmax-game)找到纳什均衡的问题:
    minmax-game

    2.2具体措施与改变

    BigGAN对batch_size(批量大小)、channels(通道数)、shared(是否加入共享嵌入)、Hier.(hierarchie latent space即分层潜在空间)、orthogonal(是否正交化)进行改变调优。

    2.2.1规模(scaling up)

    diffrent parameters

    1、首先增加baseline(基线GANs)的batch_size。表 1 的第 1-4 行表明,简单地将批量大小增加 8 倍,使现有技术 IS 提高了 46%。我们推测这是每批次覆盖更多模式的结果,为两个网络提供更好的梯度。这种缩放的一个值得注意的副作用是我们的模型在更少的迭代中达到更好
    的最终性能,但变得不稳定并且经历完全的训练崩溃。
    2、将每层中的宽度(通道数)增加 50%,大约两倍于两个模型中的参数数量。这导致IS 进一步提高 21%,我们认为这是由于模型的容量相对于数据集的复杂性而增加。加倍深度似乎不会对 ImageNet 模型产生相同的影响,反而会降低性能。
    3.用于 G 中的条件 BatchNorm 图层的类嵌入 c 包含大量权重。我们选择使用共享嵌入,而不是为每个嵌入分别设置一个层,这个嵌入会线性投影到每个层的增益和偏差(Perez et al.2018)。这降低了计算和内存成本,并将训练速度(达到给定性能所需的迭代次数)提高了 37%。接下来,我们采用分层潜在空间的变体,其中噪声向量 z 被馈送到 G 的多个层而不仅仅是初始层。这种设计背后的直觉是允许 G 使用潜在空间直接影响不同分辨率和层次结构级别的特征。对于我们的架构,通过将 z 分成每个分辨率的一个块,并将每个块连接到条件向量 c,可以很容易地实现这一
    点,条件向量 c 被投射到 BatchNorm 的增益和偏差。以前的工作(Goodfellow et al.2014; Denton et al.2015)已经考虑了这个概念的变体;我们的贡献是对此设计的一个小修改。分层延迟可以提高内存和计算成本(主要通过降低第一个线性层的参数预算),提供约 4%的适度性能提升,
    并将训练速度提高 18%。

    2.2.2截断技巧(Truncation)

    与需要通过其潜在反向传播的模型不同,GAN 可以使用任意先验 p(z),但绝大多数先前的工作选择从 N(0,I)或 U[-1,1]。我们质疑这种选择的最优性,并探索了不同的替代方案。值得注意的是,我们的最佳结果来自于使用与训练中使用的不同的潜在分布进行抽样。采用用z~N(0,I)训练的模型和从截断的正常值(其中超出范围的值被重新采样以落入该范围内)的样本 z 立即实现对 IS 和 FID(两个针对生成图片质量的评价指标) 的提升。我们将其称为截断技巧:通过重新调整幅度高于所选阈值的值来截断 z矢量导致单个样品质量的改善,但代价是整体样品品种的减少。
    对于许多模型而言,由不同采样引起的分布,相比在训练中看到的会不一样,很容易造成一些麻烦。我们的一些较大模型不适合截断,在馈送截断噪声时会产生饱和伪影。为了抵消这种情况,我们试图通过将 G 调节为平滑来强制实现截断的适应性,以便 z 的整个空间映射到良好的输出样本。为此,我们转向正交正则化(Brock et al.2017),它直接强制正交性条件,我们发现最好的版本从正则化中删除了对角项,并且目标是最小化滤波器之间的成对余弦相似性,但不限制它们的范数:

    在这里插入图片描述
    其中 1 表示一个矩阵,其中所有元素都设置为 1。我们扫描β值并选择为 1e-4,从而找到足够小的额外正则化,以提高我们的模型易于截断的可能性。 在表 1 中,我们观察到没有正交正则化时,只有 16%的模型适合截断,而有正交正则化训练时则有 60%。

    3、不稳定性分析

    稳定性不仅仅来自 G 或 D,而是来自他们通过对抗性训练过程的相互作用。 虽然他们的不良症状调节可用于追踪和识别不稳定性,但确保合理的调节是训练所必需的,但不足以防止最终的训练崩溃。 可以通过强烈约束 D 来强制实现稳定性,但这样做会导致性能上的巨大成本。 使用现有技术,可以通过放松这种调节并允许在训练的后期阶段发生塌陷来实现更好的最终性能,此时模型经过充分训练以获得良好的结果。

    4、结论

    BigGAN已经证明,对于多个类别的自然图像进行训练而训练的生成对抗网络在保真度和生成样本的多样性方面都非常有利于扩大规模。 因此,我们的模型在 ImageNet GAN 模型中创造了新的性能水平,大大提高了现有技术水平。 我们还对大规模 GAN 的训练行为进行了分析,并根据其权重的奇异值表征了它们的稳定性,并讨论了稳定性和性能之间的相互作用。

    Reference:

    1、本文摘自G-lab.
    2、百度AIstudio的课程非常棒!百度AI复现论文课程连接.

    展开全文
  • Gan 训练目标 min⁡Gmax⁡DV(D,G)=Ex∼pdatalog⁡[D(x)]+Ex∼pzlog⁡[1−D(G(x))]\min_G \max_DV(D,G)= E_{x\sim p_{data}}{ \log[D(x)]+E_{x\sim p_{z}} \log[1-D(G(x))]}Gmin​Dmax​V(D,G)=Ex∼pdata​​log[D(x)...
  • 【新智元导读】 本文详细解析了最近在 reddit 的 Machine Learning 版引起热烈讨论的一篇论文Wassertein GAN,该论文提出的 WGAN 相比原始 GAN 的算法实现流程却只改了四点,但实现了彻底解决GAN训练不稳定,基本...
  • 主要介绍了解决keras GAN训练是loss不发生变化,accuracy一直为0.5的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 1.简单的GAN训练流程 1训练流程 创建标签,判别器Discriminator区分Real Image和Fake Image归根结底是一个二分类。这里不能用数据集自带标签。 valid = Tensor(image.size(0), 1).fill_(1.0).detach() # Tensor...
  • GAN模型相比较于其他网络一直受困于三个问题的掣肘: 1. 不收敛;模型训练不稳定,收敛的慢,甚至不收敛; 2. mode collapse; 生成器产生的结果模式较为单一; 3. 训练缓慢;出现这个原因大多是发生了梯度消失的...
  • GAN训练技巧汇总

    2020-10-05 21:47:00
    GAN自推出以来就以训练困难著称,因为它的训练过程并不是寻找损失函数的最小值,而是寻找生成器和判别器之间的纳什均衡。前者可以直接通过梯度下降来完成,而后者除此之外,还需要其它的训练技巧。  下面对历年关于...
  • CycleGAN训练模型

    千次阅读 2019-10-10 19:16:38
    CycleGAN进行图像转换CycleGAN使用前言在TensorFlow中训练CycleGAN模型下载数据集并转换格式训练模型模型导出测试图片总结 CycleGAN使用 前言 ​ 图像翻译问题就是将一种类型的图片转换为另一种类型的图片。pix2px...
  • [GAN]GAN训练技巧

    2019-01-25 01:05:18
    文章翻译自: https://towardsdatascience.com/gan-ways-to-improve-gan-performance-acf37f9f59b 文章链接:https://blog.csdn.net/l7H9JA4/article/details/86109229
  • Gan训练思想

    2020-08-18 18:50:51
    训练 鉴别器网络, (1)real data 输入Dmodel 得到预测值计算损失, lossDr , 预测值越大越好, (2)Gmodel 生成的 fake data , 输入Dmodel 得到预测值计算损失 ,lossDf , 预测值越小越好 ,Gmodel.detach() ...
  • GAN训练

    2020-08-04 19:46:42
    mtcnn_basemodel class PNet(nn.Module): def __init__(self): super(PNet, self).__init__() self.features = nn.Sequential(OrderedDict([ ('conv1', nn.Conv2d(3, 10, 3, 1)), ('prelu1', nn.PReLU(10)), ...
  • 从今天开始,我们将关注训练GAN时产生的问题,作为第一篇文章,首先从几个方面来分析一下实际训练GAN和理论模型上的GAN不同之处以及实践中出现的问题。第一个部分将介绍最优判别器引发的梯度消失问题,第二部分...
  • 【GAN优化】GAN训练的几个问题

    千次阅读 2019-07-17 07:30:00
    从今天开始,我们将关注训练GAN时产生的问题,作为第一篇文章,首先从几个方面来分析一下实际训练GAN和理论模型上的GAN不同之处以及实践中出现的问题。第一个部分将介绍最...
  • gan训练失败This work borrows heavily from the Pytorch DCGAN Tutorial and the NVIDA paper on progressive GANs. 这项工作大量借鉴了Pytorch DCGAN教程 和 有关渐进式GAN 的 NVIDA论文 。 One area of computer...
  • StyleGAN — Official TensorFlow Implementation Picture: These people are not real – they were produced by our generator that allows control over different aspects of the image. This repository ...
  • 给大家分享一下keras GAN训练是loss不发生变化,accuracy一直为0.5怎么办,希望大家阅读完这篇文章后大所收获,下面让我们一起去探讨方法吧! 首先谈谈我的是如何解决的: 网络结构:AlexNet 优化器:Adam (这里...
  • BigGAN-LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS 原文:https://arxiv.org/abs/1809.11096 作者:来自DeepMind & Heriot-Watt University 译者:Tony 时长:3K字,约10分钟 .....
  • 训练GAN的一些Tips 用以解决GAN出现的模型坍塌和初始化方面的问题 1.特征匹配 GAN不稳定的特点可以通过给生成器一个新的训练目标来解决,这种方式可以避免生成器过度拟合当前的判别器。通过使用判别器中间层的特征来...
  • 该文件的正式pytorch实施“走向更快,更稳定的GAN训练,以实现高保真的少量拍摄图像合成”,可在找到该文件。 0.数据 本文中使用的数据集可以在上找到。 在对20多个数据集进行测试后,每个数据集的图像少于100个,...
  • 【GAN优化】GAN训练的小技巧

    千次阅读 2019-08-14 09:38:15
    上一期中,我们说明了GAN训练中的几个问题,例如由于把判别器训练得太好而引起的梯度消失的问题、通过采样估算距离而造成偏差的问题、minmax问题不清晰以及模式崩溃、优化选择在参数空间而非函数空间的问题等,今天...
  • GAN训练不稳定原因

    千次阅读 2019-08-16 11:25:04
    版权声明:本文为CSDN博主「weixin_43698821」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。...大多深度模型的训练都使用优化算法寻找损失函数比较低的值。优化算法通常是个可靠的“...
  • 这几天我用了好几种的gan训练了mini-imageNet数据集,我在acgan训练上有了一点效果,把数据resize成64*64进行训练,但是我看把原图也形变的严重,我就把分辨率提升为128*128,但是效果也不好,如下: ![图片说明]...
  • BigGAN Tensorflow TPU 简单的Tensorflow TPU实施 我(David Mack)一直在修改此网络,以允许对其自我注意进行配置,以促进对不同自我注意体系结构有效性的实验。 实施说明/问题 待办事项:实现BigGAN深度架构(更...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,936
精华内容 1,174
关键字:

gan训练