好的，我们可以使用遗传算法来优化 WGAN 的超参数，包括学习率、数据维度和 \lambda（通常用于梯度惩罚项）。以下是一个基于 Python 的示例代码，使用了 deap 库来实现遗传算法。deap 是一个用于进化算法的库，非常适合用于这种优化任务。
安装依赖
在运行代码之前，确保安装了以下依赖：
pip install deap torch torchvision
示例代码
以下代码展示了如何使用遗传算法优化 WGAN 的超参数：
import random
import numpy as np
from deap import base, creator, tools, algorithms
import torch
import torch.nn as nn
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 定义 WGAN 的基本结构
class Generator(nn.Module):
def __init__(self, latent_dim, img_size, channels):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(latent_dim, 128),
nn.ReLU(True),
nn.Linear(128, 256),
nn.ReLU(True),
nn.Linear(256, 512),
nn.ReLU(True),
nn.Linear(512, img_size * img_size * channels),
nn.Tanh()
)
self.img_size = img_size
self.channels = channels
def forward(self, z):
img = self.model(z)
img = img.view(img.size(0), self.channels, self.img_size, self.img_size)
return img
class Discriminator(nn.Module):
def __init__(self, img_size, channels):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(img_size * img_size * channels, 512),
nn.LeakyReLU(0.2),
nn.Linear(512, 256),
nn.LeakyReLU(0.2),
nn.Linear(256, 1)
)
def forward(self, img):
img_flat = img.view(img.size(0), -1)
validity = self.model(img_flat)
return validity
# 评估函数
def evaluate(individual):
# 解码个体
lr, latent_dim, img_size, lambda_gp = individual
img_size = int(img_size)
latent_dim = int(latent_dim)
channels = 1 # 假设是灰度图像
# 数据加载
transform = transforms.Compose([
transforms.Resize(img_size),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])
])
dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
# 初始化模型
generator = Generator(latent_dim, img_size, channels)
discriminator = Discriminator(img_size, channels)
optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr)
# 损失函数
def compute_gradient_penalty(D, real_samples, fake_samples):
alpha = torch.randn(real_samples.size(0), 1, 1, 1)
interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
d_interpolates = D(interpolates)
fake = torch.ones(real_samples.size(0), 1)
gradients = torch.autograd.grad(
outputs=d_interpolates,
inputs=interpolates,
grad_outputs=fake,
create_graph=True,
retain_graph=True,
only_inputs=True,
)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
return gradient_penalty
# 训练循环
n_epochs = 1 # 为了快速评估，只训练1个epoch
for epoch in range(n_epochs):
for i, (imgs, _) in enumerate(dataloader):
# 生成假图像
z = torch.randn(imgs.size(0), latent_dim)
fake_imgs = generator(z)
# 训练判别器
optimizer_D.zero_grad()
real_validity = discriminator(imgs)
fake_validity = discriminator(fake_imgs.detach())
gradient_penalty = compute_gradient_penalty(discriminator, imgs.data, fake_imgs.data)
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity) + lambda_gp * gradient_penalty
d_loss.backward()
optimizer_D.step()
# 训练生成器
optimizer_G.zero_grad()
fake_validity = discriminator(fake_imgs)
g_loss = -torch.mean(fake_validity)
g_loss.backward()
optimizer_G.step()
# 评估生成器的性能（简单地使用生成图像的均值作为适应度）
z = torch.randn(64, latent_dim)
generated_imgs = generator(z)
fitness = torch.mean(generated_imgs).item()
return fitness,
# 遗传算法设置
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
toolbox = base.Toolbox()
toolbox.register("attr_lr", random.uniform, 0.0001, 0.001)
toolbox.register("attr_latent_dim", random.randint, 50, 200)
toolbox.register("attr_img_size", random.randint, 28, 64)
toolbox.register("attr_lambda_gp", random.uniform, 10, 100)
toolbox.register("individual", tools.initCycle, creator.Individual,
(toolbox.attr_lr, toolbox.attr_latent_dim, toolbox.attr_img_size, toolbox.attr_lambda_gp), n=1)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
# 运行遗传算法
def main():
random.seed(42)
np.random.seed(42)
torch.manual_seed(42)
pop = toolbox.population(n=50)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", np.mean)
stats.register("std", np.std)
stats.register("min", np.min)
stats.register("max", np.max)
pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=10,
stats=stats, halloffame=hof, verbose=True)
best_individual = hof.items[0]
print("Best individual is: ", best_individual)
print("Fitness: ", best_individual.fitness.values[0])
if __name__ == "__main__":
main()
代码说明
1. WGAN 模型定义：
• 定义了简单的生成器和判别器。
• 使用了全连接层来构建网络。
2. 评估函数：
• 解码个体的超参数（学习率、隐变量维度、图像尺寸、梯度惩罚系数）。
• 使用 MNIST 数据集进行训练。
• 训练生成器和判别器，并计算生成图像的均值作为适应度。
3. 遗传算法设置：
• 使用 deap 库定义了个体和种群。
• 定义了交叉、变异和选择操作。
4. 运行遗传算法：
• 初始化种群，运行遗传算法。
• 输出最佳个体及其适应度。
注意事项
• 计算资源：训练 WGAN 是计算密集型任务，遗传算法会多次训练模型，因此需要足够的计算资源。
• 适应度函数：这里的适应度函数是生成图像的均值，实际应用中可以使用更复杂的指标，如 Inception Score。
• 超参数范围：可以根据实际情况调整超参数的范围。
希望这个代码对你有帮助！
算法详细说明
# 导入必要的库
import random
import numpy as np
import torch
from deap import base, creator, tools, algorithms
# 定义适应度函数类和个体类
creator.create("FitnessMax", base.Fitness, weights=(1.0,)) # 创建一个名为FitnessMax的适应度类，权重为1.0，表示最大化问题
creator.create("Individual", list, fitness=creator.FitnessMax) # 创建一个名为Individual的个体类，基于list，包含FitnessMax类型的适应度属性
# 创建工具箱
toolbox = base.Toolbox() # 创建一个工具箱，用于注册各种操作
# 注册生成属性的函数
toolbox.register("attr_lr", random.uniform, 0.0001, 0.001) # 注册生成学习率属性的函数，范围为0.0001到0.001
toolbox.register("attr_latent_dim", random.randint, 50, 200) # 注册生成潜在维度属性的函数，范围为50到200
toolbox.register("attr_img_size", random.randint, 28, 64) # 注册生成图像尺寸属性的函数，范围为28到64
toolbox.register("attr_lambda_gp", random.uniform, 10, 100) # 注册生成梯度惩罚系数属性的函数，范围为10到100
# 注册生成个体和种群的函数
toolbox.register("individual", tools.initCycle, creator.Individual, # 注册生成个体的函数
(toolbox.attr_lr, toolbox.attr_latent_dim, toolbox.attr_img_size, toolbox.attr_lambda_gp), n=1) # 个体由上述4个属性组成，每个属性生成一次
toolbox.register("population", tools.initRepeat, list, toolbox.individual) # 注册生成种群的函数，种群由多个个体组成
# 注册遗传算法操作
toolbox.register("evaluate", evaluate) # 注册评估函数，evaluate需要定义
toolbox.register("mate", tools.cxTwoPoint) # 注册交叉操作，采用两点交叉
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2) # 注册变异操作，采用高斯变异，均值为0，标准差为1，每个属性的变异概率为0.2
toolbox.register("select", tools.selTournament, tournsize=3) # 注册选择操作，采用锦标赛选择，锦标赛大小为3
# 定义主函数，运行遗传算法
def main():
random.seed(42) # 设置随机种子，保证结果可复现
np.random.seed(42) # 设置numpy随机种子
torch.manual_seed(42) # 设置torch随机种子
pop = toolbox.population(n=50) # 初始化种群，种群大小为50
hof = tools.HallOfFame(1) # 创建名人堂，保存最优个体
stats = tools.Statistics(lambda ind: ind.fitness.values) # 创建统计对象，统计个体的适应度值
stats.register("avg", np.mean) # 注册平均值统计
stats.register("std", np.std) # 注册标准差统计
stats.register("min", np.min) # 注册最小值统计
stats.register("max", np.max) # 注册最大值统计
pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=10, # 运行简单遗传算法
stats=stats, halloffame=hof, verbose=True) # 交叉概率0.5，变异概率0.2，进化代数10，输出统计信息
best_individual = hof.items[0] # 获取最优个体
print("Best individual is: ", best_individual) # 打印最优个体
print("Fitness: ", best_individual.fitness.values[0]) # 打印最优个体的适应度值
# 判断是否作为主程序运行
if __name__ == "__main__":
main() # 调用主函数
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
