DR-GAN代码实现记录

最新推荐文章于 2024-08-16 18:25:52 发布
最新推荐文章于 2024-08-16 18:25:52 发布
阅读量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文件

咆哮的阿杰
关注
专栏目录
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
DragGAN图像生成原理与实现
weixin_42010722的博客
05-30 3253
深度生成模型，如生成对抗网络（GANs），在合成逼真图像方面取得了重大进展。然而，在实际应用中，对合成图像内容的可控性是一个关键需求。为了满足用户的多样化需求，理想的可控图像合成方法应该具备灵活性、精确性和普适性。先前的方法只能满足其中一些特性，因此我们的目标是在本研究中实现所有这些特性。先前的方法通常通过3D模型或依赖手动注释数据的监督学习来实现对GANs的可控性。然而，这些方法无法推广到新的对象类别，且在编辑过程中缺乏精确控制。
2024年-火爆全网的DragGAN 最新图片编辑项目超基础教学
最新发布
php源码
08-16 426
第二部分是新的点跟踪方法，即最近邻检索，通过在相同的特征空间上进行点跟踪，提高了效率，并避免了累计误差损失。很多人都以为这个项目能直接选一张照片，就能像 PS 一样进行 P 图了，其实并不是，至少目前还不支持，上面你看到的这些图片都是经过训练而生成的模型，所以本质上，你是在操作一个模型，而非图片！安装过程，真是一把鼻涕一把泪，到处都是坑，先是在阿里 PAI 平台栽跟头，折腾好久才发现是基础环境问题，后来又在安装方法上翻了车，官方的安装指导也是各种报错。
DR-GAN：Disentangled Representation Learning GAN for Pose-Invariant Face Recognition论文解读
我的博客有点东西
02-15 7591
写在之前：初看这篇论文，觉得很惊艳，很巧妙，非常值得细读和动手实践，本人调通的Pytorch代码也会在后面详解。 另一篇更具有新颖性的人脸特征变换的论文是FaceID-GAN。附我的FaceID-GAN论文解读 摘要 在人脸识别领域，两张脸之间的大角度差异是一个关键的挑战。。论文提出一种能学到一种和姿势无关的人脸特征，将脸部的pose信息从特征中分离出去，这样用于人脸识别的特征提取就能适用于...
Text to image论文精读DR-GAN：分布正则化的生成对抗网络 Distribution-Regularization-for-Text-to-Image-Generation
白洞，白色的明天在等着我们
12-16 3067
DR-GAN是北京理工大学者和大连理工大学学于2022年4月提出的一种新的文本到图像生成模型，称为分布正则化生成对抗网络（Distribution-Regularization-for-Text-to-Image-Generation，DR-GAN）
DragGAN：简介，安装，使用！
s_develop的博客
08-21 2119
当然，你懂代码话，也可以把默认的改成狗子模型，那么不用去下载另外的模型了。为了让不同项目，互不影响。看别人的动态图，可能期待值拉的很满，但是，要明白一点，卖家秀和买家秀肯定不一样的。至少，这个项目把StyleGAN的使用可视化了，而且可以快速接入各种各样的模型，有能力的也可以自己训练模型.... 如果你有这财力的话...记得用1024x1024的模型，有些图片也是有明显缺陷的，有些看起来还不错。写文章的时候，发现已经更新了一个叫download_model.bat的文件，可以直接运行这个文件来下载模型。
DR-GAN: Distribution Regularization for Text-to-Image Generation 笔记
qq_44381060的博客
04-13 345
这篇 paper 提出了一个新的文本生成图像模型-分布正则化生成网络（DR-GAN）。在 DR-GAN 中，包含了两个新的模块：语义解开模块（SDM）和分布正则化模块（DNM）。SDM 包含空间自注意机制和一个新的语义解开损失（SDL），SDL 能帮助生成器在图片生成阶段提取关键的语义信息。DNM 使用变分自动编码（VAE）对图像潜在分布正则化和去噪，则还能帮助生成器更好的区分生成图像和真实图像。DNM 也采用了分布生成损失（DAL）去指导生成器通过正则化去对齐潜在空间中真实图像的分布。
Dr-Gan源码-Pytorch
02-15
查看reademe，是DR-Gan的代码实现。采用CFPdataset
DR-GAN-Tran_Yin_Liu_CVPR2017.pdf
06-17
DR-GAN，生成器的编解码结构允许DR-GAN在图像生成的同时学习一种具有生成性和判别性的表示法。第二，通过提供给解码器的姿态码和判别器中的姿态估计，显式地将该表示法与其他人脸变化(例如：姿态)分离。第三，DR-GAN...
Disentangled Representation Learning GAN for Pose-Invariant Face Recognition
09-16
本文介绍了一篇发表于2017年IEEE计算机视觉与模式识别会议（CVPR）的论文，文章的主要贡献是提出了一种新颖的生成对抗网络（GAN）架构——Disentangled Representation Learning GAN（简称DR-GAN），用于实现不受...
扫描仪驱动 dr-2010c
08-16
dr-2010c
DragGAN开源！图像编辑迎来革命性突破！
入门笔记
07-06 1492
DragGAN开源，文章末尾有部署链接和整合包链接。
《基于深度残差生成对抗网络的医学影像超分辨率算法》---论文笔记
weixin_43350614的博客
01-14 6024
本文的创新点：本文在最新的 SＲGAN 基础上，通过使用缩放卷积、去掉批量规范化层(Batch-Normalization，BN)、增加特征图数量、加深网络等对 SＲGAN 作出改进，提出了基于深度残差生成对抗网络(Deep Ｒesidual Generative Adversarial Network，DＲ-GAN)的医学影像超分辨率算法，来达到对医学影像放大 2倍后仍然保留较多的纹理和细节特征...
【图像&三维编辑】DragGAN与Drag3D（原理＋代码）
qq_45752541的博客
07-05 2389
合成满足用户需求的视觉内容通常需要对生成对象的姿态、形状、表达和布局的灵活和精确的可控性。“拖动”图像中的任何点，精确修改图像到目标点。它由两个主要组件组成1)一种基于特征的运动监督，驱动手柄点向目标位置移动；2)一种新的点跟踪方法，利用鉴别生成器特性来保持定位手柄点的位置。DragGAN可以使图像变形，精确控制像素的位置，从而操纵不同类别的姿态、形状、表达和布局，如动物、汽车、人、景观等。
DragGAN 是什么
AI生成式技术曾小健
05-27 1275
DragGAN 使用了一种创新的交互式编辑方法，仅需在图片上点击控制点和目标点，系统就会根据你的需求完成图片的修改。DragGAN 的最大特点在于它的灵活性，可以调整很多不同的特征，比如位置、形状、姿势等等。除此之外，DragGAN的精度十分高，你能够非常精确地调整各种不同的特征，真正实现完美无缺的效果。最后是它的通用性，不仅适用于不同类型的对象，而且能够满足各种不同的用户需求。简单来说，它能够让你轻松掌控图片中的人物和动物，通过拖拽控制点和目标点来调整他们的位置、形状、姿势等等。s）技术的图片编辑项目。
GragGAN：人工智能黑科技，本地使用详细教程
weixin_69464118的博客
06-06 4960
DragGAN是一种由Max Planck研究所开发的创新型人工智能工具，通过仅需几个点击和拖动操作，能够实现对照片的真实修改。根据一篇研究论文，该工具主要包括两个要素：基于特征的运动监控和一种革命性的点追踪技术。DragGAN赋予用户交互性，使其能够自主拖动图片中的点，并将其移动至所选择的目标位置。通过基于特征的运动监控，用户可以精确地调整处理点的位置，从而完全掌控图片修改的过程。此外，点追踪技术确保在整个编辑过程中准确地跟踪处理点的位置。DragGAN超越了传统图片编辑软件的功能范畴。
华人一作DragGAN爆火！拖动你的GAN：交互式图像编辑新高度
阿木寺的博客
05-20 2875
点击下方卡片，关注“CVer”公众号AI/CV重磅干货，第一时间送达点击进入—>【GAN和扩散模型】微信技术交流群转载自：机器之心 |编辑：蛋酱、小舟如果甲方想把大象 P 转身，你只需要拖动 GAN 就好了。在图像生成领域，以 Stable Diffusion 为代表的扩散模型已然成为当前占据主导地位的范式。但扩散模型依赖于迭代推理，这是一把双刃剑，因为迭代方法可以实现具有简单目标的稳定训...
超炫酷项目来袭！DragGAN 正式开源了！
程序员树先生的博客
06-30 366
之前树先生给大家介绍过一个项目 DragGAN，现在正式开源了！那还等什么，盘它！
【深度学习】AI修图——DragGAN原理解析
sdksdf的博客
04-15 1755
上一篇，我们讲述了StyleGAN2。这一篇，我们就来讲一个把StyleGAN2作为基底架构的DragGAN。DragGAN的作用主要是对图片进行编辑，说厉害点，可能和AI修图差不多。这篇论文比较新，发表自2023年参考代码：https://github.com/skimai/DragGANAI修图——DragGAN原理解析-哔哩哔哩演示（随意选择红点，让红点对应位置的像素移动到蓝点）：demo。
TASCAM DR-05录音笔2.0菜单操作指南
TASCAM DR-05是一款专业级的录音设备，适用于音乐制作、采访、会议记录等多种场合。这款录音笔的操作菜单设计得相当直观，方便用户进行各种设置和控制。 1. 部件功能介绍： - PEAK峰值指示灯：当录音信号超过设定...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值