Double DQN

Deep Reinforcement Learning în Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Double Q-learning

Q-learning supraestimează valorile Q, reducând eficiența învățării
Aceasta se datorează erorii de maximizare
Double Q-Learning elimină eroarea prin separarea selecției acțiunii de estimarea valorii

Două tabele Q (ilustrație din cursul Reinforcement Learning with Gymnasium using Python); double Q-learning le folosește alternativ

Ideea din spatele DDQN

Pornire de la DQN complet (cu Q-ținte fixe)
În ținta TD pentru DQN:
- Selecția acțiunii: rețeaua țintă
- Estimarea valorii: rețeaua țintă
În ținta TD pentru DDQN:
- Selecția acțiunii: rețeaua online
- Estimarea valorii: rețeaua țintă
Nu este exact double Q-learning (fără rețele Q alternante)
Majoritatea beneficiilor, cu modificări minime

Eroarea Bellman (DQN cu Q-ținte fixe): Q_online(s_t, a_t) - (r_t+1 + gamma max(Q_target(s_t+1, a)))

Eroarea Bellman (DDQN cu Q-ținte fixe): Q_online(s_t, a_t) - (r_t+1 + gamma Q_target(s_t+1, tilde a)) cu tilde a = argmax_a(Q_online(s_t+1, a))

Implementarea Double DQN

DQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():

    #
    #
    next_q_values = (target_network(next_states)
        .amax(1))

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

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

DDQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():






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

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

Implementarea Double DQN

DQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():

    next_actions = (target_network(next_states)
       .argmax(1).unsqueeze(1))

    next_q_values = (target_network(next_states)
       .gather(1, next_actions).squeeze(1))

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

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

DDQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():

    next_actions = (online_network(next_states)
       .argmax(1).unsqueeze(1))

    next_q_values = (target_network(next_states)
       .gather(1, next_actions).squeeze(1))

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

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

Performanța DDQN

Compararea performanței DDQN, DQN și jucători umani pe jocuri Atari
DDQN: scoruri mai mari decât DQN original
Nu este întotdeauna valabil -> încercați ambele

Diagramă cu bare care arată că DQN aproape egalizează performanța umană pentru jocul median și obține scoruri supraomenești în medie; iar DDQN depășește atât performanța umană, cât și DQN la median și medie.

¹ https://arxiv.org/abs/2303.11634

Să exersăm!

Deep Reinforcement Learning în Python