Introductie tot deep reinforcement learning

Deep Reinforcement Learning in Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Waarom Deep Reinforcement Learning

Traditionele RL werkt voor laag-dimensionale taken

Veel toepassingen hebben een hoog-dimensionale toestand- en/of actieruimte

Een agent die de Frozen Lake-omgeving verkent

Een agent die de klassieke videogame Space Invaders speelt

De ingrediënten van DRL

Reinforcement Learning-concepten
Deep Learning en PyTorch

DRL combineert deze met diepe neurale netwerken

Pixelart van een kok die ingrediënten mengt

Het RL-raamwerk

Stap t:

Een grote doos met twee kleinere dozen erin, gelabeld ‘Agent’ en ‘Omgeving’

Het RL-raamwerk

Stap t:
- Agent observeert toestand $s_t$

Een rode pijl met label Toestand s_t gaat van omgeving naar agent.

Het RL-raamwerk

Stap t:
- Agent observeert toestand $s_t$
- Agent kiest actie $a_t$

Een rode pijl met label actie a_t gaat van agent naar omgeving. De toestandspijl is nu zwart.

Het RL-raamwerk

Stap t:
- Agent observeert toestand $s_t$
- Agent kiest actie $a_t$
Stap t+1:
- Omgeving geeft beloning $r_t$
- Toestand wordt $s_{t+1}$

De pijl met s_t wordt s_t+1 en is weer rood. Een nieuwe rode pijl met beloning r_t+1 gaat van omgeving naar agent. De actiepijl is nu zwart.

Het RL-raamwerk

Stap t:
- Agent observeert toestand $s_t$
- Agent kiest actie $a_t$
Stap t+1:
- Omgeving geeft beloning $r_t$
- Toestand wordt $s_{t+1}$
Herhaal tot de episode klaar is

Dezelfde afbeelding als de vorige slide, maar alle pijlen zijn zwart.

Policy $\pi(s_t)$

Afbeelding van toestand naar actie: hoe de agent zich gedraagt in toestand $s_t$

Deterministisch:
- Geeft de gekozen actie terug
Stochastisch:
- Geeft een verdeling over acties
- Policy is een kansverdeling over mogelijke acties

Traject en episodereturn

Traject τ: reeks van alle toestanden en acties in een episode; τ = ((s0, a0), (s1, a1), ... (sT, aT))

Episodereturn Rτ: totale (gedisconteerde) beloningen langs traject τ. Rτ = som over t van gamma tot de macht t keer r_t

De omgeving opzetten

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)

De basislus

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

Buitenlus: itereren over episodes
Binnenlus: itereren over stappen
- Kies een actie
- Observeer nieuwe toestand en beloning
- Bereken loss en update het netwerk
- Update de toestand
(Loss?)

Wat komt er nu

DRL is krachtig!
Value- en policy-gebaseerde aanpakken
DQN en verfijningen
Policygradient-methoden

Een Datacamp-lerende die diep de zee in duikt om de geheimen van Deep Reinforcement Learning te ontdekken

Laten we oefenen!

Deep Reinforcement Learning in Python