# บทนำสู่การเรียนรู้แบบเสริมกำลังและ Q-Learning

![สรุปการเสริมกำลังในแมชชีนเลิร์นนิงในรูปแบบสเก็ตช์โน้ต](../../../../translated_images/th/ml-reinforcement.94024374d63348db.webp)
> สเก็ตช์โน้ตโดย [Tomomi Imura](https://www.twitter.com/girlie_mac)

การเรียนรู้แบบเสริมกำลังเกี่ยวข้องกับแนวคิดสำคัญสามอย่าง: ตัวแทน, สถานะบางอย่าง, และชุดของการกระทำในแต่ละสถานะ โดยการทำการกระทำในสถานะที่ระบุ ตัวแทนจะได้รับรางวัล ลองจินตนาการถึงเกมคอมพิวเตอร์ Super Mario คุณคือตัวมาริโอ คุณอยู่ในเลเวลเกม กำลังยืนอยู่ขอบหน้าผา เหนือคุณเป็นเหรียญ คุณในฐานะมาริโอ ในเลเวลเกม ในตำแหน่งเฉพาะ ... นั่นคือสถานะของคุณ การเคลื่อนที่หนึ่งก้าวไปทางขวา (การกระทำ) จะทำให้คุณตกหน้าผา และนั่นจะทำให้ได้คะแนนตัวเลขต่ำ อย่างไรก็ตาม การกดปุ่มกระโดดจะทำให้คุณได้คะแนนและอยู่รอดได้ นั่นคือผลลัพธ์เชิงบวกและควรได้รับคะแนนตัวเลขบวก

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

[![บทนำสู่ Reinforcement Learning](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)

> 🎥 คลิกที่ภาพด้านบนเพื่อฟัง Dmitry พูดคุยเกี่ยวกับ Reinforcement Learning

## [แบบทดสอบก่อนบรรยาย](https://ff-quizzes.netlify.app/en/ml/)

## ข้อกำหนดเบื้องต้นและการตั้งค่า

ในบทเรียนนี้ เราจะทดลองกับโค้ดในภาษา Python คุณควรจะสามารถรันโค้ด Jupyter Notebook จากบทเรียนนี้ได้ ไม่ว่าจะบนคอมพิวเตอร์ของคุณหรือที่ไหนสักแห่งในระบบคลาวด์

คุณสามารถเปิด [สมุดบันทึกบทเรียน](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) และเดินตามบทเรียนนี้เพื่อสร้างขึ้น

> **หมายเหตุ:** หากคุณเปิดโค้ดนี้จากคลาวด์ คุณจะต้องดาวน์โหลดไฟล์ [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) ด้วย ซึ่งใช้ในโค้ดสมุดบันทึก เพิ่มไฟล์นี้ในไดเรกทอรีเดียวกับสมุดบันทึก

## บทนำ

ในบทเรียนนี้ เราจะสำรวจโลกของ **[ปีเตอร์และหมาป่า](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** ได้รับแรงบันดาลใจจากนิทานเพลงโดยคีตกวีชาวรัสเซีย [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev) เราจะใช้ **การเรียนรู้แบบเสริมกำลัง** เพื่อให้ปีเตอร์สำรวจสภาพแวดล้อมของเขา เก็บแอปเปิ้ลอร่อย ๆ และหลีกเลี่ยงการพบหมาป่า

**การเรียนรู้แบบเสริมกำลัง** (RL) เป็นเทคนิคการเรียนรู้ที่ช่วยให้เราเรียนรู้พฤติกรรมที่เหมาะสมที่สุดของ **ตัวแทน** ใน **สภาพแวดล้อม** โดยการทดลองซ้ำหลายครั้ง ตัวแทนในสภาพแวดล้อมนี้ควรมี **เป้าหมาย** ซึ่งกำหนดโดย **ฟังก์ชันรางวัล**

## สภาพแวดล้อม

เพื่อความเรียบง่าย ให้พิจารณาว่าโลกของปีเตอร์เป็นกระดานสี่เหลี่ยมขนาด `width` x `height` ดังนี้:

![สภาพแวดล้อมของปีเตอร์](../../../../translated_images/th/environment.40ba3cb66256c93f.webp)

เซลล์แต่ละช่องในกระดานนี้อาจเป็น:

* **พื้นดิน** ที่ปีเตอร์และสิ่งมีชีวิตอื่น ๆ สามารถเดินได้
* **น้ำ** ซึ่งแน่นอนไม่สามารถเดินได้
* **ต้นไม้** หรือ **หญ้า** สถานที่ที่คุณสามารถพักผ่อน
* **แอปเปิ้ล** ซึ่งเป็นสิ่งที่ปีเตอร์จะดีใจหากพบเพื่อเลี้ยงตัวเอง
* **หมาป่า** ซึ่งอันตรายและควรหลีกเลี่ยง

มีโมดูล Python แยกต่างหาก [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) ซึ่งมีโค้ดสำหรับทำงานกับสภาพแวดล้อมนี้ เนื่องจากโค้ดนี้ไม่สำคัญสำหรับการเข้าใจแนวคิดของเรา เราจะนำเข้าโมดูลและใช้เพื่อสร้างกระดานตัวอย่าง (โค้ดบล็อก 1):

```python
from rlboard import *

width, height = 8,8
m = Board(width,height)
m.randomize(seed=13)
m.plot()
```

โค้ดนี้จะแสดงภาพของสภาพแวดล้อมที่คล้ายกับภาพด้านบน

## การกระทำและนโยบาย

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

ดังนั้น ในตำแหน่งใด ๆ เขาสามารถเลือกทำหนึ่งในปฏิบัติการต่อไปนี้: ขึ้น, ลง, ซ้าย และขวา

เราจะกำหนดการกระทำเหล่านั้นเป็นพจนานุกรม และแม็ปกับคู่ของการเปลี่ยนแปลงพิกัดที่สอดคล้องกัน เช่น การเคลื่อนไปทางขวา (`R`) จะสอดคล้องกับคู่ `(1,0)` (โค้ดบล็อก 2):

```python
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
action_idx = { a : i for i,a in enumerate(actions.keys()) }
```

สรุปแล้ว ยุทธศาสตร์และเป้าหมายของสถานการณ์นี้คือ:

- **ยุทธศาสตร์** ของตัวแทนของเรา (ปีเตอร์) ถูกกำหนดโดยที่เรียกว่า **นโยบาย** นโยบายเป็นฟังก์ชันที่คืนการกระทำ ณ สถานะใดสถานะหนึ่ง ในกรณีของเรา สถานะของปัญหาคือการแสดงผลโดยกระดาน รวมถึงตำแหน่งปัจจุบันของผู้เล่น

- **เป้าหมาย** ของการเรียนรู้แบบเสริมกำลังคือการเรียนรู้นโยบายที่ดีในที่สุดที่จะช่วยให้เราแก้ปัญหาได้อย่างมีประสิทธิภาพ อย่างไรก็ตาม ในฐานะฐานข้อมูล ลองพิจารณานโยบายที่ง่ายที่สุดที่เรียกว่า **การเดินแบบสุ่ม**

## การเดินแบบสุ่ม

มาลองแก้ปัญหาของเราด้วยการใช้ยุทธศาสตร์เดินแบบสุ่มก่อน ด้วยการเดินแบบสุ่ม เราจะเลือกการกระทำถัดไปแบบสุ่มจากการกระทำที่อนุญาต จนกว่าจะถึงแอปเปิ้ล (โค้ดบล็อก 3)

1. เขียนโค้ดเดินแบบสุ่มโดยใช้โค้ดด้านล่าง:

    ```python
    def random_policy(m):
        return random.choice(list(actions))
    
    def walk(m,policy,start_position=None):
        n = 0 # จำนวนก้าว
        # ตั้งค่าตำแหน่งเริ่มต้น
        if start_position:
            m.human = start_position 
        else:
            m.random_start()
        while True:
            if m.at() == Board.Cell.apple:
                return n # สำเร็จ!
            if m.at() in [Board.Cell.wolf, Board.Cell.water]:
                return -1 # ถูกหมาป่ากินหรือจมน้ำ
            while True:
                a = actions[policy(m)]
                new_pos = m.move_pos(m.human,a)
                if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
                    m.move(a) # ทำการเคลื่อนไหวจริง
                    break
            n+=1
    
    walk(m,random_policy)
    ```

    การเรียกใช้ `walk` ควรคืนค่าความยาวของเส้นทางที่สอดคล้อง ซึ่งอาจแตกต่างกันไปในแต่ละการรัน

1. รันการทดลองเดินนี้จำนวนหลายครั้ง (เช่น 100 ครั้ง) และแสดงสถิติที่ได้ (โค้ดบล็อก 4):

    ```python
    def print_statistics(policy):
        s,w,n = 0,0,0
        for _ in range(100):
            z = walk(m,policy)
            if z<0:
                w+=1
            else:
                s += z
                n += 1
        print(f"Average path length = {s/n}, eaten by wolf: {w} times")
    
    print_statistics(random_policy)
    ```

    สังเกตว่าความยาวเฉลี่ยของเส้นทางอยู่ที่ประมาณ 30-40 ก้าว ซึ่งค่อนข้างมาก เมื่อเทียบกับระยะทางเฉลี่ยไปยังแอปเปิ้ลที่ใกล้ที่สุดซึ่งอยู่ราว 5-6 ก้าว

    คุณยังสามารถเห็นการเคลื่อนที่ของปีเตอร์ในระหว่างการเดินแบบสุ่ม:

    ![การเดินแบบสุ่มของปีเตอร์](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)

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

เพื่อทำให้นโยบายของเราฉลาดยิ่งขึ้น เราจำเป็นต้องเข้าใจว่าการเคลื่อนไหวใด "ดีกว่า" อื่น ๆ ในการทำเช่นนี้ เราจำเป็นต้องกำหนดเป้าหมายของเรา

เป้าหมายสามารถกำหนดได้ในรูปแบบของ **ฟังก์ชันรางวัล** ซึ่งจะคืนค่าคะแนนสำหรับแต่ละสถานะ จำนวนที่สูงกว่าจะหมายถึงฟังก์ชันรางวัลที่ดีกว่า (โค้ดบล็อก 5)

```python
move_reward = -0.1
goal_reward = 10
end_reward = -10

def reward(m,pos=None):
    pos = pos or m.human
    if not m.is_valid(pos):
        return end_reward
    x = m.at(pos)
    if x==Board.Cell.water or x == Board.Cell.wolf:
        return end_reward
    if x==Board.Cell.apple:
        return goal_reward
    return move_reward
```

สิ่งที่น่าสนใจเกี่ยวกับฟังก์ชันรางวัลก็คือ ในหลายกรณี *เราจะได้รับรางวัลสำคัญก็ต่อเมื่อสิ้นสุดเกมเท่านั้น* ซึ่งหมายความว่าอัลกอริธึมของเราควรจะจำขั้นตอน "ดี" ที่นำไปสู่รางวัลบวกในตอนท้าย และเพิ่มความสำคัญของมัน ในทำนองเดียวกัน การเคลื่อนไหวที่นำไปสู่ผลลัพธ์ไม่ดีควรถูกลดความสำคัญ

## Q-Learning

อัลกอริธึมที่เราจะพูดถึงที่นี่เรียกว่า **Q-Learning** ในอัลกอริธึมนี้ นโยบายจะถูกกำหนดโดยฟังก์ชัน (หรืองานโครงสร้างข้อมูล)ที่เรียกว่า **Q-Table** ซึ่งบันทึกความ "ดี" ของแต่ละการกระทำในสถานะที่กำหนด

เรียกว่า Q-Table เพราะสะดวกที่จะนำเสนอเป็นตาราง หรืออาเรย์หลายมิติ เนื่องจากกระดานของเรามีขนาด `width` x `height` เราจึงสามารถแทน Q-Table ด้วยอาเรย์ numpy ที่มีรูปร่าง `width` x `height` x `len(actions)`: (โค้ดบล็อก 6)

```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```

สังเกตว่าเราเริ่มต้นค่า Q-Table ทั้งหมดที่ค่าเท่ากัน ในกรณีของเราคือ 0.25 ซึ่งสอดคล้องกับนโยบาย "เดินแบบสุ่ม" เพราะทุกการเคลื่อนไหวในแต่ละสถานะดีเท่ากัน เราสามารถส่ง Q-Table ไปยังฟังก์ชัน `plot` เพื่อแสดงภาพตารางบนกระดาน: `m.plot(Q)`

![สภาพแวดล้อมของปีเตอร์](../../../../translated_images/th/env_init.04e8f26d2d60089e.webp)

ตรงกลางของแต่ละเซลล์มี "ลูกศร" ที่ชี้ทิศทางการเคลื่อนที่ที่ต้องการ เนื่องจากทิศทางทั้งหมดเท่ากัน จึงแสดงเป็นจุด

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

## ประสบการณ์ของ Q-Learning: สมการเบลล์แมน

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

> จำไว้ว่า ไม่ใช่ผลลัพธ์ทันทีที่สำคัญ แต่เป็นผลลัพธ์สุดท้ายที่เราจะได้รับเมื่อจบการจำลอง

เพื่อคำนึงถึงรางวัลล่าช้านี้ เราต้องใช้หลักการของ **[การเขียนโปรแกรมแบบไดนามิก](https://en.wikipedia.org/wiki/Dynamic_programming)** ซึ่งช่วยให้เราคิดปัญหาเชิงเรียกซ้ำ

สมมติว่าเรากำลังอยู่ที่สถานะ *s* และเราต้องการย้ายไปสถานะถัดไป *s'* การทำเช่นนี้ เราจะได้รับรางวัลทันที *r(s,a)* ซึ่งกำหนดโดยฟังก์ชันรางวัล รวมทั้งรางวัลในอนาคต ถ้าเราสมมติว่า Q-Table ของเราสะท้อนถึงความ "น่าสนใจ" ของแต่ละการกระทำอย่างถูกต้อง ณ สถานะ *s'* เราจะเลือกการกระทำ *a* ที่มีค่าสูงสุดของ *Q(s',a')* ดังนั้น รางวัลในอนาคตที่ดีที่สุดที่เราจะได้รับที่สถานะ *s* จะถูกนิยามเป็น `max`<sub>a'</sub>*Q(s',a')* (max ที่นี่คำนวณจากการกระทำทั้งหมด *a'* ที่สถานะ *s'*)

นี่คือ **สูตรเบลล์แมน** สำหรับคำนวณค่าของ Q-Table ที่สถานะ *s* โดยให้การกระทำ *a*:

<img src="../../../../translated_images/th/bellman-equation.7c0c4c722e5a6b7c.webp"/>

ที่นี่ γ คือที่เรียกว่า **discount factor** ซึ่งกำหนดว่าคุณควรจะชอบรางวัลปัจจุบันมากกว่ารางวัลในอนาคตมากแค่ไหน หรือในทางกลับกัน

## อัลกอริธึมการเรียนรู้

จากสมการด้านบน เราสามารถเขียนโค้ดเทียมสำหรับอัลกอริธึมการเรียนรู้ของเราได้ดังนี้:

* เริ่มต้น Q-Table Q ด้วยตัวเลขเท่ากันสำหรับทุกสถานะและการกระทำ
* ตั้งอัตราการเรียนรู้ α ← 1
* ทำซ้ำการจำลองหลายครั้ง
   1. เริ่มต้นที่ตำแหน่งสุ่ม
   1. ทำซ้ำ
        1. เลือกการกระทำ *a* ณ สถานะ *s*
        2. ทำการกระทำโดยย้ายไปยังสถานะใหม่ *s'*
        3. หากพบเงื่อนไขจบเกม หรือรางวัลรวมต่ำมาก - ออกจากการจำลอง  
        4. คำนวณรางวัล *r* ที่สถานะใหม่
        5. ปรับปรุงฟังก์ชัน Q ตามสมการเบลล์แมน: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
        6. *s* ← *s'*
        7. ปรับปรุงรางวัลรวมและลดค่า α

## การใช้ประโยชน์กับการสำรวจ

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

ดังนั้น วิธีที่ดีที่สุดคือการหาสมดุลระหว่างการสำรวจและการใช้ประโยชน์ สามารถทำได้โดยการเลือกการกระทำที่สถานะ *s* ด้วยความน่าจะเป็นที่สัดส่วนกับค่าต่าง ๆ ใน Q-Table ในตอนแรก เมื่อค่าของ Q-Table ทั้งหมดเท่ากัน จะสอดคล้องกับการเลือกแบบสุ่ม แต่เมื่อเราเรียนรู้ข้อมูลเพิ่มเติมเกี่ยวกับสภาพแวดล้อม เราจะมีแนวโน้มที่จะเลือกเส้นทางที่เหมาะสมที่สุดในขณะที่ยังอนุญาตให้ตัวแทนเลือกเส้นทางที่ยังไม่เคยสำรวจเป็นบางครั้ง

## การสร้างใน Python

ตอนนี้เราพร้อมที่จะดำเนินการอัลกอริธึมการเรียนรู้ได้แล้ว ก่อนอื่นเราต้องมีฟังก์ชันที่จะแปลงตัวเลขใด ๆ ใน Q-Table ให้เป็นเวกเตอร์ของความน่าจะเป็นสำหรับการกระทำที่สอดคล้องกัน

1. สร้างฟังก์ชัน `probs()`:

    ```python
    def probs(v,eps=1e-4):
        v = v-v.min()+eps
        v = v/v.sum()
        return v
    ```

    เราเพิ่ม `eps` เล็กน้อยในเวกเตอร์ดั้งเดิมเพื่อหลีกเลี่ยงการหารด้วยศูนย์ในกรณีเริ่มต้น ที่ส่วนประกอบทั้งหมดของเวกเตอร์เหมือนกัน

รันอัลกอริธึมการเรียนรู้ผ่านการทดลอง 5000 รอบ ซึ่งเรียกว่า **epochs**: (โค้ดบล็อก 8)
```python
    for epoch in range(5000):
    
        # เลือกจุดเริ่มต้น
        m.random_start()
        
        # เริ่มเดินทาง
        n=0
        cum_reward = 0
        while True:
            x,y = m.human
            v = probs(Q[x,y])
            a = random.choices(list(actions),weights=v)[0]
            dpos = actions[a]
            m.move(dpos,check_correctness=False) # เราอนุญาตให้ผู้เล่นเคลื่อนที่ออกนอกกระดาน ซึ่งจะทำให้ตอนนั้นสิ้นสุดลง
            r = reward(m)
            cum_reward += r
            if r==end_reward or cum_reward < -1000:
                lpath.append(n)
                break
            alpha = np.exp(-n / 10e5)
            gamma = 0.5
            ai = action_idx[a]
            Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
            n+=1
```

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

<img src="../../../../translated_images/th/learned.ed28bcd8484b5287.webp"/>

## การตรวจสอบนโยบาย

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

```python
def qpolicy_strict(m):
        x,y = m.human
        v = probs(Q[x,y])
        a = list(actions)[np.argmax(v)]
        return a

walk(m,qpolicy_strict)
```


> หากคุณลองรันโค้ดข้างต้นหลายครั้ง คุณอาจสังเกตเห็นว่า บางครั้งมัน "ค้าง" และคุณต้องกดปุ่ม STOP ในโน้ตบุ๊กเพื่อหยุด นั่นเกิดขึ้นเพราะอาจมีสถานการณ์ที่สองสถานะ "ชี้" ไปยังซึ่งกันและกันในแง่ของค่าที่เหมาะสมของ Q-Value ซึ่งในกรณีนี้เอเย่นต์จะเคลื่อนที่ไปมาระหว่างสถานะนั้น ๆ โดยไม่สิ้นสุด

## 🚀ความท้าทาย

> **งานที่ 1:** ปรับฟังก์ชัน `walk` เพื่อจำกัดความยาวเส้นทางสูงสุดตามจำนวนขั้นตอนที่กำหนด (เช่น 100 ขั้นตอน) และสังเกตว่าโค้ดข้างต้นจะคืนค่านี้เป็นครั้งคราว

> **งานที่ 2:** ปรับฟังก์ชัน `walk` เพื่อไม่ให้กลับไปยังสถานที่ที่เคยไปแล้วก่อนหน้า วิธีนี้จะป้องกันไม่ให้ `walk` หมุนวนซ้ำ ๆ แม้กระนั้น เอเย่นต์ยังอาจติดอยู่ในตำแหน่งที่ไม่สามารถหลบหนีได้

## การนำทาง

นโยบายการนำทางที่ดีกว่าคือนโยบายที่เราใช้ในระหว่างการฝึกสอน ซึ่งผสมผสานทั้งการใช้ประโยชน์กับการสำรวจ ในนโยบายนี้ เราจะเลือกแต่ละการกระทำด้วยความน่าจะเป็นบางประการ สอดคล้องกับค่าที่อยู่ใน Q-Table กลยุทธ์นี้อาจทำให้เอเย่นต์ย้อนกลับไปยังตำแหน่งที่ได้สำรวจไปแล้ว แต่ตามที่เห็นจากโค้ดด้านล่าง จะเห็นได้ว่าให้เส้นทางเฉลี่ยที่สั้นมากไปยังตำแหน่งที่ต้องการ (อย่าลืมว่า `print_statistics` รันการจำลอง 100 ครั้ง): (โค้ดบล็อก 10)

```python
def qpolicy(m):
        x,y = m.human
        v = probs(Q[x,y])
        a = random.choices(list(actions),weights=v)[0]
        return a

print_statistics(qpolicy)
```

หลังจากรันโค้ดนี้ คุณควรจะได้ค่าเฉลี่ยความยาวเส้นทางที่สั้นกว่ามากในช่วง 3-6

## การสืบสวนกระบวนการเรียนรู้

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

<img src="../../../../translated_images/th/lpathlen1.0534784add58d4eb.webp"/>

สามารถสรุปการเรียนรู้ได้ดังนี้:

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

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

- **ความยาวเพิ่มขึ้นอย่างรวดเร็ว** สิ่งที่สังเกตอีกอย่างในกราฟนี้คือในบางช่วงความยาวเส้นทางเพิ่มขึ้นอย่างฉับพลัน ซึ่งบ่งชี้ถึงลักษณะสโตแคสติกของกระบวนการ และว่าเราอาจจะ "เสีย" ค่าสัมประสิทธิ์ใน Q-Table โดยการเขียนทับด้วยค่าที่ใหม่ แนะนำให้ลดผลกระทบนี้โดยลดอัตราการเรียนรู้ (เช่น ในช่วงท้ายของการฝึก เราจะปรับค่าใน Q-Table ด้วยค่าน้อย ๆ เท่านั้น)

โดยรวมแล้ว สิ่งสำคัญคือการจำไว้ว่า ความสำเร็จและคุณภาพของกระบวนการเรียนรู้นั้นขึ้นอยู่กับพารามิเตอร์ต่าง ๆ เช่น อัตราการเรียนรู้ การลดอัตราการเรียนรู้ และปัจจัยลดค่า พารามิเตอร์เหล่านี้มักถูกเรียกว่า **hyperparameters** เพื่อแยกแยะจาก **parameters** ซึ่งเราเพิ่มประสิทธิภาพในระหว่างการฝึก (เช่น ค่าสัมประสิทธิ์ Q-Table) กระบวนการค้นหาค่าที่ดีที่สุดสำหรับ hyperparameters เรียกว่า **hyperparameter optimization** และเป็นหัวข้อที่ควรแยกพูดถึง

## [แบบทดสอบหลังบรรยาย](https://ff-quizzes.netlify.app/en/ml/)

## การบ้าน
[โลกที่สมจริงมากขึ้น](assignment.md)

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ปฏิเสธความรับผิดชอบ**:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้
<!-- CO-OP TRANSLATOR DISCLAIMER END -->