tensorflow 2.0 深度学习(第五部分 GAN生成神经网络 part2)

「爱情、让人受尽委屈。」 2023-07-02 05:23 12阅读 0赞

# ![20191009191333910.png][] #

# [日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

--------------------

[tensorflow 2.0 深度学习（第一部分 part1）][tensorflow 2.0 _ part1]

[tensorflow 2.0 深度学习（第一部分 part2）][tensorflow 2.0 _ part2]

[tensorflow 2.0 深度学习（第一部分 part3）][tensorflow 2.0 _ part3]

[tensorflow 2.0 深度学习（第二部分 part1）][tensorflow 2.0 _ part1 1]

[tensorflow 2.0 深度学习（第二部分 part2）][tensorflow 2.0 _ part2 1]

[tensorflow 2.0 深度学习（第二部分 part3）][tensorflow 2.0 _ part3 1]

[tensorflow 2.0 深度学习 (第三部分 卷积神经网络 part1)][tensorflow 2.0 _ _ _ part1]

[tensorflow 2.0 深度学习 (第三部分 卷积神经网络 part2)][tensorflow 2.0 _ _ _ part2]

[tensorflow 2.0 深度学习（第四部分 循环神经网络）][tensorflow 2.0 _]

[tensorflow 2.0 深度学习（第五部分 GAN生成神经网络 part1）][tensorflow 2.0 _ GAN_ part1]

[tensorflow 2.0 深度学习（第五部分 GAN生成神经网络 part2）][tensorflow 2.0 _ GAN_ part2]

[tensorflow 2.0 深度学习（第六部分 强化学习）][tensorflow 2.0 _ 1]

--------------------

# **GAN生成对抗网络**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][] #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 15][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 17][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 18][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 19][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 20][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 21][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 22][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 23][]

def d_loss_fn(generator, discriminator, batch_z, batch_x, is_training):
        # 1. 视真实图片为真
        # 2. 视生成图片为假
        fake_image = generator(batch_z, is_training)# 生成器生成的假样本/生成样本
        d_fake_logits = discriminator(fake_image, is_training) # 假样本/生成样本输入的判别器输出
        d_real_logits = discriminator(batch_x, is_training)    # 真实样本输入的判别器输出
        d_loss_real = celoss_ones(d_real_logits) #计算判别器对真实样本输入的损失函数
        d_loss_fake = celoss_zeros(d_fake_logits)#计算判别器对假样本/生成样本输入的损失函数
        gp = gradient_penalty(discriminator, batch_x, fake_image)# 计算梯度惩罚项
        #1.第一种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，但是并没有添加梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real
        #2.第二种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，同时又添加了梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real + 1. * gp
        #3.第三种方式：WGAN-GP 判别器损失函数的定义，并不是计算交叉熵，而是直接最大化判别器的正样本输出，最小化判别器的假样本输出，同时又添加了梯度惩罚项
        #              loss = tf.reduce_mean(d_fake_logits) - tf.reduce_mean(d_real_logits) + 1 0. * gp
        loss = d_loss_fake + d_loss_real + 1. * gp #这里使用了 第二种方式
        return loss, gp
    
    def g_loss_fn(generator, discriminator, batch_z, is_training):
        fake_image = generator(batch_z, is_training) # 生成器生成的假图片
        d_fake_logits = discriminator(fake_image, is_training) # 假样本/生成样本输入的判别器输出
        #1.第一种方式：对判别器的假样本输出做了计算交叉熵sigmoid_cross_entropy_with_logits loss = celoss_ones(d_fake_logits)
        #2.第二种方式：WGAN-GP 生成器损失函数，最大化假样本的输出值 loss = - tf.reduce_mean(d_fake_logits)
        loss = celoss_ones(d_fake_logits)  #这里使用了 第一种方式
        return loss

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 24][]

import multiprocessing
    import tensorflow as tf
    
    def make_anime_dataset(img_paths, batch_size, resize=64, drop_remainder=True, shuffle=True, repeat=1):
        # @tf.function
        def _map_fn(img):
            img = tf.image.resize(img, [resize, resize])
            # img = tf.image.random_crop(img,[resize, resize])
            # img = tf.image.random_flip_left_right(img)
            # img = tf.image.random_flip_up_down(img)
            img = tf.clip_by_value(img, 0, 255)
            img = img / 127.5 - 1 #-1~1
            return img
    
        dataset = disk_image_batch_dataset(img_paths,
                                              batch_size,
                                              drop_remainder=drop_remainder,
                                              map_fn=_map_fn,
                                              shuffle=shuffle,
                                              repeat=repeat)
        img_shape = (resize, resize, 3)
        len_dataset = len(img_paths) // batch_size
        return dataset, img_shape, len_dataset
    
    def batch_dataset(dataset,
                      batch_size,
                      drop_remainder=True,
                      n_prefetch_batch=1,
                      filter_fn=None,
                      map_fn=None,
                      n_map_threads=None,
                      filter_after_map=False,
                      shuffle=True,
                      shuffle_buffer_size=None,
                      repeat=None):
        # set defaults
        if n_map_threads is None:
            n_map_threads = multiprocessing.cpu_count()
        if shuffle and shuffle_buffer_size is None:
            shuffle_buffer_size = max(batch_size * 128, 2048)  # set the minimum buffer size as 2048
        # [*] it is efficient to conduct `shuffle` before `map`/`filter` because `map`/`filter` is sometimes costly
        if shuffle:
            dataset = dataset.shuffle(shuffle_buffer_size)
        if not filter_after_map:
            if filter_fn:
                dataset = dataset.filter(filter_fn)
            if map_fn:
                dataset = dataset.map(map_fn, num_parallel_calls=n_map_threads)
        else:  # [*] this is slower
            if map_fn:
                dataset = dataset.map(map_fn, num_parallel_calls=n_map_threads)
            if filter_fn:
                dataset = dataset.filter(filter_fn)
    
        dataset = dataset.batch(batch_size, drop_remainder=drop_remainder)
        dataset = dataset.repeat(repeat).prefetch(n_prefetch_batch)
        return dataset
    
    def memory_data_batch_dataset(memory_data,
                                  batch_size,
                                  drop_remainder=True,
                                  n_prefetch_batch=1,
                                  filter_fn=None,
                                  map_fn=None,
                                  n_map_threads=None,
                                  filter_after_map=False,
                                  shuffle=True,
                                  shuffle_buffer_size=None,
                                  repeat=None):
        """Batch dataset of memory data.
        Parameters
        ----------
        memory_data : nested structure of tensors/ndarrays/lists
        """
        dataset = tf.data.Dataset.from_tensor_slices(memory_data)
        dataset = batch_dataset(dataset,
                                batch_size,
                                drop_remainder=drop_remainder,
                                n_prefetch_batch=n_prefetch_batch,
                                filter_fn=filter_fn,
                                map_fn=map_fn,
                                n_map_threads=n_map_threads,
                                filter_after_map=filter_after_map,
                                shuffle=shuffle,
                                shuffle_buffer_size=shuffle_buffer_size,
                                repeat=repeat)
        return dataset
    
    def disk_image_batch_dataset(img_paths,
                                 batch_size,
                                 labels=None,
                                 drop_remainder=True,
                                 n_prefetch_batch=1,
                                 filter_fn=None,
                                 map_fn=None,
                                 n_map_threads=None,
                                 filter_after_map=False,
                                 shuffle=True,
                                 shuffle_buffer_size=None,
                                 repeat=None):
        """Batch dataset of disk image for PNG and JPEG.
        Parameters
        ----------
            img_paths : 1d-tensor/ndarray/list of str
            labels : nested structure of tensors/ndarrays/lists
        """
        if labels is None:
            memory_data = img_paths
        else:
            memory_data = (img_paths, labels)
    
        def parse_fn(path, *label):
            img = tf.io.read_file(path)
            img = tf.image.decode_jpeg(img, channels=3)  # fix channels to 3
            return (img,) + label
    
        if map_fn:  # fuse `map_fn` and `parse_fn`
            def map_fn_(*args):
                return map_fn(*parse_fn(*args))
        else:
            map_fn_ = parse_fn
    
        dataset = memory_data_batch_dataset(memory_data,
                                            batch_size,
                                            drop_remainder=drop_remainder,
                                            n_prefetch_batch=n_prefetch_batch,
                                            filter_fn=filter_fn,
                                            map_fn=map_fn_,
                                            n_map_threads=n_map_threads,
                                            filter_after_map=filter_after_map,
                                            shuffle=shuffle,
                                            shuffle_buffer_size=shuffle_buffer_size,
                                            repeat=repeat)
    
        return dataset

import  tensorflow as tf
    from    tensorflow import keras
    from    tensorflow.keras import layers
    
    class Generator(keras.Model):
        # 生成器网络
        def __init__(self):
            super(Generator, self).__init__()
            filter = 64
            # 转置卷积层1,输出channel为filter*8,核大小4,步长1,不使用padding,不使用偏置
            self.conv1 = layers.Conv2DTranspose(filter*8, 4,1, 'valid', use_bias=False)
            self.bn1 = layers.BatchNormalization()
            # 转置卷积层2
            self.conv2 = layers.Conv2DTranspose(filter*4, 4,2, 'same', use_bias=False)
            self.bn2 = layers.BatchNormalization()
            # 转置卷积层3
            self.conv3 = layers.Conv2DTranspose(filter*2, 4,2, 'same', use_bias=False)
            self.bn3 = layers.BatchNormalization()
            # 转置卷积层4
            self.conv4 = layers.Conv2DTranspose(filter*1, 4,2, 'same', use_bias=False)
            self.bn4 = layers.BatchNormalization()
            # 转置卷积层5
            self.conv5 = layers.Conv2DTranspose(3, 4,2, 'same', use_bias=False)
    
        def call(self, inputs, training=None):
            x = inputs # [z, 100]
            # Reshape乘4D张量，方便后续转置卷积运算:(b, 1, 1, 100)
            x = tf.reshape(x, (x.shape[0], 1, 1, x.shape[1]))
            x = tf.nn.relu(x) # 激活函数
            # 转置卷积-BN-激活函数:(b, 4, 4, 512)
            x = tf.nn.relu(self.bn1(self.conv1(x), training=training))
            # 转置卷积-BN-激活函数:(b, 8, 8, 256)
            x = tf.nn.relu(self.bn2(self.conv2(x), training=training))
            # 转置卷积-BN-激活函数:(b, 16, 16, 128)
            x = tf.nn.relu(self.bn3(self.conv3(x), training=training))
            # 转置卷积-BN-激活函数:(b, 32, 32, 64)
            x = tf.nn.relu(self.bn4(self.conv4(x), training=training))
            # 转置卷积-激活函数:(b, 64, 64, 3)
            x = self.conv5(x)
            x = tf.tanh(x) # 输出x范围-1~1,与预处理一致
            return x
    
    class Discriminator(keras.Model):
        # 判别器
        def __init__(self):
            super(Discriminator, self).__init__()
            filter = 64
            # 卷积层
            self.conv1 = layers.Conv2D(filter, 4, 2, 'valid', use_bias=False)
            self.bn1 = layers.BatchNormalization()
            # 卷积层
            self.conv2 = layers.Conv2D(filter*2, 4, 2, 'valid', use_bias=False)
            self.bn2 = layers.BatchNormalization()
            # 卷积层
            self.conv3 = layers.Conv2D(filter*4, 4, 2, 'valid', use_bias=False)
            self.bn3 = layers.BatchNormalization()
            # 卷积层
            self.conv4 = layers.Conv2D(filter*8, 3, 1, 'valid', use_bias=False)
            self.bn4 = layers.BatchNormalization()
            # 卷积层
            self.conv5 = layers.Conv2D(filter*16, 3, 1, 'valid', use_bias=False)
            self.bn5 = layers.BatchNormalization()
            # 全局池化层
            self.pool = layers.GlobalAveragePooling2D()
            # 特征打平
            self.flatten = layers.Flatten()
            # 2分类全连接层
            self.fc = layers.Dense(1)
    
        def call(self, inputs, training=None):
            # 卷积-BN-激活函数:(4, 31, 31, 64)
            x = tf.nn.leaky_relu(self.bn1(self.conv1(inputs), training=training))
            # 卷积-BN-激活函数:(4, 14, 14, 128)
            x = tf.nn.leaky_relu(self.bn2(self.conv2(x), training=training))
            # 卷积-BN-激活函数:(4, 6, 6, 256)
            x = tf.nn.leaky_relu(self.bn3(self.conv3(x), training=training))
            # 卷积-BN-激活函数:(4, 4, 4, 512)
            x = tf.nn.leaky_relu(self.bn4(self.conv4(x), training=training))
            # 卷积-BN-激活函数:(4, 2, 2, 1024)
            x = tf.nn.leaky_relu(self.bn5(self.conv5(x), training=training))
            # 卷积-BN-激活函数:(4, 1024)
            x = self.pool(x)
            # 打平
            x = self.flatten(x)
            # 输出，[b, 1024] => [b, 1]
            logits = self.fc(x)
            return logits
    
    def main():
        d = Discriminator()
        g = Generator()
        x = tf.random.normal([2, 64, 64, 3])
        z = tf.random.normal([2, 100])
        prob = d(x)
        print(prob)
        x_hat = g(z)
        print(x_hat.shape)
    
    if __name__ == '__main__':
        main()

import  os
    import  numpy as np
    import  tensorflow as tf
    from    tensorflow import keras
    from    scipy.misc import toimage
    import  glob
    from    gan import Generator, Discriminator
    from    dataset import make_anime_dataset
    
    def save_result(val_out, val_block_size, image_path, color_mode):
        def preprocess(img):
            img = ((img + 1.0) * 127.5).astype(np.uint8)
            # img = img.astype(np.uint8)
            return img
        preprocesed = preprocess(val_out)
        final_image = np.array([])
        single_row = np.array([])
        for b in range(val_out.shape[0]):
            # concat image into a row
            if single_row.size == 0:
                single_row = preprocesed[b, :, :, :]
            else:
                single_row = np.concatenate((single_row, preprocesed[b, :, :, :]), axis=1)
    
            # concat image row to final_image
            if (b+1) % val_block_size == 0:
                if final_image.size == 0:
                    final_image = single_row
                else:
                    final_image = np.concatenate((final_image, single_row), axis=0)
                # reset single row
                single_row = np.array([])
    
        if final_image.shape[2] == 1:
            final_image = np.squeeze(final_image, axis=2)
        toimage(final_image).save(image_path)
    
    def celoss_ones(logits):
        # 计算属于与标签为1的交叉熵
        y = tf.ones_like(logits)
        loss = keras.losses.binary_crossentropy(y, logits, from_logits=True)
        return tf.reduce_mean(loss)
    
    def celoss_zeros(logits):
        # 计算属于与便签为0的交叉熵
        y = tf.zeros_like(logits)
        loss = keras.losses.binary_crossentropy(y, logits, from_logits=True)
        return tf.reduce_mean(loss)
    
    def d_loss_fn(generator, discriminator, batch_z, batch_x, is_training):
        # 计算判别器的误差函数
        # 采样生成图片
        fake_image = generator(batch_z, is_training)
        # 判定生成图片
        d_fake_logits = discriminator(fake_image, is_training)
        # 判定真实图片
        d_real_logits = discriminator(batch_x, is_training)
        # 真实图片与1之间的误差
        d_loss_real = celoss_ones(d_real_logits)
        # 生成图片与0之间的误差
        d_loss_fake = celoss_zeros(d_fake_logits)
        # 合并误差
        loss = d_loss_fake + d_loss_real
        return loss
    
    def g_loss_fn(generator, discriminator, batch_z, is_training):
        # 采样生成图片
        fake_image = generator(batch_z, is_training)
        # 在训练生成网络时，需要迫使生成图片判定为真
        d_fake_logits = discriminator(fake_image, is_training)
        # 计算生成图片与1之间的误差
        loss = celoss_ones(d_fake_logits)
        return loss
    
    def main():
        tf.random.set_seed(3333)
        np.random.seed(3333)
        os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
        assert tf.__version__.startswith('2.')
        z_dim = 100 # 隐藏向量z的长度
        epochs = 3000000 # 训练步数
        batch_size = 64 # batch size
        learning_rate = 0.0002
        is_training = True
    
        # 获取数据集路径
        # C:\Users\z390\Downloads\anime-faces
        # r'C:\Users\z390\Downloads\faces\*.jpg'
        img_path = glob.glob(r'C:\Users\z390\Downloads\anime-faces\*\*.jpg') + \
            glob.glob(r'C:\Users\z390\Downloads\anime-faces\*\*.png')
        # img_path = glob.glob(r'C:\Users\z390\Downloads\getchu_aligned_with_label\GetChu_aligned2\*.jpg')
        # img_path.extend(img_path2)
        print('images num:', len(img_path))
        # 构建数据集对象
        dataset, img_shape, _ = make_anime_dataset(img_path, batch_size, resize=64)
        print(dataset, img_shape)
        sample = next(iter(dataset)) # 采样
        print(sample.shape, tf.reduce_max(sample).numpy(), tf.reduce_min(sample).numpy())
        dataset = dataset.repeat(100) # 重复循环
        db_iter = iter(dataset)
    
        generator = Generator() # 创建生成器
        generator.build(input_shape = (4, z_dim))
        discriminator = Discriminator() # 创建判别器
        discriminator.build(input_shape=(4, 64, 64, 3))
        # 分别为生成器和判别器创建优化器
        g_optimizer = keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
        d_optimizer = keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
    
        generator.load_weights('generator.ckpt')
        discriminator.load_weights('discriminator.ckpt')
        print('Loaded chpt!!')
    
        d_losses, g_losses = [],[]
        for epoch in range(epochs): # 训练epochs次
            # 1. 训练判别器
            for _ in range(1):
                # 采样隐藏向量
                batch_z = tf.random.normal([batch_size, z_dim])
                batch_x = next(db_iter) # 采样真实图片
                # 判别器前向计算
                with tf.GradientTape() as tape:
                    d_loss = d_loss_fn(generator, discriminator, batch_z, batch_x, is_training)
                grads = tape.gradient(d_loss, discriminator.trainable_variables)
                d_optimizer.apply_gradients(zip(grads, discriminator.trainable_variables))
            # 2. 训练生成器
            # 采样隐藏向量
            batch_z = tf.random.normal([batch_size, z_dim])
            batch_x = next(db_iter) # 采样真实图片
            # 生成器前向计算
            with tf.GradientTape() as tape:
                g_loss = g_loss_fn(generator, discriminator, batch_z, is_training)
            grads = tape.gradient(g_loss, generator.trainable_variables)
            g_optimizer.apply_gradients(zip(grads, generator.trainable_variables))
    
            if epoch % 100 == 0:
                print(epoch, 'd-loss:',float(d_loss), 'g-loss:', float(g_loss))
                # 可视化
                z = tf.random.normal([100, z_dim])
                fake_image = generator(z, training=False)
                img_path = os.path.join('gan_images', 'gan-%d.png'%epoch)
                save_result(fake_image.numpy(), 10, img_path, color_mode='P')
    
                d_losses.append(float(d_loss))
                g_losses.append(float(g_loss))
    
                if epoch % 10000 == 1:
                    # print(d_losses)
                    # print(g_losses)
                    generator.save_weights('generator.ckpt')
                    discriminator.save_weights('discriminator.ckpt')
    
    if __name__ == '__main__':
        main()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 25][]

import  os
    import  numpy as np
    import  tensorflow as tf
    from    tensorflow import keras
    from    scipy.misc import toimage
    from    gan import Generator, Discriminator
    
    def save_result(val_out, val_block_size, image_fn, color_mode):
        def preprocess(img):
            img = ((img + 1.0) * 127.5).astype(np.uint8)
            return img
    
        preprocesed = preprocess(val_out)
        final_image = np.array([])
        single_row = np.array([])
        for b in range(val_out.shape[0]):
            # concat image into a row
            if single_row.size == 0:
                single_row = preprocesed[b, :, :, :]
            else:
                single_row = np.concatenate((single_row, preprocesed[b, :, :, :]), axis=1)
    
            # concat image row to final_image
            if (b+1) % val_block_size == 0:
                if final_image.size == 0:
                    final_image = single_row
                else:
                    final_image = np.concatenate((final_image, single_row), axis=0)
    
                # reset single row
                single_row = np.array([])
    
        if final_image.shape[2] == 1:
            final_image = np.squeeze(final_image, axis=2)
        toimage(final_image, mode=color_mode).save(image_fn)
    
    
    # shorten sigmoid cross entropy loss calculation
    def celoss_ones(logits, smooth=0.0):
        return tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logits,
                                                                      labels=tf.ones_like(logits)*(1.0 - smooth)))
    def celoss_zeros(logits, smooth=0.0):
        return tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logits,
                                                                      labels=tf.zeros_like(logits)*(1.0 - smooth)))
    
    def d_loss_fn(generator, discriminator, input_noise, real_image, is_trainig):
        fake_image = generator(input_noise, is_trainig)
        d_real_logits = discriminator(real_image, is_trainig)
        d_fake_logits = discriminator(fake_image, is_trainig)
        d_loss_real = celoss_ones(d_real_logits, smooth=0.1)
        d_loss_fake = celoss_zeros(d_fake_logits, smooth=0.0)
        loss = d_loss_real + d_loss_fake
        return loss
    
    def g_loss_fn(generator, discriminator, input_noise, is_trainig):
        fake_image = generator(input_noise, is_trainig)
        d_fake_logits = discriminator(fake_image, is_trainig)
        loss = celoss_ones(d_fake_logits, smooth=0.1)
        return loss
    
    def main():
        tf.random.set_seed(22)
        np.random.seed(22)
        os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
        assert tf.__version__.startswith('2.')
    
        # hyper parameters
        z_dim = 100
        epochs = 3000000
        batch_size = 128
        learning_rate = 0.0002
        is_training = True
    
        # for validation purpose
        assets_dir = './images'
        if not os.path.isdir(assets_dir):
            os.makedirs(assets_dir)
        val_block_size = 10
        val_size = val_block_size * val_block_size
    
        # load mnist data
        (x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
        x_train = x_train.astype(np.float32) / 255.
        db = tf.data.Dataset.from_tensor_slices(x_train).shuffle(batch_size*4).batch(batch_size).repeat()
        db_iter = iter(db)
        inputs_shape = [-1, 28, 28, 1]
    
        # create generator & discriminator
        generator = Generator()
        generator.build(input_shape=(batch_size, z_dim))
        generator.summary()
        discriminator = Discriminator()
        discriminator.build(input_shape=(batch_size, 28, 28, 1))
        discriminator.summary()
    
        # prepare optimizer
        d_optimizer = keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
        g_optimizer = keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
    
        for epoch in range(epochs):
            # no need labels
            batch_x = next(db_iter)
            # rescale images to -1 ~ 1
            batch_x = tf.reshape(batch_x, shape=inputs_shape)
            # -1 - 1
            batch_x = batch_x * 2.0 - 1.0
            # Sample random noise for G
            batch_z = tf.random.uniform(shape=[batch_size, z_dim], minval=-1., maxval=1.)
            with tf.GradientTape() as tape:
                d_loss = d_loss_fn(generator, discriminator, batch_z, batch_x, is_training)
            grads = tape.gradient(d_loss, discriminator.trainable_variables)
            d_optimizer.apply_gradients(zip(grads, discriminator.trainable_variables))
            with tf.GradientTape() as tape:
                g_loss = g_loss_fn(generator, discriminator, batch_z, is_training)
            grads = tape.gradient(g_loss, generator.trainable_variables)
            g_optimizer.apply_gradients(zip(grads, generator.trainable_variables))
    
            if epoch % 100 == 0:
                print(epoch, 'd loss:', float(d_loss), 'g loss:', float(g_loss))
                # validation results at every epoch
                val_z = np.random.uniform(-1, 1, size=(val_size, z_dim))
                fake_image = generator(val_z, training=False)
                image_fn = os.path.join('images', 'gan-val-{:03d}.png'.format(epoch + 1))
                save_result(fake_image.numpy(), val_block_size, image_fn, color_mode='L')
    
    if __name__ == '__main__':
        main()

import  tensorflow as tf
    from    tensorflow import keras
    
    class Generator(keras.Model):
        def __init__(self):
            super(Generator, self).__init__()
            self.n_f = 512
            self.n_k = 4
            # input z vector is [None, 100]
            self.dense1 = keras.layers.Dense(3 * 3 * self.n_f)
            self.conv2 = keras.layers.Conv2DTranspose(self.n_f // 2, 3, 2, 'valid')
            self.bn2 = keras.layers.BatchNormalization()
            self.conv3 = keras.layers.Conv2DTranspose(self.n_f // 4, self.n_k, 2, 'same')
            self.bn3 = keras.layers.BatchNormalization()
            self.conv4 = keras.layers.Conv2DTranspose(1, self.n_k, 2, 'same')
            return
    
        def call(self, inputs, training=None):
            # [b, 100] => [b, 3, 3, 512]
            x = tf.nn.leaky_relu(tf.reshape(self.dense1(inputs), shape=[-1, 3, 3, self.n_f]))
            x = tf.nn.leaky_relu(self.bn2(self.conv2(x), training=training))
            x = tf.nn.leaky_relu(self.bn3(self.conv3(x), training=training))
            x = tf.tanh(self.conv4(x))
            return x
    
    class Discriminator(keras.Model):
        def __init__(self):
            super(Discriminator, self).__init__()
            self.n_f = 64
            self.n_k = 4
            # input image is [-1, 28, 28, 1]
            self.conv1 = keras.layers.Conv2D(self.n_f, self.n_k, 2, 'same')
            self.conv2 = keras.layers.Conv2D(self.n_f * 2, self.n_k, 2, 'same')
            self.bn2 = keras.layers.BatchNormalization()
            self.conv3 = keras.layers.Conv2D(self.n_f * 4, self.n_k, 2, 'same')
            self.bn3 = keras.layers.BatchNormalization()
            self.flatten4 = keras.layers.Flatten()
            self.dense4 = keras.layers.Dense(1)
            return
    
        def call(self, inputs, training=None):
            x = tf.nn.leaky_relu(self.conv1(inputs))
            x = tf.nn.leaky_relu(self.bn2(self.conv2(x), training=training))
            x = tf.nn.leaky_relu(self.bn3(self.conv3(x), training=training))
            x = self.dense4(self.flatten4(x))
            return x

import  tensorflow as tf
    from    tensorflow import keras
    from    tensorflow.keras import layers
     
    class Generator(keras.Model):
        def __init__(self):
            super(Generator, self).__init__()
            # z: [b, 100] => [b, 3*3*512] => [b, 3, 3, 512] => [b, 64, 64, 3]
            self.fc = layers.Dense(3*3*512)
            self.conv1 = layers.Conv2DTranspose(256, 3, 3, 'valid')
            self.bn1 = layers.BatchNormalization()
            self.conv2 = layers.Conv2DTranspose(128, 5, 2, 'valid')
            self.bn2 = layers.BatchNormalization()
            self.conv3 = layers.Conv2DTranspose(3, 4, 3, 'valid')
    
        def call(self, inputs, training=None):
            # [z, 100] => [z, 3*3*512]
            x = self.fc(inputs)
            x = tf.reshape(x, [-1, 3, 3, 512])
            x = tf.nn.leaky_relu(x)
            x = tf.nn.leaky_relu(self.bn1(self.conv1(x), training=training))
            x = tf.nn.leaky_relu(self.bn2(self.conv2(x), training=training))
            x = self.conv3(x)
            x = tf.tanh(x)
            return x
    
    class Discriminator(keras.Model):
        def __init__(self):
            super(Discriminator, self).__init__()
            # [b, 64, 64, 3] => [b, 1]
            self.conv1 = layers.Conv2D(64, 5, 3, 'valid')
            self.conv2 = layers.Conv2D(128, 5, 3, 'valid')
            self.bn2 = layers.BatchNormalization()
            self.conv3 = layers.Conv2D(256, 5, 3, 'valid')
            self.bn3 = layers.BatchNormalization()
            # [b, h, w ,c] => [b, -1]
            self.flatten = layers.Flatten()
            self.fc = layers.Dense(1)
    
        def call(self, inputs, training=None):
            x = tf.nn.leaky_relu(self.conv1(inputs))
            x = tf.nn.leaky_relu(self.bn2(self.conv2(x), training=training))
            x = tf.nn.leaky_relu(self.bn3(self.conv3(x), training=training))
            # [b, h, w, c] => [b, -1]
            x = self.flatten(x)
            # [b, -1] => [b, 1]
            logits = self.fc(x)
            return logits
    
    def main():
        d = Discriminator()
        g = Generator()
        x = tf.random.normal([2, 64, 64, 3])
        z = tf.random.normal([2, 100])
        prob = d(x)
        print(prob)
        x_hat = g(z)
        print(x_hat.shape)
    
    if __name__ == '__main__':
        main()

import multiprocessing
    import tensorflow as tf
    
    def make_anime_dataset(img_paths, batch_size, resize=64, drop_remainder=True, shuffle=True, repeat=1):
        @tf.function
        def _map_fn(img):
            img = tf.image.resize(img, [resize, resize])
            img = tf.clip_by_value(img, 0, 255)
            img = img / 127.5 - 1
            return img
    
        dataset = disk_image_batch_dataset(img_paths,
                                              batch_size,
                                              drop_remainder=drop_remainder,
                                              map_fn=_map_fn,
                                              shuffle=shuffle,
                                              repeat=repeat)
        img_shape = (resize, resize, 3)
        len_dataset = len(img_paths) // batch_size
        return dataset, img_shape, len_dataset
    
    def batch_dataset(dataset,
                      batch_size,
                      drop_remainder=True,
                      n_prefetch_batch=1,
                      filter_fn=None,
                      map_fn=None,
                      n_map_threads=None,
                      filter_after_map=False,
                      shuffle=True,
                      shuffle_buffer_size=None,
                      repeat=None):
        # set defaults
        if n_map_threads is None:
            n_map_threads = multiprocessing.cpu_count()
        if shuffle and shuffle_buffer_size is None:
            shuffle_buffer_size = max(batch_size * 128, 2048)  # set the minimum buffer size as 2048
    
        # [*] it is efficient to conduct `shuffle` before `map`/`filter` because `map`/`filter` is sometimes costly
        if shuffle:
            dataset = dataset.shuffle(shuffle_buffer_size)
    
        if not filter_after_map:
            if filter_fn:
                dataset = dataset.filter(filter_fn)
            if map_fn:
                dataset = dataset.map(map_fn, num_parallel_calls=n_map_threads)
        else:  # [*] this is slower
            if map_fn:
                dataset = dataset.map(map_fn, num_parallel_calls=n_map_threads)
            if filter_fn:
                dataset = dataset.filter(filter_fn)
    
        dataset = dataset.batch(batch_size, drop_remainder=drop_remainder)
        dataset = dataset.repeat(repeat).prefetch(n_prefetch_batch)
        return dataset
    
    def memory_data_batch_dataset(memory_data,
                                  batch_size,
                                  drop_remainder=True,
                                  n_prefetch_batch=1,
                                  filter_fn=None,
                                  map_fn=None,
                                  n_map_threads=None,
                                  filter_after_map=False,
                                  shuffle=True,
                                  shuffle_buffer_size=None,
                                  repeat=None):
        """Batch dataset of memory data.
        Parameters
        ----------
        memory_data : nested structure of tensors/ndarrays/lists
        """
        dataset = tf.data.Dataset.from_tensor_slices(memory_data)
        dataset = batch_dataset(dataset,
                                batch_size,
                                drop_remainder=drop_remainder,
                                n_prefetch_batch=n_prefetch_batch,
                                filter_fn=filter_fn,
                                map_fn=map_fn,
                                n_map_threads=n_map_threads,
                                filter_after_map=filter_after_map,
                                shuffle=shuffle,
                                shuffle_buffer_size=shuffle_buffer_size,
                                repeat=repeat)
        return dataset
    
    def disk_image_batch_dataset(img_paths,
                                 batch_size,
                                 labels=None,
                                 drop_remainder=True,
                                 n_prefetch_batch=1,
                                 filter_fn=None,
                                 map_fn=None,
                                 n_map_threads=None,
                                 filter_after_map=False,
                                 shuffle=True,
                                 shuffle_buffer_size=None,
                                 repeat=None):
        """Batch dataset of disk image for PNG and JPEG.
        Parameters
        ----------
            img_paths : 1d-tensor/ndarray/list of str
            labels : nested structure of tensors/ndarrays/lists
        """
        if labels is None:
            memory_data = img_paths
        else:
            memory_data = (img_paths, labels)
    
        def parse_fn(path, *label):
            img = tf.io.read_file(path)
            img = tf.image.decode_png(img, 3)  # fix channels to 3
            return (img,) + label
    
        if map_fn:  # fuse `map_fn` and `parse_fn`
            def map_fn_(*args):
                return map_fn(*parse_fn(*args))
        else:
            map_fn_ = parse_fn
    
        dataset = memory_data_batch_dataset(memory_data,
                                            batch_size,
                                            drop_remainder=drop_remainder,
                                            n_prefetch_batch=n_prefetch_batch,
                                            filter_fn=filter_fn,
                                            map_fn=map_fn_,
                                            n_map_threads=n_map_threads,
                                            filter_after_map=filter_after_map,
                                            shuffle=shuffle,
                                            shuffle_buffer_size=shuffle_buffer_size,
                                            repeat=repeat)
        return dataset

import  os
    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    import  numpy as np
    import  tensorflow as tf
    from    tensorflow import keras
    from    scipy.misc import toimage
    import  glob
    from    gan import Generator, Discriminator
    from    dataset import make_anime_dataset
    
    def save_result(val_out, val_block_size, image_path, color_mode):
        def preprocess(img):
            img = ((img + 1.0) * 127.5).astype(np.uint8)
            # img = img.astype(np.uint8)
            return img
        preprocesed = preprocess(val_out)
        final_image = np.array([])
        single_row = np.array([])
        for b in range(val_out.shape[0]):
            # concat image into a row
            if single_row.size == 0:
                single_row = preprocesed[b, :, :, :]
            else:
                single_row = np.concatenate((single_row, preprocesed[b, :, :, :]), axis=1)
    
            # concat image row to final_image
            if (b+1) % val_block_size == 0:
                if final_image.size == 0:
                    final_image = single_row
                else:
                    final_image = np.concatenate((final_image, single_row), axis=0)
                # reset single row
                single_row = np.array([])
        if final_image.shape[2] == 1:
            final_image = np.squeeze(final_image, axis=2)
        toimage(final_image).save(image_path)
    
    
    def celoss_ones(logits):
        # [b, 1]
        # [b] = [1, 1, 1, 1,]
        loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=tf.ones_like(logits))
        return tf.reduce_mean(loss)
     
    def celoss_zeros(logits):
        # [b, 1]
        # [b] = [1, 1, 1, 1,]
        loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=tf.zeros_like(logits))
        return tf.reduce_mean(loss)
     
    # 梯度惩罚项计算函数
    def gradient_penalty(discriminator, batch_x, fake_image):
        batchsz = batch_x.shape[0]
        # [b, h, w, c]  每个样本均随机采样 t,用于插值
        t = tf.random.uniform([batchsz, 1, 1, 1])
        # 自动扩展为 x 的形状  [b, 1, 1, 1] => [b, h, w, c]
        t = tf.broadcast_to(t, batch_x.shape)
        # 在真假图片之间做线性插值
        interplate = t * batch_x + (1 - t) * fake_image
        # 在梯度环境中计算 D 对插值样本的梯度
        with tf.GradientTape() as tape:
            tape.watch([interplate]) # 加入梯度观察列表
            d_interplote_logits = discriminator(interplate, is_training)
        grads = tape.gradient(d_interplote_logits, interplate) # 计算每个样本的梯度
        # grads:[b, h, w, c] => [b, -1]
        grads = tf.reshape(grads, [grads.shape[0], -1])
        gp = tf.norm(grads, axis=1) #[b] 计算每个样本的梯度的L2范数
        gp = tf.reduce_mean( (gp-1)**2 ) # 计算梯度惩罚项
        return gp
     
    def d_loss_fn(generator, discriminator, batch_z, batch_x, is_training):
        # 1. 视真实图片为真
        # 2. 视生成图片为假
        fake_image = generator(batch_z, is_training)# 生成器生成的假样本/生成样本
        d_fake_logits = discriminator(fake_image, is_training) # 假样本/生成样本输入的判别器输出
        d_real_logits = discriminator(batch_x, is_training)    # 真实样本输入的判别器输出
        d_loss_real = celoss_ones(d_real_logits) #计算判别器对真实样本输入的损失函数
        d_loss_fake = celoss_zeros(d_fake_logits)#计算判别器对假样本/生成样本输入的损失函数
        gp = gradient_penalty(discriminator, batch_x, fake_image)# 计算梯度惩罚项
        #1.第一种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，但是并没有添加梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real
        #2.第二种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，同时又添加了梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real + 1. * gp
        #3.第三种方式：WGAN-GP 判别器损失函数的定义，并不是计算交叉熵，而是直接最大化判别器的正样本输出，最小化判别器的假样本输出，同时又添加了梯度惩罚项
        #              loss = tf.reduce_mean(d_fake_logits) - tf.reduce_mean(d_real_logits) + 1 0. * gp
        loss = d_loss_fake + d_loss_real + 1. * gp #这里使用了 第二种方式
        return loss, gp
     
    def g_loss_fn(generator, discriminator, batch_z, is_training):
        fake_image = generator(batch_z, is_training) # 生成器生成的假图片
        d_fake_logits = discriminator(fake_image, is_training) # 假样本/生成样本输入的判别器输出
        #1.第一种方式：对判别器的假样本输出做了计算交叉熵sigmoid_cross_entropy_with_logits loss = celoss_ones(d_fake_logits)
        #2.第二种方式：WGAN-GP 生成器损失函数，最大化假样本的输出值 loss = - tf.reduce_mean(d_fake_logits)
        loss = celoss_ones(d_fake_logits)  #这里使用了 第一种方式
        return loss
    
    def main():
        tf.random.set_seed(22)
        np.random.seed(22)
        os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
        assert tf.__version__.startswith('2.')
    
        # hyper parameters
        z_dim = 100
        epochs = 3000000
        batch_size = 512
        learning_rate = 0.002
        is_training = True
    
        img_path = glob.glob(r'C:\Users\Jackie Loong\Downloads\DCGAN-LSGAN-WGAN-GP-DRAGAN-Tensorflow-2-master\data\faces\*.jpg')
        dataset, img_shape, _ = make_anime_dataset(img_path, batch_size)
        print(dataset, img_shape)
        sample = next(iter(dataset))
        print(sample.shape, tf.reduce_max(sample).numpy(), tf.reduce_min(sample).numpy())
        dataset = dataset.repeat()
        db_iter = iter(dataset)
     
        generator = Generator()
        generator.build(input_shape = (None, z_dim))
        discriminator = Discriminator()
        discriminator.build(input_shape=(None, 64, 64, 3))
        g_optimizer = tf.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
        d_optimizer = tf.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
    
        for epoch in range(epochs):
            batch_z = tf.random.uniform([batch_size, z_dim], minval=-1., maxval=1.)
            batch_x = next(db_iter)
    
            # train 判别器
            with tf.GradientTape() as tape:
                d_loss, gp = d_loss_fn(generator, discriminator, batch_z, batch_x, is_training)
            grads = tape.gradient(d_loss, discriminator.trainable_variables)
            d_optimizer.apply_gradients(zip(grads, discriminator.trainable_variables))
            # train 生成器
            with tf.GradientTape() as tape:
                g_loss = g_loss_fn(generator, discriminator, batch_z, is_training)
            grads = tape.gradient(g_loss, generator.trainable_variables)
            g_optimizer.apply_gradients(zip(grads, generator.trainable_variables))
    
            if epoch % 100 == 0:
                print(epoch, 'd-loss:',float(d_loss), 'g-loss:', float(g_loss),  'gp:', float(gp))
                z = tf.random.uniform([100, z_dim])
                fake_image = generator(z, training=False)
                img_path = os.path.join('images', 'wgan-%d.png'%epoch)
                save_result(fake_image.numpy(), 10, img_path, color_mode='P')
     
    if __name__ == '__main__':
        main()

import  os
    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    import  numpy as np
    import  tensorflow as tf
    from    tensorflow import keras
    from    scipy.misc import toimage
    import  glob
    from    gan import Generator, Discriminator
    from    dataset import make_anime_dataset
    
    def save_result(val_out, val_block_size, image_path, color_mode):
        def preprocess(img):
            img = ((img + 1.0) * 127.5).astype(np.uint8)
            # img = img.astype(np.uint8)
            return img
    
        preprocesed = preprocess(val_out)
        final_image = np.array([])
        single_row = np.array([])
        for b in range(val_out.shape[0]):
            # concat image into a row
            if single_row.size == 0:
                single_row = preprocesed[b, :, :, :]
            else:
                single_row = np.concatenate((single_row, preprocesed[b, :, :, :]), axis=1)
            # concat image row to final_image
            if (b+1) % val_block_size == 0:
                if final_image.size == 0:
                    final_image = single_row
                else:
                    final_image = np.concatenate((final_image, single_row), axis=0)
                # reset single row
                single_row = np.array([])
        if final_image.shape[2] == 1:
            final_image = np.squeeze(final_image, axis=2)
        toimage(final_image).save(image_path)
     
    def celoss_ones(logits):
        # [b, 1]
        # [b] = [1, 1, 1, 1,]
        loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=tf.ones_like(logits))
        return tf.reduce_mean(loss)
     
    def celoss_zeros(logits):
        # [b, 1]
        # [b] = [1, 1, 1, 1,]
        loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=tf.zeros_like(logits))
        return tf.reduce_mean(loss)
    
    def d_loss_fn(generator, discriminator, batch_z, batch_x, is_training):
        # 1. 视真实图片为真
        # 2. 视生成图片为假
        fake_image = generator(batch_z, is_training) # 生成器生成的假样本/生成样本
        d_fake_logits = discriminator(fake_image, is_training)# 假样本/生成样本输入的判别器输出
        d_real_logits = discriminator(batch_x, is_training)# 真实样本输入的判别器输出
        d_loss_real = celoss_ones(d_real_logits)#计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        d_loss_fake = celoss_zeros(d_fake_logits)#计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #1.第一种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，但是并没有添加梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real
        #2.第二种方式：对判别器的正样本输出和判别器的假样本输出都做了计算交叉熵sigmoid_cross_entropy_with_logits，同时又添加了梯度惩罚项
        #              d_loss_real = celoss_ones(d_real_logits) 计算判别器对真实样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              d_loss_fake = celoss_zeros(d_fake_logits)  计算判别器对假样本/生成样本的交叉熵sigmoid_cross_entropy_with_logits损失函数
        #              loss = d_loss_fake + d_loss_real + 1. * gp
        #3.第三种方式：WGAN-GP 判别器损失函数的定义，并不是计算交叉熵，而是直接最大化判别器的正样本输出，最小化判别器的假样本输出，同时又添加了梯度惩罚项
        #              loss = tf.reduce_mean(d_fake_logits) - tf.reduce_mean(d_real_logits) + 1 0. * gp
        loss = d_loss_fake + d_loss_real #这里使用了 第一种方式
        return loss
    
    def g_loss_fn(generator, discriminator, batch_z, is_training):
        fake_image = generator(batch_z, is_training)# 生成器生成的假图片
        d_fake_logits = discriminator(fake_image, is_training)  # 假样本/生成样本输入的判别器输出
        #1.第一种方式：对判别器的假样本输出做了计算交叉熵sigmoid_cross_entropy_with_logits loss = celoss_ones(d_fake_logits)
        #2.第二种方式：WGAN-GP 生成器损失函数，最大化假样本的输出值 loss = - tf.reduce_mean(d_fake_logits)
        loss = celoss_ones(d_fake_logits) #这里使用了 第一种方式
        return loss
    
    def main():
        tf.random.set_seed(22)
        np.random.seed(22)
        os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
        assert tf.__version__.startswith('2.')
        # hyper parameters
        z_dim = 100
        epochs = 3000000
        batch_size = 512
        learning_rate = 0.002
        is_training = True
    
        img_path = glob.glob(r'C:\Users\Jackie Loong\Downloads\DCGAN-LSGAN-WGAN-GP-DRAGAN-Tensorflow-2-master\data\faces\*.jpg')
        dataset, img_shape, _ = make_anime_dataset(img_path, batch_size)
        print(dataset, img_shape)
        sample = next(iter(dataset))
        print(sample.shape, tf.reduce_max(sample).numpy(), tf.reduce_min(sample).numpy())
        dataset = dataset.repeat()
        db_iter = iter(dataset)
    
        generator = Generator()
        generator.build(input_shape = (None, z_dim))
        discriminator = Discriminator()
        discriminator.build(input_shape=(None, 64, 64, 3))
        g_optimizer = tf.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
        d_optimizer = tf.optimizers.Adam(learning_rate=learning_rate, beta_1=0.5)
    
        for epoch in range(epochs):
            batch_z = tf.random.uniform([batch_size, z_dim], minval=-1., maxval=1.)
            batch_x = next(db_iter)
    
            # train 判别器
            with tf.GradientTape() as tape:
                d_loss = d_loss_fn(generator, discriminator, batch_z, batch_x, is_training)
            grads = tape.gradient(d_loss, discriminator.trainable_variables)
            d_optimizer.apply_gradients(zip(grads, discriminator.trainable_variables))
            # train 生成器
            with tf.GradientTape() as tape:
                g_loss = g_loss_fn(generator, discriminator, batch_z, is_training)
            grads = tape.gradient(g_loss, generator.trainable_variables)
            g_optimizer.apply_gradients(zip(grads, generator.trainable_variables))
    
            if epoch % 100 == 0:
                print(epoch, 'd-loss:',float(d_loss), 'g-loss:', float(g_loss))
    
                z = tf.random.uniform([100, z_dim])
                fake_image = generator(z, training=False)
                img_path = os.path.join('images', 'gan-%d.png'%epoch)
                save_result(fake_image.numpy(), 10, img_path, color_mode='P')
    
    if __name__ == '__main__':
        main()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 26][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 27][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 28][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 29][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 30][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 31][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 32][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 33][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 34][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 35][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 36][]

[20191009191333910.png]: https://img-blog.csdnimg.cn/20191009191333910.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161
[tensorflow 2.0 _ part1]: https://azusa.blog.csdn.net/article/details/104086445
[tensorflow 2.0 _ part2]: https://azusa.blog.csdn.net/article/details/104086557
[tensorflow 2.0 _ part3]: https://azusa.blog.csdn.net/article/details/104086663
[tensorflow 2.0 _ part1 1]: https://azusa.blog.csdn.net/article/details/104086741
[tensorflow 2.0 _ part2 1]: https://azusa.blog.csdn.net/article/details/104086773
[tensorflow 2.0 _ part3 1]: https://azusa.blog.csdn.net/article/details/104087912
[tensorflow 2.0 _ _ _ part1]: https://azusa.blog.csdn.net/article/details/104088133
[tensorflow 2.0 _ _ _ part2]: https://azusa.blog.csdn.net/article/details/104088230
[tensorflow 2.0 _]: https://azusa.blog.csdn.net/article/details/104088366
[tensorflow 2.0 _ GAN_ part1]: https://azusa.blog.csdn.net/article/details/104088512
[tensorflow 2.0 _ GAN_ part2]: https://azusa.blog.csdn.net/article/details/104088559
[tensorflow 2.0 _ 1]: https://azusa.blog.csdn.net/article/details/104089741
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200126180246993.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200126180302788.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200126180301922.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200126180316886.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020012618032337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200126180329636.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200126180336855.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200126180345163.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200126180352791.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200126180400481.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200126180406511.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/2020012618040866.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200126180422566.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200126180421365.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20200126180430987.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200126180442456.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200126180442490.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200126180455843.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/2020012618050147.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20200126180459734.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20200126180515241.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20200126180511808.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20200126180528783.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/20200126180532356.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20200126180531907.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 25]: https://img-blog.csdnimg.cn/20200126180613773.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 26]: https://img-blog.csdnimg.cn/20200126180713102.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 27]: https://img-blog.csdnimg.cn/20200126180717956.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 28]: https://img-blog.csdnimg.cn/20200126180723202.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/20200126180728989.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 30]: https://img-blog.csdnimg.cn/2020012618073415.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 31]: https://img-blog.csdnimg.cn/2020012618074025.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 32]: https://img-blog.csdnimg.cn/20200126180744768.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 33]: https://img-blog.csdnimg.cn/20200126180752432.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 34]: https://img-blog.csdnimg.cn/20200126180758450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 35]: https://img-blog.csdnimg.cn/20200126180800193.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 36]: https://img-blog.csdnimg.cn/20200126180805120.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70