生成式AI

编辑日期: 2024-07-09 文章阅读: 次

生成式AI

了解生成式AI的基础知识

生成式AI（Generative AI）是一种通过学习现有数据生成新数据的技术。

它在图像生成、文本生成、音乐创作等领域有广泛应用。

本节课将介绍生成式AI的基本概念、常用技术和应用场景。

生成式AI的基本概念

定义

生成式AI是使用机器学习模型生成与训练数据相似但不完全相同的新数据的技术。

与传统的判别式模型（例如分类器）不同，

生成式模型不仅学习数据的分类边界，

还学习数据的分布。

关键技术

1. 生成对抗网络（Generative Adversarial Networks, GANs）

GANs 是一种通过两个神经网络（生成器和判别器）相互竞争来生成新数据的模型。

生成器尝试生成逼真的数据，而判别器则尝试区分生成的数据和真实的数据。

import torch
import torch.nn as nn
import torch.optim as optim

# 生成器模型
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = 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, 28*28),
            nn.Tanh()
        )

    def forward(self, x):
        return self.main(x).view(-1, 1, 28, 28)

# 判别器模型
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(28*28, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = x.view(-1, 28*28)
        return self.main(x)

# 初始化模型
generator = Generator()
discriminator = Discriminator()

# 损失函数和优化器
criterion = nn.BCELoss()
optimizer_g = optim.Adam(generator.parameters(), lr=0.0002)
optimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002)

2. 变分自编码器（Variational Autoencoders, VAEs）

VAEs 是一种生成模型，通过编码器将输入数据压缩成潜在表示，然后通过解码器从潜在表示生成新数据。

class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()
        self.fc1 = nn.Linear(784, 400)
        self.fc21 = nn.Linear(400, 20)  # 均值
        self.fc22 = nn.Linear(400, 20)  # 方差
        self.fc3 = nn.Linear(20, 400)
        self.fc4 = nn.Linear(400, 784)

    def encode(self, x):
        h1 = torch.relu(self.fc1(x))
        return self.fc21(h1), self.fc22(h1)

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5*logvar)
        eps = torch.randn_like(std)
        return mu + eps*std

    def decode(self, z):
        h3 = torch.relu(self.fc3(z))
        return torch.sigmoid(self.fc4(h3))

    def forward(self, x):
        mu, logvar = self.encode(x.view(-1, 784))
        z = self.reparameterize(mu, logvar)
        return self.decode(z), mu, logvar

# 初始化模型
vae = VAE()
optimizer = optim.Adam(vae.parameters(), lr=1e-3)