CVAE——生成0-9数字图像(Pytorch+mnist)

1、简介

  • CVAE(Conditional Variational Autoencoder,条件变分自编码器)是一种变分自编码器(VAE)的变体,用于生成有条件的数据。在传统的变分自编码器中,生成的数据是完全由潜在变量决定的,而CVAE允许在生成过程中引入外部条件信息。
  • 具体来说,CVAE在生成数据时,除了使用随机采样的潜在变量外,还会接收一个额外的条件信息。这个条件信息可以是类别标签、属性信息、或者其他形式的上下文信息,取决于具体的任务。通过将条件信息作为输入提供给编码器和解码器,CVAE能够生成与条件信息相关的数据。
  • CVAE在许多任务中都很有用,例如图像生成中的类别条件生成、属性编辑、生成特定风格的图像等。通过引入条件信息,CVAE使得生成的数据更具有控制性和可解释性。
  • 本文利用CVAE,输入数字图像和对应的标签。训练后,生成0-9数字图像。
    • (epoch=10)
    • (epoch=20)
    • (epoch=30)

2、代码

  • import torch
    import torch.nn as nn
    import torch.optim as optim
    import torchvision
    import torch.nn.functional as F
    from torchvision.utils import save_image
    
    
    # 变分自编码器
    class CVAE(nn.Module):
        def __init__(self):
            super(CVAE, self).__init__()
            self.labels = 10  # 标签数量
    
            # 编码器层
            self.fc1 = nn.Linear(input_size + self.labels, 512)  # 编码器输入层
            self.fc2 = nn.Linear(512, latent_size)
            self.fc3 = nn.Linear(512, latent_size)
    
            # 解码器层
            self.fc4 = nn.Linear(latent_size + self.labels, 512)  # 解码器输入层
            self.fc5 = nn.Linear(512, input_size)  # 解码器输出层
    
        # 编码器部分
        def encode(self, x):
            x = F.relu(self.fc1(x))  # 编码器的隐藏表示
            mu = self.fc2(x)  # 潜在空间均值
            log_var = self.fc3(x)  # 潜在空间对数方差
            return mu, log_var
    
        # 重参数化技巧
        def reparameterize(self, mu, log_var):  # 从编码器输出的均值和对数方差中采样得到潜在变量z
            std = torch.exp(0.5 * log_var)  # 计算标准差
            eps = torch.randn_like(std)  # 从标准正态分布中采样得到随机噪声
            return mu + eps * std  # 根据重参数化公式计算潜在变量z
    
        # 解码器部分
        def decode(self, z):
            z = F.relu(self.fc4(z))  # 将潜在变量 z 解码为重构图像
            return torch.sigmoid(self.fc5(z))  # 将隐藏表示映射回输入图像大小,并应用 sigmoid 激活函数,以产生重构图像
    
        # 前向传播
        def forward(self, x, y):  # 输入图像 x,标签 y 通过编码器和解码器,得到重构图像和潜在变量的均值和对数方差
            x = torch.cat([x, y], dim=1)
            mu, log_var = self.encode(x)
            z = self.reparameterize(mu, log_var)
            z = torch.cat([z, y], dim=1)
            return self.decode(z), mu, log_var
    
    
    # 使用重构损失和 KL 散度作为损失函数
    def loss_function(recon_x, x, mu, log_var):  # 参数:重构的图像、原始图像、潜在变量的均值、潜在变量的对数方差
        MSE = F.mse_loss(recon_x, x.view(-1, input_size), reduction='sum')  # 计算重构图像 recon_x 和原始图像 x 之间的均方误差
        KLD = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())  # 计算潜在变量的KL散度
        return MSE + KLD  # 返回二进制交叉熵损失和 KLD 损失的总和作为最终的损失值
    
    
    def sample_images(epoch):
        with torch.no_grad():  # 上下文管理器,确保在该上下文中不会进行梯度计算。因为在这里只是生成样本而不需要梯度
            number = 10
            # 生成标签
            sample_labels = torch.arange(10).long().to(device)  # 0-9的标签
            sample_labels_onehot = F.one_hot(sample_labels, num_classes=10).float()
            # 生成随机噪声
            sample = torch.randn(number, latent_size).to(device)  # 生成一个形状为 (64, latent_size) 的张量,其中包含从标准正态分布中采样的随机数
            sample = torch.cat([sample, sample_labels_onehot], dim=1)  # 连接图片和标签
    
            sample = model.decode(sample).cpu()  # 将随机样本输入到解码器中,解码器将其映射为图像
            save_image(sample.view(number, 1, 28, 28), f'sample{epoch}.png', nrow=int(number / 2))  # 将生成的图像保存为文件
    
    
    if __name__ == '__main__':
        batch_size = 512  # 批次大小
        epochs = 30  # 学习周期
        sample_interval = 10  # 保存结果的周期
        learning_rate = 0.001  # 学习率
        input_size = 784  # 输入大小
        latent_size = 64  # 潜在变量大小
    
        # 载入 MNIST 数据集中的图片进行训练
        transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])  # 将图像转换为张量
    
        train_dataset = torchvision.datasets.MNIST(
            root="~/torch_datasets", train=True, transform=transform, download=True
        )  # 加载 MNIST 数据集的训练集,设置路径、转换和下载为 True
    
        train_loader = torch.utils.data.DataLoader(
            train_dataset, batch_size=batch_size, shuffle=True
        )  # 创建一个数据加载器,用于加载训练数据,设置批处理大小和是否随机打乱数据
    
        # 在使用定义的 AE 类之前,有以下事情要做:
        # 配置要在哪个设备上运行
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
        # 建立 CVAE 模型并载入到 CPU 设备
        model = CVAE().to(device)
    
        # Adam 优化器,学习率
        optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    
        # 训练
        for epoch in range(epochs):
            train_loss = 0
            for batch_idx, (data, labels) in enumerate(train_loader):
                data = data.to(device)  # 将输入数据移动到设备(GPU 或 CPU)上
                data = data.view(-1, input_size)  # 重塑维度
    
                labels = F.one_hot(labels, num_classes=10).float().to(device)  # 转换为独热编码
                # print(labels[1])
    
                optimizer.zero_grad()  # 进行反向传播之前,需要将优化器中的梯度清零,以避免梯度的累积
    
                # 重构图像 recon_batch、潜在变量的均值 mu 和对数方差 log_var
                recon_batch, mu, log_var = model(data, labels)
    
                loss = loss_function(recon_batch, data, mu, log_var)  # 计算损失
                loss.backward()  # 计算损失相对于模型参数的梯度
                train_loss += loss.item()
    
                optimizer.step()  # 更新模型参数
    
            train_loss = train_loss / len(train_loader)  # # 计算每个周期的训练损失
            print('Epoch [{}/{}], Loss: {:.3f}'.format(epoch + 1, epochs, train_loss))
    
            # 每10次保存图像
            if (epoch + 1) % sample_interval == 0:
                sample_images(epoch + 1)
    
            # 每训练10次保存模型
            if (epoch + 1) % sample_interval == 0:
                torch.save(model.state_dict(), f'vae{epoch + 1}.pth')
### 条件变分自编码器(CVAE)简介 条件变分自编码器(Conditional Variational Autoencoder, CVAE)是一种扩展了标准变分自动编码器(VAE)[^1]的方法,在该架构中加入了额外的信息作为条件。这种设计允许模型更好地处理特定类型的输入到输出的一对多映射问题[^2]。 对于CVAE来说,其核心在于通过引入外部条件变量来指导生成过程。例如,在手写数字识别任务(MNIST数据集)上应用时,可以在每次向编码器和解码器传递图像的同时附加一个类别标签(label),这使得即使当两个样本位于相同的潜在空间位置时也能依据不同的标签获得各异的结果[^3]。 #### 数学表达与工作原理 假设有一个观测样本\(X\)以及相应的条件信息\(y\),那么CVAE的目标就是最大化下界: \[L_{CVAE}=\mathbb{E}_{q_\phi(z|x,y)}[\log p_\theta(x|z,y)]-\beta KL(q_\phi(z|x,y)\parallel p(z))\] 这里, - \(p_\theta(x|z,y)\)表示给定隐含变量\(z\)及条件\(y\)的情况下重建原始数据的概率分布; - \(KL(\cdot||\cdot)\)代表Kullback-Leibler散度,用来衡量近似后验概率\(q_\phi(z|x,y)\)相对于先验概率\(p(z)\)之间的差异程度; - 参数\(\beta>0\)控制着重构损失项与正则化项之间的重要性权衡。 值得注意的是,尽管表面上看似乎只是简单地增加了条件部分,但实际上这样做能够显著改善某些应用场景下的表现效果,比如在面对复杂模式或多模态数据时更加灵活有效。 ```python import torch.nn as nn class Encoder(nn.Module): def __init__(self, input_dim, condition_dim, hidden_dims, latent_dim): super().__init__() self.fc = nn.Sequential( nn.Linear(input_dim + condition_dim, hidden_dims[0]), # ... other layers ... nn.ReLU() ) self.mu_layer = nn.Linear(hidden_dims[-1], latent_dim) self.logvar_layer = nn.Linear(hidden_dims[-1], latent_dim) def forward(self, x, y): xy = torch.cat([x, y], dim=1) h = self.fc(xy) mu = self.mu_layer(h) log_var = self.logvar_layer(h) return mu, log_var class Decoder(nn.Module): def __init__(self, output_dim, condition_dim, hidden_dims, latent_dim): super().__init__() self.fc = nn.Sequential( nn.Linear(latent_dim + condition_dim, hidden_dims[0]), # ... other layers ... nn.Sigmoid() # Assuming binary cross entropy loss is used. ) def forward(self, z, y): zy = torch.cat([z, y], dim=1) out = self.fc(zy) return out ``` 上述代码片段展示了一个简单的PyTorch实现框架,其中包含了带有条件输入的编码器和解码器模块定义。注意这里的`forward()`函数接收了额外的条件参数`y`用于辅助建模。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

恣睢s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值