pytorch实战10：基于pytorch简单实现CGAN

最新推荐文章于 2024-04-09 21:12:48 发布
最新推荐文章于 2024-04-09 21:12:48 发布
阅读量2.1k 收藏 33
点赞数 8
分类专栏： pytorch学习笔记 文章标签： pytorch 深度学习 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46676835/article/details/130667091
版权

基于pytorch简单实现CGAN

前言

​ 最近在看经典的卷积网络架构，打算自己尝试复现一下，在此系列文章中，会参考很多文章，有些已经忘记了出处，所以就不贴链接了，希望大家理解。

​ 完整的代码在最后。

本系列必须的基础

​ python基础知识、CNN原理知识、pytorch基础知识

本系列的目的

​ 一是帮助自己巩固知识点；

​ 二是自己实现一次，可以发现很多之前的不足；

​ 三是希望可以给大家一个参考。

目录结构

文章目录

1. 前言：

​ 今天来实现一下‘干’系列中的CGAN，相比于原始的GAN来说，CGAN更加稳定，且引入了条件参数，可以在一定程度上控制输出。

​ 本次实现CGAN，使用pytorch库和手写数字数据集MNIST（注定了很简单的）。另外，本次的目的是简单实现一下，更深入的优化，就靠大家了。

​ 最后，补充一下我的项目结构：（特别注意：我的数据集文件夹在其它文件夹内）

├─fake_images
|  └─ 用于保存生成器生成的图片的文件夹
├─network_files
│  └─ 用于存放网络结构的文件夹
├─save_weights
|  └─ 用于存放训练好权重的文件夹
|_ 数据加载器、训练、测试文件

2. 数据介绍与数据加载器：

数据介绍

​ MNIST数据集大家应该都不陌生吧。我这里简单说明一下，这个数据集是灰度图（通道数为1），所有图片大小为28*28，内容为0-9的数字。

在这里插入图片描述

数据加载器

​ 这里不需要像前面一样，实现复杂的数据加载器。因为官方已经为我们封装好了现成的加载器，这里我们只是将之封装到文件的函数中即可，如下：

from torchvision import transforms as T
from torchvision.datasets import MNIST

# 这个简单，MNIST数据集很经典，因此可以直接调用官方的方法
def My_Dataset(train=True):
    # 定义预处理方法
    transforms = T.Compose([
        T.Resize(28), # 这个其实不需要，只是后期如果要改为其它图片，肯行需要修改
        T.ToTensor(),
        T.Normalize([0.5], [0.5])
    ])
    if train:
        #  路径需要修改为自己的
        # 另外，这个数据集会自动下载
        data = MNIST('../data/mnist',train=True,download=True,transform=transforms)
    else:
        data = MNIST('../data/mnist', train=False, download=True, transform=transforms)
    return data

3. 生成器：

​ 生成器很好定义，只需要注意最后的输出为图像尺寸即可。关于生成器的具体结构，其实论文中并没有给出，但是网上有别人实现的架构，我们可以拿来用：（下图来自GitHub项目pytorch-MNIST-CelebA-cGAN-cDCGAN）

在这里插入图片描述

​ 其中，上图中G输出784，是因为MNIST图像大小为28*28=784。另外，上图中z是输入的噪声向量，y为其对应的标签。

​ 按照上图架构，可以实现生成器：

import torch
from torch import nn
import numpy as np

class Generator(nn.Module):
    def __init__(self,in_dim,img_shape,num_classes=10):
        '''
        :param in_dim: 噪声的维度
        :param num_classes: 类别个数，为数字0-9，即10个类别
        :param img_shape: 生成的图片尺寸，一般与真实图片一致，即28*28
        '''
        super(Generator, self).__init__()
        # 初始化
        self.in_dim = in_dim
        self.num_classes = num_classes
        self.img_shape = img_shape
        self.label_embedding = nn.Embedding(self.num_classes,self.num_classes)

        # 定义模型
        self.model = nn.Sequential(
            # 不要忘记输入是真实标签+噪声
            self.block(self.in_dim+self.num_classes,128,normalize=False),
            self.block(128,256),
            self.block(256,512),
            self.block(512,1024),
            #np.prod 输入a是数组，返回指定轴上的乘积，不指定轴默认是所有元素的乘积
            nn.Linear(1024,int(np.prod(self.img_shape))),
            nn.Tanh(),
        )

    # 构建基础块
    def block(self,in_channels,out_channels,normalize=True):
        layers = []
        layers.append(nn.Linear(in_channels,out_channels))
        # 是否初始化
        if normalize:
            layers.append(nn.BatchNorm1d(out_channels))
        # 不要忘记加上激活函数
        layers.append(nn.LeakyReLU(0.2,inplace=True))
        return nn.Sequential(*layers)

    def forward(self,noise,labels):
        # 将输入标签和噪声拼接在一起
        # temp2 = labels # 256
        # temp = self.label_embedding(labels) # torch.Size([256, 10])
        # 将标签转为了向量，目的是为和噪声进行拼接
        input_x = torch.cat((self.label_embedding(labels),noise),-1) # torch.Size([256, 110])
        # 送入模型
        output_img = self.model(input_x)
        # 将输出构造成真实图片的shape信息【batch，w，h】
        output_img = output_img.view(output_img.size(0),*(self.img_shape))
        return output_img

4. 判别器：

​ 同样根据上图实现判别器，只是注意最后的输出为1个通道，这是因为我们同时输入了图像和对应标签，最后就直接输出一个概率值，这个概率值越接近1，表示判别其为真实图像，越接近0表示假图像。

​ 同样，根据上图写出判别器架构，具体可以看注释：

import numpy as np
import torch.nn as nn
import torch

class Discriminator(nn.Module):
    def __init__(self,img_shape,num_classes=10):
        '''
        :param img_shape: 图像尺寸，这里为28*28
        :param num_classes: 类别数，即10类
        '''
        super(Discriminator, self).__init__()
        # 初始化一下
        self.num_classes = num_classes
        self.img_shape = img_shape
        self.label_embedding = nn.Embedding(self.num_classes,self.num_classes)
        # 定义模型
        self.model = nn.Sequential(
            nn.Linear(self.num_classes+int(np.prod(self.img_shape)),512),
            nn.LeakyReLU(0.2,inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512,512),
            nn.Dropout(0.5),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512,512),
            nn.Dropout(0.5),
            nn.LeakyReLU(0.2, inplace=True),
            # 最后输出为1，表示分类
            nn.Linear(512,1)
        )

    def forward(self,img,labels):
        input_x = torch.cat((img.view(img.size(0), -1), self.label_embedding(labels)),-1)
        output_class = self.model(input_x)
        return output_class

5. 训练：

​ 相比于网络结构的定义，CGAN如何训练的，更重要。

​ 首先，导入基本的包和我们自己定义的数据加载器、网络结构等：

import os
from My_Dataset import My_Dataset
from network_files.Discriminator import Discriminator as D
from network_files.Generator import Generator as G

import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader
from torch.autograd import Variable
from torch import optim
from torchvision.utils import save_image # 用于生成图片、保持图片

​ 接着，定义基本的参数：

# 定义基本参数
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # 设备
batch_size = 256 # batch大小
epoch = 400 # 训练批次
lr = 0.002 # 初始学习率
img_shape = (1,28,28) # 图像shape
num_classes = 10 # 类别数目
in_dim = 100 # 噪声维度

​ 然后，创建模型、定义优化器（Adam）、损失函数（MSE）并加载数据，这都是基本操作：

# 创建模型
Generator = G(in_dim,img_shape,num_classes)
Discriminator = D(img_shape,num_classes)
Generator.to(device)
Discriminator.to(device)
# 定义损失函数
loss = nn.MSELoss()
# 优化器
optim_G = optim.Adam(Generator.parameters(),lr=lr,betas=(0.5, 0.999))
optim_D = optim.Adam(Discriminator.parameters(),lr=lr,betas=(0.5, 0.999))
# 加载数据
train_dataset = My_Dataset(train=True)
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True,drop_last=True)

​ 接着开始训练：

# 开始训练
for e in range(epoch):

​ 首先，训练到一定程度时调整学习率，这个方法也是我最近看到的，感觉可以很方便的实现调整学习率：

# 开始训练
for e in range(epoch):
    #学习率调整
    if (e + 1) == 100:
        optim_D.param_groups[0]['lr'] /= 10
        optim_G.param_groups[0]['lr'] /= 10
        print("learning rate change!")

        if (e + 1) == 250:
            optim_D.param_groups[0]['lr'] /= 10
            optim_G.param_groups[0]['lr'] /= 10
            print("learning rate change!")

​ 然后，开始训练第一个epoch，首先把数据集放入GPU中：

# 开始训练
for e in range(epoch):
    #学习率调整
    ...... # 这里不重复了，直接省略  
    for i,(batch_img,batch_label) in enumerate(train_loader):
        # 放入设备中
        batch_img,batch_label = batch_img.to(device),batch_label.to(device)

​ 接着，需要创建噪声向量和其对应的标签，并创建两个全为0和全为1的向量，用于后期与判别器输出比较（因为判别器只输出一个概率值，因此需要创建这两个向量）：

# 开始训练
for e in range(epoch):
    #学习率调整
    ...... # 这里不重复了，直接省略  
    for i,(batch_img,batch_label) in enumerate(train_loader):
        # 放入设备中
        batch_img,batch_label = batch_img.to(device),batch_label.to(device)
		# 创建噪声向量和标签
        # z = [batch,100] , labels = [64] 为要生成的数字图片标签
        z = Variable(torch.cuda.FloatTensor(np.random.normal(0, 1, (batch_size, in_dim))))  # 噪声样本
        g_labels = Variable(torch.cuda.LongTensor(np.random.randint(0, num_classes, batch_size)))  # 对应的标签
        #  用于计算损失的标签，一个全为1，一个全为0
        valid = Variable(torch.cuda.FloatTensor(batch_size, 1).fill_(1.0), requires_grad=False)  # torch.Size([64, 1])
        fake = Variable(torch.cuda.FloatTensor(batch_size, 1).fill_(0.0), requires_grad=False)  # torch.Size([64, 1])

​ 然后，开始真正的训练，训练的思路如下：

在这里插入图片描述

​ 按照上述思路，实现训练过程：

# 开始训练
for e in range(epoch):
    #学习率调整
    ...... # 这里不重复了，直接省略  
    for i,(batch_img,batch_label) in enumerate(train_loader):
        ...... # 前面那些基础的定义
        # 生成器根据噪声和标签生成假的图片
        optim_G.zero_grad()
        g_img = Generator(z,g_labels)
        # 判别器判别，输出的为[batch,1]，输出的是概率值，越接近1，表示生成的图片越真实
        g_class = Discriminator(g_img,g_labels)
        # 损失
        g_loss = loss(g_class,valid)
        g_loss.backward()
        optim_G.step()
        # 训练判别器
        optim_D.zero_grad()
        # 实图片的损失，目的就是希望其与真实标签1的损失最小
        d_real_class = Discriminator(batch_img,batch_label)
        d_real_loss = loss(d_real_class,valid)
        # g_img.detach() 不要忘记detach，不然会报错的，因为前面backward已经释放了
        # 生成的虚假图片的损失，目的就是希望其与虚假标签0的损失最小
        d_fake_class = Discriminator(g_img.detach(),g_labels)
        d_fake_loss = loss(d_fake_class,fake)
        all_loss = (d_fake_loss+d_real_loss)/2
        all_loss.backward()
        optim_D.step()
        # 每个step打印损失
        print('epoch{%d},batch{%d},D_loss: %.5f,G_loss: %.5f' % (e+1,i+1,all_loss.item(),g_loss.item()))

​ 为了能够看到训练的效果，在每经历一个epoch后，都用生成器去生成图像，并保持到指定路径（需要自己修改）：

# 开始训练
for e in range(epoch):
    #学习率调整
    ...... # 这里不重复了，直接省略  
    for i,(batch_img,batch_label) in enumerate(train_loader):
		...... # 整个训练过程省略
	# 每一个epoch，看看生成器生成的图片咋样了
    z = Variable(torch.cuda.FloatTensor(np.random.normal(0, 1, (10 ** 2, 100))))
    labels = np.array([num for _ in range(10) for num in range(10)])
    labels = Variable(torch.cuda.LongTensor(labels))
    gen_imgs = Generator(z, labels)
    # 路径自己改
    save_image(gen_imgs.data, "fake_images1/%d.png" % (e+1), nrow=10, normalize=True)

​ 完成所有的训练后，保持一下权重，方便后期用：

# 保存权重
torch.save(Generator.state_dict(),'./save_weights/G_params.pkl')
torch.save(Discriminator.state_dict(),'./save_weights/D_params.pkl')

完整训练代码

def main():
    # 定义基本参数
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # 设备
    batch_size = 256 # batch大小
    epoch = 400 # 训练批次
    lr = 0.002 # 初始学习率
    img_shape = (1,28,28) # 图像shape
    num_classes = 10 # 类别数目
    in_dim = 100 # 噪声维度
    # 创建模型
    Generator = G(in_dim,img_shape,num_classes)
    Discriminator = D(img_shape,num_classes)
    Generator.to(device)
    Discriminator.to(device)
    # 定义损失函数
    loss = nn.MSELoss()
    # 优化器
    optim_G = optim.Adam(Generator.parameters(),lr=lr,betas=(0.5, 0.999))
    optim_D = optim.Adam(Discriminator.parameters(),lr=lr,betas=(0.5, 0.999))
    # optim_G = optim.SGD(Generator.parameters(),lr=lr,momentum=0.9)
    # optim_D = optim.SGD(Discriminator.parameters(),lr=lr,momentum=0.9)
    # 加载数据
    train_dataset = My_Dataset(train=True)
    train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True,drop_last=True)

    # 开始训练
    for e in range(epoch):
        #学习率调整
        if (e + 1) == 100:
            optim_D.param_groups[0]['lr'] /= 10
            optim_G.param_groups[0]['lr'] /= 10
            print("learning rate change!")

        if (e + 1) == 250:
            optim_D.param_groups[0]['lr'] /= 10
            optim_G.param_groups[0]['lr'] /= 10
            print("learning rate change!")
        for i,(batch_img,batch_label) in enumerate(train_loader):
            # 放入设备中
            batch_img,batch_label = batch_img.to(device),batch_label.to(device)
            # 创建噪声向量和标签
            # z = [batch,100] , labels = [64] 为要生成的数字图片标签
            z = Variable(torch.cuda.FloatTensor(np.random.normal(0, 1, (batch_size, in_dim))))  # 噪声样本
            g_labels = Variable(torch.cuda.LongTensor(np.random.randint(0, num_classes, batch_size)))  # 对应的标签
            #  用于计算损失的标签，一个全为1，一个全为0
            valid = Variable(torch.cuda.FloatTensor(batch_size, 1).fill_(1.0), requires_grad=False)  # torch.Size([64, 1])
            fake = Variable(torch.cuda.FloatTensor(batch_size, 1).fill_(0.0), requires_grad=False)  # torch.Size([64, 1])
            # 生成器根据噪声和标签生成假的图片
            optim_G.zero_grad()
            g_img = Generator(z,g_labels)
            # 判别器判别，输出的为[batch,1]，输出的是概率值，越接近1，表示生成的图片越真实
            g_class = Discriminator(g_img,g_labels)
            # 损失
            g_loss = loss(g_class,valid)
            g_loss.backward()
            optim_G.step()
            # 训练判别器
            optim_D.zero_grad()
            # 实图片的损失，目的就是希望其与真实标签1的损失最小
            d_real_class = Discriminator(batch_img,batch_label)
            d_real_loss = loss(d_real_class,valid)
            # g_img.detach() 不要忘记detach，不然会报错的，因为前面backward已经释放了
            # 生成的虚假图片的损失，目的就是希望其与虚假标签0的损失最小
            d_fake_class = Discriminator(g_img.detach(),g_labels)
            d_fake_loss = loss(d_fake_class,fake)
            all_loss = (d_fake_loss+d_real_loss)/2
            all_loss.backward()
            optim_D.step()
            # 每个step打印损失
            print('epoch{%d},batch{%d},D_loss: %.5f,G_loss: %.5f' % (e+1,i+1,all_loss.item(),g_loss.item()))
        # 每一个epoch，看看生成器生成的图片咋样了
        z = Variable(torch.cuda.FloatTensor(np.random.normal(0, 1, (10 ** 2, 100))))
        labels = np.array([num for _ in range(10) for num in range(10)])
        labels = Variable(torch.cuda.LongTensor(labels))
        gen_imgs = Generator(z, labels)
        # 路径自己改
        save_image(gen_imgs.data, "fake_images1/%d.png" % (e+1), nrow=10, normalize=True)
    # 保存权重
    torch.save(Generator.state_dict(),'./save_weights/G_params.pkl')
    torch.save(Discriminator.state_dict(),'./save_weights/D_params.pkl')

6. 训练结果展示与思考：

​ 我尝试了训练400次，运行中间的结果展示如下：

在这里插入图片描述

​ 其实运行的效果，我自己不是很满意。另外，在运行过程中，发现一个非常重要的事情：训练经常容易崩溃，即我运行到50epoch的时候，效果已经不错了，但是会突然损失值增大到一个难以接受的值，导致训练崩溃。

​ 关于这一点，应该就是CGAN、GAN的缺点，就是训练不稳定，相比于原始GAN，CGAN的优点是可以控制输出长什么样，但是稳定性方面仍然有所欠缺。我尝试过换一种训练方式，比如先训练好判别器，再训练生成器，试图让优秀学生（判别器）带动差生（生成器），但是效果不佳。

​ 因此，后期我会尝试换一种更稳定的GAN网络，看看是否仍然会遇到同样的问题。

7. 预测：

​ 这个非常简单，由于训练完毕后，我们保存了模型的参数，因此可以直接把生成器参数拿来用。这里的预测，指的是生成一个张图片。

​ 代码如下：

import torch
import numpy as np
from torch.autograd import Variable
from torchvision.utils import save_image

from network_files.Generator import Generator as G

img_shape = (1,32,32)
num_classes = 10
in_dim = 100

# 创建生成器模型
G_model = G(in_dim,img_shape,num_classes)
# 加载参数
G_model.load_state_dict(torch.load('./save_weights/G_params.pkl'))
# 随机生成100个图片并显示
z = Variable(torch.FloatTensor(np.random.normal(0, 1, (10 ** 2, 100))))
labels = np.array([num for _ in range(10) for num in range(10)])
labels = Variable(torch.LongTensor(labels))
gen_imgs = G_model(z, labels)
save_image(gen_imgs.data, "fake_images/%d.png" % (100), nrow=10, normalize=True)

8. 总结：

​ 完成了CGAN，感觉生成对抗的神奇和有趣，进一步了解损失函数控制生成目标的含义。

​ 不过缺点是CGAN生成不稳定且效果并不是很好，后期可以考虑试试其它的GAN网络，看看效果是不是更好点。

参考资料

博客：
https://blog.csdn.net/qq_42721935/article/details/126600071
https://blog.csdn.net/weixin_38052918/article/details/107911739
GitHub项目：
https://github.com/znxlwm/pytorch-MNIST-CelebA-cGAN-cDCGAN

完整代码

链接：https://pan.baidu.com/s/14ZXgMaEuXgM2ETrbHBvOHg 
提取码：izol
自学小白菜
关注
  • 8
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
用PyTorch搭建条件生成对抗网络（CGAN）.ipynb
12-03
用PyTorch搭建条件生成对抗网络（CGAN），详情可参考文章：https://blog.csdn.net/didi_ya/article/details/121604572
使用Pytorch从零开始构建CGAN (conditional GAN)
GarryWang1248的博客
11-21 614
该生成器与我们使用的 DCGAN 生成器类似。和之前一样，我们生成随机值向量，并使用全连接层将维度增加到 784。我们还使用条件层将输入标签转换为 784 维度的特征向量。然后，我们对随机向量和标签特征求和。这是一个逐元素的加法运算。我们可以这样做，因为随机值和标签特征向量具有相同数量的元素。生成器网络处理随机值向量和标签特征向量的总和，以生成指定标签类别的随机图像。让我们看看如何将该Condition类集成到 DCGAN 生成器类中。return x。
第G8周：ACGAN任务
最新发布
m0_62017984的博客
04-09 376
'''定义生成器 Generator'''# 定义条件标签的生成器部分，用于将标签映射到嵌入空间中# n_classes：条件标签的总数# embedding_dim：嵌入空间的维度nn.Embedding(n_classes, embedding_dim), # 使用Embedding层将条件标签映射为稠密向量nn.Linear(embedding_dim, 16) # 使用线性层将稠密向量转换为更高维度# 定义潜在向量的生成器部分，用于将噪声向量映射到图像空间中。
CGAN模型——pytorch实现
Peach_____的博客
01-04 817
【代码】CGAN模型——pytorch实现。
PyTorch 生成动漫人物头像 CGAN(李宏毅)
qq_57886603的博客
12-09 7014
一、GAN简介 GAN由生成器(Generator)和判别器(Discriminator)组成，生成器负责生成假的图片来骗过判别器，而判别器需要不断从真实图片上学习特征来提高自己的判别能力。 GAN本质是一个博弈的过程，首先生成器G将输入的随机噪声通过神经网络生成一张图，判别网络D会对G生成的假图进行打分(分值越接近0表示图片越假，越接近1表示图片越真)，从而引导G生成更真的图(既然判别器D要引导生成器G变得更好，那么D的判别能力起到至关重要的作用，因此判别器D也在不断学...
Pytorch使用MNIST数据集实现CGAN和生成指定的数字方式
09-18
今天小编就为大家分享一篇Pytorch使用MNIST数据集实现CGAN和生成指定的数字方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
【pytorch】CGAN编程实现
热门推荐
学渣的博客
10-25 1万+
由于原始GAN生成的图像是随机的，不可预测的，无法控制网络输出特定的图片，，可控性不强。针对原始GAN不能生成具有特定属性的图片的问题， Mehdi Mirza等人提出了cGAN，其核心在于cGAN的中心思想是希望 可以控制 GAN 生成的图片，而不 是单纯的随机生成图片。具体来说，Conditional GAN 在生成器和判别器的输入中 增加了额外的 条件信息，生成器生成的图片只有足够真实 且与条件相符，才能够通过判别器。实际上 , 在无条件约束的生成模型中 , 没法控制数据生成的模式。
【pytorch】实现条件生成对抗网络 CGAN
flyconley的博客
10-27 1639
生成器网络为Unet 判别器为patchGAN 代码示例： class DoubleConv(nn.Module): def __init__(self, in_channels, out_channels): super(DoubleConv, self).__init__() self.conv = nn.Sequential( nn.Conv2d(in_channels, out_channels, 3, 1, 1, b.
pytorch 7月22日学习---cgan代码学习1
fly
07-23 2733
一. 参数 parser = argparse.ArgumentParser() parser.add_argument('--n_epochs', type=int, default=200, help='number of epochs of training') parser.add_argument('--batch_size', type=int, default=64, hel...
pytorch-GANs:pytorch环境中的各种GAN
05-09
pytorch-GAN 我的项目： 原始代码地址 项目进度 它适用于cifar10。 可以通过电子邮件获取详细信息。 mnist的结果 可以使用以下命令重现以下结果： python main.py --dataset mnist --gan_type <TYPE> --epoch 40 ...
CGAN源代码
06-02
CGAN条件生成式对抗网络源代码，可以直接运行，不错的参考资料
（CGAN）Conditional Generative Adversarial Nets
08-27
条件生成对抗网络（CGAN）， tensorflow实现
CGAN代码及数据集
02-20
压缩包中包含CGAN一篇代码及对应的minst.plk数据集。真是有效。
cGANTransfer:cGANTransfer PyTorch实施
03-09
高效的有条件GAN转移以及跨课程的知识传播 接受CVPR 2021 作者： ，， ， 和 论文： : 抽象的 生成对抗网络（GAN）在无条件图像生成和条件图像生成方面均显示出令人印象深刻的结果。 在最近的文献中，显示了可以在不同的数据集上传输经过预训练的GAN，以改善从较小目标数据生成的图像。 但是，对于条件GAN（cGAN），尚未对此进行充分研究，与无条件设置相比，条件GAN提供了新的知识转移机会。 特别是，新班级可以借鉴相关旧班级的知识，或者在彼此之间共享知识以改善培训。 这激励我们去研究有效的有条件GAN转移与跨类知识传播的问题。 为了解决这个问题，我们引入了一种新的GAN传输方法，以将知识从旧类显式传播到新类。 关键思想是强制使用普遍使用的条件批处理规范化（BN），以从旧类中学习新类的类特定信息，并在新类之间进行隐式知识共享。 这允许从旧类到新类的有效知识传播，并且BN参数随新
pytorch-GANs:我对各种GAN（生成对抗网络）架构的实现，例如香草GAN（Goodfellow等），cGAN（Mirza等），DCGAN（Radford等）等
03-18
PyTorch GAN :laptop:与 :laptop: = :red_heart:此仓库包含各种GAN架构的PyTorch实现。目的是使初学者更容易开始玩和学习GAN。我发现的所有存储库都掩盖了某些内容，例如将某些网络层中的偏向设置为False而没有解释...
cosmogan_pytorch:在pytorch中实现cosmogan的代码
03-19
介绍该存储库包含用于实现生成对抗神经网络的代码，以针对不同的宇宙学参数集生成宇宙中物质分布的图像。从PyCOLA获得的N体宇宙学模拟图的数据集一致性。目的是建立条件GAN，以产生对应于不同宇宙学参数集的不同类别...
cgan实战--pytorch
liang0502的博客
04-29 1189
cgan结构图 要点 原始gan网络无法控制输出什么图片，因此作者想通过添加一些额外的信息来控制模型输出指定的结果 添加的这个额外信息既要输入生成器也要输入判别器 代码 import numpy as np import torchvision.transforms as transforms from torchvision.utils import save_image from torch.utils.data import DataLoader from torchvision import
knn pytorch_CGAN原理分析与pytorch实现
weixin_39531582的博客
10-25 405
上文说到生成对抗网络GAN能够通过训练学习到数据分布，进而生成新的样本。可是GAN的缺点是生成的图像是随机的，不能控制生成图像属于何种类别。比如数据集包含飞机、汽车和房屋等类别，原始GAN并不能在测试阶段控制输出属于哪一类。为此，研究人员提出了Conditional Generative Adversarial Network（简称CGAN），CGAN的图像生成过程是可控的。本文包含以下3个方面：...
pytorch使用cgan生成图片
04-24
好的，很高兴为您解答。GAN（Generative Adversarial Networks）是一种深度学习模型，可以生成与训练数据相似的新数据。CGAN（Conditional GAN）是一种带条件的GAN，它能够在生成新数据时考虑输入的条件，使生成的数据更加精确和准确。在使用PyTorch实现CGAN生成图片时，一般需要先定义生成器和判别器模型，然后设置优化器、损失函数等参数。接着，将带有条件的真实图像和噪声输入到生成器中，然后将生成器生成的假图像和真实图像一起输入到判别器中进行判别，最后通过反向传播调整生成器和判别器的参数，不断优化模型，使得生成的图片更加真实和准确。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值