Generative Adversarial Networks (GAN) মডেল ট্রেনিং এবং মূল্যায়ন করা একটি অত্যন্ত আকর্ষণীয় কিন্তু চ্যালেঞ্জিং প্রক্রিয়া। GAN হলো দুটি নিউরাল নেটওয়ার্কের (একটি Generator এবং একটি Discriminator) সমন্বয়ে তৈরি একটি মডেল, যা একে অপরের সাথে প্রতিযোগিতা করে একটি ভালো সৃজনশীল (generated) ডেটা তৈরি করার জন্য।
1. GAN মডেল ট্রেনিং প্রক্রিয়া:
GAN মডেল ট্রেনিং করার জন্য দুটি মূল কম্পোনেন্ট থাকে:
- Generator: এটি একটি নতুন ডেটা তৈরি করার জন্য প্রশিক্ষিত হয় (যেমন একটি নতুন ছবি যা বাস্তব ছবির মতো দেখতে হবে)।
- Discriminator: এটি নির্ধারণ করে যে একটি ডেটা আসল নাকি তৈরি করা (fake)।
Generator এবং Discriminator এর কাজ:
- Generator: র্যান্ডম নoise ইনপুট নিয়ে একটি ডেটা তৈরি করে। এর কাজ হচ্ছে বাস্তবের মতো দেখতে ডেটা তৈরি করা।
- Discriminator: এটি Generator দ্বারা তৈরি করা ডেটা এবং আসল ডেটার মধ্যে পার্থক্য শনাক্ত করে। এটি আসল বা ভুয়া ডেটা সঠিকভাবে চিহ্নিত করার জন্য প্রশিক্ষিত হয়।
2. GAN মডেল ট্রেনিং করা:
এখন, আসুন দেখে নেওয়া যাক কীভাবে Python ব্যবহার করে GAN ট্রেনিং করতে হয়, যেখানে PyTorch ব্যবহৃত হবে।
2.1. PyTorch দিয়ে GAN ট্রেনিং:
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
# Hyperparameters
batch_size = 64
latent_dim = 100 # Latent vector size (random noise vector size)
epochs = 50
lr = 0.0002
# Data preparation (MNIST dataset)
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_data = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
# Generator model
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.fc1 = nn.Linear(latent_dim, 256)
self.fc2 = nn.Linear(256, 512)
self.fc3 = nn.Linear(512, 1024)
self.fc4 = nn.Linear(1024, 28*28) # Output size is 28x28 (MNIST image size)
self.tanh = nn.Tanh()
def forward(self, z):
x = torch.relu(self.fc1(z))
x = torch.relu(self.fc2(x))
x = torch.relu(self.fc3(x))
x = self.fc4(x)
return self.tanh(x).view(-1, 1, 28, 28)
# Discriminator model
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.fc1 = nn.Linear(28*28, 1024)
self.fc2 = nn.Linear(1024, 512)
self.fc3 = nn.Linear(512, 256)
self.fc4 = nn.Linear(256, 1) # Output: 1 for real or fake
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = x.view(-1, 28*28) # Flatten the image
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = torch.relu(self.fc3(x))
return self.sigmoid(self.fc4(x))
# Initialize models
generator = Generator()
discriminator = Discriminator()
# Optimizers
optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))
# Loss function
criterion = nn.BCELoss()
# Train the GAN model
for epoch in range(epochs):
for i, (real_images, _) in enumerate(train_loader):
# Create labels for real and fake images
real_labels = torch.ones(batch_size, 1)
fake_labels = torch.zeros(batch_size, 1)
# Train Discriminator
optimizer_D.zero_grad()
# Real images
real_images = real_images.to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))
outputs = discriminator(real_images)
loss_D_real = criterion(outputs, real_labels)
loss_D_real.backward()
# Fake images
z = torch.randn(batch_size, latent_dim).to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))
fake_images = generator(z)
outputs = discriminator(fake_images.detach())
loss_D_fake = criterion(outputs, fake_labels)
loss_D_fake.backward()
optimizer_D.step()
# Train Generator
optimizer_G.zero_grad()
outputs = discriminator(fake_images)
loss_G = criterion(outputs, real_labels) # Try to fool the discriminator
loss_G.backward()
optimizer_G.step()
print(f"Epoch [{epoch+1}/{epochs}], Loss D: {loss_D_real.item()+loss_D_fake.item()}, Loss G: {loss_G.item()}")
# Generate some fake images after every epoch
if (epoch + 1) % 10 == 0:
with torch.no_grad():
z = torch.randn(64, latent_dim).to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))
fake_images = generator(z)
grid = torchvision.utils.make_grid(fake_images, nrow=8, normalize=True)
plt.imshow(grid.permute(1, 2, 0).cpu())
plt.show()
2.2. ব্যাখ্যা:
- Generator: এটি latent vector (random noise) গ্রহণ করে এবং একটি নতুন ইমেজ (28x28 MNIST) তৈরি করে।
- Discriminator: এটি ইমেজ গ্রহণ করে এবং যাচাই করে এটি আসল না ভুয়া।
- Loss Functions:
- Discriminator: আসল ইমেজের জন্য
real_labelsএবং ফেক ইমেজের জন্যfake_labelsব্যবহৃত হয়। - Generator: Generator মডেল ফেক ইমেজ তৈরি করার সময় Discriminator কে বিভ্রান্ত করার চেষ্টা করে, যাতে Discriminator সেই ফেক ইমেজকে আসল মনে করে।
- Discriminator: আসল ইমেজের জন্য
2.3. GAN ট্রেনিং:
- Generator এবং Discriminator মডেল দুটি আলাদা আলাদা গ্রেডিয়েন্ট ব্যবহার করে ট্রেনিং হয়।
- একে অপরকে পরস্পরের সাথে প্রতিযোগিতা করে, যাতে Generator আরো ভাল ডেটা তৈরি করতে পারে এবং Discriminator আরো দক্ষভাবে ফেক এবং আসল ডেটার মধ্যে পার্থক্য করতে পারে।
3. GAN Evaluation (GAN মূল্যায়ন)
GAN মডেলের মূল্যায়ন করার জন্য, আপনি কয়েকটি পদ্ধতি ব্যবহার করতে পারেন:
- Visual Inspection: এক বা একাধিক generated ইমেজের গুণগত মান দেখতে হবে। মডেল কতটা বাস্তবসম্মত ইমেজ তৈরি করছে তা পরীক্ষা করা।
- Inception Score (IS): একটি জনপ্রিয় মেট্রিক যা ইমেজগুলির বৈচিত্র্য এবং বাস্তবতাকে মাপতে ব্যবহৃত হয়।
- Fréchet Inception Distance (FID): এই মেট্রিকটি আসল এবং ফেক ইমেজের মধ্যে পার্থক্য পরিমাপ করতে ব্যবহৃত হয়, যা GAN গুলির গুণমান মূল্যায়ন করতে সাহায্য করে।
3.1. FID ব্যবহার উদাহরণ:
from pytorch_fid import fid_score
# Calculate FID between real and generated image folders
real_img_path = "real_images/"
fake_img_path = "generated_images/"
fid_value = fid_score.calculate_fid_given_paths([real_img_path, fake_img_path], batch_size=50, device='cuda', dims=2048)
print(f"FID Score: {fid_value}")
FID যত কম হবে, তত ভালো।
সারাংশ:
- GAN মডেল ট্রেনিং দুটি মূল কম্পোনেন্ট নিয়ে কাজ করে: Generator (নতুন ডেটা তৈরি করে) এবং Discriminator (আসল এবং ভুয়া ডেটার মধ্যে পার্থক্য চিহ্নিত করে)।
- GAN ট্রেনিং একটি প্রতিযোগিতামূলক প্রক্রিয়া যেখানে দুটি মডেল একে অপরের বিরুদ্ধে কাজ করে। Generator ফেক ডেটা তৈরি করে এবং Discriminator ঐ ফেক ডেটাকে চিহ্নিত করে।
- GAN মূল্যায়ন করার জন্য FID বা Inception Score ব্যবহার করা হয়, যা আসল এবং তৈরি করা ডেটার মধ্যে পার্থক্য পরিমাপ করতে সাহায্য করে।
Content added By
Read more
