Q Learning: สิ่งที่คุณต้องรู้เกี่ยวกับ Reinforcement Learning

และ เป็นโดเมนไม่กี่แห่งที่อยู่ในกลุ่มคำที่นิยมมากที่สุดในอุตสาหกรรมและด้วยเหตุผลที่ดี AI กำลังจะสร้างงาน 2.3 ล้านตำแหน่งภายในปี 2020 โดยพิจารณาจากเป้าหมายหลักคือการทำให้เครื่องจักรสามารถเลียนแบบพฤติกรรมของมนุษย์ได้ แปลกไม่ใช่เหรอ ดังนั้นวันนี้เราจะพูดถึง Q Learning ซึ่งเป็นส่วนประกอบของการเรียนรู้แบบเสริมแรงตามลำดับต่อไปนี้:

• Reinforcement Learning คืออะไร?
• กระบวนการ Q-Learning
• สมการเบลล์แมน
• กระบวนการตัดสินใจของ Markov
• Q-Learning Demo: NumPy

Reinforcement Learning คืออะไร?

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

วิธีใช้ชุดใน java

ประเด็นสำคัญที่น่าสนใจ:

• สิ่งแวดล้อม
• หนังบู๊
• รางวัล
• สถานะ

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

กระบวนการ Q-Learning

มาทำความเข้าใจว่า Q กำลังเรียนรู้อะไรด้วยคำชี้แจงปัญหาของเราที่นี่ จะช่วยให้เรากำหนดองค์ประกอบหลักของโซลูชันการเรียนรู้แบบเสริมแรงเช่นตัวแทนสิ่งแวดล้อมการกระทำรางวัลและสถานะ

การเปรียบเทียบโรงงานรถยนต์:

เราอยู่ที่โรงงานผลิตรถยนต์ที่เต็มไปด้วยหุ่นยนต์ หุ่นยนต์เหล่านี้ช่วยคนงานในโรงงานด้วยการลำเลียงชิ้นส่วนที่จำเป็นในการประกอบรถ ชิ้นส่วนต่างๆเหล่านี้ตั้งอยู่ตามสถานที่ต่างๆภายในโรงงานจำนวน 9 สถานี ชิ้นส่วนประกอบด้วยแชสซีล้อแดชบอร์ดเครื่องยนต์และอื่น ๆ Factory Master ได้จัดลำดับความสำคัญของตำแหน่งที่จะติดตั้งแชสซีเป็นลำดับความสำคัญสูงสุด มาดูการตั้งค่าที่นี่:

รัฐ:

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

การดำเนินการ:

การกระทำไม่ใช่อะไรนอกจากการเคลื่อนไหวของหุ่นยนต์ไปยังสถานที่ใด ๆ ลองพิจารณาหุ่นยนต์อยู่ที่ตำแหน่ง L2 และตำแหน่งโดยตรงที่มันเคลื่อนที่ได้คือ L5, L1 และ L3 มาทำความเข้าใจกันให้ดีขึ้นหากเราเห็นภาพสิ่งนี้:

รางวัล:

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

โปรดจำไว้ว่าเมื่อใดที่ Factory Master จัดลำดับความสำคัญของตำแหน่งแชสซี มันคือ L7 ดังนั้นเราจะรวมข้อเท็จจริงนี้ไว้ในตารางรางวัลของเรา ดังนั้นเราจะกำหนดตัวเลขจำนวนมาก (999 ในกรณีของเรา) ในตำแหน่ง (L7, L7)

สมการเบลล์แมน

ตอนนี้สมมติว่าหุ่นยนต์ต้องไปจากจุด A ถึง B มันจะเลือกเส้นทางที่จะให้รางวัลเชิงบวก สำหรับสิ่งนั้นสมมติว่าเราให้รางวัลในแง่ของการปฏิบัติตาม

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

V (s) = สูงสุด (R (s, a) + & # 120632V (s '))

ที่ไหน:

• s = สถานะเฉพาะ
• a = การกระทำ
• s '= สถานะที่หุ่นยนต์ไปจาก s
• & # 120632 = ปัจจัยส่วนลด
• R (s, a) = ฟังก์ชันรางวัลซึ่งรับสถานะและการกระทำ (a) และแสดงผลมูลค่ารางวัล
• V (s) = ค่าของการอยู่ในสถานะเฉพาะ

ตอนนี้บล็อกด้านล่างปลายทางจะมีรางวัล 1 ซึ่งเป็นรางวัลสูงสุด แต่บล็อกอื่น ๆ ล่ะ? นี่คือที่มาของปัจจัยส่วนลดสมมติว่าปัจจัยส่วนลดเป็น 0.9 และเติมบล็อกทั้งหมดทีละบล็อก

กระบวนการตัดสินใจของ Markov

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

ดังนั้นเราจึงต้องปรับเปลี่ยนกระบวนการตัดสินใจ มันต้อง สุ่มบางส่วน และ บางส่วนอยู่ภายใต้การควบคุมของหุ่นยนต์ . ส่วนหนึ่งเป็นการสุ่มเนื่องจากเราไม่รู้ว่าเมื่อใดที่หุ่นยนต์จะทำงานผิดปกติและบางส่วนอยู่ภายใต้การควบคุมเนื่องจากหุ่นยนต์ยังคงเป็นตัวตัดสินของหุ่นยนต์ และนี่เป็นฐานสำหรับกระบวนการตัดสินใจของ Markov

กระบวนการตัดสินใจของ Markov (MDP) เป็นกระบวนการควบคุมสุ่มเวลาที่ไม่ต่อเนื่อง เป็นกรอบทางคณิตศาสตร์สำหรับการสร้างแบบจำลองการตัดสินใจในสถานการณ์ที่ผลลัพธ์เป็นแบบสุ่มบางส่วนและบางส่วนอยู่ภายใต้การควบคุมของผู้มีอำนาจตัดสินใจ

ดังนั้นเราจะใช้สมการเบลล์แมนดั้งเดิมของเราและทำการเปลี่ยนแปลงมัน สิ่งที่เราไม่รู้คือชาติหน้าเช่น s ’. สิ่งที่เรารู้คือความเป็นไปได้ทั้งหมดของเทิร์นและมาเปลี่ยนสมการกัน

วิธีทำพลังใน python

V (s) = สูงสุด (R (s, a) + & # 120632 V (s '))

V (s) = สูงสุด (R (s, a) + & # 120632 & ซิก_{s ’}P (s, a, s ') V (s '))

P (s, a, s '): ความน่าจะเป็นของการย้ายจากรัฐ เอส ถึง s ’ ด้วยการกระทำ ถึง

& ซิก_{s ’}P (s, a, s ') V (s '): ความคาดหวังในการสุ่มของหุ่นยนต์

V (s) = สูงสุด (R (s, a) + & # 120632 ((0.8V (ห้อง_ขึ้น)) + (0.1V (ห้อง_ลง) + ….))

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

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

Q (s, a) = (R (s, a) + & # 120632 & ซิก_{s ’}P (s, a, s ') V (s '))

วิธีใช้คนตัดไม้ใน java

ในสมการที่ระบุปริมาณคุณภาพของการกระทำนี้เราสามารถสันนิษฐานได้ว่า V คือค่าสูงสุดของค่า Q (s, a) ที่เป็นไปได้ทั้งหมด งั้นเรามาแทนที่ v (s ’) ด้วยฟังก์ชันของ Q ()

Q (s, a) = (R (s, a) + & # 120632 & ซิก_{s ’}P (s, a, s ') สูงสุด Q (s ’, a’))

เราอยู่ใกล้กับ Equation of Q Learning ขั้นสุดท้าย เราจะมาแนะนำ ความแตกต่างชั่วคราว เพื่อคำนวณค่า Q เกี่ยวกับการเปลี่ยนแปลงของสภาพแวดล้อมเมื่อเวลาผ่านไป แต่เราจะสังเกตการเปลี่ยนแปลงของ Q ได้อย่างไร?

TD (s, a) = (R (s, a) + & # 120632 & ซิก_{s ’}P (s, a, s ') สูงสุด Q (s ’, a’)) - Q (s, a)

เราคำนวณ Q ใหม่ใหม่ด้วยสูตรเดียวกันและลบ Q (s, a) ที่รู้จักก่อนหน้านี้ออก ดังนั้นสมการข้างต้นจึงกลายเป็น:

ถาม_t(s, a) = Q_t-1(s, a) + α TD_t(s, a)

ถาม_t(s, a) = ค่า Q ปัจจุบัน

ถาม_t-1(s, a) = ค่า Q ก่อนหน้า

ถาม_t(s, a) = Q_t-1(s, a) + α (R (s, a) + & # 120632 สูงสุด Q (s ’, a’)_-ถาม_t-1(s, a))

Q Learning Demo: NumPy

ฉันจะใช้ NumPy เพื่อสาธิตวิธีการทำงานของ Q Learning

ขั้นตอนที่ 1: การนำเข้าพารามิเตอร์สถานะการดำเนินการและรางวัล

นำเข้า numpy เป็น np gamma = 0.75 # ปัจจัยส่วนลด alpha = 0.9 # อัตราการเรียนรู้ location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} การกระทำ = [0,1,2,3,4,5,6,7,8] รางวัล = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,0,1,0]])

ขั้นตอนที่ 2: แมปดัชนีกับสถานที่

state_to_location = dict ((state, location) สำหรับตำแหน่ง, สถานะใน location_to_state.items ())

ขั้นตอนที่ 3: รับเส้นทางที่เหมาะสมที่สุดโดยใช้กระบวนการเรียนรู้ Q

def get_optimal_route (start_location, end_location): reward_new = np.copy (รางวัล) end_state = location_to_state [end_location] รางวัล _new [end_state, end_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- กระบวนการเรียนรู้สำหรับ i ในช่วง (1000): # การเลือกสถานะสุ่ม current_state = np.random.randint (0,9) # Python ไม่รวม playable_actions ขอบเขตบน = [] # วนซ้ำเมทริกซ์รางวัลใหม่สำหรับ j ในช่วง ( 9): if reward_new [current_state, j]> 0: playable_actions.append (j) # เลือกการกระทำแบบสุ่มที่จะนำเราไปสู่สถานะถัดไป next_state = np.random.choice (playable_actions) # Computing Temporal Difference TD = Rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # การอัปเดต Q-Value โดยใช้สมการ Bellman Q [current_state, next_state] + = alpha * TD # เริ่มต้นเส้นทางที่เหมาะสมที่สุดด้วยเส้นทางตำแหน่งเริ่มต้น = [start_location] #Initialize next_location ด้วยตำแหน่งเริ่มต้น next_location = star t_location # เราไม่รู้เกี่ยวกับจำนวนการทำซ้ำที่แน่นอนที่จำเป็นเพื่อไปยังตำแหน่งสุดท้ายดังนั้นในขณะที่การวนซ้ำจะเป็นทางเลือกที่ดีสำหรับการทำซ้ำในขณะที่ (next_location! = end_location): # ดึงสถานะเริ่มต้น start_state = location_to_state [start_location] # ดึงค่า Q สูงสุดที่เกี่ยวข้องกับสถานะเริ่มต้น next_state = np.argmax (Q [start_state,]) # เราได้ดัชนีของสถานะถัดไป แต่เราต้องการตัวอักษรที่ตรงกัน next_location = state_to_location [next_state] route.append (next_location) # อัปเดตตำแหน่งเริ่มต้นสำหรับการวนซ้ำครั้งถัดไป start_location = next_location return route

ขั้นตอนที่ 4: พิมพ์เส้นทาง

พิมพ์ (get_optimal_route ('L1', 'L9'))

เอาท์พุต:

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

Edureka’s ทำให้คุณมีความเชี่ยวชาญในเทคนิคต่างๆเช่นการเรียนรู้ภายใต้การดูแลการเรียนรู้ที่ไม่มีผู้ดูแลและการประมวลผลภาษาธรรมชาติ รวมถึงการฝึกอบรมเกี่ยวกับความก้าวหน้าล่าสุดและแนวทางทางเทคนิคในปัญญาประดิษฐ์และการเรียนรู้ของเครื่องเช่นการเรียนรู้เชิงลึกแบบจำลองกราฟิกและการเรียนรู้แบบเสริมกำลัง