แนะนำ Q-Learning: บทเรียนสำหรับผู้เริ่มต้น

Reinforcement learning (RL) เป็นส่วนหนึ่งของระบบนิเวศการเรียนรู้ของเครื่องที่ตัวแทนเรียนรู้ผ่านการโต้ตอบกับสภาพแวดล้อมเพื่อค้นหากลยุทธ์ที่เหมาะสมที่สุดสำหรับการบรรลุเป้าหมาย ซึ่งแตกต่างจากอัลกอริทึมการเรียนรู้แบบมีผู้สอนที่ต้องป้อนและประมวลผลข้อมูล Reinforcement learning ไม่ต้องการข้อมูลล่วงหน้า แต่จะเรียนรู้จากสภาพแวดล้อมและระบบรางวัลเพื่อช่วยให้ตัดสินใจได้ดีขึ้น

ตัวอย่างเช่น ในวิดีโอเกม Mario เมื่อทำการกระทำแบบสุ่ม (เช่น เดินไปทางซ้าย) ตัวละครอาจได้รับรางวัลตามการกระทำนั้น หลังจากลงมือทำแล้ว ตัวแทน (Mario) จะอยู่ในสถานะใหม่ และกระบวนการจะวนซ้ำไปเรื่อย ๆ จนกว่าตัวละครจะถึงปลายด่านหรือพลาดท่าตาย

รอบเหตุการณ์นี้จะเกิดซ้ำหลายครั้งจนกว่า Mario จะเรียนรู้การนำทางสภาพแวดล้อมด้วยการเพิ่มรางวัลให้มากที่สุด

ภาพโดยผู้เขียน

เราสามารถแบ่ง Reinforcement learning ออกเป็น 5 ขั้นตอนง่าย ๆ ได้ดังนี้:

1. ตัวแทนอยู่ที่สถานะเริ่มต้นในสภาพแวดล้อม
2. เลือกการกระทำตามกลยุทธ์ที่กำหนด
3. ได้รับรางวัลหรือโทษตามการกระทำนั้น
4. เรียนรู้จากการเคลื่อนไหวก่อนหน้าและปรับกลยุทธ์ให้เหมาะสม
5. ทำซ้ำกระบวนการจนกว่าจะพบกลยุทธ์ที่เหมาะสมที่สุด

เรียนรู้เพิ่มเติมได้จากบทความ Introduction to Reinforcement Learning ซึ่งจะอธิบายการทำงานของ reinforcement learning พร้อมตัวอย่างโค้ด

ในบทเรียนนี้ เราจะทำความรู้จักกับ Q-learning และเข้าใจว่าทำไมเราจึงต้องใช้ Deep Q-learning ยิ่งไปกว่านั้น เราจะลองสร้างและฝึกอัลกอริทึม Q-learning ตั้งแต่ศูนย์ด้วย Numpy และ Gymnasium

หมายเหตุ: หากเพิ่งเริ่มต้นกับการเรียนรู้ของเครื่อง ขอแนะนำให้เรียน Machine Learning Scientist with Python เพื่อทำความเข้าใจ Reinforcement learning และ Q-Learning ให้ดียิ่งขึ้น

Q-Learning คืออะไร?

Q-learning เป็นอัลกอริทึมแบบไม่พึ่งพาโมเดล (model-free) ที่อิงค่ามูลค่า (value-based) และเป็นแบบ off-policy ซึ่งจะค้นหาลำดับการกระทำที่ดีที่สุดตามสถานะปัจจุบันของตัวแทน ตัวอักษร “Q” ย่อมาจากคุณภาพ (quality) ซึ่งแทนค่าว่าการกระทำนั้นมีคุณค่าเพียงใดในการเพิ่มรางวัลในอนาคตให้สูงสุด

อัลกอริทึมแบบ พึ่งพาโมเดล (model-based) จะใช้อัตราการเปลี่ยนผ่านและฟังก์ชันรางวัลเพื่อประมาณนโยบายที่เหมาะสมและสร้างโมเดล ในทางตรงกันข้าม อัลกอริทึมแบบ ไม่พึ่งพาโมเดล (model-free) จะเรียนรู้ผลของการกระทำจากประสบการณ์ โดยไม่ต้องมีฟังก์ชันการเปลี่ยนผ่านและรางวัล

วิธีแบบ อิงค่า (value-based) จะฝึกฟังก์ชันมูลค่าเพื่อเรียนรู้ว่าสถานะใดมีคุณค่ามากกว่าและควรลงมือทำอย่างไร ขณะที่วิธีแบบ อิงนโยบาย (policy-based) จะฝึกนโยบายโดยตรงเพื่อเรียนรู้ว่าควรทำการกระทำใดในสถานะที่กำหนด

สำหรับแบบ off-policy อัลกอริทึมจะประเมินและอัปเดตนโยบายที่แตกต่างจากนโยบายที่ใช้ในการลงมือทำ ตรงกันข้าม อัลกอริทึมแบบ on-policy จะประเมินและปรับปรุงนโยบายเดียวกับที่ใช้ลงมือทำ

คำศัพท์สำคัญใน Q-learning

ก่อนเข้าสู่การทำงานของ Q-learning เราควรรู้จักคำศัพท์บางคำเพื่อเข้าใจพื้นฐานของ Q-learning

• States(s): ตำแหน่งหรือสถานะปัจจุบันของตัวแทนในสภาพแวดล้อม
• Action(a): ขั้นตอนการกระทำที่ตัวแทนทำในสถานะหนึ่ง ๆ
• Rewards: สำหรับทุกการกระทำ ตัวแทนจะได้รับรางวัลหรือโทษ
• Episodes: การสิ้นสุดด่านที่ตัวแทนไม่สามารถกระทำใหม่ได้ เกิดขึ้นเมื่อบรรลุเป้าหมายหรือพลาด
• Q(S_t+1, a): ค่า Q ที่คาดหวังอย่างเหมาะสมของการทำการกระทำหนึ่งในสถานะที่กำหนด
• Q(S_t, A_t): ค่าโดยประมาณปัจจุบันของ Q(S_t+1, a)
• Q-Table: ตารางที่ตัวแทนเก็บคู่ของสถานะและการกระทำ
• Temporal Differences (TD): ใช้ประมาณค่าที่คาดหวังของ Q(S_t+1, a) โดยอาศัยสถานะและการกระทำปัจจุบันร่วมกับของครั้งก่อน

Q-Learning ทำงานอย่างไร?

เราจะเรียนรู้รายละเอียดการทำงานของ Q-learning ผ่านตัวอย่างทะเลสาบน้ำแข็ง (frozen lake) ในสภาพแวดล้อมนี้ ตัวแทนต้องข้ามทะเลสาบน้ำแข็งจากจุดเริ่มต้นไปยังเป้าหมายโดยไม่ตกลงไปในหลุม กลยุทธ์ที่ดีที่สุดคือไปถึงเป้าหมายด้วยเส้นทางที่สั้นที่สุด

ภาพเคลื่อนไหวโดยผู้เขียน

Q-Table

ตัวแทนจะใช้ Q-table เพื่อเลือกการกระทำที่ดีที่สุดตามรางวัลที่คาดหวังสำหรับแต่ละสถานะในสภาพแวดล้อม กล่าวอย่างง่าย Q-table คือโครงสร้างข้อมูลที่ประกอบด้วยชุดของการกระทำและสถานะ และเราใช้อัลกอริทึม Q-learning เพื่ออัปเดตค่าต่าง ๆ ในตาราง

Q-Function

Q-function ใช้สมการ Bellman โดยรับสถานะ (s) และการกระทำ (a) เป็นอินพุต สมการนี้ช่วยทำให้การคำนวณค่าของสถานะและค่าของคู่สถานะ-การกระทำง่ายขึ้น 

ภาพจาก freecodecamp.org

อัลกอริทึม Q-learning

ภาพโดยผู้เขียน

เริ่มต้น Q-Table

ขั้นแรกเริ่มต้น Q-table โดยกำหนดคอลัมน์ตามจำนวนการกระทำ และแถวตามจำนวนสถานะ

ในตัวอย่างของเรา ตัวละครสามารถเคลื่อนที่ขึ้น ลง ซ้าย และขวา มีการกระทำได้สี่แบบ และมีสี่สถานะ (เริ่มต้น นิ่ง ทางผิด และสิ้นสุด) ทางผิดสามารถตีความได้ว่าเป็นการตกลงไปในหลุม เราจะเริ่มต้น Q-Table ด้วยค่าเป็น 0

ภาพโดยผู้เขียน

เลือกการกระทำ

ขั้นตอนที่สองค่อนข้างง่าย ตอนเริ่มต้น ตัวแทนจะเลือกการกระทำแบบสุ่ม (ลงหรือขวา) และในการรันครั้งต่อไปจะใช้ Q-Table ที่อัปเดตแล้วเพื่อเลือกการกระทำ

ลงมือกระทำ

การเลือกและการลงมือกระทำจะเกิดซ้ำหลายครั้งจนกว่าลูปการฝึกจะหยุด การกระทำและสถานะแรกจะถูกเลือกด้วย Q-Table ซึ่งในกรณีของเรา ค่าทั้งหมดใน Q-Table เป็นศูนย์

จากนั้นตัวแทนจะเคลื่อนที่ลงและอัปเดต Q-Table โดยใช้สมการ Bellman ในทุกครั้งที่เคลื่อนไหว เราจะอัปเดตค่าใน Q-Table และใช้มันในการตัดสินใจเส้นทางที่ดีที่สุด

เริ่มแรกตัวแทนจะอยู่ในโหมดสำรวจและเลือกการกระทำแบบสุ่มเพื่อสำรวจสภาพแวดล้อม Epsilon Greedy Strategy เป็นวิธีง่าย ๆ ในการสร้างสมดุลระหว่างการสำรวจกับการแสวงหาผลประโยชน์ Epsilon แทนความน่าจะเป็นของการเลือกสำรวจ และจะหันไปแสวงหาผลประโยชน์เมื่อโอกาสสำรวจน้อยลง

ตอนเริ่มต้น อัตรา epsilon จะสูง หมายความว่าตัวแทนกำลังสำรวจสภาพแวดล้อม ระหว่างการสำรวจ epsilon จะค่อย ๆ ลดลง และตัวแทนเริ่มแสวงหาผลประโยชน์มากขึ้น ระหว่างการสำรวจ ในทุก ๆ รอบ ตัวแทนจะมั่นใจมากขึ้นในการประมาณค่า Q

ภาพโดยผู้เขียน

ในตัวอย่างทะเลสาบน้ำแข็ง ตัวแทนยังไม่รู้จักสภาพแวดล้อม จึงเริ่มด้วยการกระทำแบบสุ่ม (เคลื่อนที่ลง) ดังที่เห็นในภาพด้านบน Q-Table ถูกอัปเดตด้วยสมการ Bellman

วัดรางวัล

หลังจากลงมือทำแล้ว เราจะวัดผลลัพธ์และรางวัล

• รางวัลเมื่อไปถึงเป้าหมายคือ +1
• รางวัลเมื่อไปทางผิด (ตกหลุม) คือ 0
• รางวัลเมื่อยืนนิ่งหรือเคลื่อนที่บนทะเลสาบน้ำแข็งก็เป็น 0 เช่นกัน

อัปเดต Q-Table

เราจะอัปเดตฟังก์ชัน Q(S_t, A_t) ตามสมการ โดยใช้ค่า Q ที่ประมาณจากรอบก่อน อัตราการเรียนรู้ และค่าคลาดเคลื่อนแบบ Temporal Differences ซึ่งคำนวณจากรางวัลทันที ค่าสูงสุดของรางวัลอนาคตที่คาดหวังแบบมีส่วนลด และค่าประมาณเดิมของ Q

กระบวนการจะทำซ้ำหลายครั้งจน Q-Table ถูกอัปเดตและฟังก์ชัน Q มีค่าสูงสุด

ภาพโดยผู้เขียน | วิชวลสมการโดย Thomas Simonini

ช่วงแรก ตัวแทนจะสำรวจสภาพแวดล้อมเพื่ออัปเดต Q-table และเมื่อ Q-Table พร้อม ตัวแทนจะเริ่มแสวงหาผลประโยชน์และตัดสินใจได้ดีขึ้น 

ภาพโดยผู้เขียน

ในกรณีทะเลสาบน้ำแข็ง ตัวแทนจะเรียนรู้ที่จะใช้เส้นทางที่สั้นที่สุดเพื่อไปถึงเป้าหมายและหลีกเลี่ยงการตกหลุม

บทเรียน Python สำหรับ Q-Learning

ในส่วนนี้ เราจะสร้างโมเดล Q-learning ตั้งแต่ต้นโดยใช้สภาพแวดล้อม Gymnasium, Pygame และ Numpy บทเรียน Python นี้ดัดแปลงจาก Notebook โดย Thomas Simonini ซึ่งครอบคลุมการเริ่มต้นสภาพแวดล้อมและ Q-Table การกำหนดนโยบายแบบ greedy การตั้งค่าพารามิเตอร์ไฮเปอร์ การสร้างและรันลูปการฝึกและการประเมินผล ตลอดจนการแสดงผลลัพธ์

หากมีปัญหาในการสร้างและรันลูปการฝึก สามารถดู ซอร์สโค้ด พร้อมผลลัพธ์ได้

การตั้งค่า

ตั้งค่า Virtual Display

เริ่มจากติดตั้งไลบรารีที่จำเป็นสำหรับสร้างวิดีโอรีเพลย์ (Gif) เราต้องใช้จอเสมือน (pyvirtualdisplay) เพื่อเรนเดอร์สภาพแวดล้อมและบันทึกเฟรม

หมายเหตุ: การใช้ %%capture จะช่วยซ่อนเอาต์พุตของเซลล์ 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()

ติดตั้งไลบรารีที่ต้องใช้

ต่อไปติดตั้งไลบรารีสำหรับสร้าง รัน และประเมินลูปการฝึก

• gymnasium: ใช้เริ่มต้นสภาพแวดล้อม FrozenLake-v1
• pygame: ใช้สำหรับ UI ของ FrozenLake-v1
• numPy: ใช้สร้างและจัดการ Q-table

%%capture
!pip install gymnasium
!pip install pygame
!pip install numpy

!pip install imageio imageio_ffmpeg

นำเข้าแพ็กเกจ

นำเข้าไลบรารีที่ต้องใช้

• Imageio ใช้สำหรับสร้างภาพเคลื่อนไหว
• tqdm ใช้สำหรับแถบสถานะความคืบหน้า

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

สภาพแวดล้อม Frozen lake ใน Gymnasium

เราจะสร้างสภาพแวดล้อม 4x4 ที่ไม่ลื่น โดยใช้ไลบรารี Frozen Lake ของ gymnasium

• มีเวอร์ชันกริดสองแบบคือ “4x4” และ “8x8”
• หาก is_slippery=True ตัวแทนอาจไม่ขยับไปทิศทางที่ตั้งใจเพราะพื้นน้ำแข็งลื่น

หลังจากเริ่มต้นสภาพแวดล้อมแล้ว เราจะวิเคราะห์สภาพแวดล้อม

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

มีพื้นที่สถานะที่ไม่ซ้ำกัน 16 ตำแหน่งในสภาพแวดล้อม ซึ่งจะแสดงแบบสุ่ม

Observation Space Discrete(16)
Sample observation 15

มาดูจำนวนการกระทำและแสดงตัวอย่างการกระทำแบบสุ่มกัน

พื้นที่การกระทำ:

• 0: ไปซ้าย
• 1: ลง
• 2: ขวา
• 3: ขึ้น

ฟังก์ชันรางวัล:

• ไปถึงเป้าหมาย: +1
• ตกหลุม: 0
• อยู่บนพื้นน้ำแข็ง: 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

สร้างและเริ่มต้น Q-table

Q-Table มีคอลัมน์เป็นการกระทำ และแถวเป็นสถานะ เราสามารถใช้ Gymnasium เพื่อดูพื้นที่การกระทำและพื้นที่สถานะ แล้วใช้ข้อมูลนี้สร้าง Q-Table

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

เพื่อเริ่มต้น Q-Table เราจะสร้างอาร์เรย์ Numpy ตามจำนวนสถานะและจำนวนการกระทำ ซึ่งจะได้อาร์เรย์ 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)

นโยบาย epsilon-greedy

ในส่วนก่อนหน้าเราได้เรียนรู้เกี่ยวกับกลยุทธ์ epsilon-greedy ที่ใช้จัดการสมดุลระหว่างการสำรวจกับการแสวงหาผลประโยชน์ โดยมีโอกาส 1 - ɛ สำหรับการแสวงหาผลประโยชน์ และโอกาส ɛ สำหรับการสำรวจ

ในฟังก์ชัน epsilon_greedy_policy เราจะ:

1. สุ่มตัวเลขระหว่าง 0 ถึง 1
2. ถ้าตัวเลขสุ่มมากกว่า epsilon เราจะแสวงหาผลประโยชน์ หมายความว่าตัวแทนจะเลือกการกระทำที่มีค่าสูงสุดในสถานะที่กำหนด
3. มิฉะนั้น จะสำรวจ (เลือกการกระทำแบบสุ่ม)

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

กำหนดนโยบาย greedy

อย่างที่ทราบ Q-learning เป็นอัลกอริทึมแบบ off-policy หมายความว่านโยบายที่ใช้ลงมือทำและนโยบายที่ใช้อัปเดตฟังก์ชันเป็นคนละชุดกัน

ในตัวอย่างนี้ นโยบาย Epsilon Greedy เป็นนโยบายสำหรับการลงมือทำ และนโยบาย Greedy เป็นนโยบายสำหรับการอัปเดต

นอกจากนี้ นโยบาย Greedy ยังเป็นนโยบายสุดท้ายเมื่อฝึกตัวแทนเสร็จสิ้น ใช้เพื่อเลือกค่าที่สูงที่สุดของสถานะและการกระทำจาก Q-Table

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

พารามิเตอร์ไฮเปอร์ของโมเดล

พารามิเตอร์เหล่านี้ใช้ในลูปการฝึก และการจูนที่เหมาะสมจะช่วยให้ได้ผลลัพธ์ที่ดียิ่งขึ้น

ตัวแทนจำเป็นต้องสำรวจพื้นที่สถานะให้เพียงพอเพื่อเรียนรู้การประมาณค่าที่ดี เราจึงต้องปรับลด epsilon แบบค่อยเป็นค่อยไป หากอัตราการลดสูงเกินไป ตัวแทนอาจติดอยู่กับทางออกเดิมเพราะยังสำรวจไม่เพียงพอ

• มี episodes สำหรับการฝึก 10,000 รอบ และสำหรับการประเมิน 100 รอบ
• อัตราการเรียนรู้ คือ 0.7
• เราใช้สภาพแวดล้อม "FrozenLake-v1" โดยจำกัด จำนวนก้าวต่อ episode สูงสุด ที่ 99
• gamma (อัตราคิดลด) คือ 0.95
• eval_seed: ค่า seed สำหรับสภาพแวดล้อมในช่วงประเมิน
• epsilon เริ่มต้นที่ 1.0 และค่าต่ำสุดคือ 0.05
• อัตราการสลายตัวแบบเอ็กซ์โปเนนเชียล ของ epsilon คือ 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           

การฝึกโมเดล

ในลูปการฝึก เราจะ:

1. สร้างลูปสำหรับ episodes การฝึก
2. ลดค่า epsilon ก่อน เพราะในแต่ละ episode ต้องการการสำรวจน้อยลงและแสวงหาผลประโยชน์มากขึ้น
3. รีเซ็ตสภาพแวดล้อม
4. สร้างลูปซ้อนสำหรับจำนวนก้าวสูงสุด
5. เลือกการกระทำด้วยนโยบาย epsilon-greedy
6. ลงมือทำ (A_t) และสังเกตรางวัลที่คาดหวัง (R_t+1) และสถานะ (S_t+1)
7. ทำการกระทำ (a) และสังเกตสถานะผลลัพธ์ (s') และรางวัล (r)
8. อัปเดตฟังก์ชัน Q ตามสูตร
9. ถ้า done= True ให้จบ episode และออกจากลูป
10. สุดท้าย เปลี่ยนสถานะปัจจุบันเป็นสถานะใหม่
11. เมื่อจบ episodes การฝึกทั้งหมด ฟังก์ชันจะคืน Q-Table ที่อัปเดตแล้ว

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

ใช้เวลาประมาณ 3 วินาทีในการฝึก 10,000 episodes

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

จะเห็นได้ว่า Q-Table ที่ฝึกแล้วมีค่า และตัวแทนจะใช้ค่านี้เพื่อนำทางสภาพแวดล้อมและบรรลุเป้าหมาย
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.        ]])
การประเมินผล
ฟังก์ชัน evaluate_agent จะรันเป็นจำนวน n_eval_episodes และคืนค่าเฉลี่ยกับส่วนเบี่ยงเบนมาตรฐานของรางวัล

ในลูป เราจะตรวจสอบก่อนว่ามีค่า evaluation seed หรือไม่ หากไม่มีก็รีเซ็ตสภาพแวดล้อมโดยไม่กำหนด seed
ลูปซ้อนจะรันจนถึง max_steps
ตัวแทนจะเลือกการกระทำที่มีรางวัลอนาคตที่คาดหวังสูงสุดในสถานะที่กำหนด โดยใช้ Q-Table
คำนวณรางวัล
เปลี่ยนสถานะ
หากจบ (ตัวแทนตกหลุมหรือบรรลุเป้าหมาย) ให้ออกจากลูป
บันทึกผลลัพธ์
สุดท้าย ใช้ผลลัพธ์เหล่านี้คำนวณค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐาน

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
ดังที่เห็น เราได้คะแนนสมบูรณ์แบบพร้อมส่วนเบี่ยงเบนมาตรฐานเป็นศูนย์ หมายความว่าตัวแทนบรรลุเป้าหมายครบทั้ง 100 episodes
# 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
การแสดงผลลัพธ์
จนถึงตอนนี้เราเล่นกับตัวเลขเป็นหลัก เพื่อสาธิต เราจะสร้าง Gif แบบภาพเคลื่อนไหวของตัวแทนตั้งแต่เริ่มจนถึงเป้าหมาย

เริ่มจากรีเซ็ตสภาพแวดล้อมด้วยเลขสุ่ม 0–500 เพื่อสร้างสถานะ
เรนเดอร์สภาพแวดล้อมเป็นอาร์เรย์ภาพด้วยโหมด rgb_array
เพิ่ม img ลงในอาร์เรย์ images
ในลูป จะเดินตาม Q-Table และเรนเดอร์ภาพในทุกก้าว
สุดท้าย ใช้อาร์เรย์นี้ร่วมกับ imageio เพื่อสร้าง Gif แบบ 1 เฟรมต่อวินาที

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)
หากใช้งานใน Jupyter notebook สามารถแสดง Gif ด้วยฟังก์ชัน Image ของ 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')
ตอนนี้สามารถแบ่งปันผลลัพธ์เหล่านี้กับเพื่อนร่วมงาน เพื่อนร่วมชั้น หรือโพสต์บนโซเชียลมีเดียได้แล้ว