Theano দিয়ে GAN তৈরি করা

Generative Adversarial Network (GAN) হল একটি গভীর শিক্ষণ মডেল যা নিউরাল নেটওয়ার্ক এর দুটি অংশ নিয়ে কাজ করে: একটি জেনারেটর (Generator) এবং একটি ডিসক্রিমিনেটর (Discriminator)। GAN গুলি বাস্তবসম্মত ডেটা তৈরি করার জন্য ব্যবহৃত হয় (যেমন ইমেজ বা অডিও)। GAN-এ, জেনারেটর একটি নতুন ডেটা তৈরি করে, আর ডিসক্রিমিনেটর সেই ডেটা সঠিক বা ভুল হিসেবে চিহ্নিত করে। উভয় নেটওয়ার্ক একে অপরের সাথে প্রতিদ্বন্দ্বিতা (adversarial) করে শিখে এবং উন্নত হয়।

এখানে একটি Theano-এর মাধ্যমে GAN তৈরি করার সহজ উদাহরণ দেয়া হলো, যেখানে আমরা জেনারেটর এবং ডিসক্রিমিনেটর নিউরাল নেটওয়ার্ক তৈরি করব।

Step 1: প্রয়োজনীয় লাইব্রেরি ইনস্টলেশন

প্রথমে Theano, NumPy, এবং SciPy ইনস্টল করা প্রয়োজন। আপনি যদি এটি ইনস্টল না করে থাকেন, তবে পিপ দিয়ে ইনস্টল করতে পারেন:

pip install theano numpy scipy

Step 2: GAN তৈরি করা (Theano দিয়ে)

আমরা একটি সিম্পল GAN তৈরি করব যেখানে:

• জেনারেটর একটি ডাটাসেট থেকে ডেটা তৈরি করবে।
• ডিসক্রিমিনেটর সেগুলি সঠিক বা ভুল হিসেবে চিহ্নিত করবে।
• এরপর, ব্যাকওয়ার্ড প্রোপাগেশন ব্যবহার করে উভয় মডেলকে ট্রেন করা হবে।

এখানে আমরা একটি সিম্পল MNIST ডেটাসেটের জন্য GAN তৈরি করব, যা হস্তাক্ষরিত ডিজিটের ছবি দিয়ে কাজ করবে।

import numpy as np
import theano
import theano.tensor as T

# ডেটা সেটআপ
X = np.random.randn(100, 784)  # সিমুলেটেড ডেটা (MNIST স্টাইল)
y = np.random.randint(2, size=(100, 1))

# থিয়ানো টেনসর
X_tensor = T.matrix('X')
y_tensor = T.matrix('y')

# জেনারেটর (Generator) নেটওয়ার্ক
def generator(z):
    W1 = theano.shared(np.random.randn(100, 256).astype(np.float32), name='W1')
    b1 = theano.shared(np.zeros(256).astype(np.float32), name='b1')
    W2 = theano.shared(np.random.randn(256, 784).astype(np.float32), name='W2')
    b2 = theano.shared(np.zeros(784).astype(np.float32), name='b2')
    
    h1 = T.nnet.relu(T.dot(z, W1) + b1)  # প্রথম লেয়ার
    output = T.nnet.sigmoid(T.dot(h1, W2) + b2)  # আউটপুট লেয়ার
    return output

# ডিসক্রিমিনেটর (Discriminator) নেটওয়ার্ক
def discriminator(x):
    W1 = theano.shared(np.random.randn(784, 256).astype(np.float32), name='W1')
    b1 = theano.shared(np.zeros(256).astype(np.float32), name='b1')
    W2 = theano.shared(np.random.randn(256, 1).astype(np.float32), name='W2')
    b2 = theano.shared(np.zeros(1).astype(np.float32), name='b2')
    
    h1 = T.nnet.relu(T.dot(x, W1) + b1)  # প্রথম লেয়ার
    output = T.nnet.sigmoid(T.dot(h1, W2) + b2)  # আউটপুট লেয়ার
    return output

# GAN মডেল তৈরি
z = T.matrix('z')  # জেনারেটরের ইনপুট
real_data = T.matrix('real_data')  # ডিসক্রিমিনেটরের ইনপুট

# জেনারেটর এবং ডিসক্রিমিনেটরের আউটপুট
generated_data = generator(z)
real_data_prob = discriminator(real_data)
fake_data_prob = discriminator(generated_data)

# ক্ষতি (Loss) ফাংশন
d_loss = -T.mean(T.log(real_data_prob) + T.log(1 - fake_data_prob))  # ডিসক্রিমিনেটর লস
g_loss = -T.mean(T.log(fake_data_prob))  # জেনারেটর লস

# গ্রেডিয়েন্ট এবং আপডেট
learning_rate = 0.0002
grad_W1_d, grad_b1_d, grad_W2_d, grad_b2_d = T.grad(d_loss, [W1, b1, W2, b2])
grad_W1_g, grad_b1_g, grad_W2_g, grad_b2_g = T.grad(g_loss, [W1, b1, W2, b2])

updates_d = [(W1, W1 - learning_rate * grad_W1_d),
             (b1, b1 - learning_rate * grad_b1_d),
             (W2, W2 - learning_rate * grad_W2_d),
             (b2, b2 - learning_rate * grad_b2_d)]

updates_g = [(W1, W1 - learning_rate * grad_W1_g),
             (b1, b1 - learning_rate * grad_b1_g),
             (W2, W2 - learning_rate * grad_W2_g),
             (b2, b2 - learning_rate * grad_b2_g)]

# ফাংশন তৈরি করা
train_discriminator = theano.function(inputs=[real_data, z], outputs=d_loss, updates=updates_d)
train_generator = theano.function(inputs=[z], outputs=g_loss, updates=updates_g)

# মডেল প্রশিক্ষণ
epochs = 10000
for epoch in range(epochs):
    # র্যান্ডমভাবে ইনপুট তৈরি
    z_input = np.random.randn(100, 784)
    real_data_input = np.random.randn(100, 784)  # সত্য ডেটা

    # ডিসক্রিমিনেটর প্রশিক্ষণ
    d_loss_val = train_discriminator(real_data_input, z_input)

    # জেনারেটর প্রশিক্ষণ
    g_loss_val = train_generator(z_input)

    if epoch % 1000 == 0:
        print(f"Epoch {epoch}, Discriminator Loss: {d_loss_val}, Generator Loss: {g_loss_val}")

# সিম্পল টেস্ট
generated_images = generator(z_input)
print("Generated Images after training:")
print(generated_images)

কোড ব্যাখ্যা:

1. ডেটা এবং টেনসর:
   • X এবং y হল সিমুলেটেড ডেটা এবং লক্ষ্য আউটপুট।
   • X_tensor এবং y_tensor হল থিয়ানো টেনসর যা ইনপুট এবং আউটপুট হিসেব ব্যবহার করা হবে।
2. জেনারেটর (Generator):
   • generator(z) ফাংশনটি একটি সিম্পল ফিডফরওয়ার্ড নেটওয়ার্ক যা র্যান্ডম z (noise) ইনপুট নেয় এবং এটি ব্যবহার করে নতুন ডেটা তৈরি করে।
3. ডিসক্রিমিনেটর (Discriminator):
   • discriminator(x) ফাংশনটি একটি নিউরাল নেটওয়ার্ক যা ইনপুট ডেটাকে গ্রহণ করে এবং এটি সঠিক বা ভুল (সত্য বা ভুয়া) আউটপুট করে।
4. লস ফাংশন:
   • ডিসক্রিমিনেটর লস (d_loss): ডিসক্রিমিনেটরের উদ্দেশ্য হল, এটি জানবে কিভাবে আসল এবং জেনারেটর দ্বারা তৈরি ভুয়া ডেটার মধ্যে পার্থক্য করতে হবে।
   • জেনারেটর লস (g_loss): জেনারেটরের উদ্দেশ্য হল, এটি এমন ডেটা তৈরি করবে যা ডিসক্রিমিনেটরের কাছে আসল হিসেবে মনে হবে।
5. গ্রেডিয়েন্ট এবং আপডেট:
   • গ্রেডিয়েন্ট বেকপ্রোপাগেশন পদ্ধতিতে লস ফাংশন থেকে গ্রেডিয়েন্ট বের করে মডেলটির প্যারামিটার (ওয়েট) আপডেট করা হয়।
6. প্রশিক্ষণ:
   • ১০,০০০ যুগ (epochs) দিয়ে মডেলটি প্রশিক্ষিত হবে, এবং প্রতি ১০০০ যুগে লস প্রিন্ট করা হবে।

সারাংশ:

এই কোডটি একটি GAN তৈরি করার একটি সিম্পল উদাহরণ, যেখানে জেনারেটর এবং ডিসক্রিমিনেটর মডেলগুলি Theano লাইব্রেরি ব্যবহার করে তৈরি করা হয়েছে। এটি একটি সিম্পল নিউরাল নেটওয়ার্ক ব্যবহার করে, যা র্যান্ডম ইনপুট গ্রহণ করে এবং ফেক (ভুয়া) ডেটা তৈরি করে, তারপর ডিসক্রিমিনেটর সেই ডেটা যাচাই করে। ফরওয়ার্ড

এবং ব্যাকওয়ার্ড পদ্ধতি ব্যবহার করে ট্রেনিং প্রক্রিয়া পরিচালিত হয়।

GPU সাপোর্ট চালু করার জন্য, আপনি আপনার কোডে CUDA এবং cuDNN ইনস্টল করে GPU ব্যবহার করতে পারবেন, যেহেতু Theano GPU তে ডিপ লার্নিং মডেল প্রশিক্ষণের জন্য ডিজাইন করা হয়েছে।