【图像生成】(二) GAN 原理 & pytorch代码实例

已于 2024-01-15 18:46:22 修改
阅读量5.5k 收藏 64
点赞数 12
CC 4.0 BY-SA版权
分类专栏： 深度学习 图像生成 机器视觉 文章标签： pytorch 人工智能 gan stable diffusion AIGC
于 2023-08-07 10:16:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Lizhi_Tech/article/details/132108893

1.简介

上一篇文章里我们介绍了【图像生成】的几种模型以及最直观的DNN的代码和效果，当然可以看出来不足的地方。这篇文章里主要介绍GAN模型的原理，以及它是怎么解决以上问题的。

2.原理

之前DNN的最大问题在于损失计算方法，如果用MSE计算loss的话生成图片将会失去随机性。那么有没有一种损失计算方法，又可以去确保生成图像的真实性，又可以确保生成图像的随机性呢？

GAN提出了这样一种方法，还是用之前的DNN来生成图像（生成器），然后让另外一个额外的DNN网络输入图片（判别器），去判断这张图片是否是真实的还是生成的（输出概率）。

怎么训练生成器和判别器可以使得生成器生成和真实图像相似的虚假图像呢？判别器的训练很好理解，把真实和虚假图像输入去训练就可以，但生成器的训练很难实现，因为它本身的输出（图像）没法与标签直接产生联系，而是需要输入进判别器后得到一个反馈才行。所以生成器的训练会很大程度上受到判别器的制约，这也是为什么GAN训练不稳定的原因。

根据以上不严谨的理解，我们可以大致得到一个pipeline：

用什么loss训练呢？这个还是需要严谨的推导。

总体来说，我们需要用生成器生成图片，生成图片的分布需要和原始数据集相似，可以表示为P_{G}(x;\theta )，那么似然函数也就是L=\prod_{i=1}^{N}P_{G}(x_{i};\theta )，现在我们要做的是根据x_{i}的分布来找到最大化L的\theta：

\begin{aligned} \theta ^{*}&=argmax_{\theta }\prod_{i=1}^{N}P_{G}(x_{i};\theta ) \\&=argmax_{\theta }log\prod_{i=1}^{N}P_{G}(x_{i};\theta ) \\& \approx argmax_{\theta }E_{x}\sim P_{data}[logP_{G}(x_{i};\theta)] \\&=argmax_{\theta }\int_{x}^{}P_{data}(x)logP_{G}(x;\theta )-\int_{x}^{}P_{data}(x)logP_{data}(x;\theta ) \\&=argmin_{\theta }\int_{x}^{}P_{data}(x)log\frac{P_{data}(x)}{P_{G}(x;\theta )}dx \\&=argmin_{\theta }KL(P_{data}(x)||P_{G}(x;\theta )) \end{aligned}

总体来说就是将log似然的期望转换为积分运算，或者直接理解成最小化两个分布的KL散度，也就是相对熵。这个其实是表达generator生成数据和原始数据的相似性，但是我们要通过discriminator来进行表达。具体的loss表现为：

max_{D}\int_{x}^{}P_{data}(x)logD(x)+P_{G}(x)log(1-D(x))dx

简单点说就是想要真实数据输入进D之后预测为1，虚假数据输入进D之后预测为0。对上式进行求导后发现D=\frac{P_{data}}{P_{data}+P_{G}}，所以最优情况下两个概率分布相等，discriminator输出为0.5为最优。

3.代码

OK，接下来我们就用pytorch来实现GAN在MNIST数据集上的生成。需要注意的是数据集和推理部分和之前DNN的没有区别，因此不再着重描述，主要对模型和训练方法上进行说明。

3.1模型

我们在之前只有Generator的基础上加上了Discriminator，两个模型都采用了简单的全连接层和卷积层/反卷积层结构。

class Generator(nn.Module):
    def __init__(self, input_dim=100, output_dim=1, class_num=10):
        '''
        初始化生成网络
        :param input_dim:输入维度，也是latent维度
        :param output_dim:输出维度，表示最终生成图片的通道数
        :param class_num:图像种类，代表condition种类
        '''
        super(Generator, self).__init__()
        # 网络的输入是latent的维度拼接上condition向量的维度
        self.input_dim = input_dim + class_num
        self.output_dim = output_dim

        self.fc = nn.Sequential(
            nn.Linear(self.input_dim, 1024),
            nn.BatchNorm1d(1024),
            nn.ReLU(),
            nn.Linear(1024, 128 * 7 * 7),
            nn.BatchNorm1d(128 * 7 * 7),
            nn.ReLU(),
        )
        self.deconv = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.ConvTranspose2d(64, self.output_dim, 4, 2, 1),
            nn.Tanh(),
        )

    def forward(self, input):
        x = self.fc(input)
        x = x.view(-1, 128, 7, 7)
        x = self.deconv(x)
        return x

class Discriminator(nn.Module):
    def __init__(self, input_dim=1, output_dim=1):
        '''
        初始化判别网络
        :param input_dim:输入通道数
        :param output_dim:输出通道数
        '''
        super(Discriminator, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim

        self.conv = nn.Sequential(
            nn.Conv2d(self.input_dim, 64, 4, 2, 1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2),
        )
        self.fc = nn.Sequential(
            nn.Linear(128 * 7 * 7, 1024),
            nn.BatchNorm1d(1024),
            nn.LeakyReLU(0.2),
            nn.Linear(1024, self.output_dim),
            nn.Sigmoid(),
        )

    def forward(self, input):
        x = self.conv(input)
        x = x.view(-1, 128 * 7 * 7)
        x = self.fc(x)

        return x

3.3训练

训练时对D和G分别更新，对D更新需要计算

    def train(self):
        print('训练开始!!')
        for epoch in range(self.epoch):
            self.G.train()
            self.D.train()
            loss_mean_G = 0
            loss_mean_D = 0
            for i, (images, labels) in enumerate(self.train_dataloader):
                # 生成对应batch和维度的latent
                z = torch.rand((self.batch_size, self.z_dim)).to(self.device)
                images, labels = images.to(self.device), labels.to(self.device)

                ### 更新D ###
                self.optimizerD.zero_grad()
                # 真实图像输入D
                D_real = self.D(images)
                D_real_loss = self.loss(D_real, self.y_real)
                # 虚假图像输入D
                images_fake = self.G(z)
                D_fake = self.D(images_fake)
                D_fake_loss = self.loss(D_fake, self.y_fake)
                # 整合并更新
                D_loss = D_real_loss + D_fake_loss
                D_loss.backward()
                self.optimizerD.step()
                loss_mean_D += D_loss.item()

                ### 更新G ###
                self.optimizerG.zero_grad()
                # 虚假图像输入D
                images_fake = self.G(z)
                D_fake = self.D(images_fake)
                # G想要D认为虚假图像是真的，所以与y_real做loss
                G_loss = self.loss(D_fake, self.y_real)
                # 更新
                G_loss.backward()
                self.optimizerG.step()
                loss_mean_G += G_loss.item()

            train_loss_G = loss_mean_G / len(self.train_dataloader)
            train_loss_D = loss_mean_D / len(self.train_dataloader)
            print('epoch:{}, training loss G:{:.4f}, loss D:{:.4f}'.format(
                epoch, train_loss_G,train_loss_D))
            self.visualize_results(epoch)

3.4推理&可视化

最后我们使用训练好的模型进行推理和可视化。噪声我们使用了固定的随机噪声，最后生成的结果如下：

 可以看到结果并不好，训练的时候G的loss也在不断上升，这就是GAN训练不稳定造成的。

4. Wasserstein改进及代码实现

GAN训练不稳定的根本原因是什么呢？我们之前得到了完美情况下的判别器的表达为D=\frac{P_{data}}{P_{data}+P_{G}}，把这个式子带入loss表达式可以写成：

2JS(P_{data}||P_{G})-2log_{2}

这种情况下，就完全依赖与两个概率分布的JS散度，JS散度表示两个分布的相似性。我们通过训练可以将两个分布不断地拉近，最终让P_{data}==P_{G}。但是当两个概率分布完全没有交集时，JS散度为0，公式就变成了-2log_{2}，因此梯度为0，无法更新。

Wasserstein用类似于“推土机”的方式将两个分布拉近，从而让它们有更多交集。具体的推导公式太过复杂（其实也没怎么看懂）就不在这里细述，感兴趣的可以参考这篇文章：令人拍案叫绝的Wasserstein GAN - 知乎 (zhihu.com)

总结下来其实Wasserstein相比于GAN只改进了4个点：

  • 判别器最后一层去掉sigmoid
  • 生成器和判别器的loss不取log
  • 每次更新判别器的参数之后把它们的绝对值截断到不超过一个固定常数c
  • 不要用基于动量的优化算法（包括momentum和Adam），推荐RMSProp，SGD也行

我们基于这4点对代码进行改动：

4.1 判别器

这里把判别器最后一层的Sigmoid去掉，意味着我们不再把输出范围限制在0-1，而是负无穷到正无穷。越接近正无穷表示输入图像越真实，越接近负无穷表示输入图像越虚假。


class Discriminator(nn.Module):
    def __init__(self, input_dim=1, output_dim=1):
        '''
        初始化判别网络
        :param input_dim:输入通道数
        :param output_dim:输出通道数
        '''
        super(Discriminator, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim

        self.conv = nn.Sequential(
            nn.Conv2d(self.input_dim, 64, 4, 2, 1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2),
        )
        self.fc = nn.Sequential(
            nn.Linear(128 * 7 * 7, 1024),
            nn.BatchNorm1d(1024),
            nn.LeakyReLU(0.2),
            nn.Linear(1024, self.output_dim),
            # nn.Sigmoid(),
        )

    def forward(self, input):
        x = self.conv(input)
        x = x.view(-1, 128 * 7 * 7)
        x = self.fc(x)

        return x

4.2 loss

由于判别器的输出范围改变，我们也改变了loss的计算方式，用单纯的输出大小来表示loss，从而满足越接近正无穷表示输入图像越真实，越接近负无穷表示输入图像越虚假的条件。

### 判别器更新 ### 
# 真实图像输入D
D_real = self.D(images)
# 想要真实图像的D输出尽可能大
D_real_loss = -torch.mean(D_real)
# 虚假图像输入D
images_fake = self.G(z)
D_fake = self.D(images_fake)
# 想要虚假图像的D输出尽可能小
D_fake_loss = torch.mean(D_fake)
### 生成器更新 ### 
# 虚假图像输入D
images_fake = self.G(z)
D_fake = self.D(images_fake)
# 想要虚假图像的D输出尽可能大
G_loss = -torch.mean(D_fake)

4.3 参数截断

按照论文设置的c=0.01对判别器参数进行截断

for p in self.D.parameters():
    p.data.clamp_(-self.c, self.c)

4.4 判别器

优化器改为非动量优化器

self.optimizerG = optim.RMSprop(self.G.parameters(), lr=self.lr)
self.optimizerD = optim.RMSprop(self.D.parameters(), lr=self.lr)

4.5 完整代码及结果

以下是完整的Wasserstein GAN代码及结果：

import torch, time, os
import numpy as np
import torch.nn as nn
import torch.optim as optim
from torchvision.datasets import MNIST
from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image
import torch.nn.functional as F


class Generator(nn.Module):
    def __init__(self, input_dim=100, output_dim=1, class_num=10):
        '''
        初始化生成网络
        :param input_dim:输入维度，也是latent维度
        :param output_dim:输出维度，表示最终生成图片的通道数
        :param class_num:图像种类，代表condition种类
        '''
        super(Generator, self).__init__()
        # 网络的输入是latent的维度拼接上condition向量的维度
        self.input_dim = input_dim + class_num
        self.output_dim = output_dim

        self.fc = nn.Sequential(
            nn.Linear(self.input_dim, 1024),
            nn.BatchNorm1d(1024),
            nn.ReLU(),
            nn.Linear(1024, 128 * 7 * 7),
            nn.BatchNorm1d(128 * 7 * 7),
            nn.ReLU(),
        )
        self.deconv = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.ConvTranspose2d(64, self.output_dim, 4, 2, 1),
            nn.Tanh(),
        )

    def forward(self, input):
        x = self.fc(input)
        x = x.view(-1, 128, 7, 7)
        x = self.deconv(x)
        return x

class Discriminator(nn.Module):
    def __init__(self, input_dim=1, output_dim=1):
        '''
        初始化判别网络
        :param input_dim:输入通道数
        :param output_dim:输出通道数
        '''
        super(Discriminator, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim

        self.conv = nn.Sequential(
            nn.Conv2d(self.input_dim, 64, 4, 2, 1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2),
        )
        self.fc = nn.Sequential(
            nn.Linear(128 * 7 * 7, 1024),
            nn.BatchNorm1d(1024),
            nn.LeakyReLU(0.2),
            nn.Linear(1024, self.output_dim),
            # nn.Sigmoid(),
        )

    def forward(self, input):
        x = self.conv(input)
        x = x.view(-1, 128 * 7 * 7)
        x = self.fc(x)

        return x

class ImageGenerator(object):
    def __init__(self):
        '''
        初始化，定义超参数、数据集、网络结构等
        '''
        self.epoch = 50
        self.sample_num = 100
        self.batch_size = 64
        self.z_dim = 100
        self.lr = 0.0002
        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        self.init_dataloader()
        self.G = Generator(input_dim=self.z_dim, output_dim=self.output_dim, class_num=0).to(self.device)
        self.D = Discriminator(input_dim=self.output_dim, output_dim=1).to(self.device)
        self.initialize_weights(self.G)
        self.initialize_weights(self.D)
        self.optimizerG = optim.RMSprop(self.G.parameters(), lr=self.lr)
        self.optimizerD = optim.RMSprop(self.D.parameters(), lr=self.lr)
        self.c = 0.01
        self.n_critic = 5
        self.fixed_z = torch.rand((self.sample_num, self.z_dim)).to(self.device)


    def initialize_weights(self, net):
        for m in net.modules():
            if isinstance(m, nn.Conv2d):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
            elif isinstance(m, nn.ConvTranspose2d):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
    def init_dataloader(self):
        '''
        初始化数据集和dataloader
        '''
        tf = transforms.Compose([
            transforms.ToTensor(),
            # transforms.Normalize((0.1307,), (0.3081,))
        ])
        train_dataset = MNIST('./data/',
                              train=True,
                              download=True,
                              transform=tf)
        self.train_dataloader = DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True)
        val_dataset = MNIST('./data/',
                            train=False,
                            download=True,
                            transform=tf)
        self.val_dataloader = DataLoader(val_dataset, batch_size=self.batch_size, shuffle=False, drop_last=True)
        self.output_dim = self.train_dataloader.__iter__().__next__()[0].shape[1]

    def train(self):
        print('训练开始!!')
        for epoch in range(self.epoch):
            self.G.train()
            self.D.train()
            loss_mean_G = 0
            loss_mean_D = 0
            for i, (images, labels) in enumerate(self.train_dataloader):
                # 生成对应batch和维度的latent
                z = torch.rand((self.batch_size, self.z_dim)).to(self.device)
                images, labels = images.to(self.device), labels.to(self.device)

                ### 更新D ###
                self.optimizerD.zero_grad()
                # 真实图像输入D
                D_real = self.D(images)
                # 想要真实图像的D输出尽可能大
                D_real_loss = -torch.mean(D_real)
                # 虚假图像输入D
                images_fake = self.G(z)
                D_fake = self.D(images_fake)
                # 想要虚假图像的D输出尽可能小
                D_fake_loss = torch.mean(D_fake)

                # 整合并更新
                D_loss = D_real_loss + D_fake_loss
                D_loss.backward()
                self.optimizerD.step()
                loss_mean_D += D_loss.item()
                # 截断
                for p in self.D.parameters():
                    p.data.clamp_(-self.c, self.c)
                ### 更新G ###
                # 每隔一定间隔再更新G
                if (i+1) % self.n_critic == 0:
                    self.optimizerG.zero_grad()
                    # 虚假图像输入D
                    images_fake = self.G(z)
                    D_fake = self.D(images_fake)
                    # 想要虚假图像的D输出尽可能大
                    G_loss = -torch.mean(D_fake)
                    # 更新
                    G_loss.backward()
                    self.optimizerG.step()
                    loss_mean_G += G_loss.item()

            train_loss_G = loss_mean_G / len(self.train_dataloader) * self.n_critic
            train_loss_D = loss_mean_D / len(self.train_dataloader)
            print('epoch:{}, training loss G:{:.4f}, loss D:{:.4f}'.format(
                epoch, train_loss_G,train_loss_D))
            self.visualize_results(epoch)

    @torch.no_grad()
    def visualize_results(self, epoch):
        self.G.eval()
        # 保存结果路径
        output_path = 'results/GAN'
        if not os.path.exists(output_path):
            os.makedirs(output_path)

        tot_num_samples = self.sample_num
        image_frame_dim = int(np.floor(np.sqrt(tot_num_samples)))

        z = self.fixed_z

        generated_images = self.G(z)
        # generated_images = (generated_images + 1) / 2
        save_image(generated_images, os.path.join(output_path, '{}.jpg'.format(epoch)), nrow=image_frame_dim)


if __name__ == '__main__':
    generator = ImageGenerator()
    generator.train()

如果训练正常，那么G的loss会是正数，并随着训练不断接近于0，D的loss会是负数，也不断接近于0。这表示判别器越来越分不清生成器生成的虚假图像和真实图像，也就是两个分布越来越接近。

需要注意的是，我们最后没有采用将输出结果(x+1)/2的操作。之所以有这个操作是因为tanh的输出范围是-1到1，所以最终可视化的时候需要将范围调整到0到1，但是经过尝试之后发现调整至0到1之后图像会发白。我分析可能是对真实图像预处理时是将范围调整至0到1而不是-1到1，因此训练使得两个概率分布相似，导致生成器输出的范围也是0到1。

4.5 condition代码及结果

如果我们要生成condition条件下的图像，那么我们按照上一篇DNN的做法，直接把labels进行热编码后与网络输入拼接。注意的是不光生成器，判别器也需要拼接。完整的代码和结果如下：

import torch, time, os
import numpy as np
import torch.nn as nn
import torch.optim as optim
from torchvision.datasets import MNIST
from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image
import torch.nn.functional as F


class Generator(nn.Module):
    def __init__(self, input_dim=100, output_dim=1, class_num=10):
        '''
        初始化生成网络
        :param input_dim:输入维度，也是latent维度
        :param output_dim:输出维度，表示最终生成图片的通道数
        :param class_num:图像种类，代表condition种类
        '''
        super(Generator, self).__init__()
        # 网络的输入是latent的维度拼接上condition向量的维度
        self.input_dim = input_dim + class_num
        self.output_dim = output_dim

        self.fc = nn.Sequential(
            nn.Linear(self.input_dim, 1024),
            nn.BatchNorm1d(1024),
            nn.ReLU(),
            nn.Linear(1024, 128 * 7 * 7),
            nn.BatchNorm1d(128 * 7 * 7),
            nn.ReLU(),
        )
        self.deconv = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.ConvTranspose2d(64, self.output_dim, 4, 2, 1),
            nn.Tanh(),
        )

    def forward(self, input, labels):
        x = torch.cat((input, labels), dim=1)
        x = self.fc(x)
        x = x.view(-1, 128, 7, 7)
        x = self.deconv(x)
        return x

class Discriminator(nn.Module):
    def __init__(self, input_dim=1, output_dim=1, class_num=10):
        '''
        初始化判别网络
        :param input_dim:输入通道数
        :param output_dim:输出通道数
        '''
        super(Discriminator, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim

        self.conv = nn.Sequential(
            nn.Conv2d(self.input_dim, 64, 4, 2, 1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2),
        )
        self.fc = nn.Sequential(
            nn.Linear(128 * 7 * 7 + class_num, 1024),
            nn.BatchNorm1d(1024),
            nn.LeakyReLU(0.2),
            nn.Linear(1024, self.output_dim),
            # nn.Sigmoid(),
        )

    def forward(self, input, labels):
        x = self.conv(input)
        x = x.view(-1, 128 * 7 * 7)
        x = torch.cat((x, labels), dim=1)
        x = self.fc(x)

        return x

class ImageGenerator(object):
    def __init__(self):
        '''
        初始化，定义超参数、数据集、网络结构等
        '''
        self.epoch = 50
        self.sample_num = 100
        self.batch_size = 64
        self.z_dim = 100
        self.lr = 0.0002
        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        self.init_dataloader()
        self.G = Generator(input_dim=self.z_dim, output_dim=self.output_dim, class_num=10).to(self.device)
        self.D = Discriminator(input_dim=self.output_dim, output_dim=1, class_num=10).to(self.device)
        self.initialize_weights(self.G)
        self.initialize_weights(self.D)
        self.optimizerG = optim.RMSprop(self.G.parameters(), lr=self.lr)
        self.optimizerD = optim.RMSprop(self.D.parameters(), lr=self.lr)
        self.c = 0.01
        self.n_critic = 5
        self.fixed_z = torch.rand((self.sample_num, self.z_dim)).to(self.device)


    def initialize_weights(self, net):
        for m in net.modules():
            if isinstance(m, nn.Conv2d):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
            elif isinstance(m, nn.ConvTranspose2d):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.02)
                m.bias.data.zero_()
    def init_dataloader(self):
        '''
        初始化数据集和dataloader
        '''
        tf = transforms.Compose([
            transforms.ToTensor(),
            # transforms.Normalize((0.1307,), (0.3081,))
        ])
        train_dataset = MNIST('./data/',
                              train=True,
                              download=True,
                              transform=tf)
        self.train_dataloader = DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True)
        val_dataset = MNIST('./data/',
                            train=False,
                            download=True,
                            transform=tf)
        self.val_dataloader = DataLoader(val_dataset, batch_size=self.batch_size, shuffle=False, drop_last=True)
        self.output_dim = self.train_dataloader.__iter__().__next__()[0].shape[1]

    def train(self):
        print('训练开始!!')
        for epoch in range(self.epoch):
            self.G.train()
            self.D.train()
            loss_mean_G = 0
            loss_mean_D = 0
            for i, (images, labels) in enumerate(self.train_dataloader):
                # 生成对应batch和维度的latent
                z = torch.rand((self.batch_size, self.z_dim)).to(self.device)
                images, labels = images.to(self.device), labels.to(self.device)
                labels = F.one_hot(labels, num_classes=10)
                ### 更新D ###
                self.optimizerD.zero_grad()
                # 真实图像输入D
                D_real = self.D(images, labels)
                # 想要真实图像的D输出尽可能大
                D_real_loss = -torch.mean(D_real)
                # 虚假图像输入D
                images_fake = self.G(z, labels)
                D_fake = self.D(images_fake, labels)
                # 想要虚假图像的D输出尽可能小
                D_fake_loss = torch.mean(D_fake)

                # 整合并更新
                D_loss = D_real_loss + D_fake_loss
                D_loss.backward()
                self.optimizerD.step()
                loss_mean_D += D_loss.item()
                # 截断
                for p in self.D.parameters():
                    p.data.clamp_(-self.c, self.c)
                ### 更新G ###
                # 每隔一定间隔再更新G
                if (i+1) % self.n_critic == 0:
                    self.optimizerG.zero_grad()
                    # 虚假图像输入D
                    images_fake = self.G(z, labels)
                    D_fake = self.D(images_fake, labels)
                    # 想要虚假图像的D输出尽可能大
                    G_loss = -torch.mean(D_fake)
                    # 更新
                    G_loss.backward()
                    self.optimizerG.step()
                    loss_mean_G += G_loss.item()

            train_loss_G = loss_mean_G / len(self.train_dataloader) * self.n_critic
            train_loss_D = loss_mean_D / len(self.train_dataloader)
            print('epoch:{}, training loss G:{:.4f}, loss D:{:.4f}'.format(
                epoch, train_loss_G,train_loss_D))
            self.visualize_results(epoch)

    @torch.no_grad()
    def visualize_results(self, epoch):
        self.G.eval()
        # 保存结果路径
        output_path = 'results/GAN'
        if not os.path.exists(output_path):
            os.makedirs(output_path)

        tot_num_samples = self.sample_num
        image_frame_dim = int(np.floor(np.sqrt(tot_num_samples)))

        z = self.fixed_z
        labels = F.one_hot(torch.Tensor(np.repeat(np.arange(10), 10)).to(torch.int64), num_classes=10).to(self.device)
        generated_images = self.G(z, labels)
        save_image(generated_images, os.path.join(output_path, '{}.jpg'.format(epoch)), nrow=image_frame_dim)


if __name__ == '__main__':
    generator = ImageGenerator()
    generator.train()

业务合作/学习交流+v：lizhiTechnology

  如果想要了解更多图像生成相关知识，可以参考我的专栏和其他相关文章：

图像生成_Lcm_Tech的博客-优快云博客

【图像生成】(一) DNN 原理 & pytorch代码实例_pytorch dnn代码-优快云博客

【图像生成】(二) GAN 原理 & pytorch代码实例_gan代码-优快云博客

【图像生成】(三) VAE原理 & pytorch代码实例_vae算法 是如何生成图的-优快云博客

【图像生成】(四) Diffusion原理 & pytorch代码实例_diffusion unet-优快云博客

如果想要了解更多深度学习相关知识，可以参考我的其他文章：

深度学习_Lcm_Tech的博客-优快云博客

【优化器】(一) SGD原理 & pytorch代码解析_sgd优化器-优快云博客

【损失函数】(一) L1Loss原理 & pytorch代码解析_l1 loss-优快云博客

【diffusers】(一) diffusers库介绍 & 框架代码解析-优快云博客

【计算机视觉】生成对抗网络（GAN）在图像生成中的应用
优快云博客专家，系统架构师，有合作、疑惑请私信博主。
04-30 9万+
生成对抗网络（GAN）在图像生成中的应用，人工智能、大模型、AI深度学习在计算机视觉领域取得了令人瞩目的进展，图像生成作为计算机视觉领域的关键任务，具有广泛的应用前景。在娱乐产业中，它可用于电影特效制作、游戏场景与角色创建，为用户带来更加逼真、奇幻的视觉体验。在设计领域，能辅助设计师快速生成创意草图、进行产品外观的初步设计，极大提高设计效率。在医疗领域，通过生成特定的医学图像，有助于医生进行疾病的模拟诊断与治疗方案规划。
生成对抗网络 (GAN) 原理与代码实例讲解
AI天才研究院
07-22 1551
生成对抗网络 (GAN) 原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词： 生成对抗网络（GAN）、深度学习、无监督学习、生成模型、图像合成、数据增强
用GAN来做图像生成，这是最好的方法
weixin_34186950的博客
08-23 5027
前言 在我们之前的文章中，我们学习了如何构造一个简单的 GAN 来生成 MNIST 手写图片。对于图像问题，卷积神经网络相比于简单地全连接的神经网络更具优势，因此，我们这一节我们将继续深入 GAN，通过融合卷积神经网络来对我们的 GAN 进行改进，实现一个深度卷积 GAN。如果还没有亲手实践过 GAN 的小伙伴可以先去学习一下上一篇专栏：生成对抗网络...
PyTorch-GAN：深度学习生成对抗网络实战教程
最新发布
weixin_28931449的博客
06-17 949
在深度学习和人工智能领域，生成对抗网络（GANs）已成为推动创新的强大工具，尤其是在图像和数据生成方面。PyTorch-GAN项目是将这种强大技术具体化的一个集合，它以PyTorch深度学习框架为支撑，提供了实现和实验各种GAN模型的平台。本项目不仅包含经典GAN模型的实现，例如DCGAN、CGAN和WGAN-GP，还提供了便于用户交互和模型训练的示例。通过本章，我们将对PyTorch-GAN项目有一个概览，涵盖项目的目标、功能和实现的广度，为后续深入探讨各章节打下基础。
基础GAN实例（pytorch代码实现）
weixin_51781852的博客
07-16 9134
输出是长度为100的噪声（正态分布随机数）输出为（1，28，28）的图片linear1100---256linear2256--512linear3reshapenn.Tanh()#对于生成器，最后一个激活函数是tanh,值域-1到1)#定义前向传播#x表示长度为100的noise输入img=img.view(-1,28,28)#转换成图片的形式输入为为（1，28，28）的图片，输出为二分类的概率值，输出使用sigmoid的激活0-1BCEloss计算交叉熵损失。...
使用 PyTorch 实现 GAN 的简单例子
weixin_35753431的博客
12-18 318
下面是使用 PyTorch 实现 GAN 的简单例子。这里假设你已经了解了 GAN 的基本原理，并且安装了 PyTorch。 首先，我们需要定义生成器和判别器。生成器是一个神经网络，它接收随机噪声作为输入，并输出假的图像。判别器是另一个神经网络，它接收图像作为输入，并输出一个值，表示这张图像是否是真实的。 ```python import torch import torch.nn as nn i...
基于生成对抗网络（GAN）人脸图像生成
tjl521314_21的博客
10-29 2282
生成器（G）：输入随机噪声，通过学习数据的分布模式生成类似真实图像的输出。判别器（D）：用来判断输入的图像是真实的还是生成器生成的。训练过程中，生成器尝试欺骗判别器，生成逼真的图像，而判别器则不断优化，以区分真实图像与生成图像。这种对抗过程最终使生成器的生成能力逐渐逼近真实图像。生成器将随机噪声（潜在向量）通过一系列转置卷积层转换为图像。每层使用ReLU激活函数，最后一层用Tanh激活函数，将输出限制在[-1, 1]。nn.Tanh()
GAN图像生成
qq_43573054的博客
02-18 2437
GAN网络生成MNIST手写数字Pytorch代码
11-22
标题"GAN网络生成MNIST手写数字Pytorch代码"指的是使用生成对抗网络（Generative Adversarial Networks, GANs）在PyTorch框架下训练模型，以生成MNIST数据集中的手写数字图像。MNIST数据集是一个广泛用于计算机视觉...
生成对抗网络GAN原理与代码实例讲解
AI天才研究院
07-08 1316
生成对抗网络GAN原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：生成对抗网络(GAN), 原理, 代码实例, TensorFlow, PyTorch 1. 背景介绍
PyTorch深度学习实战（37）——CycleGAN详解与实现
盼小辉丶的博客
02-22 7419
CycleGAN 是一种用于无监督图像转换的深度学习模型，它通过两个生成器和两个判别器的组合来学习两个不同域之间的映射关系。CycleGAN 引入循环一致性损失，确保图像转换是可逆的，从而提高生成图像的质量。通过对抗训练和循环一致性损失，CycleGAN 可以实现在没有配对标签的情况下进行图像域转换。本节介绍了 CycleGAN 的基本原理，并实现该模型用于将苹果图像转换为橙子图像，或反之将橙子图像转换为苹果图像。
pytorch:实现简单的GAN示例(MNIST数据集)
09-18
今天小编就为大家分享一篇pytorch:实现简单的GAN示例(MNIST数据集)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
图像识别中的生成对抗网络（GAN）：原理、应用与代码实现
10-26
首先，GAN可以用于图像生成，比如生成逼真的图像、艺术作品等。其次，在图像修复方面，GAN能有效填补图片的缺失部分，修复破损或损坏的图像。第三，GAN还能用于图像超分辨率，通过上采样技术提高图片的分辨率，使得...
基于GAN的图像生成模型
qq_40622955的博客
04-02 1306
记录训练GAN生成牙刷的过程，最终生成器生成牙刷的图像已经可以比较好了。 定义一些参数 创建dataset和dataloader 定义生成器 验证生成器是否正确 定义判别器 验证判别器是否正确 定义损失函数 训练 对GAN网络的训练是一个比较玄学的过程，当不收敛的时候调整学习率多尝试几次，或者动态的调整学习率。 输入一个随机值查看GAN生成器生成的效果 生成器在不同阶段生成的效果 从上面的结果来看，对于生成牙刷这样的场景这个很小的GAN网络已经
pytorch实现GAN入门案例
qq_55621259的博客
08-07 2306
最近在知乎上看到一个不错的GAN的入门案例，于是稍微修改了一下后分享出来！我们都知道GAN主要用来生成，相比于生成图片，我们这次选择更为简单的生成一个一维函数来大致了解GAN的流程及代码实现。我们的原始数据为y = 2x^2 + 1，我们让GAN来生成与之接近的分布！ 代码： 结果：可以看到我们生成的结果还是不错的！ 参考资料：......
如何使用GAN（生成对抗网络）进行图像生成
二进制的梦想
12-18 3938
生成对抗网络（GAN）是一类基于对抗训练的生成模型。其核心思想是通过让两个神经网络互相“对抗”来训练生成模型，使得生成器（Generator）能够生成与真实数据极为相似的样本。生成器（Generator）：负责生成伪造的样本。判别器（Discriminator）：负责判别样本是真实的还是生成的。GAN的训练过程可以视为一个博弈过程，生成器试图骗过判别器，而判别器则尽力识别出假样本。通过这种对抗过程，两个网络不断优化，从而提升生成图像的质量。
使用生成对抗网络（GAN）实现对图像的生成
weixin_66485159的博客
04-29 6781
本文基于python，使用生成对抗网络（GAN模型）对Fashion MNIST数据集中的图像，进行了生成。
GAN（生成对抗网络）入门，生成图片，基于pytorch，python代码
qq_28543131的博客
12-05 1736
在每个训练周期结束时，生成器会生成一批假的手写数字图像。随着训练的进行，生成的图像通常会变得越来越逼真，代码会自下载数据集，可直接运行，代码如下。主要任务是生成手写数字图像。
GAN图像生成-pyotrch
lodew920
04-07 7541
生成对抗网络 生成对抗网络（GAN）是一种算法体系结构，它使用两个神经网络，使一个神经网络与另一个神经网络（因此称为“对抗性”）相互对立，以便生成可以传递给真实数据的新的合成数据实例。 它们广泛用于图像生成，视频生成和语音生成。 虽然大多数深度生成模型是通过最大化对数可能性或对数可能性的下限来训练的，但是GAN采取了根本不同的方法，不需要推理或明确计算数据可能性。 取而代之的是，有两个模型用于求解极小极大博弈：一个对数据进行采样的生成器和一个将数据分类为真实或生成的鉴别器。理论上，这些模型能够对任意复杂的
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值