Machine Learning PyTorch দিয়ে Deep Reinforcement Learning গাইড ও নোট

Deep Reinforcement Learning (DRL) হলো একটি শক্তিশালী কৌশল যা মেশিন লার্নিং এর Reinforcement Learning (RL) ধারণা এবং Deep Learning মডেলগুলিকে একত্রিত করে। RL এ, একটি এজেন্ট একটি পরিবেশের সাথে ইন্টারঅ্যাক্ট করে এবং reward এর ভিত্তিতে সিদ্ধান্ত গ্রহণ করে, যাতে সর্বোচ্চ পুনরাবৃত্তি লাভ করা যায়। Deep Learning এ, নিউরাল নেটওয়ার্কগুলি ব্যবহার করা হয় একে অপরের মাধ্যমে জটিল সিকোয়েন্সের মাধ্যমে সিদ্ধান্ত গ্রহণ শেখানোর জন্য।

PyTorch দিয়ে DRL প্রয়োগের জন্য সাধারণত Deep Q-Network (DQN), Policy Gradient Methods, Actor-Critic Models, Proximal Policy Optimization (PPO) ইত্যাদি এলগরিদম ব্যবহার করা হয়।

এখানে, আমরা Deep Q-Network (DQN) এর সাহায্যে একটি সহজ DRL প্রজেক্ট তৈরি করব। এটি Q-Learning এর এক ধরনের উন্নত সংস্করণ যা একটি ডিপ নিউরাল নেটওয়ার্ক ব্যবহার করে।

১. PyTorch দিয়ে Deep Q-Network (DQN) তৈরি করা

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

প্রথমে PyTorch এবং অন্যান্য প্রয়োজনীয় লাইব্রেরি ইনস্টল করুন:

pip install torch torchvision gym numpy matplotlib

ধাপ ২: OpenAI Gym Environment তৈরি করা

OpenAI Gym হল একটি জনপ্রিয় লাইব্রেরি যা RL প্রোগ্রামগুলির জন্য বিভিন্ন পরিবেশ সরবরাহ করে। আমরা CartPole-v1 পরিবেশ ব্যবহার করব, যা একটি সাধারণ RL টাস্ক।

import gym

# Create the environment
env = gym.make('CartPole-v1')

# Check the action and observation space
print(env.action_space)  # The number of actions (left, right)
print(env.observation_space)  # Observation space (state size)

ধাপ ৩: DQN মডেল তৈরি করা

DQN হলো একটি নিউরাল নেটওয়ার্ক যা Q-values (state-action values) শিখে। মডেলটি ডিপ লার্নিং মডেল হিসেবে কাজ করবে এবং একটি fully connected network ব্যবহার করবে।

import torch
import torch.nn as nn
import torch.optim as optim

# Define the Deep Q-Network model
class DQN(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(input_dim, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, output_dim)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

# Initialize the DQN model
input_dim = env.observation_space.shape[0]  # The state size
output_dim = env.action_space.n  # The number of possible actions
model = DQN(input_dim, output_dim)

ধাপ ৪: Experience Replay Buffer

Experience Replay ব্যবহার করা হয়, যাতে পূর্ববর্তী অভিজ্ঞতা সঞ্চিত থাকে এবং র্যান্ডমভাবে ব্যাচে ডাটা ব্যবহার করা যায় ট্রেনিংয়ের জন্য। এটি মডেলটিকে আরও স্ট্যাবল ও গতি বৃদ্ধি করতে সাহায্য করে।

import random
from collections import deque

# Experience Replay Buffer
class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity)
    
    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))
    
    def sample(self, batch_size):
        return random.sample(self.buffer, batch_size)
    
    def size(self):
        return len(self.buffer)

# Initialize the buffer
buffer = ReplayBuffer(10000)

ধাপ ৫: Q-Learning অ্যালগরিদম

Q-Learning হল একটি এজেন্টের জন্য একটি নির্ধারিত স্টেট-অ্যাকশন পদ্ধতি, যা পরে Deep Q-Network (DQN) ব্যবহার করে একটি নিউরাল নেটওয়ার্কের মাধ্যমে ডিপ লার্নিংয়ে শিখে।

gamma = 0.99  # Discount factor
epsilon = 0.1  # Exploration factor
batch_size = 64
learning_rate = 0.001

optimizer = optim.Adam(model.parameters(), lr=learning_rate)
criterion = nn.MSELoss()

# Target network
target_model = DQN(input_dim, output_dim)
target_model.load_state_dict(model.state_dict())  # Copy weights
target_model.eval()  # Set target model to evaluation mode

def update_model():
    if buffer.size() < batch_size:
        return
    
    # Sample a batch of experience from the buffer
    batch = buffer.sample(batch_size)
    states, actions, rewards, next_states, dones = zip(*batch)

    states = torch.tensor(states, dtype=torch.float32)
    actions = torch.tensor(actions, dtype=torch.long)
    rewards = torch.tensor(rewards, dtype=torch.float32)
    next_states = torch.tensor(next_states, dtype=torch.float32)
    dones = torch.tensor(dones, dtype=torch.float32)
    
    # Get Q-values for current states
    current_q_values = model(states).gather(1, actions.unsqueeze(1))

    # Get the next Q-values from the target network
    next_q_values = target_model(next_states).max(1)[0]
    expected_q_values = rewards + (gamma * next_q_values * (1 - dones))

    # Compute loss and backpropagate
    loss = criterion(current_q_values.squeeze(), expected_q_values)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# Training loop
for episode in range(500):
    state = env.reset()
    done = False
    total_reward = 0
    
    while not done:
        # Exploration vs Exploitation
        if random.random() < epsilon:
            action = env.action_space.sample()  # Random action
        else:
            with torch.no_grad():
                action = torch.argmax(model(torch.tensor(state, dtype=torch.float32))).item()  # Select action with highest Q-value
        
        next_state, reward, done, _ = env.step(action)
        buffer.push(state, action, reward, next_state, done)  # Store experience in buffer
        
        update_model()  # Update the model with experience replay
        
        state = next_state
        total_reward += reward
        
    print(f"Episode {episode+1}, Total Reward: {total_reward}")
    
    # Update target network every 10 episodes
    if episode % 10 == 0:
        target_model.load_state_dict(model.state_dict())

ধাপ ৬: Evaluation এবং মডেল সংরক্ষণ

মডেল ট্রেনিং শেষে, আপনি মডেলটির পারফরম্যান্স পরীক্ষা করতে পারেন এবং পরবর্তীতে প্রোডাকশনে ব্যবহারের জন্য মডেলটি সংরক্ষণ করতে পারেন।

# Test the model
model.eval()
state = env.reset()
done = False
total_reward = 0

while not done:
    action = torch.argmax(model(torch.tensor(state, dtype=torch.float32))).item()
    next_state, reward, done, _ = env.step(action)
    state = next_state
    total_reward += reward

print(f"Test Total Reward: {total_reward}")

# Save the model
torch.save(model.state_dict(), 'dqn_model.pth')

সারাংশ

• Deep Q-Network (DQN) হল Reinforcement Learning এর একটি শক্তিশালী পদ্ধতি, যেখানে Q-Learning এবং Deep Learning এর সংমিশ্রণ ব্যবহৃত হয়।
• PyTorch এর মাধ্যমে DQN মডেল তৈরি করে Gym পরিবেশে Reinforcement Learning এর ভিত্তিতে কাজ করা যায়।
• Experience Replay এবং Target Network ব্যবহার করে মডেল ট্রেনিং স্থিতিশীল এবং দ্রুত করা যায়।
• মডেলটি save করা যায় এবং পরে প্রোডাকশনে ব্যবহারের জন্য load করা যায়।

এই প্রক্রিয়া ব্যবহার করে আপনি বিভিন্ন RL টাস্কে Deep Reinforcement Learning প্রয়োগ করতে পারেন, যেমন গেমস, ロボットিক্স, অটোনোমাস ভেহিকলস ইত্যাদি।