Policy gradient และ REINFORCE

Deep Reinforcement Learning ด้วย Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

ความแตกต่างจาก DQN

REINFORCE: Monte-Carlo ไม่ใช่ Temporal Difference
- อัปเดตเมื่อสิ้นสุด episode ไม่ใช่ ทุกขั้นตอน
- อัปเดตหลังผ่านไปหลาย episode ก็ได้
ไม่มี value function
ไม่มี target network
ไม่มี epsilon-greediness
ไม่มี experience replay

ภาพแสดง: action value function Q, experience replay, epsilon greediness และ fixed q-targets ซ้อนกันและมีเครื่องหมายขีดฆ่า

โครงสร้าง training loop ของ REINFORCE

for episode in range(num_episodes):

  # 1. Initialize episode

  while not done:

    # 2. Select action

    # 3. Play action and obtain next state and reward

    # 4. Add (discounted) reward to return

    # 5. Update state

  # 6. Calculate loss

  # 7. Update policy network by gradient descent

การเลือก Action

from torch.distributions import Categorical

def select_action(policy_network, state):
  action_probs = policy_network(state)

  action_dist = Categorical(action_probs)

  action = action_dist.sample()

  log_prob = action_dist.log_prob(action)

  return action.item(), log_prob.reshape(1)


action, log_prob = select_action(
                       policy_network, state)

รับค่าความน่าจะเป็นจากเครือข่าย
สุ่มเลือก action หนึ่งรายการ
คืนค่า action และ log probability ที่สอดคล้องกัน

Sampled action index: 1
Log probability of sampled action: -1.38

การคำนวณ Loss

ทบทวน policy gradient theorem:

Policy gradient theorem: gradient ของ J(pi_theta) เทียบกับ theta เท่ากับค่าคาดหวังของ trajectory tau ที่ตาม pi_theta ของผลตอบแทนของ episode คูณกับผลรวมของ gradient ของ log action probabilities รวมทุก action ใน trajectory

ฟังก์ชัน loss ของ REINFORCE สำหรับ episode: L(theta) เท่ากับลบของผลตอบแทน episode คูณผลรวมของ log probability ของ action

ใน Python:

$R_{\tau}$ แทนด้วย episode_return
เวกเตอร์ของ $\log\pi_\theta(a_t|s_t)$ แทนด้วย episode_log_probs

loss = -episode_return * episode_log_probs.sum()

Training loop ของ REINFORCE

for episode in range(50):
  state, info = env.reset(); done = False; step = 0;
  episode_log_probs = torch.tensor([])

  R = 0

  while not done:
    step += 1
    action, log_prob = select_action(policy_network, state)

    next_state, reward, terminated, truncated, _ = env.step(action)
    done = terminated or truncated

    R += (gamma ** step) * reward

    episode_log_probs = torch.cat((episode_log_probs, log_prob))

    state = next_state

  loss = - R * episode_log_probs.sum()

  optimizer.zero_grad(); loss.backward(); optimizer.step()

มาฝึกกันเถอะ!

Deep Reinforcement Learning ด้วย Python