Generative Adversarial Networks (GANs) একটি শক্তিশালী ডিপ লার্নিং আর্কিটেকচার যা নতুন ছবি, ভিডিও, বা ডেটাসেট তৈরির জন্য ব্যবহৃত হয়। GAN দুটি নেটওয়ার্কের মধ্যে প্রতিযোগিতা তৈরি করে, একটি Generator (যা নতুন তথ্য তৈরি করে) এবং একটি Discriminator (যা সেগুলি আসল বা জাল হিসেবে চিহ্নিত করে)। এই প্রক্রিয়া চালানোর মাধ্যমে, Generator সময়ের সাথে আরও ভালো ছবি তৈরি করতে শেখে। এখানে আমরা GAN ব্যবহার করে একটি ইমেজ জেনারেশন প্রজেক্ট তৈরি করার পদ্ধতি দেখব।
1. GAN এর বেসিক স্ট্রাকচার:
- Generator (G): এটি নতুন, সুনির্দিষ্ট ডেটা তৈরি করে। এই নেটওয়ার্কের কাজ হল ধ্বংসাত্মক নয় এমন ছবি তৈরি করা।
- Discriminator (D): এটি আসল ছবি এবং জেনারেটেড ছবির মধ্যে পার্থক্য চিহ্নিত করতে শেখে। এটি binary classifier হিসেবে কাজ করে (আসল বা জাল)।
2. GAN এর জন্য প্যাকেজ ইনস্টলেশন:
প্রথমে আমাদের প্রয়োজনীয় লাইব্রেরিগুলি ইনস্টল করতে হবে।
pip install tensorflow numpy matplotlib
3. GAN এর মাধ্যমে ইমেজ জেনারেশন:
এখানে একটি সহজ GAN মডেল তৈরি করা হবে, যা MNIST ডেটাসেট থেকে হাতের লেখা সংখ্যা তৈরি করবে। এই প্রজেক্টে, আমরা TensorFlow এবং Keras ব্যবহার করব।
ধাপ ১: প্রয়োজনীয় লাইব্রেরি ইম্পোর্ট করা
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Flatten
from tensorflow.keras.models import Sequential
from tensorflow.keras.datasets import mnist
ধাপ ২: MNIST ডেটাসেট লোড করা
# MNIST ডেটাসেট লোড করা
(X_train, _), (_, _) = mnist.load_data()
# ডেটাকে 0 থেকে 1 এর মধ্যে স্কেল করা
X_train = X_train / 127.5 - 1.0
# ডেটাকে ফ্ল্যাট করে রিসাইজ করা
X_train = X_train.reshape(X_train.shape[0], 784)
ধাপ ৩: Generator মডেল তৈরি করা
Generator একটি সিম্পল ফিডফরওয়ার্ড নিউরাল নেটওয়ার্ক যা z-vector (random noise) ইনপুট হিসেবে নিয়ে একটি 784 ডাইমেনশনাল ভেক্টর আউটপুট দেয় (যেটি 28x28 আকারের ছবি হতে পারে)।
def build_generator():
model = Sequential()
model.add(Dense(256, input_dim=100, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(784, activation='tanh')) # Tanh activation to normalize between -1 and 1
model.add(Reshape((28, 28))) # Image shape 28x28
return model
ধাপ ৪: Discriminator মডেল তৈরি করা
Discriminator একটি বাইনারি ক্লাসিফায়ার যা একটি ছবি ইনপুট হিসেবে নিয়ে তা আসল না জাল তা চিহ্নিত করতে শিখবে।
def build_discriminator():
model = Sequential()
model.add(Flatten(input_shape=(28, 28)))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(1, activation='sigmoid')) # Binary output (Real or Fake)
return model
ধাপ ৫: GAN মডেল তৈরি করা
এখন আমরা GAN তৈরি করব, যেখানে Discriminator শুধুমাত্র Generator এর আউটপুট (জাল ছবি) এবং আসল ছবি সনাক্ত করবে। GAN হবে Generator এবং Discriminator এর একটি কম্বিনেশন।
def build_gan(generator, discriminator):
discriminator.trainable = False # Freeze the discriminator weights during generator training
model = Sequential()
model.add(generator)
model.add(discriminator)
return model
ধাপ ৬: মডেল কম্পাইল করা
এখন আমাদের তৈরি করা Generator এবং Discriminator মডেলগুলির জন্য অপটিমাইজার এবং লস ফাংশন নির্ধারণ করতে হবে।
# অপটিমাইজার
adam = tf.keras.optimizers.Adam(lr=0.0002, beta_1=0.5)
# ডিসক্রিমিনেটর মডেল কম্পাইল করা
discriminator = build_discriminator()
discriminator.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy'])
# জেনারেটর মডেল তৈরি করা
generator = build_generator()
# GAN মডেল তৈরি করা
gan = build_gan(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=adam)
ধাপ ৭: ট্রেনিং প্রক্রিয়া
এখন আমরা Generator এবং Discriminator মডেলগুলো ট্রেনিং করব।
def train_gan(epochs, batch_size, save_interval):
half_batch = batch_size // 2
# MNIST ডেটাসেট থেকে আসল ছবি
X_train, _ = mnist.load_data()
X_train = X_train / 127.5 - 1.0
X_train = X_train.reshape(X_train.shape[0], 784)
for epoch in range(epochs):
# ডিসক্রিমিনেটরের জন্য আসল ছবি
idx = np.random.randint(0, X_train.shape[0], half_batch)
real_images = X_train[idx]
# জাল ছবি তৈরি করা
noise = np.random.normal(0, 1, (half_batch, 100))
fake_images = generator.predict(noise)
# ডিসক্রিমিনেটরকে প্রশিক্ষণ দেওয়া
d_loss_real = discriminator.train_on_batch(real_images, np.ones((half_batch, 1)))
d_loss_fake = discriminator.train_on_batch(fake_images, np.zeros((half_batch, 1)))
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# জেনারেটরকে প্রশিক্ষণ দেওয়া
noise = np.random.normal(0, 1, (batch_size, 100))
g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
# প্রতি ইটারেশন পরে ফলাফল প্রদর্শন
if epoch % save_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {d_loss[1]*100}%] [G loss: {g_loss}]")
# জেনারেটর দ্বারা একটি ছবি তৈরি করা
if epoch % (save_interval * 10) == 0:
save_generated_images(epoch)
# চিত্র সংরক্ষণ করার ফাংশন
def save_generated_images(epoch, examples=10, dim=(28,28), figsize=(10,10)):
noise = np.random.normal(0, 1, (examples, 100))
generated_images = generator.predict(noise)
generated_images = generated_images.reshape(examples, 28, 28)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(1, examples, i+1)
plt.imshow(generated_images[i], interpolation='nearest', cmap='gray')
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# মডেল ট্রেনিং শুরু করা
train_gan(epochs=10000, batch_size=64, save_interval=1000)
ধাপ ৮: চিত্র আউটপুট
প্রতি save_interval পর, GAN 1000 ইটারেশনে একবার একটি ছবি তৈরি করবে এবং সেই ছবি সংরক্ষণ করবে। এটি আপনি দেখতে পাবেন gan_generated_image_epoch_{epoch}.png ফাইল নামের মাধ্যমে।
সারাংশ:
- GAN (Generative Adversarial Networks) এর মাধ্যমে আমরা একটি সিম্পল নিউরাল নেটওয়ার্ক তৈরি করেছি যা MNIST ডেটাসেট থেকে হাতের লেখা সংখ্যা তৈরি করতে সক্ষম।
- Generator একটি ছবির আউটপুট তৈরি করে, এবং Discriminator এটিকে আসল বা জাল হিসেবে চিহ্নিত করে।
- প্রতি ইটারেশনে Generator এবং Discriminator এর মধ্যে প্রতিযোগিতা তৈরি হয়, যার ফলে Generator আরও ভালো ছবি তৈরি করতে সক্ষম হয়।
এই প্রকল্পটি ডিপ লার্নিং এবং GAN এর মৌলিক ধারণা শেখার জন্য একটি চমৎকার উপায়।
