डबल DQN

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

डबल Q-learning

Q-learning Q-values को ज़्यादा आँकता है, जिससे सीखना धीमा होता है
कारण: maximization bias
Double Q-Learning, action selection और value estimation को अलग कर bias हटाता है

दो Q-टेबल (कोर्स Reinforcement Learning with Gymnasium using Python से चित्र); डबल Q-learning इन्हें बारी-बारी से इस्तेमाल करता है

DDQN का मूल विचार

पूरे DQN (fixed Q-targets के साथ) से शुरू करें
DQN के TD target में:
- Action selection: target नेटवर्क
- Value estimation: target नेटवर्क
DDQN के TD target में:
- Action selection: ऑनलाइन नेटवर्क
- Value estimation: target नेटवर्क
बिल्कुल double Q-learning नहीं (alternating Q-networks नहीं)
कम बदलाव में अधिक लाभ

बेलमैन त्रुटि (fixed Q-targets वाला DQN): Q_online(s_t, a_t) - (r_t+1 + gamma max(Q_target(s_t+1, a)))

बेलमैन त्रुटि (fixed Q-targets वाला DDQN): Q_online(s_t, a_t) - (r_t+1 + gamma Q_target(s_t+1, tilde a)) जहाँ tilde a = argmax_a(Q_online(s_t+1, a))

डबल 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

डबल 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

DDQN प्रदर्शन

Atari गेम्स पर DDQN, DQN और मानव खिलाड़ियों का प्रदर्शन तुलना करें
DDQN: मूल DQN से ऊँचे स्कोर
हमेशा सही नहीं होता -> दोनों आज़माएँ

बार चार्ट: मीडियन गेम पर DQN लगभग मानव प्रदर्शन तक पहुँचता है और औसतन सुपरह्यूमन; DDQN मीडियन और एवरेज दोनों पर मानव और DQN से बेहतर।

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

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

Python में Deep Reinforcement Learning