Median Elimination और Policy Gradient क्या हैं? | Median Elimination and Policy Gradient in Deep Learning in Hindi


Median Elimination और Policy Gradient क्या हैं? | Median Elimination and Policy Gradient in Deep Learning in Hindi

Deep Learning और Reinforcement Learning (RL) में, **Median Elimination** और **Policy Gradient** दो महत्वपूर्ण एल्गोरिदम हैं जो Decision-Making और Optimization में सहायक होते हैं।

  • **Median Elimination:** Multi-Armed Bandit (MAB) Problems को हल करने के लिए उपयोग किया जाता है।
  • **Policy Gradient:** Continuous Action Spaces में Optimal Policy सीखने के लिए उपयोग किया जाता है।

1. Median Elimination क्या है?

Median Elimination एक Reinforcement Learning Technique है, जिसका उपयोग Multi-Armed Bandit (MAB) Problems में Best Arm (Best Action) को Select करने के लिए किया जाता है।

Median Elimination का मुख्य उद्देश्य:

  • Best Action (Arm) को High Confidence के साथ चुनना।
  • Exploration और Sample Complexity को कम करना।
  • Non-Optimal Arms को जल्दी से Eliminate करना।

Median Elimination Algorithm का गणितीय मॉडल:

Median Elimination Algorithm को निम्नलिखित Steps में Implement किया जाता है:

  1. **Exploration Step:** सभी Actions के लिए कुछ Sample Rewards प्राप्त करें।
  2. **Median Calculation:** सभी Actions के Median Reward की गणना करें।
  3. **Elimination Step:** उन Actions को हटा दें जिनका Reward Median से कम है।
  4. **Iteration:** इस प्रक्रिया को तब तक दोहराएं जब तक केवल एक Best Action न बचा हो।

Median Elimination Algorithm को Python में Implement करें

import numpy as np

def median_elimination(arms, samples=100, epsilon=0.1, delta=0.1):
    remaining_arms = arms.copy()
    
    while len(remaining_arms) > 1:
        rewards = {arm: np.mean([np.random.rand() for _ in range(samples)]) for arm in remaining_arms}
        median_reward = np.median(list(rewards.values()))
        
        remaining_arms = [arm for arm in remaining_arms if rewards[arm] >= median_reward]
    
    return remaining_arms[0]

# Simulated Multi-Armed Bandit Arms
arms = ["A", "B", "C", "D", "E"]
best_arm = median_elimination(arms)
print("Best Arm Selected:", best_arm)

Median Elimination का उपयोग

  • Multi-Armed Bandit Problems
  • Recommendation Systems
  • Online Learning Algorithms
---

2. Policy Gradient क्या है?

Policy Gradient Reinforcement Learning में एक **Policy-Based Optimization Algorithm** है, जिसका उपयोग Continuous Action Spaces में Best Policy को सीखने के लिए किया जाता है।

Policy Gradient का मुख्य उद्देश्य:

  • Action Selection को Directly Optimize करना।
  • Continuous और Stochastic Environments में Decision-Making में मदद करना।
  • Traditional Value-Based RL Methods की तुलना में अधिक लचीला होना।

Policy Gradient Algorithm का गणितीय समीकरण

Policy Gradient का लक्ष्य **Expected Reward** को अधिकतम करना है:

J(θ) = E[ R(τ) ]

जहाँ:

  • J(θ): Policy का Expected Reward
  • τ: एक Trajectory (State-Action Sequence)
  • R(τ): Trajectory का कुल Reward

Gradient Descent का उपयोग करके Policy को Update किया जाता है:

θ ← θ + α * ∇θ J(θ)

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

# Simple Neural Network 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))

Policy Gradient का उपयोग

  • Continuous Control Problems (Robotics, Self-Driving Cars)
  • Game Playing (Atari, Chess, Go)
  • Stock Market Trading
---

3. Median Elimination बनाम Policy Gradient

Feature Median Elimination Policy Gradient
मुख्य उद्देश्य Best Arm Select करना Optimal Policy सीखना
उपयोग Multi-Armed Bandits Reinforcement Learning
Algorithm Type Elimination-Based Gradient-Based
Action Space Discrete Continuous
Example Applications Recommendation Systems Autonomous Robots, Games
---

4. निष्कर्ष

Median Elimination और Policy Gradient दोनों ही Reinforcement Learning में महत्वपूर्ण Algorithms हैं:

  • **Median Elimination** का उपयोग Multi-Armed Bandit Problems को हल करने के लिए किया जाता है, जहाँ Best Action को चुना जाता है।
  • **Policy Gradient** Continuous Action Spaces में Best Policy सीखने के लिए उपयोग किया जाता है और यह Autonomous Systems तथा Game Playing में प्रभावी होता है।

दोनों Techniques AI और Deep Learning में कई Applications में उपयोगी होती हैं।

Related Post

Comments

Comments