সকাল 9 টা পি এস টি এ এমএল সিম্পোজিয়াম এই মঙ্গলবার, 19 অক্টোবর প্রথম নারী টিউন এখন রেজিস্টার

সাইকেলগ্যান

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

এই নোটবুকটি শর্তসাপেক্ষে জিএএন-এর ব্যবহার করে চিত্রের অনুবাদে অযৌক্তিক চিত্র প্রদর্শন করে, যেমন সাইকেল- কনসিস্ট্যান্ট অ্যাডভারসিয়াল নেটওয়ার্ক , যা সাইকেলগান নামে পরিচিত, ব্যবহার করে অযৌক্তিক চিত্র-থেকে-চিত্র অনুবাদে বর্ণিত। কাগজটি এমন একটি পদ্ধতির প্রস্তাব দেয় যা একটি চিত্রের ডোমেনের বৈশিষ্ট্যগুলি ক্যাপচার করতে পারে এবং নির্ধারণ করা প্রশিক্ষণের উদাহরণগুলির অভাবে এই বৈশিষ্ট্যগুলি কীভাবে অন্য চিত্রের ডোমেনে অনুবাদ করা যায় figure

এই নোটবুকটি ধরে নিয়েছে যে আপনি পিক্স 2 পিক্সের সাথে পরিচিত, যা আপনি পিক্স 2 পিক্স টিউটোরিয়ালে শিখতে পারেন। সাইকেলগ্যানের কোডটি একই রকম, প্রধান পার্থক্য হ'ল অতিরিক্ত ক্ষতির ফাংশন এবং অযৌক্তিক প্রশিক্ষণ ডেটার ব্যবহার।

জোড়যুক্ত ডেটার প্রয়োজন ছাড়াই প্রশিক্ষণ সক্ষম করতে সাইকেলগ্যান চক্রের ধারাবাহিকতা ক্ষতি ব্যবহার করে। অন্য কথায়, এটি উত্স এবং লক্ষ্য ডোমেনের মধ্যে এক থেকে এক ম্যাপিং ছাড়াই এক ডোমেন থেকে অন্য ডোমেইনে অনুবাদ করতে পারে।

এটি ফটো-বর্ধন, চিত্রের রঙিনকরণ, শৈলী স্থানান্তর ইত্যাদির মতো অনেকগুলি আকর্ষণীয় কাজ করার সম্ভাবনাটি উন্মুক্ত করে you আপনার যা দরকার তা হ'ল উত্স এবং লক্ষ্য ডেটাसेट (যা কেবল চিত্রগুলির একটি ডিরেক্টরি)।

আউটপুট চিত্র 1আউটপুট চিত্র 2

ইনপুট পাইপলাইন সেট আপ করুন

জেনারেটর এবং বৈষম্যকরকে আমদানি করতে সক্ষম করে এমন টেনসরফ্লো_এক্সেমেল প্যাকেজ ইনস্টল করুন।

pip install git+https://github.com/tensorflow/examples.git
import tensorflow as tf
import tensorflow_datasets as tfds
from tensorflow_examples.models.pix2pix import pix2pix

import os
import time
import matplotlib.pyplot as plt
from IPython.display import clear_output

AUTOTUNE = tf.data.AUTOTUNE

পাইপলাইন ইনপুট

এই টিউটোরিয়ালটি ঘোড়ার চিত্রগুলি থেকে জেব্রাগুলির চিত্রগুলিতে অনুবাদ করতে একটি মডেলকে প্রশিক্ষণ দেয়। আপনি এই ডেটাসেট এবং অনুরূপগুলি এখানে পাবেন

কাগজে উল্লিখিত হিসাবে, প্রশিক্ষণ ডেটাসেটে এলোমেলো চিকিত্সা এবং মিররিং প্রয়োগ করুন। এগুলি এমন কিছু চিত্রের বর্ধন কৌশল যা অত্যধিক মানসিক চাপ এড়ায়।

এটি পিক্স 2 পিক্সের সাথে সমান

  • এলোমেলো ঝাঁকুনিতে, চিত্রটি 286 x 286 আকারে পরিবর্তন করা হয় এবং তারপরে এলোমেলোভাবে 256 x 256 কাটা হয়।
  • এলোমেলোভাবে আয়নাতে, চিত্রটি এলোমেলোভাবে অনুভূমিক অর্থাৎ বাম থেকে ডানে উল্টানো থাকে।
dataset, metadata = tfds.load('cycle_gan/horse2zebra',
                              with_info=True, as_supervised=True)

train_horses, train_zebras = dataset['trainA'], dataset['trainB']
test_horses, test_zebras = dataset['testA'], dataset['testB']
BUFFER_SIZE = 1000
BATCH_SIZE = 1
IMG_WIDTH = 256
IMG_HEIGHT = 256
def random_crop(image):
  cropped_image = tf.image.random_crop(
      image, size=[IMG_HEIGHT, IMG_WIDTH, 3])

  return cropped_image
# normalizing the images to [-1, 1]
def normalize(image):
  image = tf.cast(image, tf.float32)
  image = (image / 127.5) - 1
  return image
def random_jitter(image):
  # resizing to 286 x 286 x 3
  image = tf.image.resize(image, [286, 286],
                          method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)

  # randomly cropping to 256 x 256 x 3
  image = random_crop(image)

  # random mirroring
  image = tf.image.random_flip_left_right(image)

  return image
def preprocess_image_train(image, label):
  image = random_jitter(image)
  image = normalize(image)
  return image
def preprocess_image_test(image, label):
  image = normalize(image)
  return image
train_horses = train_horses.cache().map(
    preprocess_image_train, num_parallel_calls=AUTOTUNE).shuffle(
    BUFFER_SIZE).batch(BATCH_SIZE)

train_zebras = train_zebras.cache().map(
    preprocess_image_train, num_parallel_calls=AUTOTUNE).shuffle(
    BUFFER_SIZE).batch(BATCH_SIZE)

test_horses = test_horses.map(
    preprocess_image_test, num_parallel_calls=AUTOTUNE).cache().shuffle(
    BUFFER_SIZE).batch(BATCH_SIZE)

test_zebras = test_zebras.map(
    preprocess_image_test, num_parallel_calls=AUTOTUNE).cache().shuffle(
    BUFFER_SIZE).batch(BATCH_SIZE)
sample_horse = next(iter(train_horses))
sample_zebra = next(iter(train_zebras))
plt.subplot(121)
plt.title('Horse')
plt.imshow(sample_horse[0] * 0.5 + 0.5)

plt.subplot(122)
plt.title('Horse with random jitter')
plt.imshow(random_jitter(sample_horse[0]) * 0.5 + 0.5)
<matplotlib.image.AxesImage at 0x7fd518202090>

পিএনজি

plt.subplot(121)
plt.title('Zebra')
plt.imshow(sample_zebra[0] * 0.5 + 0.5)

plt.subplot(122)
plt.title('Zebra with random jitter')
plt.imshow(random_jitter(sample_zebra[0]) * 0.5 + 0.5)
<matplotlib.image.AxesImage at 0x7fd5107cea90>

পিএনজি

পিক্স 2 পিক্স মডেলগুলি আমদানি করুন এবং পুনরায় ব্যবহার করুন

ইনস্টলড টেনসরফ্লো_এক্সেমেল প্যাকেজটির মাধ্যমে পিক্স 2 পিক্সে ব্যবহৃত জেনারেটর এবং বৈষম্যকারী আমদানি করুন।

এই টিউটোরিয়ালে ব্যবহৃত মডেল আর্কিটেকচারটি পিক্স 2 পিক্সের সাথে খুব মিল রয়েছে similar কিছু পার্থক্য হ'ল:

এখানে 2 জন জেনারেটর (জি এবং এফ) এবং 2 জন বৈষম্যবিদ (এক্স এবং ওয়াই) প্রশিক্ষিত হচ্ছে।

  • জেনারেটর G X ইমেজ Y রূপান্তর করতে শেখে। $ (জি: এক্স -> ওয়াই) $
  • জেনারেটর F ইমেজ রুপান্তর শিখে Y চিত্রে X । $ (এফ: ওয়াই -> এক্স) $
  • D_X X ইমেজ X এবং উত্পন্ন চিত্র X ( F(Y) ) এর মধ্যে পার্থক্য করতে শেখে।
  • D_Y ইমেজ Y এবং উত্পন্ন চিত্র Y ( G(X) ) এর মধ্যে পার্থক্য করতে শেখে।

সাইকেলগান মডেল

OUTPUT_CHANNELS = 3

generator_g = pix2pix.unet_generator(OUTPUT_CHANNELS, norm_type='instancenorm')
generator_f = pix2pix.unet_generator(OUTPUT_CHANNELS, norm_type='instancenorm')

discriminator_x = pix2pix.discriminator(norm_type='instancenorm', target=False)
discriminator_y = pix2pix.discriminator(norm_type='instancenorm', target=False)
to_zebra = generator_g(sample_horse)
to_horse = generator_f(sample_zebra)
plt.figure(figsize=(8, 8))
contrast = 8

imgs = [sample_horse, to_zebra, sample_zebra, to_horse]
title = ['Horse', 'To Zebra', 'Zebra', 'To Horse']

for i in range(len(imgs)):
  plt.subplot(2, 2, i+1)
  plt.title(title[i])
  if i % 2 == 0:
    plt.imshow(imgs[i][0] * 0.5 + 0.5)
  else:
    plt.imshow(imgs[i][0] * 0.5 * contrast + 0.5)
plt.show()
WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

পিএনজি

plt.figure(figsize=(8, 8))

plt.subplot(121)
plt.title('Is a real zebra?')
plt.imshow(discriminator_y(sample_zebra)[0, ..., -1], cmap='RdBu_r')

plt.subplot(122)
plt.title('Is a real horse?')
plt.imshow(discriminator_x(sample_horse)[0, ..., -1], cmap='RdBu_r')

plt.show()

পিএনজি

ক্ষতি ফাংশন

CycleGAN, কোন ছবিতে ডেটার উপর প্রশিক্ষণের জন্য, অত কোন গ্যারান্টি নেই যে ইনপুট হয় x এবং টার্গেট y যুগল প্রশিক্ষণের সময় অর্থপূর্ণ হয়। নেটওয়ার্কটি সঠিক ম্যাপিংটি শিখেছে তা প্রয়োগ করার জন্য, লেখকরা চক্রের ধারাবাহিকতা হ্রাসের প্রস্তাব দেয়।

বৈষম্যমূলক ক্ষতি এবং জেনারেটর ক্ষতি পিক্স 2 পিক্সে ব্যবহৃত এর মতোই

LAMBDA = 10
loss_obj = tf.keras.losses.BinaryCrossentropy(from_logits=True)
def discriminator_loss(real, generated):
  real_loss = loss_obj(tf.ones_like(real), real)

  generated_loss = loss_obj(tf.zeros_like(generated), generated)

  total_disc_loss = real_loss + generated_loss

  return total_disc_loss * 0.5
def generator_loss(generated):
  return loss_obj(tf.ones_like(generated), generated)

চক্রের ধারাবাহিকতা মানে ফলাফলটি মূল ইনপুটটির কাছাকাছি হওয়া উচিত। উদাহরণস্বরূপ, যদি কেউ একটি বাক্য ইংরেজী থেকে ফরাসী ভাষায় অনুবাদ করে এবং তারপরে ফরাসী থেকে ইংরাজিতে আবার অনুবাদ করে, তবে ফলস্বরূপ বাক্যটি মূল বাক্যটির মতোই হওয়া উচিত।

চক্র ধারাবাহিকতা ক্ষতি,

  • চিত্র $ X gene জেনারেটর via G via এর মধ্য দিয়ে যায় যা উত্পন্ন চিত্র image \ টুপি {Y} $ দেয় $
  • উত্পন্ন চিত্র $ \ টুপি via ওয়াই} gene জেনারেটর $ এফ via এর মধ্য দিয়ে গেছে যা সাইক্ল্ড চিত্র image \ টুপি {এক্স} $ দেয় $
  • গড় পরিপূর্ণ ত্রুটিটি $ X $ এবং $ \ টুপি {এক্স} between এর মধ্যে গণনা করা হয় $
$$forward\ cycle\ consistency\ loss: X -> G(X) -> F(G(X)) \sim \hat{X}$$
$$backward\ cycle\ consistency\ loss: Y -> F(Y) -> G(F(Y)) \sim \hat{Y}$$

চক্র ক্ষতি

def calc_cycle_loss(real_image, cycled_image):
  loss1 = tf.reduce_mean(tf.abs(real_image - cycled_image))

  return LAMBDA * loss1

উপরে প্রদর্শিত হিসাবে, জেনারেটর $ G image চিত্রটি $ X image চিত্র $ Y $ তে অনুবাদ করার জন্য দায়ী $ পরিচয় হ্রাস বলে যে, আপনি যদি চিত্রটি image Y gene জেনারেটর $ G image খাওয়ান, তবে এটি আসল চিত্র yield Y $ বা চিত্রের কাছাকাছি something Y yield পাওয়া উচিত $

আপনি যদি ঘোড়ায় জেব্রা-থেকে-ঘোড়া মডেল বা একটি ঘোড়াতে ঘোড়া-থেকে-জেব্রা মডেল চালান, তবে চিত্রটি তেমন কোনও পরিবর্তন করতে হবে না কারণ ছবিটিতে ইতিমধ্যে লক্ষ্য শ্রেণি রয়েছে।

$$Identity\ loss = |G(Y) - Y| + |F(X) - X|$$
def identity_loss(real_image, same_image):
  loss = tf.reduce_mean(tf.abs(real_image - same_image))
  return LAMBDA * 0.5 * loss

সমস্ত জেনারেটর এবং বৈষম্যমূলকদের জন্য অনুকূলকরণ শুরু করুন Initial

generator_g_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)
generator_f_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)

discriminator_x_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)
discriminator_y_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)

চেকপয়েন্টস

checkpoint_path = "./checkpoints/train"

ckpt = tf.train.Checkpoint(generator_g=generator_g,
                           generator_f=generator_f,
                           discriminator_x=discriminator_x,
                           discriminator_y=discriminator_y,
                           generator_g_optimizer=generator_g_optimizer,
                           generator_f_optimizer=generator_f_optimizer,
                           discriminator_x_optimizer=discriminator_x_optimizer,
                           discriminator_y_optimizer=discriminator_y_optimizer)

ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)

# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
  ckpt.restore(ckpt_manager.latest_checkpoint)
  print ('Latest checkpoint restored!!')

প্রশিক্ষণ

EPOCHS = 40
def generate_images(model, test_input):
  prediction = model(test_input)

  plt.figure(figsize=(12, 12))

  display_list = [test_input[0], prediction[0]]
  title = ['Input Image', 'Predicted Image']

  for i in range(2):
    plt.subplot(1, 2, i+1)
    plt.title(title[i])
    # getting the pixel values between [0, 1] to plot it.
    plt.imshow(display_list[i] * 0.5 + 0.5)
    plt.axis('off')
  plt.show()

যদিও প্রশিক্ষণের লুপটি জটিল দেখায়, এটি চারটি মূল পদক্ষেপ নিয়ে গঠিত:

  • পূর্বাভাস পান।
  • ক্ষতি গণনা করুন।
  • ব্যাকপ্রোপেশন ব্যবহার করে গ্রেডিয়েন্টগুলি গণনা করুন।
  • অপ্টিমাইজারে গ্রেডিয়েন্টগুলি প্রয়োগ করুন।
@tf.function
def train_step(real_x, real_y):
  # persistent is set to True because the tape is used more than
  # once to calculate the gradients.
  with tf.GradientTape(persistent=True) as tape:
    # Generator G translates X -> Y
    # Generator F translates Y -> X.

    fake_y = generator_g(real_x, training=True)
    cycled_x = generator_f(fake_y, training=True)

    fake_x = generator_f(real_y, training=True)
    cycled_y = generator_g(fake_x, training=True)

    # same_x and same_y are used for identity loss.
    same_x = generator_f(real_x, training=True)
    same_y = generator_g(real_y, training=True)

    disc_real_x = discriminator_x(real_x, training=True)
    disc_real_y = discriminator_y(real_y, training=True)

    disc_fake_x = discriminator_x(fake_x, training=True)
    disc_fake_y = discriminator_y(fake_y, training=True)

    # calculate the loss
    gen_g_loss = generator_loss(disc_fake_y)
    gen_f_loss = generator_loss(disc_fake_x)

    total_cycle_loss = calc_cycle_loss(real_x, cycled_x) + calc_cycle_loss(real_y, cycled_y)

    # Total generator loss = adversarial loss + cycle loss
    total_gen_g_loss = gen_g_loss + total_cycle_loss + identity_loss(real_y, same_y)
    total_gen_f_loss = gen_f_loss + total_cycle_loss + identity_loss(real_x, same_x)

    disc_x_loss = discriminator_loss(disc_real_x, disc_fake_x)
    disc_y_loss = discriminator_loss(disc_real_y, disc_fake_y)

  # Calculate the gradients for generator and discriminator
  generator_g_gradients = tape.gradient(total_gen_g_loss, 
                                        generator_g.trainable_variables)
  generator_f_gradients = tape.gradient(total_gen_f_loss, 
                                        generator_f.trainable_variables)

  discriminator_x_gradients = tape.gradient(disc_x_loss, 
                                            discriminator_x.trainable_variables)
  discriminator_y_gradients = tape.gradient(disc_y_loss, 
                                            discriminator_y.trainable_variables)

  # Apply the gradients to the optimizer
  generator_g_optimizer.apply_gradients(zip(generator_g_gradients, 
                                            generator_g.trainable_variables))

  generator_f_optimizer.apply_gradients(zip(generator_f_gradients, 
                                            generator_f.trainable_variables))

  discriminator_x_optimizer.apply_gradients(zip(discriminator_x_gradients,
                                                discriminator_x.trainable_variables))

  discriminator_y_optimizer.apply_gradients(zip(discriminator_y_gradients,
                                                discriminator_y.trainable_variables))
for epoch in range(EPOCHS):
  start = time.time()

  n = 0
  for image_x, image_y in tf.data.Dataset.zip((train_horses, train_zebras)):
    train_step(image_x, image_y)
    if n % 10 == 0:
      print ('.', end='')
    n += 1

  clear_output(wait=True)
  # Using a consistent image (sample_horse) so that the progress of the model
  # is clearly visible.
  generate_images(generator_g, sample_horse)

  if (epoch + 1) % 5 == 0:
    ckpt_save_path = ckpt_manager.save()
    print ('Saving checkpoint for epoch {} at {}'.format(epoch+1,
                                                         ckpt_save_path))

  print ('Time taken for epoch {} is {} sec\n'.format(epoch + 1,
                                                      time.time()-start))

পিএনজি

Saving checkpoint for epoch 40 at ./checkpoints/train/ckpt-8
Time taken for epoch 40 is 166.58266592025757 sec

পরীক্ষার ডেটাসেট ব্যবহার করে উত্পন্ন করুন

# Run the trained model on the test dataset
for inp in test_horses.take(5):
  generate_images(generator_g, inp)

পিএনজি

পিএনজি

পিএনজি

পিএনজি

পিএনজি

পরবর্তী পদক্ষেপ

এই টিউটোরিয়ালটিতে পিক 2 পিক্স টিউটোরিয়ালে বাস্তবায়িত জেনারেটর এবং বৈষম্যমূলককারী থেকে শুরু করে সাইকেলগ্যান বাস্তবায়ন করতে হবে shown পরবর্তী পদক্ষেপ হিসাবে, আপনি টেনসরফ্লো ডেটাসেটের থেকে আলাদা একটি ডেটাसेट ব্যবহার করার চেষ্টা করতে পারেন।

আপনি ফলাফলগুলি উন্নত করতে বৃহত সংখ্যক যুগের প্রশিক্ষণও দিতে পারেন বা আপনি এখানে ব্যবহৃত ইউ-নেট জেনারেটরের পরিবর্তে কাগজে ব্যবহৃত সংশোধিত রেসনেট জেনারেটর প্রয়োগ করতে পারেন।