از نویز تا هنر: ساختن اولین شبکه متخاصم مولد شما

Summarize this content to 400 words in Persian Lang
من با این ایده یادگیری ماشینی باشکوه که به عنوان شبکه‌های متخاصم مولد (GAN) شناخته می‌شود، به خصوص در حوزه تولید تصویر آشنا شدم. چارچوب دیگری به نام GANs توسط ایان گودفلو در سال 2014 توسعه یافت. معماری زیربنایی آن با استفاده از رقابت دو شبکه عصبی ساخته شده است. با توجه به وسعت این وبلاگ، اجازه دهید ابتدا معرفی کنم GAN چیست، و سپس به شما بگویم که در این وبلاگ از جمله کد موجود در TensorFlow در مورد نحوه آموزش یک GAN ساده، چه کار خواهم کرد.

GAN چیست؟در هسته خود، یک GAN از دو شبکه عصبی تشکیل شده است: البته، مولد داده های جعلی وجود دارد، و تمایز دهنده ای که یاد می گیرد چگونه بین چیزهای جعلی و واقعی تمایز قائل شود.

Generator: پس از وارد کردن نویز و سپس عبور دادن آنها برای تولید یک داده خروجی که شبیه الگوی مجموعه داده های آموزشی است.
تفکیک کننده: تمایز کننده به کار گرفته شده در توصیف این مدل یک نمونه ورودی می گیرد و سعی می کند حدس بزند که آیا نمونه از داده های آموزشی گرفته شده است یا فقط با کمک ژنراتور سنتز شده است.

این دو شبکه به طور همزمان در یک چارچوب بازی حاصل جمع صفر آموزش داده می شوند: در حالی که در GAN ها، شبکه مولد اطلاعات را به شبکه متمایز می دهد تا آن را فریب دهد تا باور کند که داده های داده شده به آن واقعی است، اما از طرف دیگر، اطلاعات متمایز کننده است. شبکه نقش تشخیص داده های واقعی از جعلی را دارد.

راهنمای گام به گام ساخت یک GAN ساده

مرحله 1: تنظیم محیط

pip install tensorflow

مرحله 2: وارد کردن کتابخانه های ضروری

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

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 3: ژنراتور را تعریف کنید

شبکه مولد سپس یک بردار نویز به طور تصادفی انتخاب می کند و آن را در یک نقطه داده که شبیه داده های آموزشی واقعی است، ترسیم می کند.

def build_generator():
model = tf.keras.Sequential()
model.add(layers.Dense(8*8*128, use_bias=False, input_shape=(100,)))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Reshape((8, 8, 128)))
assert model.output_shape == (None, 8, 8, 128) # Note: None is the batch size

model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding=’same’, use_bias=False))
assert model.output_shape == (None, 8, 8, 128)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())

model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding=’same’, use_bias=False))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
assert model.output_shape == (None, 16, 16, 128)

model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding=’same’, use_bias=False))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
assert model.output_shape == (None, 32, 32, 128)

model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding=’same’, use_bias=False))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
assert model.output_shape == (None, 64, 64, 128)

model.add(layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding=’same’, use_bias=False, activation=’tanh’))
print(model.output_shape)

return model

generator = build_generator()
generator.summary()

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 4: تشخیص دهنده را تعریف کنید

شبکه تشخیص دهنده یک نمونه ورودی را می گیرد و آن را به عنوان واقعی طبقه بندی می کند

def build_discriminator():
model = tf.keras.Sequential()
model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding=’same’,
input_shape=[128, 128, 3]))
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.Conv2D(256, (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 = build_discriminator()
discriminator.summary()

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 5: مدل ها را تست کنید

noise = tf.random.normal([1,100])
generated_image = generator(noise,training=False)
print(discriminator(generated_image))
plt.imshow(generated_image[0]*127.5+127.5)

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 6: راه اندازی عملکرد از دست دادن و بهینه ساز

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

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 7: راه اندازی ایست بازرسی

checkpoint_dir=”training_checkpoints”
checkpoint_prefix = os.path.join(checkpoint_dir,’ckpt’)
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
discriminator_optimizer=discriminator_optimizer,
generator=generator,
discriminator=discriminator)

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 8: تعریف مرحله قطار

@tf.function
def train_step(images):

noise=tf.random.normal([batch_size,noise_dims])

with tf.GradientTape() as gen_tape, tf.GradientTape() as dis_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)

gen_gradients=gen_tape.gradient(gen_loss,generator.trainable_variables)
dis_gradients=dis_tape.gradient(disc_loss,discriminator.trainable_variables)

generator_optimizer.apply_gradients(zip(gen_gradients,generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(dis_gradients,discriminator.trainable_variables))

return gen_loss,disc_loss

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 9: راه اندازی حلقه آموزشی و ذخیره تصاویر تولید شده

from IPython import display
import time

total_gloss=[]
total_dloss=[]
def train(dataset,epochs):
for epoch in range(epochs):
disc_loss=gen_loss=0
start=time.time()
count=0
for batch in dataset:
losses=train_step(batch)
count+=1
disc_loss+=losses[1]
gen_loss+=losses[0]
total_gloss.append(gen_loss.numpy())
total_dloss.append(disc_loss.numpy())

if (epoch+1)%50==0:
checkpoint.save(file_prefix=checkpoint_prefix)
display.clear_output(wait=True)
generate_and_save_output(generator,epoch+1,seed)

print(f’Time for epoch {epoch + 1} is {time.time()-start}’)
print(f’Gloss: {gen_loss.numpy()/count} , Dloss: {disc_loss.numpy()/count}’,end=’\n\n’)
display.clear_output(wait=True)
generate_and_save_output(generator,epochs,seed)

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

def generate_and_save_output(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]*127.5+127.5).numpy().astype(np.uint8),cmap=’gray’)
plt.axis(‘off’)
plt.savefig(f’image_at_epoch_{epoch}.png’)
plt.show()

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

مرحله 10: GAN را آموزش دهید

بیایید GAN خود را آموزش دهیم، من از مجموعه داده های تصویر سگ استفاده کرده ام، که در مجموعه داده سگ استانفورد Kaggle موجود است

EPOCHS = 500
noise_dims = 100
num_egs_to_generate = 16
seed = tf.random.normal([num_egs_to_generate,noise_dims])

train(train_images,EPOCHS)

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

توجه: برای تولید تصاویر با کیفیت خوب، مدل به تعداد زیادی دوره نیاز دارد.

در حال امتحان کردن مدل ما:

new_image = generator(tf.random.normal([1,100]),training=False)
plt.imshow((new_image[0]*127.5+127.5).numpy().astype(np.uint8))

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

نتیجهGAN ها در تولید مجموعه داده های واقعی مفید هستند زیرا آنها نوعی شبکه عصبی هستند که از داده های آموزشی برچسب گذاری شده یاد می گیرند و سپس داده های جدیدی ایجاد می کنند. از اینجا، فرمول بندی یک GAN معقول روشن و امکان پذیر خواهد بود و از اینجا مشهود است که یک ریتم نسبی بین حرکات مولد و همچنین تشخیص دهنده وجود دارد. این امر هدف راهنمای کنونی را که صرفاً خواننده را با موضوع GAN آشنا می‌کند و برای اولین بار از آنچه در این حوزه تحقیقاتی رو به رشد امکان‌پذیر است، به آنها ارائه می‌کند.

منابع:مقاله اصلی یان گودفلومستندات TensorFlowمخزن Github منمی توانید سوالات خود را بپرسید یا پروژه های GAN خود را در نظرات زیر به اشتراک بگذارید!

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

def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(8*8*128, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Reshape((8, 8, 128)))
    assert model.output_shape == (None, 8, 8, 128)  # Note: None is the batch size

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

    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    assert model.output_shape == (None, 16, 16, 128)

    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    assert model.output_shape == (None, 32, 32, 128)

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

    model.add(layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    print(model.output_shape)

    return model

generator = build_generator()
generator.summary()

def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
                                     input_shape=[128, 128, 3]))
    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.Conv2D(256, (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 = build_discriminator()
discriminator.summary()

noise = tf.random.normal([1,100])
generated_image = generator(noise,training=False)
print(discriminator(generated_image))
plt.imshow(generated_image[0]*127.5+127.5)

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

checkpoint_dir="training_checkpoints"
checkpoint_prefix = os.path.join(checkpoint_dir,'ckpt')
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
                                 discriminator_optimizer=discriminator_optimizer,
                                 generator=generator,
                                 discriminator=discriminator)

@tf.function
def train_step(images):

    noise=tf.random.normal([batch_size,noise_dims])

    with tf.GradientTape() as gen_tape, tf.GradientTape() as dis_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)

    gen_gradients=gen_tape.gradient(gen_loss,generator.trainable_variables)
    dis_gradients=dis_tape.gradient(disc_loss,discriminator.trainable_variables)

    generator_optimizer.apply_gradients(zip(gen_gradients,generator.trainable_variables))
    discriminator_optimizer.apply_gradients(zip(dis_gradients,discriminator.trainable_variables))

    return gen_loss,disc_loss

from IPython import display
import time

total_gloss=[]
total_dloss=[]
def train(dataset,epochs):
    for epoch in range(epochs):
        disc_loss=gen_loss=0
        start=time.time()
        count=0
        for batch in dataset:
            losses=train_step(batch)
            count+=1
            disc_loss+=losses[1]
            gen_loss+=losses[0]
        total_gloss.append(gen_loss.numpy())
        total_dloss.append(disc_loss.numpy())

        if (epoch+1)%50==0:
            checkpoint.save(file_prefix=checkpoint_prefix)
            display.clear_output(wait=True)
            generate_and_save_output(generator,epoch+1,seed)

        print(f'Time for epoch {epoch + 1} is {time.time()-start}')
        print(f'Gloss: {gen_loss.numpy()/count} , Dloss: {disc_loss.numpy()/count}',end='\n\n')
    display.clear_output(wait=True)
    generate_and_save_output(generator,epochs,seed)

def generate_and_save_output(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]*127.5+127.5).numpy().astype(np.uint8),cmap='gray')
        plt.axis('off')
      plt.savefig(f'image_at_epoch_{epoch}.png')
      plt.show()

EPOCHS = 500
noise_dims = 100
num_egs_to_generate = 16
seed = tf.random.normal([num_egs_to_generate,noise_dims])

train(train_images,EPOCHS)

new_image = generator(tf.random.normal([1,100]),training=False)
plt.imshow((new_image[0]*127.5+127.5).numpy().astype(np.uint8))