DR-GAN代码实现记录

最新推荐文章于 2024-06-17 13:08:59 发布
最新推荐文章于 2024-06-17 13:08:59 发布
阅读量5k 收藏 23
点赞数 6
分类专栏： Pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34914551/article/details/87381230
版权

我主要基于此github代码修改所写。其实只是自己修改了dataset的部分。代码使用pytorch1.0。

链接中的代码需要几个.npy文件，作者也没提供，也没有生成这些.npy文件的代码，所以我只有撸起袖子自己写这一部分，再和作者代码对接就行了。

关于DR-Gan的论文解读见here

数据读取

class FaceIdPoseDataset(Dataset):

    #  assume images  as B x C x H x W  numpy array
    def __init__(self, root, transform=None):

        with open(root,'r') as f:
            data = ['./dataset'+ line.strip() for line in f.readlines()]
        self.data = np.random.permutation(data)
        self.transform = transform
    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):

        sample = self.data[idx]
        img = Image.open(sample)
        img = img.convert('RGB')
        if sample.find('frontal') !=-1:
            pose_label = 1
        else :
            pose_label = 0
        id_label = int(sample[22:25])
        img= self.transform(img)
        return [img.float(), id_label, pose_label]

def get_batch(root,batch_size):
    data_set = FaceIdPoseDataset(root,
                                 transform=transforms.Compose([
                                     transforms.Resize((110,110)),
                                     transforms.RandomCrop((96,96)),
                                     transforms.ToTensor(),
                                     transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
                                 ]))
    dataloader = DataLoader(data_set,batch_size=batch_size,
                            shuffle=True,drop_last=True)  #drop_last is necessary,because last iteration may fail
    return dataloader

实现思路就是自定义的dataset中，使用记录了cfp 数据集文件名字中的txt文件，把文件名字读取存在list中，打乱一下。

另外要注意的是，在FaceIdPoseDataset的构造函数中有transform参数，这是必要的。在getitem中就按照index读取就行了。打开图像的方式一定是要用PIL.image.open，然后记得要convert成RGB格式的（必要）。然后用transform函数数据增强。

 

模型搭建

我仅用了single-image dr-gan做实验。代码和论文中所见一下。而且都是容易懂的代码，看一下判别器的部分。

class Discriminator(nn.Module):
    """
    multi-task CNN for identity and pose classification

    ### init
    Nd : Number of identitiy to classify
    Np : Number of pose to classify

    """

    def __init__(self, Nd, Np, channel_num):
        super(Discriminator, self).__init__()
        convLayers = [
            nn.Conv2d(channel_num, 32, 3, 1, 1, bias=False), # Bxchx96x96 -> Bx32x96x96
            nn.BatchNorm2d(32),
            nn.ELU(),
            nn.Conv2d(32, 64, 3, 1, 1, bias=False), # Bx32x96x96 -> Bx64x96x96
            nn.BatchNorm2d(64),
            nn.ELU(),
            nn.ZeroPad2d((0, 1, 0, 1)),                      # Bx64x96x96 -> Bx64x97x97
            nn.Conv2d(64, 64, 3, 2, 0, bias=False), # Bx64x97x97 -> Bx64x48x48
            nn.BatchNorm2d(64),
            nn.ELU(),
            nn.Conv2d(64, 64, 3, 1, 1, bias=False), # Bx64x48x48 -> Bx64x48x48
            nn.BatchNorm2d(64),
            nn.ELU(),
            nn.Conv2d(64, 128, 3, 1, 1, bias=False), # Bx64x48x48 -> Bx128x48x48
            nn.BatchNorm2d(128),
            nn.ELU(),
            nn.ZeroPad2d((0, 1, 0, 1)),                      # Bx128x48x48 -> Bx128x49x49
            nn.Conv2d(128, 128, 3, 2, 0, bias=False), #  Bx128x49x49 -> Bx128x24x24
            nn.BatchNorm2d(128),
            nn.ELU(),
            nn.Conv2d(128, 96, 3, 1, 1, bias=False), #  Bx128x24x24 -> Bx96x24x24
            nn.BatchNorm2d(96),
            nn.ELU(),
            nn.Conv2d(96, 192, 3, 1, 1, bias=False), #  Bx96x24x24 -> Bx192x24x24
            nn.BatchNorm2d(192),
            nn.ELU(),
            nn.ZeroPad2d((0, 1, 0, 1)),                      # Bx192x24x24 -> Bx192x25x25
            nn.Conv2d(192, 192, 3, 2, 0, bias=False), # Bx192x25x25 -> Bx192x12x12
            nn.BatchNorm2d(192),
            nn.ELU(),
            nn.Conv2d(192, 128, 3, 1, 1, bias=False), # Bx192x12x12 -> Bx128x12x12
            nn.BatchNorm2d(128),
            nn.ELU(),
            nn.Conv2d(128, 256, 3, 1, 1, bias=False), # Bx128x12x12 -> Bx256x12x12
            nn.BatchNorm2d(256),
            nn.ELU(),
            nn.ZeroPad2d((0, 1, 0, 1)),                      # Bx256x12x12 -> Bx256x13x13
            nn.Conv2d(256, 256, 3, 2, 0, bias=False),  # Bx256x13x13 -> Bx256x6x6
            nn.BatchNorm2d(256),
            nn.ELU(),
            nn.Conv2d(256, 160, 3, 1, 1, bias=False), # Bx256x6x6 -> Bx160x6x6
            nn.BatchNorm2d(160),
            nn.ELU(),
            nn.Conv2d(160, 320, 3, 1, 1, bias=False), # Bx160x6x6 -> Bx320x6x6
            nn.BatchNorm2d(320),
            nn.ELU(),
            nn.AvgPool2d(6, stride=1), #  Bx320x6x6 -> Bx320x1x1
        ]

        self.convLayers = nn.Sequential(*convLayers)
        self.fc = nn.Linear(320, Nd+1+Np)

        # 重みは全て N(0, 0.02) で初期化
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                m.weight.data.normal_(0, 0.02)

            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.02)

    def forward(self, input):
        # 畳み込み -> 平均プーリングの結果 B x 320 x 1 x 1の出力を得る
        x = self.convLayers(input)

        x = x.view(-1, 320)

        # 全結合
        x = self.fc(x) # Bx320 -> B x (Nd+1+Np)

        return x

构造函数里面，依照选卷积后FC层的设计思路，然后初始化参数。因为用了batch norm，所以卷积的bias就可以不要了。

这里值得注意的是，卷积部分有一个zeroPad的操作。用来做啥的呢？仅仅encoder部分设置一样。那么encoder部分为啥要加zeroPad呢？这是为了和decoder部分对应。decoder是反卷积的过程，与encoder是对称结构。因为encoder和D是一样的结构，所以我们直接看看decoder的代码。

class Generator(nn.Module):
    """
    Encoder/Decoder conditional GAN conditioned with pose vector and noise vector

    ### init
    Np : Dimension of pose vector (Corresponds to number of dicrete pose classes of the data)
    Nz : Dimension of noise vector

    """

    def __init__(self, Np, Nz, channel_num):
        super(Generator, self).__init__()
        self.features = []

       G_enc_convLayers=[
        xxxxxxxxx
        '''
        省略encoder的搭建
        '''
        ]
        
        self.G_enc_convLayers = nn.Sequential(*G_enc_convLayers)

        G_dec_convLayers = [
            nn.ConvTranspose2d(320,160, 3,1,1, bias=False), # Bx320x6x6 -> Bx160x6x6
            nn.BatchNorm2d(160),
            nn.ELU(),
            nn.ConvTranspose2d(160, 256, 3,1,1, bias=False), # Bx160x6x6 -> Bx256x6x6
            nn.BatchNorm2d(256),
            nn.ELU(),
            nn.ConvTranspose2d(256, 256, 3,2,0, bias=False), # Bx256x6x6 -> Bx256x13x13
            nn.BatchNorm2d(256),
            nn.ELU(),
            Crop([0, 1, 0, 1]),
            nn.ConvTranspose2d(256, 128, 3,1,1, bias=False), # Bx256x12x12 -> Bx128x12x12
            nn.BatchNorm2d(128),
            nn.ELU(),
            nn.ConvTranspose2d(128, 192,  3,1,1, bias=False), # Bx128x12x12 -> Bx192x12x12
            nn.BatchNorm2d(192),
            nn.ELU(),
            nn.ConvTranspose2d(192, 192,  3,2,0, bias=False), # Bx128x12x12 -> Bx192x25x25
            nn.BatchNorm2d(192),
            nn.ELU(),
            Crop([0, 1, 0, 1]),
            nn.ConvTranspose2d(192, 96,  3,1,1, bias=False), # Bx192x24x24 -> Bx96x24x24
            nn.BatchNorm2d(96),
            nn.ELU(),
            nn.ConvTranspose2d(96, 128,  3,1,1, bias=False), # Bx96x24x24 -> Bx128x24x24
            nn.BatchNorm2d(128),
            nn.ELU(),
            nn.ConvTranspose2d(128, 128,  3,2,0, bias=False), # Bx128x24x24 -> Bx128x49x49
            nn.BatchNorm2d(128),
            nn.ELU(),
            Crop([0, 1, 0, 1]),
            nn.ConvTranspose2d(128, 64,  3,1,1, bias=False), # Bx128x48x48 -> Bx64x48x48
            nn.BatchNorm2d(64),
            nn.ELU(),
            nn.ConvTranspose2d(64, 64,  3,1,1, bias=False), # Bx64x48x48 -> Bx64x48x48
            nn.BatchNorm2d(64),
            nn.ELU(),
            nn.ConvTranspose2d(64, 64,  3,2,0, bias=False), # Bx64x48x48 -> Bx64x97x97
            nn.BatchNorm2d(64),
            nn.ELU(),
            Crop([0, 1, 0, 1]),
            nn.ConvTranspose2d(64, 32,  3,1,1, bias=False), # Bx64x96x96 -> Bx32x96x96
            nn.BatchNorm2d(32),
            nn.ELU(),
            nn.ConvTranspose2d(32, channel_num,  3,1,1, bias=False), # Bx32x96x96 -> Bxchx96x96
            nn.Tanh(),
        ]

        self.G_dec_convLayers = nn.Sequential(*G_dec_convLayers)

        self.G_dec_fc = nn.Linear(320+Np+Nz, 320*6*6)

        # 重みは全て N(0, 0.02) で初期化
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                m.weight.data.normal_(0, 0.02)

            elif isinstance(m, nn.ConvTranspose2d):
                m.weight.data.normal_(0, 0.02)

            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.02)



    def forward(self, input, pose, noise):

        x = self.G_enc_convLayers(input) # Bxchx96x96 -> Bx320x1x1

        x = x.view(-1,320)

        self.features = x

        x = torch.cat([x, pose, noise], 1)  # Bx320 -> B x (320+Np+Nz)

        x = self.G_dec_fc(x) # B x (320+Np+Nz) -> B x (320x6x6)

        x = x.view(-1, 320, 6, 6) # B x (320x6x6) -> B x 320 x 6 x 6

        x = self.G_dec_convLayers(x) #  B x 320 x 6 x 6 -> Bxchx96x96

        return x

看到G_dec_convLayers 这个列表中，有crop这个类，是用来截去特征图的，丢弃map的最后一行和最后一列。为啥要这样做呢？这是因为nn.convTranspose2d这个类的forward输出的结果导致的。

我们想想，转置卷积（反卷积）的目的是扩大特征图，扩大的倍数是往往是两倍，那么就是说扩大的特征图总是2的倍数。

可是卷积过程就不是这样了。比如说，map尺寸为15或者14，stride为2的卷积，且用same方式，都能得到7的map。

那对应的转置卷积，到底要输出14的map，还是输出15的map呢？答案是15，但如果此时对应的卷积过程的输入时14呢？

我们上面看到的decoder过程恰恰就属于上面的情况，所以crop一下，去掉一个像素单位的边。

损失函数

loss_criterion = nn.CrossEntropyLoss()
loss_criterion_gan = nn.BCEWithLogitsLoss()

一个是标准交叉熵，另一个是二类交叉熵。

            batch_ones_label = t.ones(conf.batch_size)  # 真偽判別用のラベル
            batch_zeros_label = t.zeros(conf.batch_size)

            fixed_noise = t.FloatTensor(
                np.random.uniform(-1, 1, (conf.batch_size, conf.nz)))
            tmp = t.LongTensor(np.random.randint(conf.np, size=conf.batch_size))
            pose_code = one_hot(tmp, conf.np)  # Condition 付に使用
            pose_code_label = t.LongTensor(tmp)  # CrossEntropy 誤差に使用

前两行分别是真实样本和假样本的真假标签。

fixed_noise 就是论文中提到的 noise z。

tmp只是为了获得下面的pose code，是独热编码，就是把离散的pose当做分类问题。

下面是D的损失函数：

    L_id    = loss_criterion(real_output[:, :Nd], batch_id_label)
    L_gan   = loss_criterion_gan(real_output[:, Nd], batch_ones_label) + loss_criterion_gan(syn_output[:, Nd], batch_zeros_label)
    L_pose  = loss_criterion(real_output[:, Nd+1:], batch_pose_label)

    d_loss = L_gan + L_id + L_pose

real_output就是真实样本送进D的输出，是一个Nd+1+Np维向量。D是要把真实样本分到前Nd个位置代表的类中，这就是第一行为啥这么写。和论文中损失函数也是对应的。

D还要把假样本分到第Nd+1的位置对应的类上，就是第二行做的事情，将真样本都当做正样本，把假样本都当做负样本。是二分类问题，所有使用的是二类交叉熵。

D还要把真样本的pose分类对，就是第三行做的事情。

这么一解释，G的损失函数相信看代码就明白了。

 

代码工程下载地址：here

查看reademe文件

咆哮的阿杰
关注
  • 6
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
生成对抗网络GANs（笔记一）主线
qq_21210467的博客
08-19 1万+
生成式对抗网络（Generative Adversarial Nets, GAN） 一、发展历程： 最开始接触GANs是因为想了解有关于在少量数据的情况下如何做数据增广。然后就了解到了DCGAN生成手写数字的案例，简直是惊为天人，然今才逐渐开始了解生成对抗网络的思想。到了后来一直想用生成对抗网络的思想做语音识别和语音合成这一方面，一直找到合适的资料。再后来，鬼使神差的想结合GANs来做毕业论文...
GAN相关模型和论文
A1_abc的博客
11-12 3792
以下是来自该作者的 github上 整理的部分论文， 具体在此https://github.com/hindupuravinash/the-gan-zoo 3D-ED-GAN - 使用3D生成对抗网络和循环卷积网络进行形状修复 3D-GAN - 通过3D生成 - 对抗建模（github）学习对象形状的概率潜在空间 3D-IWGAN - 用于3D对象生成和重建的改进的对抗系统（github） 3...
DragGAN图像生成原理与实现
weixin_42010722的博客
05-30 3232
深度生成模型，如生成对抗网络（GANs），在合成逼真图像方面取得了重大进展。然而，在实际应用中，对合成图像内容的可控性是一个关键需求。为了满足用户的多样化需求，理想的可控图像合成方法应该具备灵活性、精确性和普适性。先前的方法只能满足其中一些特性，因此我们的目标是在本研究中实现所有这些特性。先前的方法通常通过3D模型或依赖手动注释数据的监督学习来实现对GANs的可控性。然而，这些方法无法推广到新的对象类别，且在编辑过程中缺乏精确控制。
Dr-Gan源码-Pytorch
02-15
查看reademe，是DR-Gan的代码实现。采用CFPdataset
生成对抗网络——GAN（代码+理解）
最新发布
CXDNW的博客
06-17 2799
一、GAN模型介绍GAN，全称 Generative Adversarial Network，即生成对抗网络，是一种基于 对抗学习的深度生成模型。该模型由Ian Goodfellow在 2014年 首次提出，并迅速成为 学术界研究的热点，推动了生成模型领域的发展。GAN模型主要由两部分组成：生成器（Generator）和判别器（Discriminator）。，其 输入是 随机噪声，输出则是 生成的样本。。2. 判别器：判别器模型同样。
DR-GAN
05-10
*仍在开发中，尚未检查此隐含的结果（2017/9/25） 作者：栾T，尹锡，刘晓明 CVPR2017： ：//cvlab.cse.msu.edu/pdfs/Tran_Yin_Liu_CVPR2017.pdf DR-GAN的Pytorch含义（“通过旋转脸来进行表示学习”中的更新版本） 由提供支持 要求 python 3.6 pytorch 0.2.0 numpy的1.13.1 scipy 0.18.1 matplotlib 2.0.0 如何使用 单图像DR-GAN 修改main.py的DataLoader函数以定义适用于您的数据的dataloader 数据需要具有ID，并且姿势标签对应于每个图像 如果没有，则使用“ -random”选项可以查看代码如何处理无意义的随机数据。 python main.py-随机 运行main.py训练模型 训练有素的模型和Loss_lo
DR-GAN (CVPR 2017, Disentangled Representation Learning GAN for Pose-Invariant Face Recognition)
便纵有千种风情
01-07 734
Text to image论文精读DR-GAN：分布正则化的生成对抗网络 Distribution-Regularization-for-Text-to-Image-Generation
白洞，白色的明天在等着我们
12-16 3023
DR-GAN是北京理工大学者和大连理工大学学于2022年4月提出的一种新的文本到图像生成模型，称为分布正则化生成对抗网络（Distribution-Regularization-for-Text-to-Image-Generation，DR-GAN）
DR-GAN：Disentangled Representation Learning GAN for Pose-Invariant Face Recognition论文解读
我的博客有点东西
02-15 7571
写在之前：初看这篇论文，觉得很惊艳，很巧妙，非常值得细读和动手实践，本人调通的Pytorch代码也会在后面详解。 另一篇更具有新颖性的人脸特征变换的论文是FaceID-GAN。附我的FaceID-GAN论文解读 摘要 在人脸识别领域，两张脸之间的大角度差异是一个关键的挑战。。论文提出一种能学到一种和姿势无关的人脸特征，将脸部的pose信息从特征中分离出去，这样用于人脸识别的特征提取就能适用于...
多身份人脸重现使用CrossID-GAN网络
在本文中，我们提出了一个独特的CrossID-GAN网络来执行多ID人脸重现。给定具有提取的面部地标的监督和无监督设置都被提出来训练和指导我们的模型。我们的定性/定量结果证实了我们的模型的鲁棒性和有效性，消
"Dr-Net：学习图像先验和数据保真度的盲反卷积方法
在本文中，我们提出了一种称为Dr-Net的方法，该方法不需要任何这样的估计，并且还能够在盲图像恢复任务中反转模糊的影响。这些图像恢复问题通常有两个术语，数据保真度术语（用于忠实重建）和图像先验（用于逼真的...
DR-GAN-Tran_Yin_Liu_CVPR2017.pdf
06-17
DR-GAN，生成器的编解码结构允许DR-GAN在图像生成的同时学习一种具有生成性和判别性的表示法。第二，通过提供给解码器的姿态码和判别器中的姿态估计，显式地将该表示法与其他人脸变化(例如：姿态)分离。第三，DR-GAN可以将一幅或多幅图像作为输入，并与任意数量的合成图像一起生成一个统一的表示。对受控数据库和野生数据库的定量和定性评价证明了DR-GAN先进的优势。
论文笔记（一）【 Disentangled Representation Learning GAN for Pose-Invariant Face Recognition】
热门推荐
daydayjump的博客
07-07 1万+
论文地址：论文 大体分为两部分，第一部分是自己读文章时的记录，第二部分是自己总的感想。 一、论文概述： 1、在摘要中提出了DR-GAN的名字，给出了论文的三个创新点。 （1）通过generator 的encoder-decoder框架学习了生成和判别的表示（representation）； （2）这种表示是从姿态这种人脸变量得出。姿态（pose）代码传输到decoder，姿态的估计（es...
DR-GAN: Distribution Regularization for Text-to-Image Generation 笔记
qq_44381060的博客
04-13 337
这篇 paper 提出了一个新的文本生成图像模型-分布正则化生成网络（DR-GAN）。在 DR-GAN 中，包含了两个新的模块：语义解开模块（SDM）和分布正则化模块（DNM）。SDM 包含空间自注意机制和一个新的语义解开损失（SDL），SDL 能帮助生成器在图片生成阶段提取关键的语义信息。DNM 使用变分自动编码（VAE）对图像潜在分布正则化和去噪，则还能帮助生成器更好的区分生成图像和真实图像。DNM 也采用了分布生成损失（DAL）去指导生成器通过正则化去对齐潜在空间中真实图像的分布。
【深度学习】DragGAN
richard_yuu的博客
04-21 770
DragGAN作为一种基于StyleGAN的图像拖拽编辑方法，为用户提供了一种直观、易用的图像编辑方式。通过优化StyleGAN中的风格信息w latent Code，DragGAN能够实现对图像的精确控制，同时保持图像的整体风格和结构不变。未来，随着深度学习技术的不断发展，我们可以期待DragGAN在图像编辑领域发挥更大的作用，为用户带来更加丰富的创作体验。
AI修图工具DragGAN
jinke2010_happy的博客
08-17 350
DragGAN 是一种基于生成对抗网络（GAN）的人工智能模型，旨在实现照片主体的形状、神态、位置和大小的变化。DragGAN 可以对图像进行编辑和转换，使用户能够通过拖动操作来修改图像中的特定区域。
DragGAN 是什么
AI生成式技术曾小健
05-27 1255
DragGAN 使用了一种创新的交互式编辑方法，仅需在图片上点击控制点和目标点，系统就会根据你的需求完成图片的修改。DragGAN 的最大特点在于它的灵活性，可以调整很多不同的特征，比如位置、形状、姿势等等。除此之外，DragGAN的精度十分高，你能够非常精确地调整各种不同的特征，真正实现完美无缺的效果。最后是它的通用性，不仅适用于不同类型的对象，而且能够满足各种不同的用户需求。简单来说，它能够让你轻松掌控图片中的人物和动物，通过拖拽控制点和目标点来调整他们的位置、形状、姿势等等。s）技术的图片编辑项目。
DragGAN:interactive point-based manipulation on the generative image manifold
liguandong
05-26 1180
DragGAN主要还是应用于图像编辑领域，在图像编辑领域之前有代表性的可控生成的作品包括editgan和styleclip，前者是通过分割图去定点控制生成图，后者是通过文本来实现控制，DragGAN将控制的方式变成了人工交互，通过点移动的方式，draggan的理论框架：点在图像空间中的移动对应于GAN的潜在空间中的移动，利用这一观察结果，制定了一个优化问题，旨在最小化用户输入和生成的图像之间的差异，该优化问题通过一种基于梯度的方法解决，该方法调整GAN的latent code以匹配用户的输入。
推荐深度学习新星：DragGAN - 拖拽式图像生成与编辑
gitblog_00018的博客
03-19 403
推荐深度学习新星：DragGAN - 拖拽式图像生成与编辑 项目地址:https://gitcode.com/XingangPan/DragGAN 在数字艺术和计算机视觉领域，人工智能已经扮演了重要角色。近期，由Xingang Pan开发的开源项目DragGAN引起了广泛关注。这个项目利用先进的生成对抗网络（GAN）技术，让用户可以通过简单的拖拽操作对图像进行实时编辑，为AI辅助创作带来了革命性的...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值