Thuật toán DQN hoàn chỉnh

Deep Reinforcement Learning bằng Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Thuật toán DQN

 

 

  • Đã học DQN với Replay Kinh nghiệm
  • Gần với DQN bản đầu tiên (2015)
  • Còn thiếu hai thành phần:
    • Epsilon-greediness -> tăng khám phá
    • Fixed Q-targets -> học ổn định hơn

Một nhà thám hiểm đứng, cạnh là chữ cái Hy Lạp epsilon

Chữ Q in hoa bị đóng băng trong một khối băng

Deep Reinforcement Learning bằng Python

Epsilon-greediness trong DQN

  • Triển khai epsilon-greediness suy giảm trong select_action()
def select_action(q_values, step, start, end, decay):

    # Tính ngưỡng cho bước này
    epsilon = (
        end + (start-end) * math.exp(-step / decay))

    # Lấy số ngẫu nhiên trong [0, 1]
    sample = random.random()

    if sample < epsilon:
        # Trả về chỉ số hành động ngẫu nhiên
        return random.choice(range(len(q_values)))

    # Trả về chỉ số hành động có Q-value lớn nhất
    return torch.argmax(q_values).item()
  • $\varepsilon = end + (start-end) \cdot e^{-\frac{step}{decay}}$
  • Chọn hành động ngẫu nhiên với xác suất $\varepsilon$
  • Chọn hành động giá trị cao nhất với xác suất $1 - \varepsilon$

Đồ thị lịch trình suy giảm Epsilon cho các giá trị tham số decay khác nhau.

Deep Reinforcement Learning bằng Python

Fixed Q-targets

 

  • Trong Bellman Error:
    • Q-Network dùng cho cả Q-Value và TD-Target
    • Mất ổn định do mục tiêu thay đổi

 

  • Thêm target network để ổn định mục tiêu

 

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)

Deep Reinforcement Learning bằng Python

Triển khai 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
  • Ban đầu Online Network = Target Network
  • State dict của mạng chứa toàn bộ trọng số: biểu diễn state dictionary của một mạng, gồm các mục fc1.weight, fc1.bias, và fc2.weight; giá trị mỗi mục là một tensor.
  • Mỗi bước, mọi trọng số của Target Network tiến gần Online Network một chút
Deep Reinforcement Learning bằng Python

Tính loss với fixed Q-targets

# Trong vòng lặp trong, sau khi chọn hành động
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 dùng online_network
  • Target Q-values dùng target_network
  • Dùng torch.no_grad() để tắt gradient cho target Q-values
  • Vẫn dùng Mean Squared Bellman Error để tính loss
  • Dùng update_target_network() để cập nhật chậm target_network
Deep Reinforcement Learning bằng Python

Ayo berlatih!

Deep Reinforcement Learning bằng Python

Preparing Video For Download...