डीप रिइनफोर्समेंट लर्निंग का परिचय

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

डीप रिइनफोर्समेंट लर्निंग क्यों

पारंपरिक RL कम-डायमेंशनल टास्क के लिए उपयुक्त है

कई एप्लिकेशन में हाई-डायमेंशनल state और/या action space होते हैं

एक एजेंट Frozen Lake वातावरण को एक्सप्लोर करते हुए

एक एजेंट क्लासिक Space Invaders वीडियो गेम खेलते हुए

DRL की सामग्री

Reinforcement Learning की अवधारणाएँ
Deep Learning और PyTorch

DRL इन अवधारणाओं को डीप न्यूरल नेटवर्क्स के साथ जोड़ता है

सामग्री मिलाते हुए एक कुक का पिक्सेल आर्ट चित्र

RL फ्रेमवर्क

स्टेप t:

एक बड़ा बॉक्स जिसमें दो छोटे बॉक्स हैं, उन पर 'Agent' और 'Environment' लिखे हैं

RL फ्रेमवर्क

स्टेप t:
- एजेंट state $s_t$ observe करता है

Environment से Agent की ओर State s_t लेबल वाला एक लाल तीर।

RL फ्रेमवर्क

स्टेप t:
- एजेंट state $s_t$ observe करता है
- एजेंट action $a_t$ लेता है

Agent से Environment की ओर action a_t लेबल वाला लाल तीर। अब state वाला तीर काला है।

RL फ्रेमवर्क

स्टेप t:
- एजेंट state $s_t$ observe करता है
- एजेंट action $a_t$ लेता है
स्टेप t+1:
- Environment reward $r_t$ देता है
- State बदलकर $s_{t+1}$ हो जाती है

State s_t तीर का लेबल बदलकर state s_t+1 हो जाता है और यह फिर से लाल है। Environment से Agent की ओर reward r_t+1 लेबल वाला नया लाल तीर। अब action वाला तीर काला है।

RL फ्रेमवर्क

स्टेप t:
- एजेंट state $s_t$ observe करता है
- एजेंट action $a_t$ लेता है
स्टेप t+1:
- Environment reward $r_t$ देता है
- State बदलकर $s_{t+1}$ हो जाती है
एपिसोड पूरा होने तक दोहराएँ

पिछली स्लाइड जैसा ही चित्र, लेकिन सभी तीर काले हैं।

Policy $\pi(s_t)$

State से action तक मैपिंग, जो दिए गए state $s_t$ में एजेंट का व्यवहार बताए

Deterministic:
- चुना गया action लौटाता है
Stochastic:
- actions पर एक distribution लौटाता है
- पॉलिसी संभावित actions पर एक probability distribution है

ट्रैजेक्टरी और एपिसोड रिटर्न

ट्रैजेक्टरी tau: किसी एपिसोड में सभी states और actions का अनुक्रम; tau = ((s0, a0), (s1, a1), ... (sT, aT))

एपिसोड रिटर्न Rtau: ट्रैजेक्टरी tau पर जमा कुल (डिस्काउंटेड) रिवार्ड्स। Rtau = sum over t of gamma to the power of t times r_t

एंवायरमेंट सेटअप करना

env = gym.make("ALE/SpaceInvaders-v5")

# Define neural network architecture
class Network(nn.Module):
    def __init__(self, dim_inputs, dim_outputs):
        super(Network, self).__init__()
        self.linear = nn.Linear(dim_inputs, dim_outputs)
    def forward(self, x):
        return self.linear(x)

# Instantiate network
network = Network(dim_inputs, dim_outputs)

# Instantiate optimizer
optimizer = optim.Adam(network.parameters(), lr=0.0001)

बेसिक लूप

for episode in range(1000):
  state, info = env.reset()
  done = False

  while not done:

    action = select_action(network, state)

    next_state, reward, terminated, truncated, _ = (
                                     env.step(action))
    done = terminated or truncated


    loss = calculate_loss(network, state, action, 
          next_state, reward, done)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()


    state = next_state

Outer loop: एपिसोड्स पर iterate करें
Inner loop: स्टेप्स पर iterate करें
- एक action चुनें
- नया state और reward observe करें
- loss निकालें और नेटवर्क अपडेट करें
- state अपडेट करें
(Loss?)

अगला क्या

DRL शक्तिशाली है!
Value-based और policy-based अप्रोचेज
DQN और उसके सुधार
Policy gradient मेथड्स

Deep Reinforcement Learning के रहस्यों की खोज में समुद्र में गहराई तक डुबकी लगाता एक Datacamp लर्नर

अभ्यास करते हैं!

Python में Deep Reinforcement Learning