人工智能应用-实验8-用生成对抗网络生成数字图像

文章目录

- 🧡🧡实验内容🧡🧡
- 🧡🧡代码🧡🧡
- 🧡🧡分析结果🧡🧡
- 🧡🧡实验总结🧡🧡

🧡🧡实验内容🧡🧡

以MNIST 数据集为训练数据,用生成对抗网络生成手写数字 5的图像(编程语言不限,如Python 等)。

🧡🧡代码🧡🧡

import torch
from torch import nn
from torch.optim import Adam
import torch.nn.functional as F
from torchvision import transforms, datasets
import matplotlib.pyplot as plt
import time
import pandas

transform = transforms.Compose([
    transforms.ToTensor(),
])

train_set = datasets.MNIST('data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=1, shuffle=False) # 批次为1，不打乱数据

# !nvidia-smi
# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

#@title 模型
#返回size大小的均值为0，均方误差为1的随机数
def generate_random(size):
    random_data = torch.randn(size)
    return random_data

# def generate_random(size): # 均匀分布的随机数，会产生模式崩溃
#     random_data = torch.rand(size)
#     return random_data

#判别器
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model=nn.Sequential(
            nn.Linear(784, 200), # 全连接层 784维特征（像素点） => 200维特征
            nn.LeakyReLU(0.02), # 激活层：f(x)=max(ax,x) a
            nn.LayerNorm(200), # 归一化层
            nn.Linear(200, 1), # 全连接层 200维特征（像素点） => 1维标量
            nn.Sigmoid() # 将1维标量缩放结果到0-1之间，以0.5作为二分类结果
        )

        self.loss_function = nn.BCELoss() # 定义损失函数
        self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001) # 创建优化器，使用Adam梯度下降
        # 计数器和损失记录
        self.counter = 0
        self.loss_list = []

    def forward(self, inputs):
        return self.model(inputs)

    def train(self, inputs, targets):
        outputs = self.forward(inputs)  # 计算网络前向传播输出
        loss = self.loss_function(outputs, targets) # 计算损失值


        self.counter += 1
        if (self.counter % 10 == 0): # 每训练10次记录损失值
            self.loss_list.append(loss.item())
        if (self.counter % 10000 == 0): # 每训练10000次打印进程
            print("counter = ", self.counter)

        self.optimiser.zero_grad() #在反向传播前先把梯度归零
        loss.backward() #反向传播,计算各参数对于损失loss的梯度
        self.optimiser.step()  #根据反向传播得到的梯度，更新模型权重参数

    def plot_loss_process(self):
        df = pandas.DataFrame(self.loss_list, columns=['Discriminator Loss'])
        ax = df.plot(figsize=(12,6), alpha=0.1,
        marker='.', grid=True, yticks=(0, 0.25, 0.5, 1.0, 5.0))
        ax.set_title("Discriminator Loss")


# 生成器
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        # 定义神经网络层
        self.model = nn.Sequential(
            nn.Linear(100, 200), # 全连接层 100维噪声 => 200维特征
            nn.LeakyReLU(0.02), # 激活函数
            nn.LayerNorm(200), # 标准化
            nn.Linear(200, 784), # 200维特征 => 784像素特征
            nn.Sigmoid() # 每个像素点缩放到0-1
        )
        # 创建生成器，使用Adam梯度下降
        self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001)
        # 计数器和损失记录
        self.counter = 0
        self.loss_list = []

    def forward(self, inputs):
        # 运行模型
        return self.model(inputs)

    def train(self, D, inputs, targets):

        g_output = self.forward(inputs) # 计算网络输出
        d_output = D.forward(g_output) # 输入判别器
        loss = D.loss_function(d_output, targets) # 计算损失值

        self.counter += 1
        if (self.counter % 10 == 0):  # 每训练10次记录损失值
            self.loss_list.append(loss.item())

        # 梯度归零，反向传播，并更新权重
        self.optimiser.zero_grad()
        loss.backward()

        #更新由self.optimiser而不是D.optimiser触发。这样一来，只有生成器的链接权重得到更新
        self.optimiser.step()

    def plot_loss_process(self):
        df = pandas.DataFrame(self.loss_list, columns=['Generator Loss'])
        ax = df.plot(figsize=(12,6), alpha=0.1,
        marker='.', grid=True, yticks=(0, 0.25, 0.5, 1.0, 5.0))
        ax.set_title("Generator Loss")

D = Discriminator()
G = Generator()
D = D.to(device)
G = G.to(device)

#@title train
epochs=1
start_time=time.time()
for epoch in range(epochs):
    print(f"=============Epoch={epoch}============")
    for step, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        image_data_tensor=images.view(-1)
        # ==使用真实数据训练判别器， 并标注真实数据为正样本（1）==
        D.train( image_data_tensor, torch.FloatTensor([1.0]).to(device) )

        # ==用生成数据（fake）训练判别器， 并标注生成数据为负样本（0）==
        # 同时使用detach()以避免计算生成器G中的梯度
        D.train( G.forward(generate_random(100).to(device)).detach(), torch.FloatTensor([0.0]).to(device) )

        # ==训练生成器， 让判别器对于生成器的生成数据评分尽可能接近正样本（1）==
        G.train( D, generate_random(100).to(device), torch.FloatTensor([1.0]).to(device) )
print(f"cost all time={(time.time()-start_time)/60} minutes")

# 保存模型
torch.save(D, 'GAN_Digits_D.pt')
torch.save(G, 'GAN_Digits_G.pt')
# 加载模型
D=torch.load('GAN_Digits_D.pt')
G=torch.load('GAN_Digits_G.pt')
G.plot_loss_process()
D.plot_loss_process()
# 生成效果图
f, axarr = plt.subplots(2,3, figsize=(16,8))
for i in range(2):
    for j in range(3):
        output = G.forward(generate_random(100).to(device))
        output = output.cpu()
        img = output.detach().numpy().reshape(28,28)
        axarr[i,j].imshow(img, interpolation='none', cmap='Blues')

🧡🧡分析结果🧡🧡

数据预处理：
加载数据集：
加载torch库中自带的minst数据集
转换数据：
转为tensor变量（相当于直接除255归一化到值域为(0,1)）。
此处不同于CNN和BP网络实验，不再对其进行transforms.Normalize()处理，因为对抗网络中，生成器输入的是一个随机噪声向量，不是预处理后的图像；判别器中，输入的是真实图像和生成图像，而不是预处理后的图像，如果对输入数据进行归一化处理，会改变图像的数值范围，可能会影响判别器的判断结果。

构建对抗网络
构造判别器：

nn.Linear()：全连接层，转换特征维度。
nn.LeakyReLU(0.02)：激活层，激活函数如下，0.02即为negative_slope，用于控制负斜率的角度。相比于不具备负值响应（x<0，则y为0）的传统ReLU，LeakyReLU在负数区间表现的更加平滑，增强非线性表达能力，有助于判别器更好地区分真实样本和真实样本。

nn.LayerNorm(200)：对中间层的输出值进行标准化，让它们均值为0，避免较大值引起的梯度消失。200表示要标准化的维度数目。
nn.Sigmoid()：将1维标量缩放结果到0-1之间，以0.5作为二分类结果。

构造生成器：

nn.Linear()：全连接层，转换特征维度。这里设定输入的随机噪声维度为100，最后输出一张784像素图片。
nn.LeakyReLU、nn.LayerNorm、nn.Sigmoid作用同上述类似

选取损失函数：
对于分类问题，损失函数使用二元交叉熵BCELoss()往往比均方误差MSELoss()效果更好。因为它能对正确分类进行奖励，而对错误分类进行惩罚。
由于生成器无需定义损失函数，所以我们只需要修改鉴别器的损失函数即可：

训练和评估

每10张图记录1次loss，1次epoch训练60000张图，则1次epoch记录6000次loss，6次epoch记录36000次loss。而1次epoch训练1次生成器，训练2次判别器（1次正样本判别、1次负样本判别），所以生成器loss迭代变化横坐标为36000次，判别器loss迭代变化横坐标为72000次。

loss迭代变化如下图。

从图中整体来看，一开始生成器loss较高，判别器接近0，后面生成器和判别器loss逐渐分布均匀（方差减少，数值大小越来越集中）。

分析生成对抗网络中生成器和判别器的关系
实验中，判别器的loss定义为：区分真实图像和假图像的能力，即loss越小，区分能力越强
而生成器虽然没有直接定义loss，但是利用了判别器的loss，使得判别器对生成器生成的假图像的评分尽可能接近正样本，也即loss越小，生成器生成的假数据越来越接近真实图像。
上述loss的记录迭代次数太多，可能不够直观观察判别器和生成器的相对变化，计算每次epoch的平均loss如下图：

可以看到，刚开始生成器与判别器的博弈中处于下风，随着训练进行，生成器的loss大幅减少，说明生成器生成的图像越来越逼真，反观判别器loss增大，说明判别器开始处于下风。最后，可以看到两者的loss都趋于平稳，说明此时渐渐达到了博弈平衡，从直观的图像清晰度也能看到，对比训练初期，图像5相比最开始变得比较清晰，但当迭代一定训练次数后，清晰度似乎不再变化了。

🧡🧡实验总结🧡🧡

理论理解：
GAN的核心思想：生成器G和判别器D的一代代博弈

生成器：
生成网络，通过输入生成图像
判别器：
二分类网络，将生成器生成图像作为负样本，真实图像作为正样本
优化判别器D：
给定G，通过G生成图像产生负样本，并结合真实图像作为正样本来训练D
优化生成器G：
给定D，以使得D对G生成图像的评分尽可能接近正样本作为目标来训练G

G和D的训练过程交替进行，这个对抗的过程使得G生成的图像越来越逼真，D辨别的能力也越来越强。

代码实操：

模式崩溃：
在生成器生成随机数时，若生成的方法不对，可能会导致模式崩溃问题，它指的是生成器倾向于生成相似或重复的样本，而不是多样化的输出（如下图）。

在python中，torch.rand()产生的是0-1之间均匀分布的随机数，很容易导致模式崩溃，因为均匀分布的随机数无法提供足够的多样性，从而使得生成器可能会生成类似的样本。为了解决这个问题，使用torch,randn()函数从高斯分布中抽取随机数，从而增大生成器的多样性。
判断对抗网络模型的收敛情况
一方面生成器和判别器的损失函数值来监控两者的优化过程，它们的相对变化可以一定程度反映它们的博弈情况，当它们的loss的变化都慢慢趋于平稳时，可以认为模型达到收敛。当然，另一方面，通过观察图像清晰度也是比较直观的方法。