GAN生成对抗网络：花卉生成

2023-12-08 19:30
文章标签 生成 网络 对抗 gan 花卉

本文主要是介绍GAN生成对抗网络：花卉生成，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 简介
  • 一、GAN生成对抗网络基础知识
  • 二、数据集介绍
  • 三、代码实现
    • 参数设置
    • 数据处理
    • 搭建网络
    • 定义优化器与损失函数
    • 训练网络
    • 保存网络
    • 结果展示
  • 总结

简介

本篇文章利用pytorch搭建GAN生成对抗网络实现花卉生成的任务

一、GAN生成对抗网络基础知识

关于GAN生成对抗网络的基础知识以下文章有详细讲解，可供参考：
GAN（生成对抗网络）的系统全面介绍（醍醐灌顶）

二、数据集介绍

本文使用花卉数据集，该数据集包含了4317张图片，包含雏菊、蒲公英、玫瑰、向日葵、郁金香五种花卉，我已将数据集拆分为训练集和测试集两部分，本文仅使用了训练集部分，以下是数据集目录：
在这里插入图片描述在这里插入图片描述
数据集已放于以下链接，有需要可自行下载
花卉数据集

三、代码实现

参数设置

step1.参数continue_train：是否继续训练
step2.参数dir：训练集路径
step3.参数batch_size：单次训练图片量
step4.参数device：使用GPU
step5.参数epochs：训练周期
step6.参数generator_num：每k轮训练一次生成器
step7.参数discriminator_num：每k轮训练一次判别器

if __name__ == '__main__':parser = argparse.ArgumentParser()parser.add_argument('--continue_train', type=bool, default=False, help='continue training')parser.add_argument('--dir', type=str, default='./flowers/train', help='dataset path')parser.add_argument('--batch_size', type=int, default=50, help='batch size')parser.add_argument('--device', type=int, default=0, help='GPU id')parser.add_argument('--epochs', type=int, default=200, help='train epochs')parser.add_argument('--generator_num', type=int, default=5, help='train generator every k epochs')parser.add_argument('--discriminator_num', type=int, default=1, help='train discriminator every k epochs')args = parser.parse_args()main(args)

数据处理

step1.定义训练集中图像输入判别器前的transform操作
step2.准备Dataset与Dataloader

    transform = transforms.Compose([transforms.Resize((96, 96)),  # 将图片resize至 96 * 96transforms.ToTensor(),  # 转换为张量transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])data_set = datasets.ImageFolder(root=args.dir, transform=transform)data_loader = dataloader.DataLoader(dataset=data_set, batch_size=args.batch_size, num_workers=4, shuffle=True, drop_last=True)print('already load data...')

搭建网络

step1.生成器使用反卷积，最终输出3 * 96 * 96大小的图片，且像素值 ∈ [ − 1 , 1 ] ∈[-1,1] ∈[−1,1]
step2.生成器使用卷积，最终输出判别为真的概率

class Generator(nn.Module):def __init__(self):super(Generator,self).__init__()self.main = nn.Sequential(      # 神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行nn.ConvTranspose2d(100, 512, kernel_size=4, stride=1, padding=0, bias=False),nn.BatchNorm2d(512),nn.ReLU(True),       # 512 × 4 × 4        (1-1)*1+1*(4-1)+0+1 = 4nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(256),nn.ReLU(True),      # 256 × 8 × 8     (4-1)*2-2*1+1*(4-1)+0+1 = 8nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(128),nn.ReLU(True),  # 128 × 16 × 16nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(64),nn.ReLU(True),      # 64 × 32 × 32nn.ConvTranspose2d(64, 3, kernel_size=5, stride=3, padding=1, bias=False),nn.Tanh()       # 3 * 96 * 96)def forward(self, input):return self.main(input)class Discriminator(nn.Module):def __init__(self):super(Discriminator,self).__init__()self.main = nn.Sequential(nn.Conv2d(3, 64, kernel_size=5, stride=3, padding=1, bias=False),nn.LeakyReLU(0.2, inplace=True),        # 64 * 32 * 32nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(128),nn.LeakyReLU(0.2, inplace=True),         # 128 * 16 * 16nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(256),nn.LeakyReLU(0.2, inplace=True),  # 256 * 8 * 8nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(512),nn.LeakyReLU(0.2, inplace=True),  # 512 * 4 * 4nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=0, bias=False),nn.Sigmoid()        # 输出一个概率)def forward(self, input):return self.main(input).view(-1)

定义优化器与损失函数

step1.生成器与判别器的优化器都使用Adam
step2.将损失函数使用二元交叉熵损失

    optimizer_G = torch.optim.Adam(model_G.parameters(), lr=2e-4, betas=(0.5, 0.999))optimizer_D = torch.optim.Adam(model_D.parameters(), lr=2e-4, betas=(0.5, 0.999))loss = nn.BCELoss()print('already prepared optimizer and loss_function...')

训练网络

每discriminator_num轮：
step1.输入真图片让判别器鉴别
step2.生成器利用随机噪声生成图片，并让判别器鉴别
step3.计算判别器损失（真鉴别为真，假鉴别为假），反向传播后更新判别器参数
每generator_num轮：
step4.生成器利用随机噪声生成图片，并让判别器鉴别
step5.计算生成器损失（假鉴别为真），反向传播后更新生成器参数
step6.每100轮保存一次结果

    print('start training...')for epoch in range(args.epochs):print('epoch:{}'.format(epoch + 1))for i, data in enumerate(data_loader):if (i + 1) % args.discriminator_num == 0:optimizer_D.zero_grad()real_img = data[0]batchsize = len(real_img)real_img = real_img.cuda(args.device)out_D_real = model_D(real_img)real_labels = torch.ones(batchsize).cuda(args.device)loss_D_real = loss(out_D_real, real_labels)loss_D_real.backward()noise = torch.randn(args.batch_size, 100, 1, 1).cuda(args.device)fake_img = model_G(noise)out_D_fake = model_D(fake_img)fake_labels = torch.zeros(batchsize).cuda(args.device)loss_D_fake = loss(out_D_fake, fake_labels)loss_D_fake.backward()optimizer_D.step()if (i + 1) % args.generator_num == 0:optimizer_G.zero_grad()real_img = data[0]batchsize = len(real_img)noise = torch.randn(args.batch_size, 100, 1, 1).cuda(args.device)fake_img = model_G(noise)out_D_fake = model_D(fake_img)real_labels = torch.ones(batchsize).cuda(args.device)loss_G = loss(out_D_fake, real_labels)loss_G.backward()optimizer_G.step()if (epoch + 1) % 100 == 0:fix_noise = torch.randn(40, 100, 1, 1).cuda(args.device)final_img = model_G(fix_noise)final_img = final_img * 0.5 + 0.5final_img = final_img.cpu()plt.figure(1)for i in range(40):img = final_img[i].detach().numpy()plt.subplot(5, 8, i+1)plt.imshow(np.transpose(img, (1, 2, 0)))plt.savefig("./outcome/{}.png".format(epoch + 1))plt.show()print('end training...')

保存网络

    torch.save(model_G.state_dict(), './generator.pt')torch.save(model_D.state_dict(), './discriminator.pt')print('already saved model...')

结果展示

训练3000轮后得到结果如下：
在这里插入图片描述

总结

以上就是利用生成对抗网络实现图像生成的介绍，完整代码如下：

import argparse
import torchvision.datasets as datasets
import torch.utils.data.dataloader as dataloader
import torchvision.transforms as transforms
import torch.nn as nn
import torch
import numpy as np
import matplotlib.pyplot as pltclass Generator(nn.Module):def __init__(self):super(Generator,self).__init__()self.main = nn.Sequential(      # 神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行nn.ConvTranspose2d(100, 512, kernel_size=4, stride=1, padding=0, bias=False),nn.BatchNorm2d(512),nn.ReLU(True),       # 512 × 4 × 4        (1-1)*1+1*(4-1)+0+1 = 4nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(256),nn.ReLU(True),      # 256 × 8 × 8     (4-1)*2-2*1+1*(4-1)+0+1 = 8nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(128),nn.ReLU(True),  # 128 × 16 × 16nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(64),nn.ReLU(True),      # 64 × 32 × 32nn.ConvTranspose2d(64, 3, kernel_size=5, stride=3, padding=1, bias=False),nn.Tanh()       # 3 * 96 * 96)def forward(self, input):return self.main(input)class Discriminator(nn.Module):def __init__(self):super(Discriminator,self).__init__()self.main = nn.Sequential(nn.Conv2d(3, 64, kernel_size=5, stride=3, padding=1, bias=False),nn.LeakyReLU(0.2, inplace=True),        # 64 * 32 * 32nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(128),nn.LeakyReLU(0.2, inplace=True),         # 128 * 16 * 16nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(256),nn.LeakyReLU(0.2, inplace=True),  # 256 * 8 * 8nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1, bias=False),nn.BatchNorm2d(512),nn.LeakyReLU(0.2, inplace=True),  # 512 * 4 * 4nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=0, bias=False),nn.Sigmoid()        # 输出一个概率)def forward(self, input):return self.main(input).view(-1)def main(args):transform = transforms.Compose([transforms.Resize((96, 96)),  # 将图片resize至 96 * 96transforms.ToTensor(),  # 转换为张量transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])data_set = datasets.ImageFolder(root=args.dir, transform=transform)data_loader = dataloader.DataLoader(dataset=data_set, batch_size=args.batch_size, num_workers=4, shuffle=True, drop_last=True)print('already load data...')model_G = Generator()model_D = Discriminator()if args.continue_train == True:model_G.load_state_dict(torch.load('./generator.pt'))model_D.load_state_dict(torch.load('./discriminator.pt'))model_G.train()model_D.train()print('already prepared model...')optimizer_G = torch.optim.Adam(model_G.parameters(), lr=2e-4, betas=(0.5, 0.999))optimizer_D = torch.optim.Adam(model_D.parameters(), lr=2e-4, betas=(0.5, 0.999))loss = nn.BCELoss()print('already prepared optimizer and loss_function...')if torch.cuda.is_available() == True:model_G.cuda(args.device)model_D.cuda(args.device)loss.cuda(args.device)print('already in GPU...')print('start training...')for epoch in range(args.epochs):print('epoch:{}'.format(epoch + 1))for i, data in enumerate(data_loader):if (i + 1) % args.discriminator_num == 0:optimizer_D.zero_grad()real_img = data[0]batchsize = len(real_img)real_img = real_img.cuda(args.device)out_D_real = model_D(real_img)real_labels = torch.ones(batchsize).cuda(args.device)loss_D_real = loss(out_D_real, real_labels)loss_D_real.backward()noise = torch.randn(args.batch_size, 100, 1, 1).cuda(args.device)fake_img = model_G(noise)out_D_fake = model_D(fake_img)fake_labels = torch.zeros(batchsize).cuda(args.device)loss_D_fake = loss(out_D_fake, fake_labels)loss_D_fake.backward()optimizer_D.step()if (i + 1) % args.generator_num == 0:optimizer_G.zero_grad()real_img = data[0]batchsize = len(real_img)noise = torch.randn(args.batch_size, 100, 1, 1).cuda(args.device)fake_img = model_G(noise)out_D_fake = model_D(fake_img)real_labels = torch.ones(batchsize).cuda(args.device)loss_G = loss(out_D_fake, real_labels)loss_G.backward()optimizer_G.step()if (epoch + 1) % 10 == 0:fix_noise = torch.randn(40, 100, 1, 1).cuda(args.device)final_img = model_G(fix_noise)final_img = final_img * 0.5 + 0.5final_img = final_img.cpu()plt.figure(1)for i in range(40):img = final_img[i].detach().numpy()plt.subplot(5, 8, i+1)plt.imshow(np.transpose(img, (1, 2, 0)))plt.savefig("./outcome/{}.png".format(epoch + 1))plt.show()print('end training...')torch.save(model_G.state_dict(), './generator.pt')torch.save(model_D.state_dict(), './discriminator.pt')print('already saved model...')if __name__ == '__main__':parser = argparse.ArgumentParser()parser.add_argument('--continue_train', type=bool, default=False, help='continue training')parser.add_argument('--dir', type=str, default='./flowers/train', help='dataset path')parser.add_argument('--batch_size', type=int, default=50, help='batch size')parser.add_argument('--device', type=int, default=0, help='GPU id')parser.add_argument('--epochs', type=int, default=3000, help='train epochs')parser.add_argument('--generator_num', type=int, default=5, help='train generator every k epochs')parser.add_argument('--discriminator_num', type=int, default=1, help='train discriminator every k epochs')args = parser.parse_args()main(args)

这篇关于GAN生成对抗网络：花卉生成的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/471063。

相关文章

如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

《如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解》：本文主要介绍如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别的相关资料,描述了如何使用海康威视设备网络SD... 目录前言开发流程问题和解决方案dll库加载不到的问题老旧版本sdk不兼容的问题关键实现流程总结前言作为
阅读更多...
浅析如何使用Swagger生成带权限控制的API文档

浅析如何使用Swagger生成带权限控制的API文档

《浅析如何使用Swagger生成带权限控制的API文档》当涉及到权限控制时,如何生成既安全又详细的API文档就成了一个关键问题,所以这篇文章小编就来和大家好好聊聊如何用Swagger来生成带有... 目录准备工作配置 Swagger权限控制给 API 加上权限注解查看文档注意事项在咱们的开发工作里，API
阅读更多...
Java使用POI-TL和JFreeChart动态生成Word报告

Java使用POI-TL和JFreeChart动态生成Word报告

《Java使用POI-TL和JFreeChart动态生成Word报告》本文介绍了使用POI-TL和JFreeChart生成包含动态数据和图表的Word报告的方法,并分享了实际开发中的踩坑经验,通过代码... 目录前言一、需求背景二、方案分析三、 POI-TL + JFreeChart 实现3.1 Maven
阅读更多...
MybatisGenerator文件生成不出对应文件的问题

MybatisGenerator文件生成不出对应文件的问题

《MybatisGenerator文件生成不出对应文件的问题》本文介绍了使用MybatisGenerator生成文件时遇到的问题及解决方法,主要步骤包括检查目标表是否存在、是否能连接到数据库、配置生成... 目录MyBATisGenerator 文件生成不出对应文件先在项目结构里引入“targetProje
阅读更多...
Python使用qrcode库实现生成二维码的操作指南

Python使用qrcode库实现生成二维码的操作指南

《Python使用qrcode库实现生成二维码的操作指南》二维码是一种广泛使用的二维条码,因其高效的数据存储能力和易于扫描的特点,广泛应用于支付、身份验证、营销推广等领域,Pythonqrcode库是... 目录一、安装 python qrcode 库二、基本使用方法1. 生成简单二维码2. 生成带 Log
阅读更多...
SSID究竟是什么? WiFi网络名称及工作方式解析

SSID究竟是什么? WiFi网络名称及工作方式解析

《SSID究竟是什么?WiFi网络名称及工作方式解析》SID可以看作是无线网络的名称，类似于有线网络中的网络名称或者路由器的名称,在无线网络中，设备通过SSID来识别和连接到特定的无线网络... 当提到 Wi-Fi 网络时，就避不开「SSID」这个术语。简单来说，SSID 就是 Wi-Fi 网络的名称。比如
阅读更多...
Python使用Pandas库将Excel数据叠加生成新DataFrame的操作指南

Python使用Pandas库将Excel数据叠加生成新DataFrame的操作指南

《Python使用Pandas库将Excel数据叠加生成新DataFrame的操作指南》在日常数据处理工作中,我们经常需要将不同Excel文档中的数据整合到一个新的DataFrame中,以便进行进一步... 目录一、准备工作二、读取Excel文件三、数据叠加四、处理重复数据（可选）五、保存新DataFram
阅读更多...
SpringBoot生成和操作PDF的代码详解

SpringBoot生成和操作PDF的代码详解

《SpringBoot生成和操作PDF的代码详解》本文主要介绍了在SpringBoot项目下,通过代码和操作步骤,详细的介绍了如何操作PDF,希望可以帮助到准备通过JAVA操作PDF的你,项目框架用的... 目录本文简介PDF文件简介代码实现PDF操作基于PDF模板生成，并下载完全基于代码生成，并保存合并P
阅读更多...
Java实现任务管理器性能网络监控数据的方法详解

Java实现任务管理器性能网络监控数据的方法详解

《Java实现任务管理器性能网络监控数据的方法详解》在现代操作系统中,任务管理器是一个非常重要的工具,用于监控和管理计算机的运行状态,包括CPU使用率、内存占用等,对于开发者和系统管理员来说,了解这些... 目录引言一、背景知识二、准备工作1. Maven依赖2. Gradle依赖三、代码实现四、代码详解五
阅读更多...
详解Java中如何使用JFreeChart生成甘特图

详解Java中如何使用JFreeChart生成甘特图

《详解Java中如何使用JFreeChart生成甘特图》甘特图是一种流行的项目管理工具,用于显示项目的进度和任务分配,在Java开发中,JFreeChart是一个强大的开源图表库,能够生成各种类型的图... 目录引言一、JFreeChart简介二、准备工作三、创建甘特图1. 定义数据集2. 创建甘特图3.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2