AI学习指南深度学习篇-生成对抗网络的Python实践

🕗 发布于 2024-10-13 12:46 ai

AI学习指南深度学习篇——生成对抗网络的Python实践

生成对抗网络（GAN）是一种强大的生成模型，它通过对抗的方式训练两个神经网络：生成器（Generator）和判别器（Discriminator）。在本文中，我们将详细介绍GAN的基本原理，并提供使用Python及深度学习库（如TensorFlow和PyTorch）实现GAN的示例代码。通过具体的实施，您将能深入理解GAN的训练流程和实现细节。

1. 生成对抗网络概述

生成对抗网络由Ian Goodfellow等人在2014年提出。GAN的基本思想是通过两个网络的对抗训练来生成新数据样本：

生成器 (Generator)：尝试生成真实的样本，以“欺骗”判别器。
判别器 (Discriminator)：尝试区分真实样本和生成器生成的假样本。

GAN的数学定义非常简单，通过最小化一个特定的损失函数来实现这两个网络的对抗。

1.1 GAN的数学模型

GAN的目标是最大化判别器的准确率，同时生成器目标是使判别器预测错误。具体优化过程可以表示为：

$\min_G \max_D V(D, G) = E_{x \sim p_{data}(x)}[\log D(x)] + E_{z \sim p_{z}(z)}[\log(1 - D(G(z)))]$

其中：

$p_{data}(x) )$ 是真实数据的分布。
$p_{z}(z) )$ 是潜在变量的分布。

1.2 GAN的工作流程

生成网络和判别网络的工作流程如下：

随机生成噪声输入样本 $(z)$ 。
生成器生成图像 $(G (z))$ 。
判别器接受真实图像和生成图像并进行评估。
依据判别器的反馈调整生成器和判别器的参数。

2. 实现生成对抗网络

在此部分，我们将在TensorFlow和PyTorch中实现一个简单的GAN。首先设置所需的库。

2.1 安装所需库

确保您已安装tensorflow和torch等库：

pip install tensorflow torch torchvision matplotlib

2.2 使用TensorFlow实现GAN

下面的代码示例演示了如何使用TensorFlow实现简单的GAN以生成手写数字（MNIST 数据集）。

2.2.1 数据准备

导入MNIST数据集：

import tensorflow as tf
from tensorflow.keras import layers
import matplotlib.pyplot as plt

# 加载MNIST数据集
(x_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = x_train / 255.0  # 归一化到[0, 1]
x_train = x_train.reshape(-1, 28, 28, 1)  # 添加通道维度

2.2.2 定义生成器

生成器使用全连接层和转置卷积层来生成图像：

def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(128, activation="relu", input_shape=(100,)))  # 输入100维噪声向量
    model.add(layers.Dense(7 * 7 * 128, activation="relu"))
    model.add(layers.Reshape((7, 7, 128)))
    model.add(layers.Conv2DTranspose(128, 3, strides=2, padding="same", activation="relu"))
    model.add(layers.Conv2DTranspose(64, 3, strides=2, padding="same", activation="relu"))
    model.add(layers.Conv2D(1, 7, activation="sigmoid", padding="same"))
    return model

generator = build_generator()

2.2.3 定义判别器

判别器使用卷积层来评估图像的真实性：

def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, 3, strides=2, padding="same", input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))
    model.add(layers.Conv2D(128, 3, strides=2, padding="same"))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))
    model.add(layers.Flatten())
    model.add(layers.Dense(1, activation="sigmoid"))
    return model

discriminator = build_discriminator()

2.2.4 定义损失函数和优化器

loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)

generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

2.2.5 训练过程

我们将实现训练循环，产生100个批次的噪声样本并进行训练：

@tf.function
def train_step(images):
    noise = tf.random.normal([BATCH_SIZE, 100])

    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        generated_images = generator(noise, training=True)

        real_output = discriminator(images, training=True)
        fake_output = discriminator(generated_images, training=True)

        gen_loss = loss_object(tf.ones_like(fake_output), fake_output)
        disc_loss = loss_object(tf.ones_like(real_output), real_output) + \
                    loss_object(tf.zeros_like(fake_output), fake_output)

    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)

    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

# 创建训练循环
EPOCHS = 50
BATCH_SIZE = 256
num_examples_to_generate = 16

for epoch in range(EPOCHS):
    for image_batch in tf.data.Dataset.from_tensor_slices(x_train).shuffle(60000).batch(BATCH_SIZE):
        train_step(image_batch)

2.2.6 生成并展示图像

def generate_and_save_images(model, epoch, test_input):
    predictions = model(test_input, training=False)
    plt.figure(figsize=(4, 4))
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(predictions[i, :, :, 0], cmap="gray")
        plt.axis("off")
    plt.savefig(f"gan_epoch_{epoch}.png")
    plt.show()

# 在训练后生成示例图像
seed = tf.random.normal([num_examples_to_generate, 100])
generate_and_save_images(generator, EPOCHS, seed)

2.3 使用PyTorch实现GAN

接下来，我们用PyTorch实现相同的GAN。

2.3.1 数据准备

同样下载MNIST数据：

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 数据准备
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.MNIST(root="./data", train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

2.3.2 定义生成器

import torch.nn as nn

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(True),
            nn.Linear(256, 512),
            nn.ReLU(True),
            nn.Linear(512, 1024),
            nn.ReLU(True),
            nn.Linear(1024, 1 * 28 * 28),  # 1个通道
            nn.Tanh()  # 输出范围[-1, 1]
        )

    def forward(self, z):
        z = self.model(z)
        return z.view(-1, 1, 28, 28)

generator = Generator()

2.3.3 定义判别器

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(1 * 28 * 28, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()  # 输出范围[0, 1]
        )

    def forward(self, img):
        img_flat = img.view(-1, 1 * 28 * 28)
        validity = self.model(img_flat)
        return validity

discriminator = Discriminator()

2.3.4 定义损失函数和优化器

criterion = nn.BCELoss()
optimizer_G = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

2.3.5 训练过程

实现训练循环：

for epoch in range(50):
    for i, (imgs, _) in enumerate(trainloader):

        # 训练判别器
        optimizer_D.zero_grad()

        z = torch.randn(imgs.shape[0], 100)
        generated_imgs = generator(z)

        real_loss = criterion(discriminator(imgs), torch.ones(imgs.shape[0], 1))
        fake_loss = criterion(discriminator(generated_imgs.detach()), torch.zeros(imgs.shape[0], 1))
        d_loss = real_loss + fake_loss
        d_loss.backward()
        optimizer_D.step()

        # 训练生成器
        optimizer_G.zero_grad()
        g_loss = criterion(discriminator(generated_imgs), torch.ones(imgs.shape[0], 1))
        g_loss.backward()
        optimizer_G.step()

2.3.6 生成并展示图像

def generate_and_save_images(generator, epoch):
    z = torch.randn(16, 100)
    generated_imgs = generator(z)
    
    plt.figure(figsize=(4, 4))
    for i in range(generated_imgs.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(generated_imgs[i].detach().numpy()[0], cmap="gray")
        plt.axis("off")
    plt.savefig(f"gan_pytorch_epoch_{epoch}.png")
    plt.show()

generate_and_save_images(generator, epoch)

3. 总结

在本教程中，我们使用了TensorFlow和PyTorch两个流行的深度学习框架，展示了如何构建和训练生成对抗网络。通过实践，您已了解生成器和判别器的结构、训练流程以及如何生成样本。生成对抗网络是一个不断发展的领域，您可以通过尝试不同类型的网络架构或数据集来进一步探索。

未来的研究可以更加深入，如：

条件生成对抗网络（Conditional GAN）
CycleGAN
循环生成网络等。

希望本指南能帮助您在AI深度学习的旅程中更进一步！

原文地址：https://blog.csdn.net/zhaopeng_yu/article/details/142457271

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：GitLab Runner 通过 Pipeline 流水线实现持续集成 CI
下一篇：监控工具之Prometheus与Zabbix和Nagios对比分析

开发指南072-图片热点
/处理跳转： area.getAttribute('href');平台支持使用图像导航界面，例如展示如下一张图，用户点击对应位置触发对应动作。热点数据通过后台接口获取（注意处理权限，没有权限的热点不生
阅读更多2024-10-13
使用机器学习边缘设备的快速目标检测
这项机器学习研究探讨了一种低成本的边缘设备，该设备与具有计算机视觉功能的嵌入式系统集成，以提高目标检测和分类的推理时间和精度。研究的主要目标是减少推理时间并降低功耗，以支持一个竞技型类人机器人的嵌入式
阅读更多2024-10-13
【Windows】【DevOps】Windows Server 2022 安装ansible，基于powershell实现远程自动化运维部署入门到放弃！
文件URL：https://www.python.org/ftp/python/3.13.0/python-3.13.0-amd64.exe。直接拿linux主机测试ansible连接windows
阅读更多2024-10-13
C# 中循环的应用说明
一循环的概念说明二、循环类型三、循环控制语句四、无限循环
阅读更多2024-10-13
Linux `vmstat` 命令详解
vmstat（Virtual Memory Statistics）是 Linux 系统中的一个监控工具，用于报告系统的虚拟内存、进程、CPU 活动等信息。它能帮助用户了解系统的整体性能状况，尤其是内存
阅读更多2024-10-13
Linux下多任务编程（网络编程2）
本文介绍解决accpet和recv相互阻塞的问题，可以用多线程并发外也可以用epoll I/O多路复用的方式解决。
阅读更多2024-10-13
[单master节点k8s部署]37.微服务（一)springCloud 微服务
微服务架构的一个重要特点是，它与开发中使用的具体或无关。每个微服务都可以使用最适合其功能需求的语言或技术来实现。例如，一个微服务可以用Java编写，另一个微服务可以用Python、Go、Node.js
阅读更多2024-10-13
Zynq(3)使用外设MIO/EMIO
使用MIO/EMIO实现流水灯，着重介绍Zynq IP核的配置，解读vitis中的c语言程序，介绍MIO与EMIO的区别。
阅读更多2024-10-13
笔试算法总结
思路很简单，但是当时做题提交的时候，通过率总是18%。不知道为啥，后面我改成了Long类型，然后就通过了全部用例。（易错1：第一次提交没考虑0的情况）使用 StringBuilder 模拟栈的行为，通
阅读更多2024-10-13
快速学习一个算法，Transformer模型架构
它的主要思想是在同一时间通过多个独立的注意力头（Attention Head）来关注序列中不同部分的信息，然后将这些信息综合起来，生成更丰富的表示。自注意力机制的目的是对输入序列中的每个元素计算一个输
阅读更多2024-10-13

AI学习指南深度学习篇-生成对抗网络的Python实践