क्यू-लर्निंग का परिचय: शुरुआती लोगों के लिए ट्यूटोरियल

रिइनफोर्समेंट लर्निंग (RL) मशीन लर्निंग इकोसिस्टम का वह हिस्सा है जहाँ एजेंट लक्ष्य हासिल करने के लिए सर्वोत्तम रणनीति पाने हेतु परिवेश के साथ इंटरैक्ट करके सीखता है। यह सुपरवाइज्ड मशीन लर्निंग एल्गोरिदम से काफी अलग है, जहाँ हमें डेटा इनजेस्ट और प्रोसेस करना पड़ता है। रिइनफोर्समेंट लर्निंग को डेटा की आवश्यकता नहीं होती; यह बेहतर निर्णय लेने के लिए परिवेश और रिवार्ड सिस्टम से सीखती है।

उदाहरण के लिए, मारियो वीडियो गेम में, यदि कोई किरदार कोई रैंडम एक्शन लेता है (जैसे बाएँ जाना), तो उस एक्शन के आधार पर उसे रिवार्ड मिल सकता है। एक्शन लेने के बाद एजेंट (मारियो) एक नई स्टेट में होता है, और यह प्रक्रिया तब तक दोहरती है जब तक गेम कैरेक्टर स्टेज के अंत तक नहीं पहुँच जाता या मर नहीं जाता। 

यह एपिसोड कई बार दोहराया जाएगा जब तक कि मारियो रिवार्ड अधिकतम करके परिवेश में नेविगेट करना न सीख ले। 

छवि: लेखक द्वारा

हम रिइनफोर्समेंट लर्निंग को पाँच सरल चरणों में बाँट सकते हैं:

1. एजेंट किसी परिवेश में स्टेट ज़ीरो पर है।
2. वह किसी विशिष्ट रणनीति के आधार पर एक्शन लेगा।
3. उस एक्शन के आधार पर उसे रिवार्ड या पनिशमेंट मिलेगा।
4. पिछली चालों से सीखकर और रणनीति को ऑप्टिमाइज़ करके। 
5. यह प्रक्रिया तब तक दोहरती है जब तक कोई ऑप्टिमल रणनीति न मिल जाए। 

हमारे ट्यूटोरियल Introduction to Reinforcement Learning को पढ़कर और जानें। आप कोड उदाहरणों के साथ समझेंगे कि रिइनफोर्समेंट लर्निंग कैसे काम करती है। 

इस ट्यूटोरियल में, हम Q-learning के बारे में जानेंगे और समझेंगे कि हमें डीप Q-learning की आवश्यकता क्यों पड़ती है। साथ ही, हम Numpy और Gymnasium का उपयोग करके Q-learning एल्गोरिदम को शुरू से बनाएँगे और ट्रेन करेंगे।

नोट: यदि आप मशीन लर्निंग में नए हैं, तो हम सलाह देंगे कि आप हमारा Machine Learning Scientist with Python करियर ट्रैक लें ताकि रिइनफोर्समेंट लर्निंग और Q-Learning को बेहतर समझ सकें। 

Q-Learning क्या है?

Q-learning एक मॉडल-फ्री, वैल्यू-बेस्ड, ऑफ-पॉलिसी एल्गोरिदम है जो एजेंट की वर्तमान अवस्था के आधार पर एक्शनों की सबसे अच्छी श्रृंखला ढूँढता है। यहाँ “Q” का अर्थ क्वालिटी है। क्वालिटी दर्शाती है कि भविष्य के रिवार्ड को अधिकतम करने में कोई एक्शन कितना मूल्यवान है।  

मॉडल-बेस्ड एल्गोरिदम ट्रांज़िशन और रिवार्ड फ़ंक्शनों का उपयोग करके ऑप्टिमल पॉलिसी का अनुमान लगाते हैं और मॉडल बनाते हैं। इसके विपरीत, मॉडल-फ्री एल्गोरिदम ट्रांज़िशन और रिवार्ड फ़ंक्शन के बिना ही अनुभव से अपने एक्शनों के परिणाम सीखते हैं। 

वैल्यू-बेस्ड पद्धति वैल्यू फ़ंक्शन को ट्रेन करती है ताकि यह सीखा जा सके कि कौन-सी स्टेट अधिक मूल्यवान है और क्या एक्शन लेना है। दूसरी ओर, पॉलिसी-बेस्ड विधियाँ सीधे पॉलिसी को ट्रेन करती हैं ताकि दी गई स्टेट में कौन-सा एक्शन लेना है, यह सीखा जा सके।

ऑफ-पॉलिसी में, एल्गोरिदम उस पॉलिसी का आकलन और अद्यतन करता है जो एक्शन लेने में इस्तेमाल पॉलिसी से भिन्न होती है। इसके विपरीत, ऑन-पॉलिसी एल्गोरिदम उसी पॉलिसी का आकलन और सुधार करता है जिसे एक्शन लेने में उपयोग किया गया है।  

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: एजेंट स्टेट्स और एक्शनों के सेट की Q-टेबल बनाए रखता है।
• Temporal Differences (TD): वर्तमान स्टेट-एक्शन और पूर्ववर्ती स्टेट-एक्शन का उपयोग करके Q(S_t+1, a) के अपेक्षित मान का अनुमान लगाने में प्रयुक्त। 

Q-Learning कैसे काम करती है?

हम एक जमा हुई झील (फ्रोज़न लेक) के उदाहरण से विस्तार से सीखेंगे कि Q-learning कैसे काम करती है। इस परिवेश में, एजेंट को शुरुआत से लक्ष्य तक जमी हुई झील पार करनी है, बिना गड्ढों में गिरे। सबसे अच्छी रणनीति सबसे छोटे रास्ते से लक्ष्य तक पहुँचना है। 

Gif: लेखक द्वारा

Q-Table

एजेंट परिवेश की हर स्टेट के लिए अपेक्षित रिवार्ड के आधार पर सर्वोत्तम संभव एक्शन लेने के लिए Q-टेबल का उपयोग करेगा। सरल शब्दों में, Q-टेबल एक डाटा स्ट्रक्चर है जिसमें एक्शनों और स्टेट्स के सेट होते हैं, और हम टेबल में मानों को अपडेट करने के लिए Q-learning एल्गोरिदम का उपयोग करते हैं। 

Q-Function

Q-फ़ंक्शन बेलमैन समीकरण का उपयोग करता है और इनपुट के रूप में स्टेट(s) और एक्शन(a) लेता है। यह समीकरण स्टेट वैल्यू और स्टेट-एक्शन वैल्यू की गणना को सरल बनाता है। 

छवि स्रोत: freecodecamp.org

Q-learning एल्गोरिदम

छवि: लेखक द्वारा

Q-Table इनिशियलाइज़ करें

हम पहले Q-टेबल को इनिशियलाइज़ करेंगे। टेबल में कॉलम्स एक्शनों की संख्या पर और पंक्तियाँ स्टेट्स की संख्या पर आधारित होंगी।

हमारे उदाहरण में, किरदार ऊपर, नीचे, बाएँ और दाएँ जा सकता है। हमारे पास चार संभावित एक्शन और चार स्टेट्स (start, Idle, wrong path, और end) हैं। आप गलत रास्ते में गड्ढे में गिरने को भी मान सकते हैं। हम Q-टेबल को 0 मानों से इनिशियलाइज़ करेंगे। 

छवि: लेखक द्वारा

एक्शन चुनें

दूसरा चरण काफी सरल है। शुरुआत में एजेंट रैंडम एक्शन (नीचे या दाएँ) लेना चुनेगा, और दूसरी रन पर, वह एक्शन चुनने के लिए अपडेटेड Q-टेबल का उपयोग करेगा। 

एक्शन निष्पादित करें

एक्शन चुनना और उसे निष्पादित करना कई बार दोहराया जाएगा जब तक कि ट्रेनिंग लूप रुक न जाए। पहला एक्शन और स्टेट Q-टेबल का उपयोग करके चुने जाते हैं। हमारे मामले में, Q-टेबल के सभी मान शून्य हैं। 

फिर एजेंट नीचे की ओर बढ़ेगा और बेलमैन समीकरण का उपयोग करके Q-टेबल को अपडेट करेगा। हर चाल के साथ, हम Q-टेबल के मानों को अपडेट करेंगे और सर्वोत्तम कार्यवाही तय करने के लिए उसी का उपयोग करेंगे। 

शुरुआत में एजेंट एक्सप्लोरेशन मोड में होता है और परिवेश का पता लगाने के लिए कोई रैंडम एक्शन चुनता है। एप्सिलन ग्रीडी स्ट्रैटेजी एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन बनाने की एक सरल पद्धति है। एप्सिलन उस प्रायिकता को दर्शाता है जिसके साथ एजेंट एक्सप्लोर करता है, और जब एक्सप्लोर करने की संभावना कम होती है तो एक्सप्लॉइट करता है। 

शुरुआत में एप्सिलन रेट अधिक होता है, यानी एजेंट एक्सप्लोरेशन मोड में होता है। परिवेश की खोज करते समय, एप्सिलन घटता है और एजेंट एक्सप्लॉइट करना शुरू करता है। एक्सप्लोरेशन के दौरान, हर इटरेशन के साथ, एजेंट Q-वैल्यू का अनुमान लगाने में अधिक आत्मविश्वासी होता जाता है।

छवि: लेखक द्वारा

फ्रोज़न लेक के उदाहरण में, एजेंट परिवेश से अनजान है, इसलिए शुरू में वह रैंडम एक्शन (नीचे जाना) लेता है। जैसा कि ऊपर की छवि में देखा जा सकता है, बेलमैन समीकरण का उपयोग करके Q-टेबल अपडेट की जाती है।

रिवार्ड मापना

एक्शन लेने के बाद, हम परिणाम और रिवार्ड को मापेंगे। 

• लक्ष्य तक पहुँचने का रिवार्ड +1 है
• गलत रास्ता लेने (गड्ढे में गिरने) का रिवार्ड 0 है
• Idle रहना या फ्रोज़न लेक पर चलने का रिवार्ड भी 0 है। 

Q-Table अपडेट करें

हम Q(S_t, A_t) फ़ंक्शन को समीकरण का उपयोग करके अपडेट करेंगे। यह पिछले एपिसोड के अनुमानित Q-वैल्यू, लर्निंग रेट और टेम्पोरल डिफरेंसेज़ एरर का उपयोग करता है। टेम्पोरल डिफरेंसेज़ एरर को इमीडिएट रिवार्ड, छूटे हुए (डिस्काउंटेड) अधिकतम अपेक्षित भविष्य के रिवार्ड, और पुराने अनुमानित Q-वैल्यू से गणना किया जाता है। 

यह प्रक्रिया कई बार दोहराई जाती है जब तक Q-टेबल अपडेट न हो जाए और Q-वैल्यू फ़ंक्शन अधिकतम न हो जाए। 

छवि: लेखक द्वारा | समीकरण के विज़ुअल्स: Thomas Simonini

शुरुआत में एजेंट Q-टेबल को अपडेट करने के लिए परिवेश का अन्वेषण कर रहा होता है। और जब Q-टेबल तैयार हो जाती है, तो एजेंट एक्सप्लॉइट करना शुरू करता है और बेहतर निर्णय लेने लगता है। 

छवि: लेखक द्वारा

फ्रोज़न लेक के मामले में, एजेंट लक्ष्य तक पहुँचने के लिए सबसे छोटा रास्ता लेना और गड्ढों में कूदने से बचना सीख लेगा। 

Q-Learning Python ट्यूटोरियल 

इस खंड में, हम Gymnasium परिवेश, Pygame और Numpy का उपयोग करके शुरू से अपना Q-learning मॉडल बनाएँगे। यह Python ट्यूटोरियल Thomas Simonini के Notebook का संशोधित संस्करण है। इसमें परिवेश और Q-टेबल इनिशियलाइज़ करना, ग्रीडी पॉलिसी परिभाषित करना, हाइपरपैरामीटर्स सेट करना, ट्रेनिंग लूप और इवैल्यूएशन बनाना व चलाना, और परिणामों को विज़ुअलाइज़ करना शामिल है।   

यदि आपको अपना ट्रेनिंग लूप बनाने और चलाने में समस्या आ रही है, तो आप आउटपुट सहित कोड स्रोत देख सकते हैं।   

सेटअप

वर्चुअल डिस्प्ले सेटअप करें

हम पहले रिप्ले वीडियो (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: FrozenLake-v1 UI के लिए उपयोग होता है।
• numPy: Q-टेबल बनाने और हैंडल करने के लिए उपयोग होता है।

%%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

फ्रोज़न लेक Gymnasium परिवेश 

हम Frozen Lake gymnasium लाइब्रेरी का उपयोग करके एक नॉन-स्लिपरी 4x4 परिवेश बनाएँगे। 

• दो ग्रिड वर्ज़न हैं, “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-टेबल बनाएँ और इनिशियलाइज़ करें

Q-टेबल में कॉलम्स एक्शन होते हैं और पंक्तियाँ स्टेट्स। हम Gymnasium का उपयोग करके एक्शन स्पेस और स्टेट स्पेस पता कर सकते हैं। फिर हम इस जानकारी का उपयोग 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

Q-टेबल इनिशियलाइज़ करने के लिए, हम state_space और action space का एक 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)

एप्सिलन-ग्रीडी पॉलिसी

पिछले खंड में, हमने एप्सिलन ग्रीडी स्ट्रैटेजी के बारे में सीखा जो एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन संभालती है। प्रायिकता 1 - ɛ के साथ हम एक्सप्लॉइट करते हैं, और प्रायिकता ɛ के साथ हम एक्सप्लोर करते हैं। 

epsilon_greedy_policy में हम:

1. 0 से 1 के बीच रैंडम संख्या जनरेट करेंगे।
2. यदि रैंडम संख्या एप्सिलन से बड़ी है, तो हम एक्सप्लॉइटेशन करेंगे। यानी एजेंट दी गई स्टेट पर सबसे बड़े मान वाला एक्शन लेगा।
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

ग्रीडी पॉलिसी परिभाषित करें

जैसा कि अब हमें पता है, Q-learning एक ऑफ-पॉलिसी एल्गोरिदम है, जिसका अर्थ है कि एक्शन लेने और फ़ंक्शन अपडेट करने की पॉलिसी अलग होती है। 

इस उदाहरण में, Epsilon Greedy पॉलिसी एक्टिंग पॉलिसी है, और Greedy पॉलिसी अपडेटिंग पॉलिसी है। 

एजेंट के ट्रेन होने पर Greedy पॉलिसी ही अंतिम पॉलिसी होगी। यह Q-टेबल से सबसे बड़ा स्टेट और एक्शन मान चुनने के लिए उपयोग होती है।

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

मॉडल हाइपरपैरामीटर्स

ये हाइपरपैरामीटर्स ट्रेनिंग लूप में उपयोग होते हैं, और इन्हें फाइन-ट्यून करने से बेहतर परिणाम मिलेंगे। 

एजेंट को अच्छा वैल्यू एप्रॉक्सिमेशन सीखने के लिए पर्याप्त स्टेट स्पेस का अन्वेषण करना चाहिए; इसलिए हमें एप्सिलन का प्रोग्रेसिव डिके चाहिए। यदि डिके रेट अधिक है, तो एजेंट फँस सकता है क्योंकि उसने पर्याप्त स्टेट स्पेस का अन्वेषण नहीं किया होगा।

• 10,000 ट्रेनिंग और 100 इवैल्यूएशन एपिसोड हैं।
• लर्निंग रेट 0.7 है।
• हम 99 अधिकतम स्टेप प्रति एपिसोड के साथ "FrozenLake-v1" को परिवेश के रूप में उपयोग कर रहे हैं।
• गामा (डिस्काउंट रेट) 0.95 है।
• eval_seed: परिवेश के लिए इवैल्यूएशन सीड।
• शुरुआत में एक्सप्लोरेशन की एप्सिलन प्रायिकता 1.0 है, और न्यूनतम प्रायिकता 0.05 होगी।
• एप्सिलन प्रायिकता के लिए एक्सपोनेंशियल डिके रेट 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. ट्रेनिंग एपिसोड्स के लिए एक लूप बनाएँगे।
2. हम पहले एप्सिलन को घटाएँगे। हर एपिसोड के साथ हमें कम एक्सप्लोरेशन और अधिक एक्सप्लॉइटेशन चाहिए। 
3. परिवेश रीसेट करें।
4. अधिकतम स्टेप्स के लिए एक नेस्टेड लूप बनाएँ।
5. एप्सिलन ग्रीडी पॉलिसी का उपयोग करके एक्शन चुनें। 
6. एक्शन (A_t) लें और अपेक्षित रिवार्ड (R_t+1) और स्टेट (S_t+1) का अवलोकन करें।
7. एक्शन (a) लें और परिणामी स्टेट (s') और रिवार्ड (r) देखें।
8. सूत्र का उपयोग करके Q-फ़ंक्शन अपडेट करें। 
9. यदि done= True है, तो एपिसोड समाप्त करें और लूप तोड़ दें।
10. अंत में, वर्तमान स्टेट को नई स्टेट में बदलें। 
11. सभी ट्रेनिंग एपिसोड्स पूरे होने के बाद, फ़ंक्शन अपडेटेड Q-टेबल लौटाएगा। 

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

10,000 ट्रेनिंग एपिसोड्स पूरे करने में हमें 3 सेकंड लगे। 

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

जैसा कि हम देख सकते हैं, प्रशिक्षित Q-टेबल में मान आ गए हैं, और अब एजेंट इन मानों का उपयोग करके परिवेश में नेविगेट करेगा और लक्ष्य हासिल करेगा।  
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 एपिसोड्स के लिए चलता है और रिवार्ड का औसत और मानक विचलन लौटाता है। 

लूप में, हम पहले जाँचेंगे कि कोई इवैल्यूएशन सीड है या नहीं। यदि नहीं, तो हम बिना सीड के परिवेश रीसेट करेंगे। 
नेस्टेड लूप max_steps तक चलेगा।
एजेंट Q-टेबल का उपयोग करके दी गई स्टेट में अधिकतम अपेक्षित भविष्य के रिवार्ड वाला एक्शन लेगा। 
रिवार्ड की गणना करें।
स्टेट बदलें।
यदि done (एजेंट गड्ढे में गिर गया या लक्ष्य प्राप्त हो गया), तो लूप तोड़ दें।
परिणाम जोड़ें।
अंत में, हम औसत और मानक विचलन की गणना के लिए इन परिणामों का उपयोग करेंगे। 

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 एपिसोड्स में लक्ष्य हासिल किया है। 
# 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 की रैंडम पूर्णांक के साथ परिवेश रीसेट करके स्टेट बनाएँगे। 
rdb_array का उपयोग करके परिवेश को रेंडर करें और इमेज ऐरे बनाएँ। 
फिर img को images ऐरे में जोड़ें। 
लूप में, हम Q-टेबल का उपयोग करके स्टेप लेंगे और हर स्टेप के लिए इमेज रेंडर करेंगे। 
अंत में, हम इस ऐरे और imageio का उपयोग करके प्रति सेकंड एक फ़्रेम वाला Gif बनाएँगे। 

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 नोटबुक में हैं, तो आप IPython.display की Image फ़ंक्शन का उपयोग करके Gif प्रदर्शित कर सकते हैं। 
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')
अब आप इन परिणामों को अपने सहकर्मियों और सहपाठियों के साथ साझा कर सकते हैं या सोशल मीडिया पर पोस्ट कर सकते हैं।