卷积神经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()的常见方法：
-
模型架构调整：
• 确保模型具有足够的容量（即参数数量）来捕捉数据的复杂性，但也要避免过拟合。
• 使用正则化技术，如L1、L2正则化，或dropout层来减少过拟合。
-
数据预处理：
• 对输入数据进行适当的缩放和归一化，使其分布在模型更容易处理的范围内。
• 确保标签数据是二进制的（0或1），因为nn.BCELoss()期望的是这种格式。
-
损失函数输入：
• 确保传递给nn.BCELoss()的预测值是原始得分（logits），而不是已经通过sigmoid函数转换过的概率。nn.BCELoss()内部会对这些得分应用sigmoid函数。
-
学习率和优化器：
• 使用合适的学习率。学习率太高可能导致训练不稳定，而学习率太低则会使训练过程收敛缓慢。
• 选择合适的优化器，如SGD、Adam或RMSprop，并调整其超参数（如动量、权重衰减）。
-
批量大小：
• 尝试不同的批量大小以找到最佳的内存使用效率和梯度估计。
-
训练过程监控：
• 定期监控训练损失和验证损失，以及任何其他相关指标（如准确率）。
• 使用早停（early stopping）策略来防止过拟合，即在验证损失停止改善时停止训练。
-
梯度裁剪：
• 如果遇到梯度爆炸问题，可以尝试使用梯度裁剪来限制梯度的最大范数。
-
标签平滑：
• 在某些情况下，对标签应用标签平滑可以减少模型对错误标签的过度自信，从而改善泛化能力。
-
数据增强：
• 对输入数据进行增强（如旋转、翻转、缩放等），以增加数据多样性，减少过拟合。
-
模型集成：
• 通过训练多个模型并将它们的预测结果结合起来（如通过平均或投票），可以提高整体性能。
请注意，这些优化策略并不是孤立的，而是应该相互结合使用，以找到最适合特定任务和数据的组合。此外，对于每个任务和数据集，最佳实践可能会有所不同，因此通常需要进行实验和调整来找到最佳配置。
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)计算了预测值和真实值之间的二元交叉熵损失。
