Python知识点：如何使用Python实现图像生成（GANs）

杰哥在此

于 2024-09-04 08:25:14 发布

阅读量346

点赞数 12

分类专栏： Python系列文章标签： python 开发语言编程面试

本文链接：https://blog.csdn.net/bigorsmallorlarge/article/details/141882766

版权

Python系列专栏收录该内容

98 篇文章 2 订阅

订阅专栏

要在 Python 中实现图像生成，通常可以使用生成对抗网络 (GANs)。GANs 是一种深度学习模型，它包含两个网络：生成器 (Generator) 和判别器 (Discriminator)。生成器负责生成伪造数据，判别器则负责区分生成的数据和真实的数据。训练过程中，这两个网络相互对抗，最终生成器可以生成看起来非常真实的图像。

以下是使用 TensorFlow 和 Keras 实现简单 GAN 的步骤，来生成类似 MNIST 手写数字的图像。

步骤 1：安装依赖库

你需要安装 TensorFlow 库来构建和训练 GANs：

pip install tensorflow

步骤 2：加载数据并预处理

我们将使用 MNIST 数据集来训练 GAN。这个数据集包含 28x28 像素的手写数字图片。

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

# 加载并预处理 MNIST 数据集
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # 将像素值归一化到[-1, 1]

BUFFER_SIZE = 60000
BATCH_SIZE = 256

# 创建数据集并打乱
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

步骤 3：定义生成器和判别器

生成器将随机噪声转换为图像，而判别器则试图区分真实图像和生成器生成的图像。

生成器模型

def make_generator_model():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    
    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    
    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    
    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    
    return model

generator = make_generator_model()

判别器模型

def make_discriminator_model():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    
    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    
    model.add(layers.Flatten())
    model.add(layers.Dense(1))
    
    return model

discriminator = make_discriminator_model()

步骤 4：定义损失函数和优化器

cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)

def discriminator_loss(real_output, fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
    total_loss = real_loss + fake_loss
    return total_loss

def generator_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output), fake_output)

generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

步骤 5：训练模型

定义训练过程，包括如何在每个训练步骤中更新生成器和判别器。

import tensorflow as tf

EPOCHS = 50
noise_dim = 100
num_examples_to_generate = 16

# 生成的种子 (用来在训练过程中评估生成器的效果)
seed = tf.random.normal([num_examples_to_generate, noise_dim])

@tf.function
def train_step(images):
    noise = tf.random.normal([BATCH_SIZE, noise_dim])
    
    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        generated_images = generator(noise, training=True)
        
        real_output = discriminator(images, training=True)
        fake_output = discriminator(generated_images, training=True)
        
        gen_loss = generator_loss(fake_output)
        disc_loss = discriminator_loss(real_output, fake_output)
    
    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
    
    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

def train(dataset, epochs):
    for epoch in range(epochs):
        for image_batch in dataset:
            train_step(image_batch)
        
        # 每个epoch结束后生成并保存图像
        generate_and_save_images(generator, epoch + 1, seed)
    
    # 训练完成后生成最终图像
    generate_and_save_images(generator, epochs, seed)

def generate_and_save_images(model, epoch, test_input):
    predictions = model(test_input, training=False)
    
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig(f'image_at_epoch_{epoch:04d}.png')
    plt.show()

# 开始训练
train(train_dataset, EPOCHS)