本文介绍了深度卷积生成对抗网络（DCGAN）的基础，包括其架构和在PyTorch中的实现。通过条件生成对抗网络（CGAN）的讲解，阐述了如何在生成器和判别器中加入条件信息以生成特定属性的图像。文章详细展示了数据预处理、模型构建（生成器和判别器）、损失函数定义、优化器设置以及模型训练的过程，最后通过插值分析展示了模型生成图像的能力。
- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊
- 🚀 参考文章：GAN入门｜第二篇：人脸图像生成（DCGAN）
一、课题背景和开发环境
深度卷积对抗网络（Deep Convolutional Generative Adversarial Networks，简称DCGAN）是一种深度学习模型，由生成器（Generator）和判别器（Discriminator）两个神经网络组成。DCGAN结合了卷积神经网络（Convolutional Neural Networks，简称CNN）和生成对抗网络（Generative Adversarial Networks，简称GAN）的思想，用于生成逼真的图像。
📌第G3周：CGAN｜生成手势图像📌
- Python 3.8.12
- numpy==1.21.5 -> 1.24.3
- pytorch==1.8.1+cu111
📌 基础任务：
- 条件生成对抗网络（CGAN）的基本原理
- 学习本文CGAN代码，并跑通代码
🎈进阶任务：
- 生成指定手势的图像（下周公布）
二、理论知识
条件生成对抗网络（CGAN）是在生成对抗网络（GAN）的基础上进行了一些改进。对于原始GAN的生成器而言，其生成的图像数据是随机不可预测的，因此我们无法控制网络的输出，在实际操作中的可控性不强。
针对上述原始GAN无法生成具有特定属性的图像数据的问题，Mehdi Mirza等人在2014年提出了条件生成对抗网络，通过给原始生成对抗网络中的生成器G和判别器D增加额外的条件，例如我们需要生成器G生成一张没有阴影的图像，此时判别器D就需要判断生成器所生成的图像是否是一张没有阴影的图像。条件生成对抗网络的本质是将额外添加的信息融入到生成器和判别器中，其中添加的信息可以是图像的类别、人脸表情和其他辅助信息等，旨在把无监督学习的GAN转化为有监督学习的CGAN，便于网络能够在我们的掌控下更好地进行训练。CGAN网络结构如下图所示。
由上图的网络结构可知，条件信息y作为额外的输入被引入对抗网络中，与生成器中的噪声z合并作为隐含层表达；而在判别器D中，条件信息y则与原始数据x合并作为判别函数的输入。这种改进在以后的诸多方面研究中被证明是非常有效的，也为后续的相关工作提供了积极的指导作用。
三、准备工作
1.导入数据
# 参数配置
dataroot = "./data/rps/" # 数据路径
n_epochs = 10 # 训练的总轮数
batch_size = 128 # 训练过程中的批次大小
image_shape = (3, 128, 128) # 图像的尺寸（宽度和高度）
image_dim = int(np.prod(image_shape)) # 图像的维度
latent_dim = 100
n_classes = 3
embedding_dim = 100
learning_rate = 0.0002 # 学习率
beta1 = 0.5 # Adam优化器的Beta1超参数
beta2 = 0.999 # Adam优化器的Beta2超参数
# 选择要在哪个设备上运行代码
device = torch.device("cuda:0" if (torch.cuda.is_available()) else "cpu")
print("使用的设备是：",device)
# 导入数据
train_transform = transforms.Compose([transforms.Resize(128), # 中心裁剪图像
transforms.ToTensor(), # 将图像转换为张量
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),]) # 标准化图像张量
train_dataset = datasets.ImageFolder(root=dataroot,
transform=train_transform)
train_dataloader = DataLoader(dataset=train_dataset,
batch_size=batch_size, # 批量大小
shuffle=True) # 是否打乱数据集
2.数据可视化
def show_images(images):
fig, ax = plt.subplots(figsize=(20, 20))
ax.set_xticks([])
ax.set_yticks([])
ax.imshow(make_grid(images.detach(), nrow=22).permute(1, 2, 0))
def show_batch(dl):
for images, _ in dl:
show_images(images)
break
# 数据可视化
show_batch(train_dataloader)
四、构建模型
# 自定义权重初始化函数，作用于netG和netD
def weights_init(m):
# 获取当前层的类名
classname = m.__class__.__name__
# 如果类名中包含'Conv'，即当前层是卷积层
if classname.find('Conv') != -1:
# 使用正态分布初始化权重数据，均值为0，标准差为0.02
nn.init.normal_(m.weight.data, 0.0, 0.02)
# 如果类名中包含'BatchNorm'，即当前层是批归一化层
elif classname.find('BatchNorm') != -1:
# 使用正态分布初始化权重数据，均值为1，标准差为0.02
nn.init.normal_(m.weight.data, 1.0, 0.02)
# 使用常数初始化偏置项数据，值为0
# torch.nn.init.zeros_(m.bias)
nn.init.constant_(m.bias.data, 0)
1.构建生成器
'''
定义生成器 Generator
'''
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
# 定义条件标签的生成器部分，用于将标签映射到嵌入空间中
# n_classes：条件标签的总数
# embedding_dim：嵌入空间的维度
self.label_conditioned_generator = nn.Sequential(
nn.Embedding(n_classes, embedding_dim), # 使用Embedding层将条件标签映射为稠密向量
nn.Linear(embedding_dim, 16) # 使用线性层将稠密向量转换为更高维度
)
# 定义潜在向量的生成器部分，用于将噪声向量映射到图像空间中
# latent_dim：潜在向量的维度
self.latent = nn.Sequential(
nn.Linear(latent_dim, 4*4*512), # 使用线性层将潜在向量转换为更高维度
nn.LeakyReLU(0.2, inplace=True) # 使用LeakyReLU激活函数进行非线性映射
)
# 定义生成器的主要结构，将条件标签和潜在向量合并成生成的图像
self.model = nn.Sequential(
# 反卷积层1：将合并后的向量映射为64x8x8的特征图
nn.ConvTranspose2d(513, 64*8, 4, 2, 1, bias=False),
nn.BatchNorm2d(64*8, momentum=0.1, eps=0.8), # 批标准化
nn.ReLU(True), # ReLU激活函数
# 反卷积层2：将64x8x8的特征图映射为64x4x4的特征图
nn.ConvTranspose2d(64*8, 64*4, 4, 2, 1, bias=False),
nn.BatchNorm2d(64*4, momentum=0.1, eps=0.8),
nn.ReLU(True),
# 反卷积层3：将64x4x4的特征图映射为64x2x2的特征图
nn.ConvTranspose2d(64*4, 64*2, 4, 2, 1, bias=False),
nn.BatchNorm2d(64*2, momentum=0.1, eps=0.8),
nn.ReLU(True),
# 反卷积层4：将64x2x2的特征图映射为64x1x1的特征图
nn.ConvTranspose2d(64*2, 64*1, 4, 2, 1, bias=False),
nn.BatchNorm2d(64*1, momentum=0.1, eps=0.8),
nn.ReLU(True),
# 反卷积层5：将64x1x1的特征图映射为3x64x64的RGB图像
nn.ConvTranspose2d(64*1, 3, 4, 2, 1, bias=False),
nn.Tanh() # 使用Tanh激活函数将生成的图像像素值映射到[-1, 1]范围内
)
def forward(self, inputs):
noise_vector, label = inputs
# 通过条件标签生成器将标签映射为嵌入向量
label_output = self.label_conditioned_generator(label)
# 将嵌入向量的形状变为（batch_size, 1, 4, 4），以便与潜在向量进行合并
label_output = label_output.view(-1, 1, 4, 4)
# 通过潜在向量生成器将噪声向量映射为潜在向量
latent_output = self.latent(noise_vector)
# 将潜在向量的形状变为（batch_size, 512, 4, 4），以便与条件标签进行合并
latent_output = latent_output.view(-1, 512, 4, 4)
# 将条件标签和潜在向量在通道维度上进行合并，得到合并后的特征图
concat = torch.cat((latent_output, label_output), dim=1)
# 通过生成器的主要结构将合并后的特征图生成为RGB图像
image = self.model(concat)
return image
# 创建生成器
generator = Generator().to(device)
# 使用 "weights_init" 函数对所有权重进行随机初始化，
# 平均值(mean)设置为0，标准差(stdev)设置为0.02。
generator.apply(weights_init)
# 打印生成器模型
print(generator)
summary(generator)
Generator(
(label_conditioned_generator): Sequential(
(0): Embedding(3, 100)
(1): Linear(in_features=100, out_features=16, bias=True)
)
(latent): Sequential(
(0): Linear(in_features=100, out_features=8192, bias=True)
(1): LeakyReLU(negative_slope=0.2, inplace=True)
)
(model): Sequential(
(0): ConvTranspose2d(513, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(1): BatchNorm2d(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(2): ReLU(inplace=True)
(3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(4): BatchNorm2d(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(5): ReLU(inplace=True)
(6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(7): BatchNorm2d(128, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(8): ReLU(inplace=True)
(9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(10): BatchNorm2d(64, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(11): ReLU(inplace=True)
(12): ConvTranspose2d(64, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(13): Tanh()
)
)
=================================================================
Layer (type:depth-idx) Param #
=================================================================
Generator --
├─Sequential: 1-1 --
│ └─Embedding: 2-1 300
│ └─Linear: 2-2 1,616
├─Sequential: 1-2 --
│ └─Linear: 2-3 827,392
│ └─LeakyReLU: 2-4 --
├─Sequential: 1-3 --
│ └─ConvTranspose2d: 2-5 4,202,496
│ └─BatchNorm2d: 2-6 1,024
│ └─ReLU: 2-7 --
│ └─ConvTranspose2d: 2-8 2,097,152
│ └─BatchNorm2d: 2-9 512
│ └─ReLU: 2-10 --
│ └─ConvTranspose2d: 2-11 524,288
│ └─BatchNorm2d: 2-12 256
│ └─ReLU: 2-13 --
│ └─ConvTranspose2d: 2-14 131,072
│ └─BatchNorm2d: 2-15 128
│ └─ReLU: 2-16 --
│ └─ConvTranspose2d: 2-17 3,072
│ └─Tanh: 2-18 --
=================================================================
Total params: 7,789,308
Trainable params: 7,789,308
Non-trainable params: 0
=================================================================
2.构建判别器
'''
定义判别器 Discriminator
'''
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
# 定义一个条件标签的嵌入层，用于将类别标签转换为特征向量
self.label_condition_disc = nn.Sequential(
nn.Embedding(n_classes, embedding_dim), # 嵌入层将类别标签编码为固定长度的向量
nn.Linear(embedding_dim, 3*128*128) # 线性层将嵌入的向量转换为与图像尺寸相匹配的特征张量
)
# 定义主要的鉴别器模型
self.model = nn.Sequential(
nn.Conv2d(6, 64, 4, 2, 1, bias=False), # 输入通道为6（包含图像和标签的通道数），输出通道为64，4x4的卷积核，步长为2，padding为1
nn.LeakyReLU(0.2, inplace=True), # LeakyReLU激活函数，带有负斜率，增加模型对输入中的负值的感知能力
nn.Conv2d(64, 64*2, 4, 3, 2, bias=False), # 输入通道为64，输出通道为64*2，4x4的卷积核，步长为3，padding为2
nn.BatchNorm2d(64*2, momentum=0.1, eps=0.8), # 批量归一化层，有利于训练稳定性和收敛速度
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64*2, 64*4, 4, 3, 2, bias=False), # 输入通道为64*2，输出通道为64*4，4x4的卷积核，步长为3，padding为2
nn.BatchNorm2d(64*4, momentum=0.1, eps=0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64*4, 64*8, 4, 3, 2, bias=False), # 输入通道为64*4，输出通道为64*8，4x4的卷积核，步长为3，padding为2
nn.BatchNorm2d(64*8, momentum=0.1, eps=0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Flatten(), # 将特征图展平为一维向量，用于后续全连接层处理
nn.Dropout(0.4), # 随机失活层，用于减少过拟合风险
nn.Linear(4608, 1), # 全连接层，将特征向量映射到输出维度为1的向量
nn.Sigmoid() # Sigmoid激活函数，用于输出范围限制在0到1之间的概率值
)
def forward(self, inputs):
img, label = inputs
# 将类别标签转换为特征向量
label_output = self.label_condition_disc(label)
# 重塑特征向量为与图像尺寸相匹配的特征张量
label_output = label_output.view(-1, 3, 128, 128)
# 将图像特征和标签特征拼接在一起作为鉴别器的输入
concat = torch.cat((img, label_output), dim=1)
# 将拼接后的输入通过鉴别器模型进行前向传播，得到输出结果
output = self.model(concat)
return output
# 创建判别器对象
discriminator = Discriminator().to(device)
# 应用 "weights_init" 函数来随机初始化所有权重
# 使用 mean=0, stdev=0.2 的方式进行初始化
discriminator.apply(weights_init)
# 打印判别器模型
print(discriminator)
summary(discriminator)
Discriminator(
(label_condition_disc): Sequential(
(0): Embedding(3, 100)
(1): Linear(in_features=100, out_features=49152, bias=True)
)
(model): Sequential(
(0): Conv2d(6, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(1): LeakyReLU(negative_slope=0.2, inplace=True)
(2): Conv2d(64, 128, kernel_size=(4, 4), stride=(3, 3), padding=(2, 2), bias=False)
(3): BatchNorm2d(128, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(4): LeakyReLU(negative_slope=0.2, inplace=True)
(5): Conv2d(128, 256, kernel_size=(4, 4), stride=(3, 3), padding=(2, 2), bias=False)
(6): BatchNorm2d(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(7): LeakyReLU(negative_slope=0.2, inplace=True)
(8): Conv2d(256, 512, kernel_size=(4, 4), stride=(3, 3), padding=(2, 2), bias=False)
(9): BatchNorm2d(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)
(10): LeakyReLU(negative_slope=0.2, inplace=True)
(11): Flatten(start_dim=1, end_dim=-1)
(12): Dropout(p=0.4, inplace=False)
(13): Linear(in_features=4608, out_features=1, bias=True)
(14): Sigmoid()
)
)
=================================================================
Layer (type:depth-idx) Param #
=================================================================
Discriminator --
├─Sequential: 1-1 --
│ └─Embedding: 2-1 300
│ └─Linear: 2-2 4,964,352
├─Sequential: 1-2 --
│ └─Conv2d: 2-3 6,144
│ └─LeakyReLU: 2-4 --
│ └─Conv2d: 2-5 131,072
│ └─BatchNorm2d: 2-6 256
│ └─LeakyReLU: 2-7 --
│ └─Conv2d: 2-8 524,288
│ └─BatchNorm2d: 2-9 512
│ └─LeakyReLU: 2-10 --
│ └─Conv2d: 2-11 2,097,152
│ └─BatchNorm2d: 2-12 1,024
│ └─LeakyReLU: 2-13 --
│ └─Flatten: 2-14 --
│ └─Dropout: 2-15 --
│ └─Linear: 2-16 4,609
│ └─Sigmoid: 2-17 --
=================================================================
Total params: 7,729,709
Trainable params: 7,729,709
Non-trainable params: 0
=================================================================
五、训练模型
1.定义损失函数
# 定义损失函数
adversarial_loss = nn.BCELoss()
def generator_loss(fake_output, label):
gen_loss = adversarial_loss(fake_output, label)
return gen_loss
def discriminator_loss(output, label):
disc_loss = adversarial_loss(output, label)
return disc_loss
2.定义优化器
# 定义优化器
G_optimizer = optim.Adam(generator.parameters(), lr=learning_rate, betas=(beta1, beta2))
D_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate, betas=(beta1, beta2))
3.训练模型
# 初始化用于存储每轮训练中判别器和生成器损失的列表
D_loss_plot, G_loss_plot = [], []
print("Starting Training Loop...") # 输出训练开始的提示信息
# 进行多个epoch的训练
for epoch in range(1,n_epochs+1):
# 初始化每轮训练中判别器和生成器损失的临时列表
D_loss_list, G_loss_list = [], []
# 遍历训练数据加载器中的数据
for index, (real_images, labels) in enumerate(train_dataloader):
D_optimizer.zero_grad() # 清除判别器网络的梯度
# 准备真实图像的数据
real_images = real_images.to(device)
labels = labels.to(device)
# 将标签的形状从一维向量转换为二维张量（用于后续计算）
labels = labels.unsqueeze(1).long()
# 创建真实目标和虚假目标的张量（用于判别器损失函数）
real_target = Variable(torch.ones(real_images.size(0), 1).to(device))
fake_target = Variable(torch.zeros(real_images.size(0), 1).to(device))
# 计算判别器对真实图像的损失
D_real_loss = discriminator_loss(discriminator((real_images, labels)), real_target)
# 从噪声向量中生成假图像（生成器的输入）
noise_vector = torch.randn(real_images.size(0), latent_dim, device=device)
noise_vector = noise_vector.to(device)
generated_image = generator((noise_vector, labels))
# 计算判别器对假图像的损失（注意detach()函数用于分离生成器梯度计算图）
output = discriminator((generated_image.detach(), labels))
D_fake_loss = discriminator_loss(output, fake_target)
# 计算判别器总体损失（真实图像损失和假图像损失的平均值）
D_total_loss = (D_real_loss + D_fake_loss) / 2
D_loss_list.append(D_total_loss)
# 反向传播更新判别器的参数
D_total_loss.backward()
D_optimizer.step()
# 清空生成器的梯度缓存
G_optimizer.zero_grad()
# 计算生成器的损失
G_loss = generator_loss(discriminator((generated_image, labels)), real_target)
G_loss_list.append(G_loss)
# 反向传播更新生成器的参数
G_loss.backward()
G_optimizer.step()
# 打印当前轮次的判别器和生成器的平均损失
print('Epoch: [%d/%d]: D_loss: %.3f, G_loss: %.3f' % (
(epoch), n_epochs, torch.mean(torch.FloatTensor(D_loss_list)),
torch.mean(torch.FloatTensor(G_loss_list))))
# 将当前轮次的判别器和生成器的平均损失保存到列表中
D_loss_plot.append(torch.mean(torch.FloatTensor(D_loss_list)))
G_loss_plot.append(torch.mean(torch.FloatTensor(G_loss_list)))
if epoch%10 == 0:
# 将生成的假图像保存为图片文件
save_image(generated_image.data[:50], './output/images/sample_%d' % epoch + '.png', nrow=5, normalize=True)
# 将当前轮次的生成器和判别器的权重保存到文件
torch.save(generator.state_dict(), './output/generator_epoch_%d.pth' % (epoch))
torch.save(discriminator.state_dict(), './output/discriminator_epoch_%d.pth' % (epoch))
Starting Training Loop...
Epoch: [1/50]: D_loss: 0.338, G_loss: 1.378
Epoch: [2/50]: D_loss: 0.232, G_loss: 2.410
Epoch: [3/50]: D_loss: 0.343, G_loss: 2.193
Epoch: [4/50]: D_loss: 0.420, G_loss: 1.682
Epoch: [5/50]: D_loss: 0.321, G_loss: 2.068
Epoch: [6/50]: D_loss: 0.465, G_loss: 1.884
Epoch: [7/50]: D_loss: 0.464, G_loss: 1.641
Epoch: [8/50]: D_loss: 0.423, G_loss: 1.480
Epoch: [9/50]: D_loss: 0.386, G_loss: 1.736
Epoch: [10/50]: D_loss: 0.428, G_loss: 1.933
Epoch: [11/50]: D_loss: 0.439, G_loss: 2.126
Epoch: [12/50]: D_loss: 0.601, G_loss: 1.992
Epoch: [13/50]: D_loss: 0.430, G_loss: 1.811
Epoch: [14/50]: D_loss: 0.477, G_loss: 1.651
Epoch: [15/50]: D_loss: 0.488, G_loss: 1.621
Epoch: [16/50]: D_loss: 0.452, G_loss: 1.783
Epoch: [17/50]: D_loss: 0.385, G_loss: 1.733
Epoch: [18/50]: D_loss: 0.474, G_loss: 1.798
Epoch: [19/50]: D_loss: 0.362, G_loss: 1.898
Epoch: [20/50]: D_loss: 0.385, G_loss: 2.099
Epoch: [21/50]: D_loss: 0.365, G_loss: 2.241
Epoch: [22/50]: D_loss: 0.373, G_loss: 2.232
Epoch: [23/50]: D_loss: 0.332, G_loss: 2.252
Epoch: [24/50]: D_loss: 0.394, G_loss: 2.183
Epoch: [25/50]: D_loss: 0.411, G_loss: 2.068
Epoch: [26/50]: D_loss: 0.481, G_loss: 1.929
Epoch: [27/50]: D_loss: 0.388, G_loss: 1.699
Epoch: [28/50]: D_loss: 0.449, G_loss: 1.660
Epoch: [29/50]: D_loss: 0.448, G_loss: 1.612
Epoch: [30/50]: D_loss: 0.405, G_loss: 1.662
Epoch: [31/50]: D_loss: 0.460, G_loss: 1.596
Epoch: [32/50]: D_loss: 0.433, G_loss: 1.545
Epoch: [33/50]: D_loss: 0.452, G_loss: 1.667
Epoch: [34/50]: D_loss: 0.434, G_loss: 1.577
Epoch: [35/50]: D_loss: 0.428, G_loss: 1.572
Epoch: [36/50]: D_loss: 0.405, G_loss: 1.668
Epoch: [37/50]: D_loss: 0.412, G_loss: 1.658
Epoch: [38/50]: D_loss: 0.403, G_loss: 1.629
Epoch: [39/50]: D_loss: 0.436, G_loss: 1.723
Epoch: [40/50]: D_loss: 0.502, G_loss: 1.899
Epoch: [41/50]: D_loss: 0.359, G_loss: 1.716
Epoch: [42/50]: D_loss: 0.368, G_loss: 1.706
Epoch: [43/50]: D_loss: 0.384, G_loss: 1.754
Epoch: [44/50]: D_loss: 0.499, G_loss: 1.946
Epoch: [45/50]: D_loss: 0.357, G_loss: 1.754
Epoch: [46/50]: D_loss: 0.389, G_loss: 1.860
Epoch: [47/50]: D_loss: 0.421, G_loss: 1.926
Epoch: [48/50]: D_loss: 0.350, G_loss: 1.818
Epoch: [49/50]: D_loss: 0.403, G_loss: 1.875
Epoch: [50/50]: D_loss: 0.344, G_loss: 1.876
六、模型分析
# 模型分析
generator.load_state_dict(torch.load('./output/generator_epoch_50.pth'), strict=False)
generator.eval()
# 生成潜在空间的点，作为生成器的输入
def generate_latent_points(latent_dim, n_samples, n_classes=3):
# 从标准正态分布中生成潜在空间的点
x_input = randn(latent_dim * n_samples)
# 将生成的点整形成用于神经网络的输入的批量
z_input = x_input.reshape(n_samples, latent_dim)
return z_input
# 在两个潜在空间点之间进行均匀插值
def interpolate_points(p1, p2, n_steps=10):
# 在两个点之间进行插值，生成插值比率
ratios = linspace(0, 1, num=n_steps)
# 线性插值向量
vectors = list()
for ratio in ratios:
v = (1.0 - ratio) * p1 + ratio * p2
vectors.append(v)
return asarray(vectors)
# 生成两个潜在空间的点
pts = generate_latent_points(100, 2)
# 在两个潜在空间点之间进行插值
interpolated = interpolate_points(pts[0], pts[1])
# 将数据转换为torch张量并将其移至GPU（假设device已正确声明为GPU）
interpolated = torch.tensor(interpolated).to(device).type(torch.float32)
output = None
# 对于三个类别的循环，分别进行插值和生成图片
for label in range(3):
# 创建包含相同类别标签的张量
labels = torch.ones(10) * label
labels = labels.to(device)
labels = labels.unsqueeze(1).long()
print(labels.size())
# 使用生成器生成插值结果
predictions = generator((interpolated, labels))
predictions = predictions.permute(0,2,3,1)
pred = predictions.detach().cpu()
if output is None:
output = pred
else:
output = np.concatenate((output,pred))
nrow = 3
ncol = 10
fig = plt.figure(figsize=(15,4))
gs = gridspec.GridSpec(nrow, ncol)
k = 0
for i in range(nrow):
for j in range(ncol):
pred = (output[k, :, :, :] + 1 ) * 127.5
pred = np.array(pred)
ax= plt.subplot(gs[i,j])
ax.imshow(pred.astype(np.uint8))
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.axis('off')
k += 1
plt.show()
扫一扫
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
