DQN met experience replay

Deep Reinforcement Learning in Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Introductie tot experience replay

Kale DQN-agent leert alleen van de laatste ervaring
- Opeenvolgende updates zijn sterk gecorreleerd
- Agent vergeet snel
Oplossing: Experience Replay
- Sla ervaringen op in een buffer
- Leer elke stap van een willekeurige batch uit het verleden

Een luchtfoto van een haagdoolhof

De double-ended queue

from collections import deque


# Instantieer met beperkte capaciteit
buffer = deque([1,2,3,4], maxlen=7)


# Uitbreiden aan de rechterkant
buffer.extend([5,6,7,8])

Boven capaciteit vallen de oudste items weg

Een deque met capaciteit zeven met vier elementen, gelabeld één tot en met vier.

Een deque met capaciteit zeven met vier elementen, gelabeld één tot en met vier. Vier extra elementen, vijf tot en met acht, staan rechts.

Een deque met capaciteit zeven met zeven elementen, gelabeld één tot en met zeven. Eén extra element, 8, staat rechts.

Een deque met capaciteit zeven met zeven elementen, gelabeld twee tot en met acht. Eén extra element, 1, staat links.

Replaybuffer implementeren

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)


...

Replaygeheugen: deque met beperkte capaciteit
.push():
- Ervaring als transitie-tuple
- Voeg ervaring toe aan buffer
- Bij volle capaciteit: oudste ervaring valt weg

Replaybuffer implementeren

...
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

Willekeurig trekken uit eerdere ervaringen
batch: van lijst met transitie-tuplets...
...naar tuple van lijsten...
...naar tuple van PyTorch-tensors

Experience replay integreren in DQN

Voor de trainingslus: replay_buffer = ReplayBuffer(10000)
In de trainingslus, na actieselectie:

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)

Initialiseer replaybuffer
Push laatste transitie naar buffer

Als bufferlengte $\geq$ batch_size:

Trek een willekeurige batch en bereken de loss
Lossberekening conceptueel onveranderd
Mean Squared Bellman Error op een replaybatch
- Leren is stabieler en efficiënter

Laten we oefenen!

Deep Reinforcement Learning in Python