Giới thiệu về Q-Learning: Hướng dẫn cho người mới bắt đầu

Học tăng cường (RL) là một phần của hệ sinh thái học máy, nơi tác tử học bằng cách tương tác với môi trường để tìm ra chiến lược tối ưu nhằm đạt được mục tiêu. Nó khá khác với các thuật toán học có giám sát, nơi chúng ta cần nạp và xử lý dữ liệu. Học tăng cường không yêu cầu dữ liệu sẵn có. Thay vào đó, nó học từ môi trường và hệ thống phần thưởng để đưa ra quyết định tốt hơn.

Ví dụ, trong trò chơi Mario, nếu một nhân vật thực hiện hành động ngẫu nhiên (ví dụ: di chuyển sang trái), dựa trên hành động đó, nhân vật có thể nhận được phần thưởng. Sau khi thực hiện hành động, tác tử (Mario) sẽ ở một trạng thái mới, và quy trình này lặp lại cho đến khi nhân vật trò chơi đi đến cuối màn hoặc chết.

Tập (episode) này sẽ lặp lại nhiều lần cho đến khi Mario học cách điều hướng môi trường bằng cách tối đa hóa phần thưởng.

Hình ảnh của Tác giả

Chúng ta có thể chia nhỏ học tăng cường thành năm bước đơn giản:

1. Tác tử ở trạng thái ban đầu trong một môi trường.
2. Tác tử sẽ thực hiện một hành động dựa trên một chiến lược cụ thể.
3. Tác tử sẽ nhận được phần thưởng hoặc hình phạt dựa trên hành động đó.
4. Học hỏi từ các nước đi trước đó và tối ưu hóa chiến lược.
5. Quy trình sẽ lặp lại cho đến khi tìm được chiến lược tối ưu.

Tìm hiểu thêm qua hướng dẫn Giới thiệu về Học Tăng cường. Bạn sẽ khám phá cách học tăng cường hoạt động với các ví dụ mã nguồn.

Trong hướng dẫn này, chúng ta sẽ học về Q-learning và hiểu vì sao cần Deep Q-learning. Ngoài ra, chúng ta sẽ học cách tạo và huấn luyện thuật toán Q-learning từ đầu bằng Numpy và OpenAI Gym.

Lưu ý: Nếu bạn mới làm quen với học máy, chúng tôi khuyến nghị bạn học lộ trình nghề nghiệp Machine Learning Scientist with Python để hiểu rõ hơn về Học tăng cường và Q-Learning.

Q-Learning là gì?

Q-learning là một thuật toán không mô hình, dựa trên giá trị, off-policy, sẽ tìm chuỗi hành động tốt nhất dựa trên trạng thái hiện tại của tác tử. Chữ “Q” viết tắt cho quality (chất lượng). Chất lượng biểu thị mức độ giá trị của hành động trong việc tối đa hóa phần thưởng trong tương lai.

Các thuật toán có mô hình sử dụng hàm chuyển trạng thái và phần thưởng để ước lượng chính sách tối ưu và tạo ra mô hình. Ngược lại, thuật toán không mô hình học hệ quả của các hành động thông qua trải nghiệm mà không cần hàm chuyển và phần thưởng.

Phương pháp dựa trên giá trị huấn luyện hàm giá trị để học trạng thái nào có giá trị hơn và thực hiện hành động. Ngược lại, phương pháp dựa trên chính sách huấn luyện trực tiếp chính sách để học hành động nào cần thực hiện trong một trạng thái nhất định.

Trong off-policy, thuật toán đánh giá và cập nhật một chính sách khác với chính sách được dùng để thực hiện hành động. Ngược lại, thuật toán on-policy đánh giá và cải thiện cùng chính sách được dùng để hành động.

Thuật ngữ then chốt trong Q-learning

Trước khi tìm hiểu Q-learning hoạt động thế nào, chúng ta cần biết một vài thuật ngữ hữu ích để hiểu nền tảng của Q-learning.

• Trạng thái (s): vị trí hiện tại của tác tử trong môi trường.
• Hành động (a): một bước mà tác tử thực hiện tại một trạng thái cụ thể.
• Phần thưởng: với mỗi hành động, tác tử nhận được phần thưởng hoặc hình phạt.
• Tập (episode): kết thúc của một màn, nơi tác tử không thể thực hiện hành động mới. Xảy ra khi tác tử đạt mục tiêu hoặc thất bại.
• Q(S_t+1, a): giá trị Q tối ưu kỳ vọng của việc thực hiện hành động tại một trạng thái cụ thể.
• Q(S_t, A_t): ước lượng hiện tại của Q(S_t+1, a).
• Bảng Q (Q-Table): tác tử duy trì bảng Q gồm tập các trạng thái và hành động.
• Chênh lệch theo thời gian (Temporal Differences - TD): dùng để ước lượng giá trị kỳ vọng của Q(S_t+1, a) bằng cách sử dụng trạng thái và hành động hiện tại và trước đó.

Q-Learning hoạt động thế nào?

Chúng ta sẽ tìm hiểu chi tiết cách Q-learning hoạt động bằng ví dụ về một hồ nước đóng băng. Trong môi trường này, tác tử phải băng qua hồ từ điểm bắt đầu đến mục tiêu, mà không rơi vào các hố. Chiến lược tốt nhất là đến mục tiêu bằng đường đi ngắn nhất.

Gif của Tác giả

Bảng Q

Tác tử sẽ sử dụng bảng Q để chọn hành động tốt nhất có thể dựa trên phần thưởng kỳ vọng cho mỗi trạng thái trong môi trường. Nói đơn giản, bảng Q là cấu trúc dữ liệu gồm các tập hành động và trạng thái, và chúng ta dùng thuật toán Q-learning để cập nhật các giá trị trong bảng.

Hàm Q

Hàm Q sử dụng phương trình Bellman và nhận trạng thái (s) và hành động (a) làm đầu vào. Phương trình này đơn giản hóa việc tính giá trị trạng thái và giá trị trạng thái-hành động.

Hình ảnh từ freecodecamp.org

Thuật toán Q-learning

Hình ảnh của Tác giả

Khởi tạo Bảng Q

Đầu tiên, chúng ta sẽ khởi tạo bảng Q. Ta xây dựng bảng với số cột dựa trên số hành động và số hàng dựa trên số trạng thái.

Trong ví dụ của chúng ta, nhân vật có thể di chuyển lên, xuống, trái và phải. Ta có bốn hành động có thể và bốn trạng thái (bắt đầu, đứng yên, sai đường, và kết thúc). Bạn cũng có thể xem sai đường là rơi vào hố. Chúng ta sẽ khởi tạo Bảng Q với các giá trị bằng 0.

Hình ảnh của Tác giả

Chọn một Hành động

Bước thứ hai khá đơn giản. Lúc bắt đầu, tác tử sẽ chọn hành động ngẫu nhiên (xuống hoặc phải), và ở lần chạy thứ hai, nó sẽ dùng Bảng Q đã cập nhật để chọn hành động.

Thực hiện Hành động

Việc chọn và thực hiện hành động sẽ lặp lại nhiều lần cho đến khi vòng lặp huấn luyện dừng. Hành động và trạng thái đầu tiên được chọn bằng Bảng Q. Trong trường hợp của chúng ta, mọi giá trị trong Bảng Q đều bằng không.

Sau đó, tác tử sẽ di chuyển xuống và cập nhật Bảng Q bằng phương trình Bellman. Với mỗi bước đi, chúng ta sẽ cập nhật giá trị trong Bảng Q và cũng dùng nó để xác định lộ trình tốt nhất.

Ban đầu, tác tử ở chế độ khám phá và chọn hành động ngẫu nhiên để khám phá môi trường. Chiến lược Epsilon Greedy là một cách đơn giản để cân bằng giữa khám phá và khai thác. Epsilon là xác suất chọn khám phá, và sẽ khai thác khi xác suất khám phá nhỏ.

Lúc bắt đầu, tỷ lệ epsilon cao, nghĩa là tác tử đang ở chế độ khám phá. Khi khám phá môi trường, epsilon giảm dần, và tác tử bắt đầu khai thác môi trường. Trong quá trình khám phá, qua mỗi vòng lặp, tác tử tự tin hơn trong việc ước lượng các giá trị Q.

Hình ảnh của Tác giả

Trong ví dụ hồ băng, tác tử chưa biết gì về môi trường, nên nó thực hiện hành động ngẫu nhiên (di chuyển xuống) để bắt đầu. Như có thể thấy trong hình trên, Bảng Q được cập nhật bằng phương trình Bellman.

Đo lường Phần thưởng

Sau khi thực hiện hành động, chúng ta sẽ đo lường kết quả và phần thưởng.

• Phần thưởng khi đến mục tiêu là +1
• Phần thưởng khi đi sai đường (rơi vào hố) là 0
• Phần thưởng khi đứng yên hoặc di chuyển trên hồ băng cũng là 0.

Cập nhật Bảng Q

Chúng ta sẽ cập nhật hàm Q(S_t, A_t) bằng công thức. Nó sử dụng các giá trị Q ước lượng từ tập trước, tốc độ học và sai số Chênh lệch theo thời gian. Sai số TD được tính bằng Phần thưởng tức thời, phần thưởng tương lai kỳ vọng tối đa đã chiết khấu, và giá trị Q ước lượng trước đó.

Quy trình được lặp lại nhiều lần cho đến khi Bảng Q được cập nhật và hàm giá trị Q được tối đa hóa.

Hình ảnh của Tác giả | Hình minh họa phương trình từ Thomas Simonini

Lúc đầu, tác tử đang khám phá môi trường để cập nhật Bảng Q. Và khi Bảng Q đã sẵn sàng, tác tử sẽ bắt đầu khai thác và đưa ra quyết định tốt hơn.

Hình ảnh của Tác giả

Trong trường hợp hồ băng, tác tử sẽ học cách đi đường ngắn nhất để đến mục tiêu và tránh nhảy vào các hố.

Hướng dẫn Q-Learning bằng Python

Trong phần này, chúng ta sẽ xây dựng mô hình Q-learning từ đầu bằng môi trường Gym, Pygame và Numpy. Hướng dẫn Python này là phiên bản điều chỉnh từ Notebook của Thomas Simonini. Nó bao gồm khởi tạo môi trường và Bảng Q, định nghĩa chính sách greedy, thiết lập siêu tham số, tạo và chạy vòng lặp huấn luyện và đánh giá, và trực quan hóa kết quả.

Nếu bạn gặp vấn đề khi tạo và chạy vòng lặp huấn luyện, bạn có thể kiểm tra mã nguồn kèm đầu ra.

Thiết lập

Thiết lập Màn hình ảo

Đầu tiên, chúng ta sẽ cài đặt tất cả phụ thuộc để tạo video phát lại (Gif). Chúng ta sẽ cần một màn hình ảo (pyvirtualdisplay) để render môi trường và ghi khung hình.

Lưu ý: bằng cách sử dụng %%capture chúng ta đang ẩn đầu ra của ô Jupyter.

%%capture
!pip install pyglet==1.5.1
!apt install python-opengl
!apt install ffmpeg
!apt install xvfb
!pip3 install pyvirtualdisplay

# Virtual display
from pyvirtualdisplay import Display

virtual_display = Display(visible=0, size=(1400, 900))
virtual_display.start()

Cài đặt phụ thuộc

Bây giờ chúng ta sẽ cài đặt các phụ thuộc giúp tạo, chạy và đánh giá vòng lặp huấn luyện.

• gym: Dùng để khởi tạo môi trường FrozenLake-v1.
• pygame: Dùng cho giao diện FrozenLake-v1.
• numPy: Dùng để tạo và xử lý Bảng Q.

%%capture
!pip install gym==0.24
!pip install pygame
!pip install numpy

!pip install imageio imageio_ffmpeg

Import các gói

Bây giờ, chúng ta sẽ import các thư viện cần thiết.

• Imageio dùng để tạo ảnh động.
• tqdm dùng để hiển thị thanh tiến trình.

import numpy as np
import gym
import random
import imageio
from tqdm.notebook import trange

Môi trường Frozen Lake trong Gym

Chúng ta sẽ tạo môi trường 4x4 không trơn trượt bằng thư viện Frozen Lake của gym.

• Có hai phiên bản lưới, “4x4” và “8x8”.
• Nếu is_slippery=True, tác tử có thể không di chuyển theo hướng dự định do mặt hồ băng trơn trượt.

Sau khi khởi tạo môi trường, chúng ta sẽ phân tích môi trường.

env = gym.make("FrozenLake-v1",map_name="4x4",is_slippery=False)

print("Observation Space", env.observation_space)
print("Sample observation", env.observation_space.sample()) # display a random observation

Có 16 không gian trạng thái riêng biệt trong môi trường được hiển thị ở các vị trí ngẫu nhiên.

Observation Space Discrete(16)
Sample observation 15

Hãy tìm số lượng hành động và hiển thị một hành động ngẫu nhiên.

Không gian hành động:

• 0: di chuyển trái
• 1: di chuyển xuống
• 2: di chuyển phải
• 3: di chuyển lên

Hàm phần thưởng:

• Đến mục tiêu: +1
• Rơi vào hố: 0
• Ở trên mặt hồ băng: 0

print("Action Space Shape", env.action_space.n)
print("Action Space Sample", env.action_space.sample())

Action Space Shape 4
Action Space Sample 1

Tạo và Khởi tạo Bảng Q

Bảng Q có các cột là hành động và các hàng là trạng thái. Chúng ta có thể dùng OpenAI Gym để tìm không gian hành động và không gian trạng thái. Sau đó dùng thông tin này để tạo Bảng Q.

state_space = env.observation_space.n
print("There are ", state_space, " possible states")

action_space = env.action_space.n
print("There are ", action_space, " possible actions")

There are  16  possible states
There are  4  possible actions

Để khởi tạo Bảng Q, chúng ta sẽ tạo một mảng Numpy với kích thước không gian trạng thái và không gian hành động. Chúng ta sẽ tạo mảng 16 x 4.

def initialize_q_table(state_space, action_space):
  Qtable = np.zeros((state_space, action_space))
  return Qtable

Qtable_frozenlake = initialize_q_table(state_space, action_space)

Chính sách epsilon-greedy

Ở phần trước, chúng ta đã học về chiến lược epsilon greedy để xử lý đánh đổi giữa khám phá và khai thác. Với xác suất 1 - ɛ, chúng ta khai thác; với xác suất ɛ, chúng ta khám phá.

Trong epsilon_greedy_policy, chúng ta sẽ:

1. Sinh một số ngẫu nhiên trong khoảng 0 đến 1.
2. Nếu số ngẫu nhiên lớn hơn epsilon, chúng ta sẽ khai thác. Nghĩa là tác tử sẽ chọn hành động có giá trị cao nhất với một trạng thái cho trước.
3. Ngược lại, chúng ta sẽ khám phá (chọn hành động ngẫu nhiên).

def epsilon_greedy_policy(Qtable, state, epsilon):
  random_int = random.uniform(0,1)
  if random_int > epsilon:
    action = np.argmax(Qtable[state])
  else:
    action = env.action_space.sample()
  return action

Định nghĩa chính sách greedy

Như chúng ta biết, Q-learning là thuật toán off-policy, nghĩa là chính sách dùng để hành động và chính sách dùng để cập nhật là khác nhau.

Trong ví dụ này, chính sách Epsilon Greedy là chính sách hành động, còn chính sách Greedy là chính sách cập nhật.

Chính sách Greedy cũng sẽ là chính sách cuối cùng khi tác tử đã được huấn luyện. Nó được dùng để chọn giá trị trạng thái và hành động cao nhất từ Bảng Q.

def greedy_policy(Qtable, state):
  action = np.argmax(Qtable[state])
  return action

Siêu tham số của mô hình

Các siêu tham số này được dùng trong vòng lặp huấn luyện, và tinh chỉnh chúng sẽ cho kết quả tốt hơn.

Tác tử cần khám phá đủ không gian trạng thái để học xấp xỉ giá trị tốt; chúng ta cần giảm epsilon dần dần. Nếu tốc độ giảm quá cao, tác tử có thể bị kẹt vì chưa khám phá đủ không gian trạng thái.

• Có 10.000 tập huấn luyện và 100 tập đánh giá.
• Tốc độ học là 0,7.
• Chúng ta dùng môi trường "FrozenLake-v1" với 99 bước tối đa mỗi tập.
• Gamma (tỷ lệ chiết khấu) là 0,95.
• eval_seed: seed đánh giá cho môi trường.
• Xác suất khám phá epsilon lúc đầu là 1,0, và xác suất tối thiểu là 0,05.
• Tốc độ suy giảm theo hàm mũ cho epsilon là 0,0005.

# Training parameters
n_training_episodes = 10000
learning_rate = 0.7        

# Evaluation parameters
n_eval_episodes = 100      

# Environment parameters
env_id = "FrozenLake-v1"   
max_steps = 99             
gamma = 0.95               
eval_seed = []             

# Exploration parameters
max_epsilon = 1.0           
min_epsilon = 0.05           
decay_rate = 0.0005           

Huấn luyện mô hình

Trong vòng lặp huấn luyện, chúng ta sẽ:

1. Tạo vòng lặp cho các tập huấn luyện.
2. Giảm epsilon trước. Vì qua mỗi tập, chúng ta cần ít khám phá hơn và nhiều khai thác hơn.
3. Đặt lại môi trường.
4. Tạo vòng lặp lồng cho số bước tối đa.
5. Chọn hành động bằng chính sách epsilon greedy.
6. Thực hiện hành động (A_t) và quan sát phần thưởng kỳ vọng (R_t+1) và trạng thái (S_t+1).
7. Thực hiện hành động (a) và quan sát trạng thái kết quả (s') và phần thưởng (r).
8. Cập nhật hàm Q bằng công thức.
9. Nếu done= True, kết thúc tập và thoát vòng lặp.
10. Cuối cùng, chuyển trạng thái hiện tại sang trạng thái mới.
11. Sau khi hoàn thành tất cả tập huấn luyện, hàm sẽ trả về Bảng Q đã cập nhật.

def train(n_training_episodes, min_epsilon, max_epsilon, decay_rate, env, max_steps, Qtable):
  for episode in trange(n_training_episodes):
 
    epsilon = min_epsilon + (max_epsilon - min_epsilon)*np.exp(-decay_rate*episode)
    # Reset the environment
    state = env.reset()
    step = 0
    done = False

    # repeat
    for step in range(max_steps):
   
      action = epsilon_greedy_policy(Qtable, state, epsilon)

   
      new_state, reward, done, info = env.step(action)

   
      Qtable[state][action] = Qtable[state][action] + learning_rate * (reward + gamma * np.max(Qtable[new_state]) - Qtable[state][action])

      # If done, finish the episode
      if done:
        break
     
      # Our state is the new state
      state = new_state
  return Qtable

Chúng ta mất 3 giây để hoàn thành 10.000 tập huấn luyện.

Qtable_frozenlake = train(n_training_episodes, min_epsilon, max_epsilon, decay_rate, env, max_steps, Qtable_frozenlake)

Như có thể thấy, Bảng Q đã được huấn luyện có các giá trị, và giờ tác tử sẽ dùng các giá trị này để điều hướng môi trường và đạt được mục tiêu.
Qtable_frozenlake
array([[0.73509189, 0.77378094, 0.77378094, 0.73509189],
      [0.73509189, 0.        , 0.81450625, 0.77378094],
      [0.77378094, 0.857375  , 0.77378094, 0.81450625],
      [0.81450625, 0.        , 0.77378094, 0.77378094],
      [0.77378094, 0.81450625, 0.        , 0.73509189],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.9025    , 0.        , 0.81450625],
      [0.        , 0.        , 0.        , 0.        ],
      [0.81450625, 0.        , 0.857375  , 0.77378094],
      [0.81450625, 0.9025    , 0.9025    , 0.        ],
      [0.857375  , 0.95      , 0.        , 0.857375  ],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.9025    , 0.95      , 0.857375  ],
      [0.9025    , 0.95      , 1.        , 0.9025    ],
      [0.        , 0.        , 0.        , 0.        ]])
Đánh giá
Hàm evaluate_agent chạy trong n_eval_episodes tập và trả về giá trị trung bình và độ lệch chuẩn của phần thưởng.

Trong vòng lặp, trước tiên chúng ta sẽ kiểm tra có seed đánh giá hay không. Nếu không, thì đặt lại môi trường không có seed.
Vòng lặp lồng chạy đến max_steps.
Tác tử sẽ thực hiện hành động có phần thưởng tương lai kỳ vọng tối đa tại một trạng thái cho trước bằng Bảng Q.
Tính phần thưởng.
Thay đổi trạng thái.
Nếu done (tác tử rơi vào hố hoặc đã đạt mục tiêu), thoát vòng lặp.
Ghi nhận kết quả.
Cuối cùng, chúng ta dùng các kết quả này để tính giá trị trung bình và độ lệch chuẩn.

def evaluate_agent(env, max_steps, n_eval_episodes, Q, seed):

  episode_rewards = []
  for episode in range(n_eval_episodes):
    if seed:
      state = env.reset(seed=seed[episode])
    else:
      state = env.reset()
    step = 0
    done = False
    total_rewards_ep = 0
   
    for step in range(max_steps):
      # Take the action (index) that have the maximum reward
      action = np.argmax(Q[state][:])
      new_state, reward, done, info = env.step(action)
      total_rewards_ep += reward
       
      if done:
        break
      state = new_state
    episode_rewards.append(total_rewards_ep)
  mean_reward = np.mean(episode_rewards)
  std_reward = np.std(episode_rewards)

  return mean_reward, std_reward
Như bạn thấy, chúng ta đạt điểm tuyệt đối với độ lệch chuẩn bằng không. Điều đó có nghĩa là tác tử đã đạt mục tiêu trong cả 100 tập.
# Evaluate our Agent
mean_reward, std_reward = evaluate_agent(env, max_steps, n_eval_episodes, Qtable_frozenlake, eval_seed)
print(f"Mean_reward={mean_reward:.2f} +/- {std_reward:.2f}")
Mean_reward=1.00 +/- 0.00
Trực quan hóa kết quả
Đến giờ, chúng ta mới chỉ làm việc với các con số, và để minh họa, chúng ta cần tạo một ảnh Gif động của tác tử từ lúc bắt đầu cho đến khi đạt mục tiêu.

Đầu tiên, chúng ta sẽ tạo trạng thái bằng cách đặt lại môi trường với một số nguyên ngẫu nhiên 0-500.
Render môi trường bằng rdb_array để tạo mảng ảnh.
Sau đó thêm img vào mảng images.
Trong vòng lặp, chúng ta sẽ bước theo Bảng Q và render ảnh cho mỗi bước.
Cuối cùng, chúng ta sẽ dùng mảng này và imageio để tạo Gif với một khung hình mỗi giây.

def record_video(env, Qtable, out_directory, fps=1):
  images = [] 
  done = False
  state = env.reset(seed=random.randint(0,500))
  img = env.render(mode='rgb_array')
  images.append(img)
  while not done:
    # Take the action (index) that have the maximum expected future reward given that state
    action = np.argmax(Qtable[state][:])
    state, reward, done, info = env.step(action) # We directly put next_state = state for recording logic
    img = env.render(mode='rgb_array')
    images.append(img)
  imageio.mimsave(out_directory, [np.array(img) for i, img in enumerate(images)], fps=fps)
Nếu bạn ở trong Jupyter notebook, bạn có thể hiển thị Gif bằng hàm Image của IPython.display.
video_path="/content/replay.gif"
video_fps=1
record_video(env, Qtable_frozenlake, video_path, video_fps)

from IPython.display import Image
Image('./replay.gif')
Bây giờ bạn có thể chia sẻ những kết quả này với đồng nghiệp, bạn cùng lớp hoặc đăng lên mạng xã hội.