Experience replay के साथ DQN

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

Experience replay का परिचय

 

  • बेसिक DQN एजेंट सिर्फ लेटेस्ट experience से सीखता है
    • लगातार अपडेट्स में हाई correlation होता है
    • एजेंट जल्दी भूल जाता है
  • समाधान: Experience Replay
    • experiences को एक बफ़र में स्टोर करें
    • हर स्टेप पर, पुराने experiences से एक रैंडम बैच लेकर सीखें

 

हेज भूलभुलैया का एरियल दृश्य

Python में Deep Reinforcement Learning

Double-Ended Queue

 

from collections import deque


# सीमित क्षमता के साथ instantiate करें
buffer = deque([1,2,3,4], maxlen=7)


# दाहिनी ओर extend करें
buffer.extend([5,6,7,8])
  • क्षमता से आगे जाने पर, सबसे पुराने items हट जाते हैं

सात क्षमता वाला deque, जिसमें एक से चार तक चार एलिमेंट हैं.

सात क्षमता वाला deque, जिसमें एक से चार तक चार एलिमेंट हैं. दाहिनी ओर पाँच से आठ तक चार और एलिमेंट दिख रहे हैं.

सात क्षमता वाला deque, जिसमें एक से सात तक सात एलिमेंट हैं. दाहिनी ओर 8 नाम का एक अतिरिक्त एलिमेंट दिख रहा है.

सात क्षमता वाला deque, जिसमें दो से आठ तक सात एलिमेंट हैं. बाँयीं ओर 1 नाम का एक अतिरिक्त एलिमेंट दिख रहा है.

Python में Deep Reinforcement Learning

Replay Buffer लागू करना

import random


class ReplayBuffer:

    def __init__(self, capacity):

        self.memory = deque([], maxlen=capacity)


    def push(self, state, action, 
             reward, next_state, done):

        experience_tuple = (state, action, 
                            reward, next_state, done)

        self.memory.append(experience_tuple)


    def __len__(self):
        return len(self.memory)


...
  • Replay memory: सीमित क्षमता वाला deque
  • .push():
    • Experience एक transition tuple के रूप में
    • experience को बफ़र में जोड़ें
    • क्षमता पूरी होने पर: सबसे पुराना experience हटता है
Python में Deep Reinforcement Learning

Replay Buffer लागू करना

...
def sample(self, batch_size):

    batch = random.sample(self.memory, batch_size)

    states, actions, rewards, next_states, dones = (
      zip(*batch))


    states_tensor = torch.tensor(
      states, dtype=torch.float32)
    ... # repeat identically for 
        # rewards, next_states, dones

    actions_tensor = torch.tensor(
      actions, dtype=torch.long).unsqueeze(1)


    return states_tensor, actions_tensor, 
rewards_tensor, next_states_tensor, dones_tensor

 

  • पुराने experiences से रैंडम सैंपल लें
  • batch: transition tuples की लिस्ट से...
  • ...लिस्ट्स के tuple तक...
  • ...और फिर PyTorch tensors के tuple तक
Python में Deep Reinforcement Learning

DQN में Experience Replay जोड़ना

  1. ट्रेनिंग लूप से पहले: replay_buffer = ReplayBuffer(10000)

  2. ट्रेनिंग लूप में, action चुनने के बाद:

replay_buffer.push((state, action, 
                    reward, next_state, done))

if len(replay_buffer) >= batch_size:

    states, actions, rewards, next_states, dones = (
           replay_buffer.sample(batch_size))

    q_values = (
        q_network(states).gather(1, actions).squeeze(1))

    next_states_q_values = q_network(next_states).amax(1)

    target_q_values = (
                rewards + 
                gamma * next_states_q_values * (1-dones))

    loss = nn.MSELoss()(target_q_values, q_values)
  • Replay buffer इनिशियलाइज़ करें
  • लेटेस्ट transition बफ़र में पुश करें

यदि buffer length $\geq$ batch_size:

  • बफ़र से रैंडम बैच लें और loss कैलकुलेशन करें
  • Loss कैलकुलेशन अवधारणात्मक रूप से समान रहता है
  • Replay memory बैच पर Mean Squared Bellman Error
    • सीखना ज़्यादा स्थिर और प्रभावी होता है
Python में Deep Reinforcement Learning

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

Python में Deep Reinforcement Learning

Preparing Video For Download...