生成对抗网络GAN(MNIST实现、时间序列实现)

这篇具有很好参考价值的文章主要介绍了生成对抗网络GAN(MNIST实现、时间序列实现)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

生成对抗网络介绍

生成对抗网络(Generative Adversarial Network,简称GAN)是一种深度学习模型,由Ian Goodfellow等人于2014年提出。它由两个主要组件组成:生成器(Generator)和判别器(Discriminator)。GAN的目标是通过两个网络之间的对抗学习来生成逼真的数据。

  1. 生成器(Generator): 生成器是一个神经网络,它接收一个随机噪声向量作为输入,并试图将这个随机噪声转换为逼真的数据样本。在训练过程中,生成器不断试图提高生成样本的质量,使其能够欺骗判别器。初始阶段生成的样本可能不够真实,但随着训练的进行,生成器逐渐学会生成更加逼真的数据样本。
  2. 判别器(Discriminator): 判别器也是一个神经网络,它的任务是区分真实数据样本和由生成器生成的假样本。它类似于一个二分类器,努力将输入样本分为“真实”和“假”的两个类别。在训练过程中,判别器通过不断学习区分真实样本和生成样本,使得判别器的准确率不断提高。

GAN的训练过程是一个对抗过程:

  1. 生成器通过将随机噪声转换为生成样本,并将这些生成样本传递给判别器。
  2. 判别器根据传递给它的真实样本和生成样本对其进行分类,并输出相应的概率分数。
  3. 根据判别器的输出,生成器试图生成能够欺骗判别器的更逼真的样本。
  4. 这个过程不断重复,直到生成器生成的样本足够逼真,判别器无法准确区分真假样本。

通过这种对抗学习的过程,GAN能够生成高质量的数据样本,广泛应用于图像、音频、文本等领域。然而,训练GAN也存在一些挑战,如训练不稳定、模式崩溃等问题,需要经验丰富的研究人员进行调优和改进。

MNIST—GAN

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

# 定义生成器和判别器的类
class Generator(nn.Module):
    def __init__(self, z_dim=100, hidden_dim=128, output_dim=784):
        super(Generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(z_dim, hidden_dim),
            nn.LeakyReLU(0.01),
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.LeakyReLU(0.01),
            nn.Linear(hidden_dim * 2, output_dim),
            nn.Tanh()
        )

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

class Discriminator(nn.Module):
    def __init__(self, input_dim=784, hidden_dim=128):
        super(Discriminator, self).__init__()
        self.disc = nn.Sequential(
            nn.Linear(input_dim, hidden_dim * 2),
            nn.LeakyReLU(0.01),
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.LeakyReLU(0.01),
            nn.Linear(hidden_dim, 1),
            nn.Sigmoid()
        )

    def forward(self, image):
        return self.disc(image)

# 定义训练函数
def train_gan(generator, discriminator, dataloader, num_epochs=50, z_dim=100, lr=0.0002):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    generator.to(device)
    discriminator.to(device)
    
    gen_optim = optim.Adam(generator.parameters(), lr=lr)
    disc_optim = optim.Adam(discriminator.parameters(), lr=lr)
    criterion = nn.BCELoss()

    for epoch in range(num_epochs):
        for batch_idx, (real_images, _) in enumerate(dataloader):
            batch_size = real_images.size(0)
            real_images = real_images.view(batch_size, -1).to(device)
            ones_labels = torch.ones(batch_size, 1).to(device)
            zeros_labels = torch.zeros(batch_size, 1).to(device)

            # 训练判别器
            disc_optim.zero_grad()
            real_preds = discriminator(real_images)
            real_loss = criterion(real_preds, ones_labels)

            noise = torch.randn(batch_size, z_dim).to(device)
            fake_images = generator(noise)
            fake_preds = discriminator(fake_images.detach())
            fake_loss = criterion(fake_preds, zeros_labels)

            disc_loss = (real_loss + fake_loss) / 2
            disc_loss.backward()
            disc_optim.step()

            # 训练生成器
            gen_optim.zero_grad()
            noise = torch.randn(batch_size, z_dim).to(device)
            fake_images = generator(noise)
            preds = discriminator(fake_images)
            gen_loss = criterion(preds, ones_labels)
            gen_loss.backward()
            gen_optim.step()

        print(f"Epoch [{epoch+1}/{num_epochs}], Generator Loss: {gen_loss.item():.4f}, Discriminator Loss: {disc_loss.item():.4f}")

# 主函数
if __name__ == "__main__":
    # 定义参数和数据加载
    z_dim = 100
    batch_size = 64
    num_epochs = 50
    lr = 0.0002

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

    dataset = MNIST(root="data", transform=transform, download=True)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    # 创建生成器和判别器实例
    generator = Generator(z_dim=z_dim)
    discriminator = Discriminator()

    # 训练GAN
    train_gan(generator, discriminator, dataloader, num_epochs=num_epochs, z_dim=z_dim, lr=lr)

    # 生成并显示一些图像样本
    num_samples = 16
    noise = torch.randn(num_samples, z_dim)
    generated_images = generator(noise).detach().cpu()
    plt.figure(figsize=(8, 8))
    for i in range(num_samples):
        plt.subplot(4, 4, i + 1)
        plt.imshow(generated_images[i].view(28, 28), cmap='gray')
        plt.axis('off')
    plt.show()

Conditional GAN (CGAN)—时间序列预测

生成对抗网络(GAN)通常用于生成静态数据,例如图像、文本等。然而,要将GAN应用于时间序列预测,则需要对GAN进行适当的修改。在这里,我将向你介绍一个基于GAN的时间序列预测方法——Conditional GAN (CGAN)。

Conditional GAN (CGAN) 是GAN的扩展,它在生成器和判别器的输入中加入条件信息,使得生成器可以生成与给定条件相关的时间序列数据。在时间序列预测任务中,我们将使用历史时间序列数据作为条件信息来预测未来的时间序列值。文章来源地址https://www.toymoban.com/news/detail-813139.html

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 准备合成时间序列数据
def generate_time_series(num_samples, num_timesteps):
    freq1, freq2, offset1, offset2 = np.random.rand(4, num_samples, 1)
    time = np.linspace(0, 1, num_timesteps)
    series = 0.5 * np.sin((time - offset1) * (freq1 * 10 + 10))
    series += 0.2 * np.sin((time - offset2) * (freq2 * 20 + 20))
    series += 0.1 * (np.random.rand(num_samples, num_timesteps) - 0.5)
    return series[..., np.newaxis].astype(np.float32)

# 数据预处理
def prepare_data(data, seq_length):
    num_samples, num_timesteps, num_features = data.shape
    X, y = [], []
    for i in range(num_timesteps - seq_length):
        X.append(data[:, i:i+seq_length, :])
        y.append(data[:, i+seq_length, :])
    X = np.array(X)
    y = np.array(y)
    return X, y

# 生成器和判别器的定义
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim=64):
        super(Generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.ReLU(),
            nn.Linear(hidden_dim * 2, output_dim)
        )

    def forward(self, noise, condition):
        combined_input = torch.cat((noise, condition), dim=1)
        return self.gen(combined_input)

class Discriminator(nn.Module):
    def __init__(self, input_dim, hidden_dim=64):
        super(Discriminator, self).__init__()
        self.disc = nn.Sequential(
            nn.Linear(input_dim, hidden_dim * 2),
            nn.ReLU(),
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 1),
            nn.Sigmoid()
        )

    def forward(self, sequence, condition):
        combined_input = torch.cat((sequence, condition), dim=1)
        return self.disc(combined_input)

# 训练CGAN
def train_cgan(generator, discriminator, data, num_epochs=1000, batch_size=64, seq_length=10, noise_dim=20, lr=0.001):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    generator.to(device)
    discriminator.to(device)

    gen_optim = optim.Adam(generator.parameters(), lr=lr)
    disc_optim = optim.Adam(discriminator.parameters(), lr=lr)
    criterion = nn.BCELoss()

    for epoch in range(num_epochs):
        idx = np.random.randint(0, data.shape[0] - seq_length, batch_size)
        real_data = torch.tensor(data[idx]).to(device)
        condition = torch.tensor(data[idx + seq_length]).to(device)

        # 训练判别器
        disc_optim.zero_grad()
        noise = torch.randn(batch_size, noise_dim).to(device)
        fake_data = generator(noise, condition)
        disc_real_preds = discriminator(real_data, condition)
        disc_fake_preds = discriminator(fake_data, condition)

        real_labels = torch.ones(batch_size, 1).to(device)
        fake_labels = torch.zeros(batch_size, 1).to(device)

        disc_real_loss = criterion(disc_real_preds, real_labels)
        disc_fake_loss = criterion(disc_fake_preds, fake_labels)
        disc_loss = (disc_real_loss + disc_fake_loss) / 2
        disc_loss.backward()
        disc_optim.step()

        # 训练生成器
        gen_optim.zero_grad()
        noise = torch.randn(batch_size, noise_dim).to(device)
        fake_data = generator(noise, condition)
        gen_disc_preds = discriminator(fake_data, condition)
        gen_labels = torch.ones(batch_size, 1).to(device)

        gen_loss = criterion(gen_disc_preds, gen_labels)
        gen_loss.backward()
        gen_optim.step()

        if epoch % 100 == 0:
            print(f"Epoch [{epoch}/{num_epochs}], Generator Loss: {gen_loss.item():.4f}, Discriminator Loss: {disc_loss.item():.4f}")

# 主函数
if __name__ == "__main__":
    # 定义参数和合成时间序列数据集
    num_samples = 1000
    num_timesteps = 50
    seq_length = 10
    noise_dim = 20
    lr = 0.001
    num_epochs = 2000

    data = generate_time_series(num_samples, num_timesteps)
    X, y = prepare_data(data, seq_length)

    # 创建生成器和判别器实例
    input_dim = noise_dim + seq_length
    output_dim = y.shape[-1]
    generator = Generator(input_dim, output_dim)
    discriminator = Discriminator(input_dim)

    # 训练CGAN
    train_cgan(generator, discriminator, X, num_epochs=num_epochs, batch_size=64, seq_length=seq_length, noise_dim=noise_dim, lr=lr)

    # 预测未来的时间序列
    num_predictions = 5
    noise = torch.randn(num_predictions, noise_dim).to(device)
    condition = torch.tensor(data[-num_predictions:, -seq_length:, :]).to(device)
    generated_data = generator(noise, condition).detach().cpu().numpy()

    # 显示生成的时间序列
    plt.figure(figsize=(10, 6))
    for i in range(num_predictions):
        plt.plot(range(num_timesteps - seq_length, num_timesteps), condition[i, :, 0], 'b-')
        plt.plot(range(num_timesteps, num_timesteps + seq_length), generated_data[i, :, 0], 'r--')
    plt.xlabel('Time')
    plt.ylabel('Value')
    plt.legend(['Past', 'Generated Future'])
    plt.show()

到了这里,关于生成对抗网络GAN(MNIST实现、时间序列实现)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【计算机视觉|生成对抗】生成对抗网络(GAN)

    本系列博文为深度学习/计算机视觉论文笔记,转载请注明出处 标题: Generative Adversarial Nets 链接:Generative Adversarial Nets (nips.cc) 我们提出了一个通过**对抗(adversarial)**过程估计生成模型的新框架,在其中我们同时训练两个模型: 一个生成模型G,捕获数据分布 一个判别模型

    2024年02月12日
    浏览(58)
  • GAN实现mnist生成

    GAN参考,他写的超好 在上面的代码中,优化 Discriminator(D)和 Generator(G)是分开进行的。当优化 Discriminator 时,只有 Discriminator 的参数会被更新。这是通过执行 d_loss.backward() 和 d_optimizer.step() 来实现的。在这一步,Generator 的参数不会被更新。 同样地,当优化 Generator 时,只

    2024年02月07日
    浏览(50)
  • 生成对抗网络----GAN

    ` GAN (Generative Adversarial Network) : 通过两个神经网络,即生成器(Generator)和判别器(Discriminator),相互竞争来学习数据分布。 { 生成器 ( G e n e r a t o r ) : 负责从随机噪声中学习生成与真实数据相似的数据。 判别器 ( D i s c r i m i n a t o r ) : 尝试区分生成的数据和真实数据。

    2024年02月20日
    浏览(46)
  • GAN(生成对抗网络)

    简介:GAN生成对抗网络本质上是一种思想,其依靠神经网络能够拟合任意函数的能力,设计了一种架构来实现数据的生成。 原理:GAN的原理就是最小化生成器Generator的损失,但是在最小化损失的过程中加入了一个约束,这个约束就是使Generator生成的数据满足我们指定数据的分

    2024年02月11日
    浏览(47)
  • GAN生成对抗网络介绍

    GAN 全称是Generative Adversarial Networks,即 生成对抗网络 。 “生成”表示它是一个生成模型,而“对抗”代表它的训练是处于一种对抗博弈状态中的。 一个可以自己创造数据的网络! 判别模型与生成模型 判别模型(Discriminative Model) 主要目标是对给定输入数据直接进行建模,

    2024年01月17日
    浏览(52)
  • 了解生成对抗网络 (GAN)

            Yann LeCun将其描述为“过去10年来机器学习中最有趣的想法”。当然,来自深度学习领域如此杰出的研究人员的赞美总是对我们谈论的主题的一个很好的广告!事实上,生成对抗网络(简称GAN)自2014年由Ian J. Goodfellow和共同作者在《

    2024年02月12日
    浏览(39)
  • 生成式对抗网络GAN

    Generative Adversarial Nets 由伊恩·古德费洛(Ian J.Goodfellow)等人于2014年发表在Conference on Neural Information Processing Systems (NeurIPS)上。NeurIPS是机器学习和计算神经科学领域的顶级国际学术会议之一。 图像生成: 论文地址:styleGAN styleGAN2 图像生成是生成模型的基本问题,GAN相对先前的

    2024年01月16日
    浏览(40)
  • 生成对抗网络 (GAN)

    生成对抗网络(Generative Adversarial Networks,GAN)是由Ian Goodfellow等人在2014年提出的一种深度学习模型。GAN由两部分组成:一个生成器(Generator)和一个判别器(Discriminator),它们通过对抗过程来训练,从而能够生成非常逼真的数据。 生成器(Generator) 生成器的任务是创建尽可

    2024年03月10日
    浏览(57)
  • GAN-对抗生成网络

    generator:

    2024年02月09日
    浏览(37)
  • 【神经网络】生成对抗网络GAN

    欢迎访问Blog总目录! Generative Adversarial Networks 生成对抗网络(GAN) - 知乎 (zhihu.com) 深度学习----GAN(生成对抗神经网络)原理解析_gan神经网络-CSDN博客 图解 生成对抗网络GAN 原理 超详解_生成对抗网络gan图解-CSDN博客 GAN包含两个模型: 生成模型(Generator) :接收随机噪声,生

    2024年04月13日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包