पूरा DQN एल्गोरिदम

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

DQN एल्गोरिदम

 

 

  • हमने Experience Replay के साथ DQN पढ़ा
  • मूल DQN (2015) के काफ़ी करीब
  • दो घटक अभी बाकी हैं:
    • Epsilon-greediness -> ज़्यादा exploration
    • Fixed Q-targets -> ज़्यादा stable learning

एक साहसी व्यक्ति, उसके साथ ग्रीक अक्षर epsilon

बड़े अक्षर Q का एक ब्लॉक बर्फ में जमा हुआ

Python में Deep Reinforcement Learning

DQN में Epsilon-greediness

  • select_action() में Decayed Epsilon-greediness लागू करें
def select_action(q_values, step, start, end, decay):

    # Calculate the threshold value for this step
    epsilon = (
        end + (start-end) * math.exp(-step / decay))

    # Draw a random number between 0 and 1
    sample = random.random()

    if sample < epsilon:
        # Return a random action index
        return random.choice(range(len(q_values)))

    # Return the action index with highest Q-value
    return torch.argmax(q_values).item()
  • $\varepsilon = end + (start-end) \cdot e^{-\frac{step}{decay}}$
  • संभावना $\varepsilon$ पर random action लें
  • संभावना $1 - \varepsilon$ पर सबसे ऊँचा Q-value वाला action लें

विभिन्न decay मानों के लिए Epsilon decay शेड्यूल का प्लॉट।

Python में Deep Reinforcement Learning

Fixed Q-targets

 

  • Bellman Error में:
    • Q-Value और TD-Target दोनों की गणना में Q-Network
    • बदलते target से instability

 

  • Target network जोड़ें ताकि target stabilized रहे

 

Bellman Error: (r_t+1 + gamma max(Q(s_t+1, a))) - Q(s_t, a_t)

(r_t+1 + gamma max(Q_target(s_t+1, a))) - Q_online(s_t, a_t)

Python में Deep Reinforcement Learning

Fixed Q-targets लागू करना

online_network = QNetwork(state_size, action_size)
target_network = QNetwork(state_size, action_size)

target_network.load_state_dict(
                       online_network.state_dict())


def update_target_network(
                 target_network, online_network, tau):

  target_net_state_dict = target_network.state_dict()
  online_net_state_dict = online_network.state_dict()
  for key in online_net_state_dict:

    target_net_state_dict[key] = (
         online_net_state_dict[key] * tau + 
         target_net_state_dict[key] * (1 - tau))

    target_network.load_state_dict(
                          target_net_state_dict)

  return None
  • शुरुआत में Online Network = Target Network
  • किसी नेटवर्क का state dict सभी weights रखता है: नेटवर्क स्टेट डिक्शनरी का चित्रण, जिसमें fc1.weight, fc1.bias, और fc2.weight प्रविष्टियाँ हैं; हर प्रविष्टि का मान एक tensor है.
  • हर step पर Target Network के हर weight को Online Network के करीब अपडेट करें
Python में Deep Reinforcement Learning

Fixed Q-targets के साथ loss गणना

# In the inner loop, after action selection
if len(replay_buffer) >= batch_size:
  states, actions, rewards, next_states, dones = 
      replay_buffer.sample(64)

  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()(target_q_values, q_values)
  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

  update_target_network(
               target_network, online_network, tau)

 

  • Q-values के लिए online_network उपयोग करें
  • Target Q-values के लिए target_network उपयोग करें
  • Target Q-values पर gradient tracking बंद करने हेतु torch.no_grad() उपयोग करें
  • हानि के लिए Mean Squared Bellman Error ही उपयोग करें
  • update_target_network() से target_network को धीरे-धीरे अपडेट करें
Python में Deep Reinforcement Learning

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

Python में Deep Reinforcement Learning

Preparing Video For Download...