文章目录
Pix2pix介绍Pix2pix应用Pix2pix生成器及判别器网络结构代码实现1、导入需要的库2、下载数据包3、加载并展示数据包中的图片4、处理图片4.1 将图像调整为更大的高度和宽度4.2
SEO靠我 随机裁剪到目标尺寸4.3 随机将图像做水平镜像处理4.4 图像归一化4.5 处理训练集图片4.6 处理测试集图片4.7 将训练集所有图片进行切片操作,放入一个dataset中4.8 将测试集所有图片
SEO靠我进行切片操作,放入一个dataset中 5、定义网络结构5.1 定义下采样函数5.2 定义上采样函数5.3 定义生成器(UNet网络)5.4 查看生成器结构5.5定义判别器(PatchGAN网络)5.
SEO靠我6 查看判别器结构 6、定义损失函数6.1 定义生成器损失函数6.2 定义判别器损失函数 7、定义优化函数8、定义图像生成并显示的函数9、定义一次梯度下降过程10、训练模型10.1 定义训练过程10.
SEO靠我2 开始训练 参考资料
Pix2pix介绍
在传统的GAN里,输入一个随机噪声,就会输出一幅随机图像。但通常如果我们想输出的图像是我们想要的那种图像,和我们的输入是对应的、有关联的,比如输入一只猫的草图,SEO靠我输出同一形态的猫的真实图片。比如:
那么这个时候,Pix2pix就派上用场了。
pix2pix对传统的GAN做了个小改动,它不再输入随机噪声,而是输入用户给的图片:
但这也就产生了新的问题:我们怎样建立输入SEO靠我和输出的对应关系。此时G的输出如果是下面这样,D会判断是真图:
但如果G的输出是下面这样的,D拿来一看,也会认为是真的图片。也就是说,这样做并不能训练出输入和输出对应的网络G,因为是否对应根本不影响D的SEO靠我判断。
为了体现这种对应关系,解决方案也很简单,你可以也已经想到了:我们把
GG的输入和输出一起作为DD的输入
不就好了?于是现在的优化目标变成了这样:
Pix2pix应用
Pix2pix可以应用在:草图转图片SEO靠我、图片自动着色、灰度图变彩色图等领域,如下图所示。
Pix2pix生成器及判别器网络结构
Pix2pix论文地址:Pix2pix论文。
如上图所示,生成器G用到的是Unet结构,输入的轮廓图 x x x编码
SEO靠我再解码成真实图片,判别器D用到的是作者自己提出来的条件判别器PatchGAN,判别器D的作用是在轮廓图 x x x的条件下,对于生成的图片 G ( x ) G(x) G(x)判断为假,对于真实判断为真
SEO靠我。
为什么选择Unet?
作者提到,输入和输出图像的外表面(surface appearance)应该不同而潜在的结构(underlying structure)应该相似,对于image translatSEO靠我ion的任务来说,输入和输出应该共享一些底层的信息,因此使用Unet这种跳层连接(skip connection)的方法,这里说的跳层连接是 i i i层直接与 n − i n-i n−i层相加,如下SEO靠我所示:
为什么选择PatchGAN?为了能更好得对图像的局部做判断,作者提出patchGAN的结构,也就是说把图像等分成patch,分别判断每个Patch的真假,最后再取平均。作者最后说,文章提出的这个
SEO靠我PatchGAN可以看成所以另一种形式的纹理损失或样式损失。在具体实验时,作者使用了不同尺寸的patch,最后发现70x70的尺寸比较合适。
代码实现
1、导入需要的库
import tensorflow
SEO靠我as tf
import os
import matplotlib.pyplot as plt
from IPython import display
_URL = https://people.eecs.berkeley.edu/~tinghuiz/projects/pix2pix/datasets/facades.tar.gzpath
SEO靠我_to_zip = tf.keras.utils.get_file(facades.tar.gz,origin=_URL,extract=True)PATH = os.path.join(os.pat
SEO靠我h.dirname(path_to_zip), facades/)
3、加载并展示数据包中的图片
def load(image_file):image = tf.io.read_file(image_fi
SEO靠我le)image = tf.image.decode_jpeg(image)w = tf.shape(image)[1]w = w // 2real_image = image[:, :w, :]in
SEO靠我put_image = image[:, w:, :]input_image = tf.cast(input_image, tf.float32)real_image = tf.cast(real_i
SEO靠我mage, tf.float32)return input_image, real_imageinp, re = load(PATH+train/100.jpg)
# casting
SEO靠我to int for matplotlib to show the image
plt.figure()
plt.imshow(inp/255.0)
p
SEO靠我lt.figure()
plt.imshow(re/255.0)
因为原图片为:
但我们需要的是一张输入图片(草图)和一张真实图片(真实建筑),所以我们定义
load()
函数,其主要功能是将SEO靠我一种图片拆分成两张。
得到结果:
4、处理图片
4.1 将图像调整为更大的高度和宽度
def resize(input_image, real_image, height, width):input_imag
SEO靠我e = tf.image.resize(input_image, [height, width],method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)real_
SEO靠我image = tf.image.resize(real_image, [height, width],method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)re
SEO靠我turn input_image, real_image
4.2 随机裁剪到目标尺寸
对一张图片进行多次(如10次)随机裁剪,将得到的10张图片放到一起看时,有一种图片在跳动的感觉。所以称这种方法为RanSEO靠我dom jittering,其主要作用是防止过拟合。
# 目标尺寸
IMG_WIDTH = 256
IMG_HEIGHT = 256
def random
SEO靠我_crop(input_image, real_image):stacked_image = tf.stack([input_image, real_image], axis=0)cropped_im
SEO靠我age = tf.image.random_crop(stacked_image, size=[2, IMG_HEIGHT, IMG_WIDTH, 3])return cropped_image[0]
SEO靠我, cropped_image[1]
4.3 随机将图像做水平镜像处理
水平镜像处理的目的也是为了防止过拟合。
def random_jitter(input_image, real_image):# re
SEO靠我sizing to 286 x 286 x 3input_image, real_image = resize(input_image, real_image, 286, 286)# randomly
SEO靠我 cropping to 256 x 256 x 3input_image, real_image = random_crop(input_image, real_image)if tf.random
SEO靠我.uniform(()) > 0.5:# random mirroringinput_image = tf.image.flip_left_right(input_image)real_image =
SEO靠我 tf.image.flip_left_right(real_image)return input_image, real_image
4.4 图像归一化
# normalizing the images
SEO靠我 to [-1, 1]
def normalize(input_image, real_image):input_image = (input_image / 127.5) - 1re
SEO靠我al_image = (real_image / 127.5) - 1return input_image, real_image
4.5 处理训练集图片
def load_image_train(ima
SEO靠我ge_file):input_image, real_image = load(image_file)input_image, real_image = random_jitter(input_ima
SEO靠我ge, real_image)input_image, real_image = normalize(input_image, real_image)return input_image, real_
SEO靠我image
4.6 处理测试集图片
def load_image_test(image_file):input_image, real_image = load(image_file)input_imag
SEO靠我e, real_image = resize(input_image, real_image,IMG_HEIGHT, IMG_WIDTH)input_image, real_image = norma
SEO靠我lize(input_image, real_image)return input_image, real_image
4.7 将训练集所有图片进行切片操作,放入一个dataset中
BUFFER_SIZ
SEO靠我E = 400
BATCH_SIZE = 1train_dataset = tf.data.Dataset.list_files(PATH+train/*.jpg)
t
SEO靠我rain_dataset = train_dataset.map(load_image_train,num_parallel_calls=tf.data.experimental.AUTOTUNE)
SEO靠我 train_dataset = train_dataset.shuffle(BUFFER_SIZE)
train_dataset = train_dataset.bat
SEO靠我ch(BATCH_SIZE)
4.8 将测试集所有图片进行切片操作,放入一个dataset中
test_dataset = tf.data.Dataset.list_files(PATH+test/*.j
SEO靠我pg)
test_dataset = test_dataset.map(load_image_test)
test_dataset = test_dataset.bat
SEO靠我ch(BATCH_SIZE)
5、定义网络结构
5.1 定义下采样函数
为了不每次都在网络中定义批归一化层和激活函数层,我们先定义一个下采样函数,其中包括池化层、批归一化层以及LeakyReLU()激活函数SEO靠我层。
OUTPUT_CHANNELS = 3
def downsample(filters, size, apply_batchnorm=True):initializer = tf.r
SEO靠我andom_normal_initializer(0., 0.02)result = tf.keras.Sequential()result.add(tf.keras.layers.Conv2D(fi
SEO靠我lters, size, strides=2, padding=same,kernel_initializer=initializer, use_bias=False))if apply_batchn
SEO靠我orm:result.add(tf.keras.layers.BatchNormalization())result.add(tf.keras.layers.LeakyReLU())return re
SEO靠我sult
5.2 定义上采样函数
def upsample(filters, size, apply_dropout=False):initializer = tf.random_normal_initi
SEO靠我alizer(0., 0.02)result = tf.keras.Sequential()result.add(tf.keras.layers.Conv2DTranspose(filters, si
SEO靠我ze, strides=2,padding=same,kernel_initializer=initializer,use_bias=False))result.add(tf.keras.layers
SEO靠我.BatchNormalization())if apply_dropout:result.add(tf.keras.layers.Dropout(0.5))result.add(tf.keras.l
SEO靠我ayers.ReLU())return result
5.3 定义生成器(UNet网络)
def Generator():inputs = tf.keras.layers.Input(shape=[256
SEO靠我,256,3])down_stack = [downsample(64, 4, apply_batchnorm=False), # (bs, 128, 128, 64)downsample(128,
SEO靠我4), # (bs, 64, 64, 128)downsample(256, 4), # (bs, 32, 32, 256)downsample(512, 4), # (bs, 16, 16, 512
SEO靠我)downsample(512, 4), # (bs, 8, 8, 512)downsample(512, 4), # (bs, 4, 4, 512)downsample(512, 4), # (bs
SEO靠我, 2, 2, 512)downsample(512, 4), # (bs, 1, 1, 512)]up_stack = [upsample(512, 4, apply_dropout=True),
SEO靠我# (bs, 2, 2, 512)+(bs, 2, 2, 512)=(bs, 2, 2, 1024)upsample(512, 4, apply_dropout=True), # (bs, 4, 4,
SEO靠我 1024)upsample(512, 4, apply_dropout=True), # (bs, 8, 8, 1024)upsample(512, 4), # (bs, 16, 16, 1024)
SEO靠我upsample(256, 4), # (bs, 32, 32, 512)upsample(128, 4), # (bs, 64, 64, 256)upsample(64, 4), # (bs, 12
SEO靠我8, 128, 128)]initializer = tf.random_normal_initializer(0., 0.02)last = tf.keras.layers.Conv2DTransp
SEO靠我ose(OUTPUT_CHANNELS, 4,strides=2,padding=same,kernel_initializer=initializer,activation=tanh) # (bs,
SEO靠我 256, 256, 3)x = inputs# Downsampling through the modelskips = []for down in down_stack:x = down(x)s
SEO靠我kips.append(x)skips = reversed(skips[:-1])# Upsampling and establishing the skip connectionsfor up,
SEO靠我skip in zip(up_stack, skips):x = up(x) # 第一个x是(bs, 1, 1, 512)x = tf.keras.layers.Concatenate()([x, s
SEO靠我kip])x = last(x)return tf.keras.Model(inputs=inputs, outputs=x)
5.4 查看生成器结构
generator = Generator()
SEO靠我 tf.keras.utils.plot_model(generator, show_shapes=True, dpi=64)
5.5定义判别器(PatchGAN网络)
def Discrimi
SEO靠我nator():initializer = tf.random_normal_initializer(0., 0.02)inp = tf.keras.layers.Input(shape=[256,
SEO靠我256, 3], name=input_image)tar = tf.keras.layers.Input(shape=[256, 256, 3], name=target_image)x = tf.
SEO靠我keras.layers.concatenate([inp, tar]) # (bs, 256, 256, channels*2)down1 = downsample(64, 4, False)(x)
SEO靠我 # (bs, 128, 128, 64)down2 = downsample(128, 4)(down1) # (bs, 64, 64, 128)down3 = downsample(256, 4)
SEO靠我(down2) # (bs, 32, 32, 256)zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3) # (bs, 34, 34, 256)con
SEO靠我v = tf.keras.layers.Conv2D(512, 4, strides=1,kernel_initializer=initializer,use_bias=False)(zero_pad
SEO靠我1) # (bs, 31, 31, 512)batchnorm1 = tf.keras.layers.BatchNormalization()(conv)leaky_relu = tf.keras.l
SEO靠我ayers.LeakyReLU()(batchnorm1)zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu) # (bs, 33, 33,
SEO靠我512)last = tf.keras.layers.Conv2D(1, 4, strides=1,kernel_initializer=initializer)(zero_pad2) # (bs,
SEO靠我30, 30, 1)return tf.keras.Model(inputs=[inp, tar], outputs=last)
5.6 查看判别器结构
discriminator = Discrimin
SEO靠我ator()
tf.keras.utils.plot_model(discriminator, show_shapes=True, dpi=64)
6、定义损失函数
6.1 定义生成器损失SEO靠我函数
LAMBDA = 100
loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)def generat
SEO靠我or_loss(disc_generated_output, gen_output, target):gan_loss = loss_object(tf.ones_like(disc_generate
SEO靠我d_output), disc_generated_output)# mean absolute errorl1_loss = tf.reduce_mean(tf.abs(target - gen_o
SEO靠我utput))total_gen_loss = gan_loss + (LAMBDA * l1_loss)return total_gen_loss, gan_loss, l1_loss
一部分损失来源SEO靠我于将生成图片输入判别器后得到的结果与1(判定为真)之间的交叉熵损失;另一部分损失来自生成的图像与真实建筑图像之间的L1损失。
6.2 定义判别器损失函数
def discriminator_loss(di
SEO靠我sc_real_output, disc_generated_output):real_loss = loss_object(tf.ones_like(disc_real_output), disc_
SEO靠我real_output)generated_loss = loss_object(tf.zeros_like(disc_generated_output), disc_generated_output
SEO靠我)total_disc_loss = real_loss + generated_lossreturn total_disc_loss
一部分损失来源于将生成图片输入判别器后得到的结果与0(判定为假)之SEO靠我间的交叉熵损失;另一部分损失来自将真实建筑图片输入判别器后得到的结果与1(判定为真)之间的交叉熵损失。
7、定义优化函数
generator_optimizer = tf.keras.optimizers
SEO靠我.Adam(2e-4, beta_1=0.5)
discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)
SEO靠我
8、定义图像生成并显示的函数
def generate_images(model, test_input, tar):prediction = model(test_input, training=Tr
SEO靠我ue)plt.figure(figsize=(15,15))display_list = [test_input[0], tar[0], prediction[0]]title = [Input Im
SEO靠我age, Ground Truth, Predicted Image]for i in range(3):plt.subplot(1, 3, i+1)plt.title(title[i])# gett
SEO靠我ing the pixel values between [0, 1] to plot it.plt.imshow(display_list[i] * 0.5 + 0.5)plt.axis(off)p
SEO靠我lt.show()
此函数的作用是将输入图像、真实建筑图像以及输出的图像一起显示出来。如:
for example_input, example_target in test_dataset.take(1
SEO靠我):generate_images(generator, example_input, example_target)
9、定义一次梯度下降过程
def train_step(input_image, t
SEO靠我arget, epoch):with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:gen_output = genera
SEO靠我tor(input_image, training=True)disc_real_output = discriminator([input_image, target], training=True
SEO靠我)disc_generated_output = discriminator([input_image, gen_output], training=True)gen_total_loss, gen_
SEO靠我gan_loss, gen_l1_loss = generator_loss(disc_generated_output, gen_output, target)disc_loss = discrim
SEO靠我inator_loss(disc_real_output, disc_generated_output)generator_gradients = gen_tape.gradient(gen_tota
SEO靠我l_loss,generator.trainable_variables)discriminator_gradients = disc_tape.gradient(disc_loss,discrimi
SEO靠我nator.trainable_variables)generator_optimizer.apply_gradients(zip(generator_gradients,generator.trai
SEO靠我nable_variables))discriminator_optimizer.apply_gradients(zip(discriminator_gradients,discriminator.t
SEO靠我rainable_variables))
10、训练模型
10.1 定义训练过程
训练过程:首先选择一组测试集图片(包括输入图片与真实建筑图片),将模型在训练集中训练epochs次,每训练完一次(遍历一遍训SEO靠我练集)就将此模型应用到刚才选择的测试集图片中并显示结果。
def fit(train_ds, epochs, test_ds):for epoch in range(epochs):display.cl
SEO靠我ear_output(wait=True)for example_input, example_target in test_ds.take(1):generate_images(generator,
SEO靠我 example_input, example_target)print("Epoch: ", epoch)# Trainfor n, (input_image, target) in train_d
SEO靠我s.enumerate():print(., end=)if (n+1) % 100 == 0:print()train_step(input_image, target, epoch)print()
SEO靠我
10.2 开始训练
EPOCHS = 100
fit(train_dataset, EPOCHS, test_dataset)
得到最终结果:
参考资料
生成对抗网络系列(4)——pix2piSEO靠我x
一文读懂GAN, pix2pix, CycleGAN和pix2pixHD
[GAN笔记] pix2pix