DQN और Policy Gradient क्या हैं? | DQN and Policy Gradient in Hindi

DQN और Policy Gradient क्या हैं? | DQN and Policy Gradient in Hindi

Reinforcement Learning (RL) में **DQN (Deep Q-Learning)** और **Policy Gradient** दो महत्वपूर्ण Techniques हैं। इन दोनों का उपयोग **Agent** को **Optimal Policy** सीखने में मदद करने के लिए किया जाता है, लेकिन दोनों Techniques में मुख्य अंतर है कि कैसे Action Selection और Policy Optimization को हैंडल किया जाता है।

1. DQN (Deep Q-Learning) क्या है?

Deep Q-Learning (DQN) Q-learning का Deep Learning के साथ एक Extension है। इसमें, Q-values को **Neural Networks** द्वारा Approximate किया जाता है, जिससे Q-learning को **High-Dimensional State Spaces** जैसे **Images** और **Continuous Spaces** के लिए उपयुक्त बनाया जाता है।

DQN में, **Experience Replay** और **Target Networks** का उपयोग किया जाता है, जिससे **Training Stability** और **Convergence** में सुधार होता है।

DQN के मुख्य घटक:

• Experience Replay: Training Data को Replay Buffer में स्टोर किया जाता है, जिससे Data Correlation कम होती है और Stable Training सुनिश्चित होती है।
• Target Network: Q-values को Update करने के लिए एक Fixed Target Network का उपयोग किया जाता है, जिससे Overestimation Bias कम होता है।

DQN Algorithm:

1. Environment से Experiences (s, a, r, s′) Collect करें।
2. Experience Replay Buffer में Save करें।
3. Mini-Batch Gradient Descent से Q-Network को Update करें।
4. Target Network का उपयोग करके Q-Values को Update करें।

DQN को Python में Implement करें:

import tensorflow as tf
import numpy as np
import gym

# OpenAI Gym Environment लोड करें
env = gym.make("CartPole-v1")
state_size = env.observation_space.shape[0]
action_size = env.action_space.n

# DQN Model
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(24, activation="relu", input_shape=(state_size,)),
    tf.keras.layers.Dense(24, activation="relu"),
    tf.keras.layers.Dense(action_size, activation="linear")
])

optimizer = tf.keras.optimizers.Adam(lr=0.01)
loss_fn = tf.keras.losses.MeanSquaredError()

# Q-Update Function
def train_dqn(states, actions, rewards, next_states, done):
    target_q_values = rewards + 0.9 * np.max(model.predict(next_states), axis=1) * (1 - done)
    with tf.GradientTape() as tape:
        predicted_q_values = model(states)
        action_q_values = tf.reduce_sum(predicted_q_values * actions, axis=1)
        loss = loss_fn(target_q_values, action_q_values)
    
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))

# Training Loop
for episode in range(1000):
    state = env.reset()
    done = False
    while not done:
        state = np.reshape(state, [1, state_size])
        action_prob = model.predict(state)
        action = np.argmax(action_prob)
        
        next_state, reward, done, _ = env.step(action)
        train_dqn(state, action, reward, next_state, done)
        state = next_state

2. Policy Gradient क्या है?

Policy Gradient एक Reinforcement Learning Algorithm है, जो **Policy-Based Methods** का हिस्सा है। यह Method Agent को **Directly Policy Optimize** करने के लिए सक्षम बनाता है, बजाय इसके कि वह **Value Functions** को Optimize करे। Policy Gradient का उपयोग **Continuous Action Spaces** और **Stochastic Environments** में किया जाता है, जहाँ Q-Learning जैसे **Value-Based Methods** काम नहीं करते।

Policy Gradient Method में, **Policy** को **Neural Networks** के साथ Approximate किया जाता है, और **Gradient Descent** का उपयोग करके उसे Optimize किया जाता है।

Policy Gradient Algorithm:

1. Policy Network को Initialize करें।
2. Environment में Actions लें और Rewards प्राप्त करें।
3. Policy के Gradient को Compute करें।
4. Gradient Descent के माध्यम से Policy को Update करें।

Policy Gradient को Python में Implement करें:

import tensorflow as tf
import numpy as np
import gym

# OpenAI Gym Environment लोड करें
env = gym.make("CartPole-v1")
state_size = env.observation_space.shape[0]
action_size = env.action_space.n

# Policy Gradient Model
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(24, activation="relu", input_shape=(state_size,)),
    tf.keras.layers.Dense(24, activation="relu"),
    tf.keras.layers.Dense(action_size, activation="softmax")
])

optimizer = tf.keras.optimizers.Adam(lr=0.01)

# Policy Gradient Update Function
def policy_gradient_update(states, actions, rewards):
    with tf.GradientTape() as tape:
        probs = model(states)
        action_prob = tf.reduce_sum(actions * probs, axis=1)
        loss = -tf.reduce_mean(tf.math.log(action_prob) * rewards)
    
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))

# Policy Gradient Training
for episode in range(1000):
    state = env.reset()
    states, actions, rewards = [], [], []
    
    done = False
    while not done:
        state = np.reshape(state, [1, state_size])
        action_prob = model.predict(state)
        action = np.random.choice(action_size, p=action_prob[0])
        
        next_state, reward, done, _ = env.step(action)
        
        states.append(state)
        action_onehot = np.zeros(action_size)
        action_onehot[action] = 1
        actions.append(action_onehot)
        rewards.append(reward)
        
        state = next_state
    
    policy_gradient_update(np.vstack(states), np.vstack(actions), np.array(rewards))

3. DQN और Policy Gradient के बीच अंतर

4. निष्कर्ष

**DQN** और **Policy Gradient** दोनों Reinforcement Learning के महत्वपूर्ण Algorithms हैं, जिनका उपयोग अलग-अलग समस्याओं के समाधान के लिए किया जाता है।

• **DQN** एक Value-Based Approach है, जो Discrete Action Spaces में अधिक प्रभावी है।
• **Policy Gradient** एक Policy-Based Approach है, जो Continuous Action Spaces में बेहतर काम करता है और अधिक Flexibility प्रदान करता है।

इन दोनों Algorithms का उपयोग AI, Robotics, Game AI, और Autonomous Systems में किया जा रहा है, जिससे Complex Decision-Making समस्याओं को हल करना आसान हो रहा है।