from keras.layers import LeakyReLU from keras.layers import BatchNormalization from keras.optimizers import RMSprop import math def build_generator(inputs, image_size): ''' 生成者网络与编解码网络中的解码器如出一辙,输入给它的一维随机向量相当于输入解码器网络的编码向量， 解码器网络将一维向量反向构造成图片所对应的二维向量，这也是生成者要做的工作，所以下面代码与我们做过 的解码器网络几乎一模一样 ''' image_resize = image_size // 4 kernel_size = 5 layer_filters = [128, 64, 32, 1] x = Dense(image_resize * image_resize * layer_filters[0])(inputs) x = Reshape((image_resize, image_resize, layer_filters[0]))(x) #构造三层反卷积网络 for filters in layer_filters: if filters > layer_filters[-2]: strides = 2 else: strides = 1 #使用batch normalization将输入反卷积网络的向量做预处理，没有这一步GAN的训练就会失败 x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2DTranspose(filters = filters, kernel_size = kernel_size, strides = strides, padding = 'same')(x) x = Activation('sigmoid')(x) generator = Model(inputs, x, name = 'generator') return generator
def build_discriminator(inputs): ''' 识别者网络与编码器很像，它使用三层卷积网络从图片中抽取信息，最后使用sigmoid函数输出 图片是否为真的概率 ''' kernel_size = 5 layer_filters = [32, 64, 128, 256] x = inputs for filters in layer_filters: if filters == layer_filters[-1]: strides = 1 else: strides = 2 x = LeakyReLU(alpha = 0.2)(x) x = Conv2D(filters=filters, kernel_size=kernel_size , strides = strides, padding = 'same')(x) x = Flatten()(x) x = Dense(1)(x) x = Activation('sigmoid')(x) discriminator = Model(inputs, x, name='discriminator') return discriminator
def build_and_train_models(): ''' 将生成者和识别者连城一个网络进行训练 ''' (x_train, _), (_, _) = mnist.load_data() image_size = x_train.shape[1] x_train = np.reshape(x_train, [-1, image_size, image_size, 1]) x_train = x_train.astype('float32') / 255 #设置训练相关的参数 model_name = '/content/gdrive/My Drive/dcgan_mnist' latent_size = 100 batch_size = 64 train_steps = 40000 lr = 2e-4 decay = 6e-8 input_shape = (image_size, image_size, 1) #构建识别者网络 inputs = Input(shape = input_shape, name = 'discriminator_input') discriminator = build_discriminator(inputs) optimizer = RMSprop(lr = lr, decay = decay) discriminator.compile(loss = 'binary_crossentropy', optimizer = optimizer, metrics = ['accuracy']) #构建生成者网络 input_shape = (latent_size, ) inputs = Input(shape = input_shape, name = 'z_input') generator = build_generator(inputs, image_size) optimizer = RMSprop(lr = lr * 0.5, decay = decay * 0.5) #将生成者和识别者连接成一个网络时要冻结识别者，因为训练生成者时识别者网络要保持不变 discriminator.trainable = False adversarial = Model(inputs, discriminator(generator(inputs)), name = model_name) adversarial.compile(loss = 'binary_crossentropy', optimizer = optimizer, metrics = ['accuracy']) models = (generator, discriminator, adversarial) params = (batch_size, latent_size, train_steps, model_name) train(models, x_train, params)
def train(models, x_train, params): ''' 训练时需要遵守的步骤是，先冻结生成者网络，把真实图片输入到识别者网络，训练识别者网络识别真实图片。 然后冻结识别者网络，让生成者网络构造图片输入给识别者网络识别，根据识别结果来改进生成者网络 ''' #先获得生成者，识别者，以及两者的结合体 generator, discriminator, adversarial = models batch_size, latent_size , train_steps, model_name = params save_interval = 500 #构造给生成者网络的一维随机向量 noise_input = np.random.uniform(-1.0, 1.0, size = [16, latent_size]) train_size = x_train.shape[0] for i in range(train_steps): #先训练识别者网络,将真实图片和伪造图片同时输入识别者，让识别者学会区分真假图片 rand_indexes = np.random.randint(0, train_size, size = batch_size) real_images = x_train[rand_indexes] noise = np.random.uniform(-1.0, 1.0, size = [batch_size, latent_size]) #让生成者构造虚假图片 fake_images = generator.predict(noise) x = np.concatenate((real_images, fake_images)) y = np.ones([2 * batch_size, 1]) #真实图片对应标签1，虚假图片对应标签0 y[batch_size : , :] = 0.0 loss, acc = discriminator.train_on_batch(x, y) log = "%d: [discriminator loss: %f, acc: %f]" % (i, loss, acc) #冻结识别者，让生成者构造一系列图片输入识别者，根据识别者识别结果改进生成者网络 noise = np.random.uniform(-1.0, 1.0, size = [batch_size, latent_size]) y = np.ones([batch_size, 1]) #训练生成者时需要使用到识别者返回的结果，因此我们从两者连接后的网络进行训练 loss, acc = adversarial.train_on_batch(noise, y) log = "%s [adversarial loss: %f, acc: %f]" % (log, loss, acc) print(log) if (i + 1) % save_interval == 0: if (i + 1) == train_steps: show = True else: show = False #将生成者构造的图片绘制出来 plot_images(generator, noise_input = noise_input, show = show, step = (i + 1), model_name = model_name) #将生成者当前的网络参数存储成文件 generator.save(model_name + ".h5")
def plot_images(generator, noise_input, show = False, step = 0, model_name = ''): os.makedirs(model_name, exist_ok = True) filename = os.path.join(model_name, "%05d.png" % step) images = generator.predict(noise_input) plt.figure(figsize = (2.2, 2.2)) num_images = images.shape[0] image_size = images.shape[1] rows = int(math.sqrt(noise_input.shape[0])) for i in range(num_images): plt.subplot(rows, rows, i + 1) image = np.reshape(images[i], [image_size, image_size]) plt.imshow(image, cmap= 'gray') plt.axis('off') plt.savefig(filename) if show: plt.show() else: plt.close('all')
from google.colab import drive drive.mount('/content/gdrive')
from keras.datasets import mnist from keras.layers import LeakyReLU from keras.layers import Activation from keras.optimizers import RMSprop import os build_and_train_models()
from keras.models import load_model import os generator = load_model('/content/gdrive/My Drive/dcgan_mnist.h5') #构造一批随机初始化的一维向量让生成者网络创造图片 noise = np.random.randint(-1.0, 1.0, size=[16, 100]) plot_images(generator, noise_input = noise, show = True, model_name="test_image")
from keras.layers.merge import concatenate from keras.utils import to_categorical def build_cgan_discriminator(inputs, y_labels, image_size): ''' 识别图片，并将图片与输入的one-hot-vector关联起来 ''' kernel_size = 5 layer_filters = [32, 64, 128, 256] x = inputs y = Dense(image_size * image_size)(y_labels) y = Reshape((image_size, image_size, 1))(y) #把图片数据与one-hot-vector拼接起来,这里是唯一与前面代码不同之处 x = concatenate([x, y]) for filters in layer_filters: if filters == layer_filters[-1]: strides = 1 else: strides = 2 x = LeakyReLU(alpha=0.2)(x) x = Conv2D(filters = filters, kernel_size = kernel_size, strides = strides, padding = 'same')(x) x = Flatten()(x) x = Dense(1)(x) x = Activation('sigmoid')(x) discriminator = Model([inputs, y_labels], x , name = 'discriminator') return discriminator
def build_cgan_generator(inputs, y_labels, image_size): ''' 生成者网络在构造图片时，需要将输入向量与对应的one-hot-vector结合在一起考虑 ''' image_resize = image_size // 4 kernel_size = 5 layer_filters = [128, 64, 32, 1] #将输入向量与One-hot-vector结合在一起 x = concatenate([inputs, y_labels], axis = 1) x = Dense(image_resize * image_resize * layer_filters[0])(x) x = Reshape((image_resize, image_resize, layer_filters[0]))(x) for filters in layer_filters: if filters > layer_filters[-2]: strides = 2 else: strides = 1 x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2DTranspose(filters = filters, kernel_size = kernel_size, strides = strides, padding = 'same')(x) x = Activation('sigmoid')(x) generator = Model([inputs, y_labels], x, name='generator') return generator
def train_cgan(models, data, params): generator, discriminator, adversarial = models #获取图片数据以及图片对应数字的one-hot-vector x_train, y_train = data batch_size, latent_size, train_steps, num_labels, model_name = params save_interval = 500 noise_input = np.random.uniform(-1.0, 1.0, size=[16, latent_size]) ''' np.eye产生对角矩阵,例如np.eye(3) = [[1,0,0], [0,1,0], [0,0,1]], 于是np.eye(3)[2, 3, 1] = [[0,1,0], [0,0,1], [1,0,0]] ''' noise_class = np.eye(num_labels)[np.arange(0, 16) % num_labels] train_size = x_train.shape[0] print(model_name, "Labels for generated images: ", np.argmax(noise_class, 1)) for i in range(train_steps): rand_indexes = np.random.randint(0, train_size, size = batch_size) real_images = x_train[rand_indexes] #增加图片对应的one-hot-vector real_labels = y_train[rand_indexes] noise = np.random.uniform(-1.0, 1.0, size = [batch_size, latent_size]) #增加构造图片对应的one-hot-vector fake_labels = np.eye(num_labels)[np.random.choice(num_labels, batch_size)] fake_images = generator.predict([noise, fake_labels]) #把真实图片和虚假图片连接起来 x = np.concatenate((real_images, fake_images)) #将真实图片对应的one-hot-vecotr和虚假图片对应的One-hot-vector连接起来 y_labels = np.concatenate((real_labels, fake_labels)) y = np.ones([2 * batch_size, 1]) #上半部分图片为真，下半部分图片为假 y[batch_size:, :] = 0.0 #先训练识别者网络，这里需要将图片及对应的one-hot-vector输入 loss, acc = discriminator.train_on_batch([x, y_labels], y) log = "%d: [discriminator loss : %f, acc: %f]" % (i, loss, acc) ''' 冻结识别者网络，构造随机一维向量以及指定数字的one-hot-vector输入生成者 网络进行训练 ''' noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) fake_labels = np.eye(num_labels)[np.random.choice(num_labels, batch_size)] y = np.ones([batch_size, 1]) loss, acc = adversarial.train_on_batch([noise, fake_labels], y) log = "%s [adversarial loss :%f, acc: %f]" % (log, loss, acc) if (i + 1) % save_interval == 0: print(log) if (i+1) == train_steps: show = True else: show = False plot_images_cgan(generator, noise_input = noise_input, noise_class = noise_class, show = show, step = (i+1), model_name = model_name) generator.save(model_name + ".h5")
def build_and_train_models_cgan(): (x_train, y_train), (_,_) = mnist.load_data() image_size = x_train.shape[1] x_train = np.reshape(x_train, [-1, image_size, image_size, 1]) x_train = x_train.astype('float32') / 255 #获得要生成数字的最大值 num_labels = np.amax(y_train) + 1 #转换为one-hot-vector y_train = to_categorical(y_train) model_name = "/content/gdrive/My Drive/cgan_mnist" latent_size = 100 batch_size = 64 train_steps = 40000 lr = 2e-4 decay = 6e-8 input_shape = (image_size, image_size, 1) label_shape = (num_labels, ) inputs = Input(shape=input_shape, name='discriminator_input') labels = Input(shape=label_shape, name = 'class_labels') #构建识别者网络时要传入图片对应的One-hot-vector discriminator = build_cgan_discriminator(inputs, labels, image_size) optimizer = RMSprop(lr=lr, decay = decay) discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics = ['accuracy']) input_shape = (latent_size,) inputs = Input(shape=input_shape, name='z_input') #构造生成者时也要传入one-hot-vector generator = build_cgan_generator(inputs, labels, image_size) optimizer = RMSprop(lr = lr*0.5, decay = decay * 0.5) #将生成者和识别者连接起来时要冻结识别者 discriminator.trainable = False outputs = discriminator([generator([inputs, labels]), labels]) adversarial = Model([inputs, labels], outputs, name = model_name) adversarial.compile(loss ='binary_crossentropy', optimizer = optimizer, metrics = ['accuracy']) models = (generator, discriminator, adversarial) data = (x_train, y_train) params = (batch_size, latent_size, train_steps, num_labels, model_name) train_cgan(models, data, params)
def plot_images_cgan(generator, noise_input, noise_class, show = False, step = 0, model_name = ''): os.makedirs(model_name, exist_ok = True) filename = os.path.join(model_name, "%05d.png" % step) images = generator.predict([noise_input, noise_class]) print(model_name, "labels for generated images: ", np.argmax(noise_class, axis =1)) plt.figure(figsize = (2.2, 2.2)) num_images = images.shape[0] image_size = images.shape[1] rows = int(math.sqrt(noise_input.shape[0])) for i in range(num_images): plt.subplot(rows, rows, i + 1) image = np.reshape(images[i], [image_size, image_size]) plt.imshow(image, cmap= 'gray') plt.axis('off') plt.savefig(filename) if show: plt.show() else: plt.close('all')
from keras.layers import LeakyReLU from keras.layers import BatchNormalization from keras.optimizers import RMSprop import math from keras.layers import Activation, Dense, Input build_and_train_models_cgan()
