卷积神经05-GAN对抗神经网络

卷积神经05-GAN对抗神经网络

使用Python3.9+CUDA11.8+Pytorch实现一个CNN优化版的对抗神经网络

• 简单的GAN图片生成
  

• CNN优化后的图片生成
  

• 优化模型代码对比
  

0-核心逻辑脉络

• 1）Anacanda使用CUDA+Pytorch
• 2）使用本地MNIST进行手写图片训练
• 3）添加CNN进行训练过程优化
• 4）Flask点击生成图片

---

1-参考网址

• 1）GAN解读及代码实现：https://www.bilibili.com/video/BV1yE421u7Gj
• 2）个人实现代码：https://gitee.com/enzoism/gan_pytorch
• 3）CUDA+Pytorch环境安装参考：https://blog.csdn.net/2301_77717148/article/details/145083431

---

2-CUDA+Pytorch安装

# 1-Anacanda使用Python3.9
conda create -n GAN3.9 python=3.9
conda activate GAN3.9


# 2-使用cudatoolkit=11.8
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
conda install pytorch torchvision torchaudio cudatoolkit=11.8 -c pytorch

# 3-安装所需依赖包
pip install matplotlib 

# 4-查看GPU使用命令
nvidia-smi
watch -n 1 nvidia-smi

3-代码实现-本地版

import gzip

import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 检查是否有可用的 GPU，如果没有则使用 CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")


# 定义生成器和判别器
class Generator(nn.Module):
    def __init__(self, z_dim=100, img_dim=784):
        super(Generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(z_dim, 256),
            nn.ReLU(),
            nn.Linear(256, img_dim),
            nn.Tanh(),  # 输出范围在 -1 到 1 之间
        )

    def forward(self, x):
        return self.gen(x)


class Discriminator(nn.Module):
    def __init__(self, img_dim=784):
        super(Discriminator, self).__init__()
        self.dis = nn.Sequential(
            nn.Linear(img_dim, 128),
            nn.LeakyReLU(0.01),
            nn.Linear(128, 1),
            nn.Sigmoid(),  # 输出范围在 0 到 1 之间
        )

    def forward(self, x):
        return self.dis(x)


# 定义加载本地 MNIST 数据集的函数
MNIST_FILE_PATH = 'D:/TT_WORK+/PyCharm/20250109_1_CNN/MNIST/'


def load_data():
    # 加载图像数据
    with gzip.open(MNIST_FILE_PATH + 'train-images-idx3-ubyte.gz', 'rb') as f:  # 训练集
        X_train = np.frombuffer(f.read(), dtype=np.uint8, offset=16).reshape(-1, 28 * 28)

    with gzip.open(MNIST_FILE_PATH + 't10k-images-idx3-ubyte.gz', 'rb') as f:  # 测试集
        X_test = np.frombuffer(f.read(), dtype=np.uint8, offset=16).reshape(-1, 28 * 28)

    # 加载标签数据
    with gzip.open(MNIST_FILE_PATH + 'train-labels-idx1-ubyte.gz', 'rb') as f:  # 训练集标签
        y_train = np.frombuffer(f.read(), dtype=np.uint8, offset=8)

    with gzip.open(MNIST_FILE_PATH + 't10k-labels-idx1-ubyte.gz', 'rb') as f:  # 测试集标签
        y_test = np.frombuffer(f.read(), dtype=np.uint8, offset=8)

    return (X_train, y_train), (X_test, y_test)


# 加载数据并转换为 PyTorch 张量
(X_train, y_train), (X_test, y_test) = load_data()

# 将数据转换为 PyTorch 张量并归一化到 [-1, 1] 范围
X_train = torch.tensor(X_train, dtype=torch.float32) / 255.0 * 2 - 1
X_test = torch.tensor(X_test, dtype=torch.float32) / 255.0 * 2 - 1

# 创建数据集和数据加载器
train_dataset = TensorDataset(X_train)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 初始化生成器和判别器，并将它们移动到设备上
z_dim = 100
img_dim = 28 * 28

generator = Generator(z_dim, img_dim).to(device)
discriminator = Discriminator(img_dim).to(device)

lr = 0.0001
num_epochs = 100

optimizer_gen = optim.Adam(generator.parameters(), lr=lr)
optimizer_dis = optim.Adam(discriminator.parameters(), lr=lr)

criterion = nn.BCELoss()

# 记录损失值
train_loss_g = []
train_loss_d = []

# 训练过程
for epoch in range(num_epochs):
    gen_loss_epoch = 0
    disc_loss_epoch = 0

    for batch_idx, (real,) in enumerate(train_loader):
        real = real.to(device)
        batch_size = real.size(0)

        # 训练判别器
        noise = torch.randn(batch_size, z_dim, device=device)
        fake = generator(noise)
        disc_real_loss = criterion(discriminator(real), torch.ones(batch_size, 1, device=device))
        disc_fake_loss = criterion(discriminator(fake.detach()), torch.zeros(batch_size, 1, device=device))
        disc_loss = (disc_real_loss + disc_fake_loss) / 2

        optimizer_dis.zero_grad()
        disc_loss.backward()
        optimizer_dis.step()

        # 训练生成器
        noise = torch.randn(batch_size, z_dim, device=device)
        fake = generator(noise)
        gen_loss = criterion(discriminator(fake), torch.ones(batch_size, 1, device=device))

        optimizer_gen.zero_grad()
        gen_loss.backward()
        optimizer_gen.step()

        gen_loss_epoch += gen_loss.item()
        disc_loss_epoch += disc_loss.item()

        if batch_idx % 100 == 0:
            print(f"Epoch [{epoch}/{num_epochs}] Batch {batch_idx}/{len(train_loader)} \
                  Loss D: {disc_loss.item():.4f}, loss G: {gen_loss.item():.4f}")

    # 记录每个 epoch 的平均损失
    train_loss_g.append(gen_loss_epoch / len(train_loader))
    train_loss_d.append(disc_loss_epoch / len(train_loader))

    # 每个 epoch 保存一些生成的图像
    generator.eval()
    with torch.no_grad():
        noise = torch.randn(1, z_dim, device=device)
        generated_img = generator(noise).view(28, 28).cpu().numpy()
        plt.imshow(generated_img, cmap='gray')
        plt.savefig(f'generated_img_epoch_{epoch}.png')
        plt.close()
    generator.train()

# 5-保存模型
torch.save(generator.state_dict(), 'generator.pt')
torch.save(discriminator.state_dict(), 'discriminator.pt')

# 绘制训练损失曲线
plt.figure(figsize=(10, 5))
plt.title("Generator and Discriminator Loss During Training")
plt.plot(train_loss_g, label="G")
plt.plot(train_loss_d, label="D")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.savefig("GAN_loss_curve.png")
plt.show()

---

4-代码实现-本地版-添加卷积层

1-修改后的生成器

# 定义生成器
class Generator(nn.Module):
    def __init__(self, z_dim=100):
        super(Generator, self).__init__()
        self.gen = nn.Sequential(
            nn.ConvTranspose2d(z_dim, 128, kernel_size=7, stride=1, padding=0, bias=False),  # 输出尺寸: (128, 7, 7)
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),  # 输出尺寸: (64, 14, 14)
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1, bias=False),  # 输出尺寸: (1, 28, 28)
            nn.Tanh()  # 输出范围在 -1 到 1 之间
        )

    def forward(self, x):
        x = x.view(-1, x.size(1), 1, 1)  # 将输入张量调整为合适的形状
        return self.gen(x)

2-修改后的判别器

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.dis = nn.Sequential(
            nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1, bias=False),  # 输出尺寸: (64, 14, 14)
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),  # 输出尺寸: (128, 7, 7)
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2),
            nn.Flatten(),
            nn.Linear(128 * 7 * 7, 1),
            nn.Sigmoid()  # 输出范围在 0 到 1 之间
        )

    def forward(self, x):
        return self.dis(x)

5-代码实现-Flask预览图片

import base64
import io

import numpy as np
import torch
from PIL import Image
from flask import Flask, render_template, jsonify

from main00_gan_model_define import Generator  # 从你的模型文件中导入Generator类

app = Flask(__name__)

# 加载生成器模型
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
z_dim = 100
generator = Generator(z_dim).to(device)
generator.load_state_dict(torch.load('gan_train_cnn/generator.pt', map_location=device))
generator.eval()


@app.route('/')
def index():
    return render_template('index.html')


@app.route('/generate', methods=['POST'])
def generate():
    images = []
    for _ in range(5):
        noise = torch.randn(1, z_dim, device=device)
        with torch.no_grad():
            generated_img = generator(noise).squeeze(0).cpu().numpy()

        # 将生成的图像转换为PIL图像，并进行编码以便在网页中显示
        generated_img = (generated_img * 0.5 + 0.5) * 255  # 反归一化
        generated_img = generated_img.astype(np.uint8)
        img = Image.fromarray(generated_img[0], mode='L')  # 假设是单通道灰度图像
        buffered = io.BytesIO()
        img.save(buffered, format="PNG")
        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
        images.append(img_str)

    return jsonify(images=images)


if __name__ == '__main__':
    app.run(debug=True)

---

6-什么是nn.BCELoss()

优化nn.BCELoss()并不是直接对损失函数本身进行优化，而是指通过调整模型、数据预处理、训练过程等方面的策略，以最小化该损失函数计算得到的损失值，从而提高模型的性能。以下是一些优化nn.BCELoss()的常见方法：

1. 模型架构调整：

   • 确保模型具有足够的容量（即参数数量）来捕捉数据的复杂性，但也要避免过拟合。

   • 使用正则化技术，如L1、L2正则化，或dropout层来减少过拟合。

2. 数据预处理：

   • 对输入数据进行适当的缩放和归一化，使其分布在模型更容易处理的范围内。

   • 确保标签数据是二进制的（0或1），因为nn.BCELoss()期望的是这种格式。

3. 损失函数输入：

   • 确保传递给nn.BCELoss()的预测值是原始得分（logits），而不是已经通过sigmoid函数转换过的概率。nn.BCELoss()内部会对这些得分应用sigmoid函数。

4. 学习率和优化器：

   • 使用合适的学习率。学习率太高可能导致训练不稳定，而学习率太低则会使训练过程收敛缓慢。

   • 选择合适的优化器，如SGD、Adam或RMSprop，并调整其超参数（如动量、权重衰减）。

5. 批量大小：

   • 尝试不同的批量大小以找到最佳的内存使用效率和梯度估计。

6. 训练过程监控：

   • 定期监控训练损失和验证损失，以及任何其他相关指标（如准确率）。

   • 使用早停（early stopping）策略来防止过拟合，即在验证损失停止改善时停止训练。

7. 梯度裁剪：

   • 如果遇到梯度爆炸问题，可以尝试使用梯度裁剪来限制梯度的最大范数。

8. 标签平滑：

   • 在某些情况下，对标签应用标签平滑可以减少模型对错误标签的过度自信，从而改善泛化能力。

9. 数据增强：

   • 对输入数据进行增强（如旋转、翻转、缩放等），以增加数据多样性，减少过拟合。

10. 模型集成：

    • 通过训练多个模型并将它们的预测结果结合起来（如通过平均或投票），可以提高整体性能。

请注意，这些优化策略并不是孤立的，而是应该相互结合使用，以找到最适合特定任务和数据的组合。此外，对于每个任务和数据集，最佳实践可能会有所不同，因此通常需要进行实验和调整来找到最佳配置。

---

7-如何优化nn.BCELoss()

nn.BCELoss()是 PyTorch 中用于二分类问题的损失函数，全称是 Binary Cross Entropy Loss。这个函数计算的是目标值（通常是二分类问题的真实标签，取值范围为 {0, 1}）和预测值（通常是模型输出的概率值，取值范围为 [0, 1]）之间的二元交叉熵损失。

二元交叉熵损失的计算公式为：
L = − 1 N ∑ i = 1 N [ y i ⋅ log ⁡ ( x i ) + ( 1 − y i ) ⋅ log ⁡ ( 1 − x i ) ] L = -\frac{1}{N} \sum_{i=1}^{N} \left[ y_i \cdot \log(x_i) + (1 - y_i) \cdot \log(1 - x_i) \right] L=−N1i=1∑N[yi⋅log(xi)+(1−yi)⋅log(1−xi)]

其中：

• NNN是样本数量。

• yiy_iyi是第iii个样本的真实标签（0 或 1）。

• xix_ixi是第iii个样本的预测概率。

这个函数常用于二分类任务中，比如判断一张图片是否包含某个物体、一封邮件是否是垃圾邮件等场景。使用nn.BCELoss()时，需要确保输入的目标值和预测值都是未经过 sigmoid 激活的原始值（即预测值应该是模型最后一层的线性输出），因为在计算损失时，该函数内部会对预测值应用 sigmoid 函数，将其转换为概率值。

示例用法：

import torch
import torch.nn as nn

假设有3个样本的预测值和真实标签

predictions = torch.tensor([0.2, 0.8, 0.4], dtype=torch.float32)  # 预测概率
targets = torch.tensor([0, 1, 0], dtype=torch.float32)  # 真实标签

初始化 BCELoss

criterion = nn.BCELoss()

计算损失

loss = criterion(predictions, targets)
print(loss)  # 输出损失值

在这个例子中，predictions是模型输出的预测概率，targets是真实的标签，criterion(predictions, targets)计算了预测值和真实值之间的二元交叉熵损失。

---