Python의 GAN 알고리즘 예

GAN(Generative Adversarial Networks)은 서로 경쟁하는 두 개의 신경망을 통해 새로운 데이터를 생성하는 딥러닝 알고리즘입니다. GAN은 이미지, 오디오, 텍스트 및 기타 분야의 생성 작업에 널리 사용됩니다. 이 기사에서는 Python을 사용하여 손으로 쓴 숫자 이미지를 생성하는 GAN 알고리즘의 예를 작성합니다.

1. 데이터 세트 준비

MNIST 데이터 세트를 훈련 데이터 세트로 사용하겠습니다. MNIST 데이터 세트에는 60,000개의 훈련 이미지와 10,000개의 테스트 이미지가 포함되어 있으며 각 이미지는 28x28 회색조 이미지입니다. TensorFlow 라이브러리를 사용하여 데이터세트를 로드하고 처리하겠습니다. 데이터 세트를 로드하기 전에 TensorFlow 라이브러리와 NumPy 라이브러리를 설치해야 합니다.

tf로 tensorflow 가져오기
np로 numpy 가져오기

(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

dataset preprocessing

train_images = train_images.reshape( train_images. Shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5 # 픽셀 값을 [-1, 1]

2. 범위로 정규화합니다. GAN 아키텍처 설계 training

우리의 GAN에는 생성자 네트워크와 판별자 네트워크라는 두 개의 신경 네트워크가 포함됩니다. 생성기 네트워크는 노이즈 벡터를 입력으로 받고 28x28 이미지를 출력합니다. 판별자 네트워크는 28x28 이미지를 입력으로 받고 해당 이미지가 실제 이미지일 확률을 출력합니다.

생성자 네트워크와 판별자 네트워크 모두의 아키텍처는 CNN(컨볼루션 신경망)을 사용합니다. 생성기 네트워크에서는 디콘볼루션 레이어를 사용하여 노이즈 벡터를 28x28 이미지로 디코딩합니다. 판별자 네트워크에서는 컨볼루션 레이어를 사용하여 입력 이미지를 분류합니다.

생성기 네트워크에 대한 입력은 길이 100의 노이즈 벡터입니다. tf.keras.Sequential 함수를 사용하여 네트워크 레이어를 쌓겠습니다.

def make_generator_model():

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.LeakyReLU())

model.add(tf.keras.layers.Reshape((7, 7, 256)))
assert model.output_shape == (None, 7, 7, 256) # 注意：batch size没有限制

model.add(tf.keras.layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
assert model.output_shape == (None, 7, 7, 128)
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.LeakyReLU())

model.add(tf.keras.layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
assert model.output_shape == (None, 14, 14, 64)
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.LeakyReLU())

model.add(tf.keras.layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
assert model.output_shape == (None, 28, 28, 1)

return model

판별기 네트워크의 입력은 28x28 이미지입니다. tf.keras.Sequential 함수를 사용하여 네트워크 레이어를 쌓겠습니다.

def make_discriminator_model():

model = tf.keras.Sequential()
model.add(tf.keras.layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
                                 input_shape=[28, 28, 1]))
model.add(tf.keras.layers.LeakyReLU())
model.add(tf.keras.layers.Dropout(0.3))

model.add(tf.keras.layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
model.add(tf.keras.layers.LeakyReLU())
model.add(tf.keras.layers.Dropout(0.3))

model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(1))

return model

다음으로 학습 코드를 작성하겠습니다. 각 배치에서 생성자 네트워크와 판별자 네트워크를 교대로 훈련하겠습니다. 훈련 과정에서 tf.GradientTape() 함수를 사용하여 기울기를 기록한 다음 tf.keras.optimizers.Adam() 함수를 사용하여 네트워크를 최적화합니다.

generator = make_generator_model()
판별자 = make_discriminator_model()

손실 함수

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

판별자 손실 함수

def discriminator_loss(real_output , fake_ 출력):

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)

optimizer

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

훈련 함수 정의

@tf.function
def train_step(images):

noise = tf.random.normal([BATCH_SIZE, 100])

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))

BATCH_SIZE = 256
EPOCHS = 100

for epoch in range(EPOCHS):

for i in range(train_images.shape[0] // BATCH_SIZE):
    batch_images = train_images[i*BATCH_SIZE:(i+1)*BATCH_SIZE]
    train_step(batch_images)

3. 훈련에서 새 이미지 생성

완료되면 , 생성기 네트워크를 사용하여 새 이미지를 생성합니다. 우리는 무작위로 100개의 노이즈 벡터를 생성하고 이를 생성기 네트워크에 입력하여 손으로 쓴 숫자의 새로운 이미지를 생성합니다.

matplotlib.pyplot을 plt로 가져오기

def generate_and_save_images(model, epoch, test_input):

# 注意 training` 设定为 False
# 因此，所有层都在推理模式下运行（batchnorm）。
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('image_at_epoch_{:04d}.png'.format(epoch))
plt.show()

무작위로 노이즈 벡터 생성

noise = tf.random.normal([16, 100])
generate_and_save_images(generator, 0, 소음)

결과는 생성기가 새로운 손글씨 숫자 이미지를 성공적으로 생성했음을 보여줍니다. 훈련 에포크 수를 점진적으로 늘려 모델의 성능을 향상시킬 수 있습니다. 또한, 다른 하이퍼파라미터 조합과 네트워크 아키텍처를 시도하여 GAN의 성능을 더욱 향상시킬 수 있습니다.

간단히 말하면, GAN 알고리즘은 다양한 유형의 데이터를 생성하는 데 사용할 수 있는 매우 유용한 딥러닝 알고리즘입니다. 이 기사에서는 Python을 사용하여 손으로 쓴 숫자 이미지를 생성하기 위한 GAN 알고리즘의 예를 작성하고 생성기 네트워크를 훈련하고 사용하여 새로운 이미지를 생성하는 방법을 보여주었습니다.

위 내용은 Python의 GAN 알고리즘 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!