ML-For-Beginners/translations/bn/8-Reinforcement/2-Gym

কার্টপোল স্কেটিং

আমরা যা সমস্যা আগের পাঠে সমাধান করেছিলাম তা হয়তো একটি খেলনা সমস্যা মনে হতে পারে, বাস্তব জীবনের পরিস্থিতিতে খুব একটা প্রযোজ্য নয়। কিন্তু তা নয়, কারণ অনেক বাস্তব জগতের সমস্যা এই পরিস্থিতির সাথে মিল আছে - যেমন দাবা বা গো খেলা। এগুলো একই রকম কারণ আমাদেরও একটি বোর্ড এবং নির্ধারিত নিয়ম আছে এবং একটি বিচ্ছিন্ন অবস্থা।

পাঠ পূর্ববর্তী কুইজ

পরিচিতি

এই পাঠে আমরা Q-লার্নিংয়ের একই নীতিগুলো একটি অবিচ্ছিন্ন অবস্থা বিশিষ্ট সমস্যায় প্রয়োগ করব, অর্থাৎ এমন একটি অবস্থা যা এক বা একাধিক বাস্তব সংখ্যার দ্বারা নির্ধারিত। আমরা নিম্নলিখিত সমস্যার সাথে যুক্ত হব:

সমস্যা: যদি পিটার নেকড়ে থেকে পালাতে চায়, তাকে দ্রুত গতিতে চলতে জানতে হবে। আমরা দেখব পিটার কীভাবে স্কেট শিখতে পারে, বিশেষত, কীভাবে ভারসাম্য বজায় রাখতে পারে, Q-লার্নিং ব্যবহার করে।

পিটার এবং তার বন্ধুরা নেকড়ে থেকে পালানোর জন্য সৃজনশীল হচ্ছে! ছবি: জেন লুপার

আমরা ভারসাম্য বজায় রাখার একটি সরলীকৃত সংস্করণ ব্যবহার করব, যা কার্টপোল সমস্যা নামে পরিচিত। কার্টপোল জগতে, আমাদের একটি অনুভূমিক স্লাইডার আছে যা বাঁয়ে বা ডানে সরতে পারে, এবং লক্ষ হল স্লাইডারের উপরে একটি উল্লম্ব খুঁটি ভারসাম্য বজায় রাখা।

পূর্ব-প্রয়োজনীয়তা

এই পাঠে, আমরা OpenAI Gym নামে একটি লাইব্রেরি ব্যবহার করব বিভিন্ন পরিবেশ অনুকরণ করতে। আপনি এই পাঠের কোড স্থানীয়ভাবে (যেমন Visual Studio Code থেকে) চালাতে পারেন, যেটাতে সিমুলেশন একটি নতুন উইন্ডোতে খুলবে। অনলাইনে কোড চালানোর সময় কিছু সামঞ্জস্য প্রয়োজন হতে পারে, যেমন এখানে বর্ণিত এখানে।

OpenAI Gym

পূর্ববর্তী পাঠে, আমরা গেমের নিয়ম এবং অবস্থা নিজস্ব সংজ্ঞায়িত Board ক্লাস দ্বারা দিয়েছিলাম। এখানে আমরা একটি বিশেষ সিমুলেশন পরিবেশ ব্যবহার করব, যা ভারসাম্যপূর্ণ খুটির পিছনে ফিজিক্স অনুকরণ করবে। প্রশিক্ষণের জন্য সবচেয়ে জনপ্রিয় সিমুলেশন পরিবেশগুলোর মধ্যে একটি হল Gym, যা OpenAI দ্বারা রক্ষণাবেক্ষণ করা হয়। এই জিম ব্যবহার করে আমরা কার্টপোল সিমুলেশন থেকে অ্যাটারি গেম পর্যন্ত বিভিন্ন পরিবেশ তৈরি করতে পারি।

দ্রষ্টব্য: OpenAI Gym থেকে উপলব্ধ অন্যান্য পরিবেশগুলি আপনি দেখতে পারেন এখানে।

প্রথমে, চলুন জিম ইনস্টল করি এবং প্রয়োজনীয় লাইব্রেরিগুলো আমদানি করি (কোড ব্লক ১):

import sys
!{sys.executable} -m pip install gym 

import gym
import matplotlib.pyplot as plt
import numpy as np
import random

অনুশীলন - একটি কার্টপোল পরিবেশ initialized করুন

কার্টপোল ভারসাম্য সমস্যা নিয়ে কাজ করতে হলে আমাদের সংশ্লিষ্ট পরিবেশটি initialized করতে হবে। প্রতিটি পরিবেশ একটি নিম্নলিখিত গুণাবলীর সাথে যুক্ত:

• পর্যবেক্ষণ স্থান যা পরিবেশ থেকে প্রাপ্ত তথ্যের গঠন নির্ধারণ করে। কার্টপোল সমস্যায় আমরা খুটির অবস্থান, গতি এবং কিছু অন্যান্য মান পেয়ে থাকি।

• ক্রিয়াকলাপ স্থান যা সম্ভাব্য ক্রিয়াকলাপ নির্ধারণ করে। আমাদের ক্ষেত্রে, ক্রিয়াকলাপ স্থান বিভক্ত এবং দুটি ক্রিয়াকলাপ নিয়ে গঠিত - বাঁয়ে এবং ডানে। (কোড ব্লক ২)

১. initialized করতে নিচের কোডটি টাইপ করুন:

```python
env = gym.make("CartPole-v1")
print(env.action_space)
print(env.observation_space)
print(env.action_space.sample())
```

পরিবেশটি কিভাবে কাজ করছে তা দেখতে, আসুন ১০০ ধাপের একটি সংক্ষিপ্ত সিমুলেশন চালাই। প্রতিটি ধাপে, আমরা যে একটি ক্রিয়াকলাপ নেওয়ার কথা সেটি প্রদান করি - এই সিমুলেশনে আমরা শুধু এলোমেলো ভাবে একটি ক্রিয়াকলাপ action_space থেকে বেছে নিলে।

১. নিচের কোডটি চালান এবং দেখুন এর ফলাফল কী হয়।

✅ মনে রাখবেন, স্থানীয় পাইথন ইনস্টলেশনে এটি চালানোই সর্বোত্তম! (কোড ব্লক ৩)

```python
env.reset()

for i in range(100):
   env.render()
   env.step(env.action_space.sample())
env.close()
```

আপনি কিছু এরকম ছবি দেখতে পাবেন:

![ভারসাম্যহীন কার্টপোল](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)

১. সিমুলেশন চলাকালে, আমাদের পর্যবেক্ষণ পেতে হবে যাতে সিদ্ধান্ত নেওয়া যায় কীভাবে কাজ করতে হবে। আসলে, step ফাংশন বর্তমান পর্যবেক্ষণ, একটি পুরস্কার ফাংশন, এবং একটি ডন ফ্ল্যাগ (যা নির্দেশ করে সিমুলেশন চালিয়ে যাওয়া উচিত কিনা) প্রদান করে: (কোড ব্লক ৪)

```python
env.reset()

done = False
while not done:
   env.render()
   obs, rew, done, info = env.step(env.action_space.sample())
   print(f"{obs} -> {rew}")
env.close()
```

আপনি নতুনালে আউটপুটে কিছু এরকম দেখতে পাবেন:

```text
[ 0.03403272 -0.24301182  0.02669811  0.2895829 ] -> 1.0
[ 0.02917248 -0.04828055  0.03248977  0.00543839] -> 1.0
[ 0.02820687  0.14636075  0.03259854 -0.27681916] -> 1.0
[ 0.03113408  0.34100283  0.02706215 -0.55904489] -> 1.0
[ 0.03795414  0.53573468  0.01588125 -0.84308041] -> 1.0
...
[ 0.17299878  0.15868546 -0.20754175 -0.55975453] -> 1.0
[ 0.17617249  0.35602306 -0.21873684 -0.90998894] -> 1.0
```

প্রতিটি সিমুলেশনের ধাপে ফেরত দেওয়া পর্যবেক্ষণ ভেক্টরে নিম্নলিখিত মান থাকে:
- কার্টের অবস্থান
- কার্টের গতি
- খুটির কোণ
- খুটির ঘূর্ণন হার

১. সেই সংখ্যাগুলোর সর্বনিম্ন এবং সর্বোচ্চ মান পান: (কোড ব্লক ৫)

```python
print(env.observation_space.low)
print(env.observation_space.high)
```

আপনি লক্ষ্য করবেন প্রতিটি সিমুলেশন ধাপে পুরস্কার মান সর্বদা ১। কারণ আমাদের লক্ষ্য যত দিন সম্ভব বেঁচে থাকা, অর্থাৎ খুটিকে যথাযথ উল্লম্ব অবস্থায় দীর্ঘ সময় ধরে রাখা।

✅ আসলে, কার্টপোল সিমুলেশন সমাধান করা হয়েছে বলে গণ্য হয় যদি আমরা ১০০ ধারাবাহিক চেষ্টা জুড়ে গড় পুরস্কার ১৯৫ বা তার বেশি পাই।

অবস্থা বিচ্ছিন্নকরণ

Q-লার্নিং-এ, আমাদের একটি Q-টেবিল তৈরি করতে হবে যা প্রতিটি অবস্থায় কী করতে হবে তা নির্ধারণ করে। এটি করার জন্য, আমাদের অবস্থা বিচ্ছিন্ন হতে হবে, অর্থাৎ নির্দিষ্ট সংখ্যক বিচ্ছিন্ন মান থাকা উচিত। তাই আমাদের পর্যবেক্ষণ গুলোকে বিচ্ছিন্নকরণ করতে হবে, অর্থাৎ সেগুলোকে একটি সীমাবদ্ধ সংখ্যা অবস্থা বা স্টেটে রূপান্তর করতে হবে।

আমরা এটি করার কয়েকটি উপায় আছে:

• বিনে ভাগ করা। যদি আমরা একটি নির্দিষ্ট মানের সীমা জানি, তাহলে আমরা সেই সীমাকে অনেকগুলো বিন এ ভাগ করতে পারি, এবং মানটিকে সেই বিন নম্বর দিয়ে প্রতিস্থাপন করতে পারি যেখানে তা পড়ে। এটি numpy এর digitize পদ্ধতি ব্যবহার করে করা যায়। এই ক্ষেত্রে, আমরা অবস্থা আকার নির্দিষ্টভাবে জানব, কারণ তা নির্ভর করবে কতগুলো বিন ব্যবহার করেছি তার উপর।

✅ আমরা লিনিয়ার ইন্টারপোলেশন ব্যবহার করে মানগুলোকে একটি সীমাবদ্ধ অন্তরালে (ধরি, -২০ থেকে ২০) নিয়ে যেতে পারি, এবং তারপর রাউন্ড করে পূর্ণসংখ্যায় রূপান্তর করতে পারি। এটি অবস্থা আকারে কম নিয়ন্ত্রণ দেয়, বিশেষ করে ইনপুট মানগুলোর সঠিক সীমা জানা না থাকলে। যেমন আমাদের ক্ষেত্রে ৪ মানের মধ্যে ২টির মানের উর্ধ্ব বা নিম্ন সীমা নির্ধারিত নয়, যার ফলে অবস্থা সংখ্যাই অসীম হতে পারে।

আমাদের উদাহরণে, আমরা দ্বিতীয় পদ্ধতিটি গ্রহণ করব। আপনি পরে লক্ষ্য করবেন, যেখানে উর্ধ্ব/নিম্ন সীমা নির্ধারিত নেই সেখানে মানগুলি বিরলভাবে সীমাবদ্ধটির বাইরে যায়, তাই চরম মানের অবস্থা খুব কমই হবে।

১. এখানে একটি ফাংশন যা আমাদের মডেল থেকে পর্যবেক্ষণ নিয়ে ৪টি পূর্ণসংখ্যার টিউপল তৈরি করবে: (কোড ব্লক ৬)

```python
def discretize(x):
    return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
```

১. অন্য একটি বিন-ভিত্তিক বিচ্ছিন্নকরণ পদ্ধতি পরীক্ষা করা যাক: (কোড ব্লক ৭)

```python
def create_bins(i,num):
    return np.arange(num+1)*(i[1]-i[0])/num+i[0]

print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))

ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # প্রতিটি প্যারামিটারের জন্য মানের অন্তরগুলো
nbins = [20,20,10,10] # প্রতিটি প্যারামিটারের জন্য বিনের সংখ্যা
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]

def discretize_bins(x):
    return tuple(np.digitize(x[i],bins[i]) for i in range(4))
```

১. এখন একটি সংক্ষিপ্ত সিমুলেশন চালিয়ে ঐ বিচ্ছিন্ন পরিবেশের মান পর্যবেক্ষণ করি। আপনি চাইলে উভয় discretize ও discretize_bins চেষ্টা করতে পারেন এবং পার্থক্য দেখতে পারেন।

✅ `discretize_bins` বিন নম্বর প্রদান করে, যা ০-ভিত্তিক। তাই ইনপুট ভেরিয়েবলের মান ০ এর আশেপাশে হলে এটি অন্তরের মাঝের নম্বর (১০) দেয়। `discretize` তে, আমরা আউটপুট মানের সীমার ব্যাপারে চিন্তিত ছিলাম না, তাই মান নেতিবাচকও হতে পারে, ফলে অবস্থা মান স্থানান্তর হয়নি এবং ০ এর মান ০ই।

```python
env.reset()

done = False
while not done:
   #env.render()
   obs, rew, done, info = env.step(env.action_space.sample())
   #print(discretize_bins(obs))
   print(discretize(obs))
env.close()
```

✅ আপনি যদি দেখতে চান পরিবেশ কিভাবে কাজ করে, তাহলে `env.render` দিয়ে শুরু হওয়া লাইনের মন্তব্য তুলে দিন। না হলে আপনি এটিকে পেছনে চলতে দিবেন, যা দ্রুত হয়। আমরা Q-লার্নিং প্রক্রিয়ায় এই "অদৃশ্য" কার্যকরকরণ ব্যবহার করব।

Q-টেবিল কাঠামো

পূর্ববর্তী পাঠে, অবস্থা ছিল সরল ০ থেকে ৮ পর্যন্ত জোড় সংখ্যার, তাই Q-টেবিল উপযুক্ত ছিল numpy টেনসর দ্বারা আকার ৮x৮x২ যেখানে ৮x৮ অবস্থা এবং ২ অ্যাকশনের সংখ্যা। বিন-ভিত্তিক বিচ্ছিন্নকরণ করলে অবস্থা ভেক্টরের আকারও জানা থাকবে, তাই আমরা একই পদ্ধতি ব্যবহার করতে পারি এবং অবস্থা উপস্থাপন করতে পারি একটি অ্যারেতে যার আকার ২০x২০x১০x১০x২ (এখানে ২ অ্যাকশন স্পেসের মাত্রা, এবং প্রথম মাত্রাগুলো বিনের সংখ্যা যা আমরা প্রতিটি পর্যবেক্ষণ প্যারামিটারের জন্য নির্বাচন করেছি)।

কিন্তু কখনো কখনো পর্যবেক্ষণ স্পেসের সঠিক মাত্রা জানা যায় না। discretize ফাংশনের ক্ষেত্রে, আমরা কখনো নিশ্চিত হতে পারি না আমাদের অবস্থা নির্দিষ্ট সীমার মধ্যে থাকবে, কারণ কিছু মানের কোন সীমা নেই। তাই আমরা সামান্য ভিন্ন পদ্ধতি ব্যবহার করব এবং Q-টেবিলকে একটি ডিকশনারি দ্বারা উপস্থাপন করব।

১. (state, action) জোড়াটিকে ডিকশনারির কী হিসেবে ব্যবহার করুন, এবং মান হবে সেই Q-টেবিলের এন্ট্রি মান। (কোড ব্লক ৯)

```python
Q = {}
actions = (0,1)

def qvalues(state):
    return [Q.get((state,a),0) for a in actions]
```

এখানে আমরা একটি ফাংশন `qvalues()` সংজ্ঞায়িত করেছি, যা একটি নির্দিষ্ট অবস্থার জন্য সমস্ত সম্ভাব্য অ্যাকশনের Q-টেবিল মানের একটি তালিকা প্রদান করে। যদি Q-টেবিলে এন্ট্রি না থাকে, আমরা ডিফল্ট হিসেবে ০ ফেরত দেব।

চলুন Q-লার্নিং শুরু করি

এখন আমরা পিটারকে ভারসাম্য শিখাতে প্রস্তুত!

১. প্রথমে, কিছু হাইপারপ্যারামিটার সেট করি: (কোড ব্লক ১০)

```python
# হাইপারপ্যারামিটারসমূহ
alpha = 0.3
gamma = 0.9
epsilon = 0.90
```

এখানে, `alpha` হলো **লার্নিং রেট** যা প্রতিটি ধাপে Q-টেবিলের বর্তমান মান কতটুকু সামঞ্জস্য করতে হবে তা নির্ধারণ করে। পূর্ববর্তী পাঠে আমরা ১ দিয়ে শুরু করেছিলাম এবং প্রশিক্ষণের সময় ধীরে ধীরে `alpha` কমিয়েছিলাম। এই উদাহরণে, আমরা সহজতার জন্য এটিকে ধ্রুবক রাখব, এবং আপনি পরে `alpha` মান পরিবর্তন করে পরীক্ষা করতে পারেন।

`gamma` হলো **ডিসকাউন্ট ফ্যাক্টর** যা দেখায় ভবিষ্যতের পুরস্কার বর্তমান পুরস্কারের তুলনায় কতটা গুরুত্ব পাবে।

`epsilon` হলো **এক্সপ্লোরেশন/এক্সপ্লাইটেশন ফ্যাক্টর** যা নির্ধারণ করে আমরা অনুসন্ধান (explore) করব না শোষণ (exploit) করব। আমাদের অ্যালগরিদমে, `epsilon` শতাংশ সময় আমরা Q-টেবিল অনুসারে পরবর্তী অ্যাকশন নির্বাচন করব, আর বাকি সময় এলোমেলো অ্যাকশন চালাব। এটি আমাদের আগে কখনো না দেখা অনুসন্ধান অঞ্চলগুলি পরীক্ষা করার সুযোগ দেবে।

✅ ভারসাম্যের ক্ষেত্রে - এলোমেলো পদক্ষেপ (exploration) হবে ভুল দিকের একটি হঠাৎ ধাক্কা, যেখান থেকে খুটিকে শেখা লাগবে কিভাবে ভারসাম্য পুনরুদ্ধার করতে হয়।

অ্যালগরিদম উন্নত করুন

আমরা পূর্ববর্তী পাঠের থেকে আমাদের অ্যালগরিদমে দুটি উন্নতি করতে পারি:

• গড় সম্মিলিত পুরস্কার হিসাব করুন, অনেক সিমুলেশনের উপর। আমরা প্রতিটি ৫০০০ পুনরাবৃত্তিতে অগ্রগতি মুদ্রণ করব, এবং ঐ সময়কালের মধ্যে গড় সম্মিলিত পুরস্কার হিসাব করব। অর্থাৎ যদি আমরা ১৯৫ এর বেশি পেয়ে থাকি, আমরা সমস্যাটি সমাধান বলে বিবেচনা করতে পারব যা প্রয়োজনীয়তার থেকেও ভালো।

• সর্বোচ্চ গড় সম্মিলিত ফলাফলের হিসাব, Qmax, এবং সেই ফলাফলের জন্য Q-টেবিল সংরক্ষণ করব। যখন আপনি প্রশিক্ষণ চালাবেন, দেখতে পাবেন মাঝে মাঝে গড় সম্মিলিত ফলাফল কমতে শুরু করে, এবং আমরা সেই Q-টেবিল মান রাখতে চাই যা প্রশিক্ষণের সর্বোত্তম মডেলের সাথে মিলে।

১. প্রতিটি সিমুলেশনের সম্মিলিত পুরস্কার rewards ভেক্টরে সংগ্রহ করুন পরবর্তী প্লটিং-এর জন্য। (কোড ব্লক ১১)

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

Qmax = 0
cum_rewards = []
rewards = []
for epoch in range(100000):
    obs = env.reset()
    done = False
    cum_reward=0
    # == সিমুলেশন চালান ==
    while not done:
        s = discretize(obs)
        if random.random()<epsilon:
            # শোষণ - Q-টেবিলের সম্ভাবনা অনুযায়ী কার্য নির্বাচন করুন
            v = probs(np.array(qvalues(s)))
            a = random.choices(actions,weights=v)[0]
        else:
            # অনুসন্ধান - এলোমেলোভাবে কার্য নির্বাচন করুন
            a = np.random.randint(env.action_space.n)

        obs, rew, done, info = env.step(a)
        cum_reward+=rew
        ns = discretize(obs)
        Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
    cum_rewards.append(cum_reward)
    rewards.append(cum_reward)
    # == নিয়মিত ফলাফল মুদ্রণ করুন এবং গড় পুরস্কার গণনা করুন ==
    if epoch%5000==0:
        print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
        if np.average(cum_rewards) > Qmax:
            Qmax = np.average(cum_rewards)
            Qbest = Q
        cum_rewards=[]
```

আপনি যে ফলাফলগুলো দেখতে পারেন তা হলো:

• লক্ষ্যের খুব কাছাকাছি। আমরা ১৯৫ সম্মিলিত পুরস্কার ১০০ ধারাবাহিক সিমুলেশনের মধ্যে পাওয়ার লক্ষ্য খুব কাছাকাছি বা হয়তো ইতিমধ্যেই অর্জিত! যদিও ছোট মান আসে, আমরা নিশ্চিত নই কারণ আমরা ৫০০০ এর উপর গড় করছি, এবং আনুষ্ঠানিক শর্তে শুধুমাত্র ১০০ রান প্রয়োজন।

• পুরস্কার কমতে শুরু। মাঝে মাঝে পুরস্কার কমতে পারে, অর্থাৎ আমরা Q-টেবিলে ইতিমধ্যে শেখা মানগুলো ভয়ানক মান দিয়ে "ধ্বংস" করতে পারি।

এই পর্যবেক্ষণটা স্পষ্ট হয় যদি আমরা প্রশিক্ষণের অগ্রগতি প্লট করি।

প্রশিক্ষণের অগ্রগতি প্লট করা

প্রশিক্ষণের সময়, আমরা প্রতিটি পুনরাবৃত্তিতে সম্মিলিত পুরস্কার rewards ভেক্টরে সংগ্রহ করেছি। এটি পুনরাবৃত্তি সংখ্যার বিপরীতে প্লট করলে এরূপ দেখা যায়:

plt.plot(rewards)

এই গ্রাফ থেকে কিছুই বলা যায় না, কারণ স্টোকাস্টিক প্রশিক্ষণ প্রক্রিয়ার প্রকৃতির কারণে সেশনগুলোর দৈর্ঘ্য অনেক ভিন্ন। এতে আরো অর্থ আনতে, আমরা একটি নির্দিষ্ট পরিসরের গড় বের করতে পারি, বলে নিই ১০০। এটা np.convolve ব্যবহার করে সহজে করা যায়: (কোড ব্লক ১২)

def running_average(x,window):
    return np.convolve(x,np.ones(window)/window,mode='valid')

plt.plot(running_average(rewards,100))

হাইপারপ্যারামিটার পরিবর্তন

শেখাকে আরো স্থিতিশীল করতে, প্রশিক্ষণের সময় কিছু হাইপারপ্যারামিটার সামঞ্জস্য করা বুদ্ধিমানের কাজ। বিশেষ করে:

• লার্নিং রেট alpha এর জন্য, আমরা সম্ভবত ১ এর কাছাকাছি মান দিয়ে শুরু করব, তারপর ধীরে ধীরে কমাব। সময়ের সঙ্গে Q-টেবিলের মান ভাল সম্ভাবনা পাবে, তাই আমরা ছোটখাটো পরিবর্তন করব এবং পুরোপুরি নতুন মান দেওয়া থেকে বিরত থাকব।

• epsilon বাড়ানো। আমরা epsilon ধীরে ধীরে বাড়াতে চাইব, যাতে কম অনুসন্ধান হয় এবং বেশি শোষণ। সম্ভবত শুরুতে epsilon কম রাখব এবং ধীরে ধীরে ১ এর কাছাকাছি নিয়ে যাব।

কাজ ১: হাইপারপ্যারামিটার মান নিয়ে পরীক্ষা চালান এবং দেখুন আপনি কি উচ্চ সম্মিলিত পুরস্কার পেতে পারেন। আপনি কি ১৯৫ এর উপরে পৌঁছাতে পারছেন?

কাজ ২: সমস্যাটি আনুষ্ঠানিকভাবে সমাধান করতে, আপনাকে ১০০ ধারাবাহিক চালানোর উপর গড়ে ১৯৫ পুরস্কার পেতে হবে। প্রশিক্ষণের সময় এটি মাপুন এবং নিশ্চিত করুন যে আপনি আনুষ্ঠানিকভাবে সমস্যাটি সমাধান করেছেন!

ফলাফল কার্যকরভাবে দেখা

প্রকৃতপক্ষে প্রশিক্ষিত মডেলটি কীভাবে আচরণ করে তা দেখা আকর্ষণীয় হবে। চলুন সিমুলেশন চালাই এবং প্রশিক্ষণের সময় যেমন ছিল তেমনই Q-টেবিলের সম্ভাব্যতা বিতরণের অনুযায়ী নমুনা নিয়ে একই ক্রিয়া নির্বাচন কৌশল অনুসরণ করি: (কোড ব্লক ১৩)

obs = env.reset()
done = False
while not done:
   s = discretize(obs)
   env.render()
   v = probs(np.array(qvalues(s)))
   a = random.choices(actions,weights=v)[0]
   obs,_,done,_ = env.step(a)
env.close()

আপনি এরকম কিছু দেখতে পাবেন:

---

🚀চ্যালেঞ্জ

কাজ ৩: এখানে, আমরা শেষ কপি Q-টেবিল ব্যবহার করছিলাম, যা হয়তো সেরা নয়। মনে রাখবেন আমরা সেরা পারফর্ম করা Q-টেবিলটি Qbest ভেরিয়েবলে সংরক্ষণ করেছি! একই উদাহরণ সেরা পারফর্ম করা Q-টেবিল ব্যবহার করে চেষ্টা করুন, Qbest থেকে Q তে কপি করে এবং দেখুন পার্থক্য লক্ষ্য করছেন কিনা।

কাজ ৪: এখানে আমরা প্রতিটি ধাপে সেরা ক্রিয়া নির্বাচন করছিলাম না, বরং সংশ্লিষ্ট সম্ভাব্যতা বিতরণের মাধ্যমে নমুনা নিচ্ছিলাম। সর্বদা সর্বোচ্চ Q-টেবিল মানের ক্রিয়াটি নির্বাচন করা কি আরও যুক্তিযুক্ত হবে? এটি np.argmax ফাংশন ব্যবহার করে করা যায় যা সর্বোচ্চ Q-টেবিল মানের সাথে সংশ্লিষ্ট ক্রিয়ার নম্বর বের করে। এই কৌশলটি বাস্তবায়ন করুন এবং দেখুন এটি ব্যালান্সিং উন্নত করছে কিনা।

পোস্ট-লেকচার কুইজ

অ্যাসাইনমেন্ট

একটি মাউন্টেন কার প্রশিক্ষণ দিন

উপসংহার

আমরা এখন শিখেছি কীভাবে একটি অ্যাজেন্টকে একটি পুরস্কার ফাংশন দিয়ে প্রশিক্ষণ দেওয়া যায় যা গেমের কাঙ্ক্ষিত অবস্থাটি নির্ধারণ করে এবং তাদের বুদ্ধিমত্তার সাথে অনুসন্ধান স্থান অন্বেষণ করার সুযোগ দেয়। আমরা সফলভাবে Q-লার্নিং অ্যালগরিদম প্রয়োগ করেছি ডিসক্রিট এবং ধারাবাহিক পরিবেশের ক্ষেত্রে, তবে ডিসক্রিট ক্রিয়াগুলির সাথে।

এটি গুরুত্বপূর্ণ যে আমরা এমন পরিস্থিতিও অধ্যয়ন করি যেখানে ক্রিয়া ক্ষেত্রও ধারাবাহিক, এবং পর্যবেক্ষণের ক্ষেত্র অনেক বেশি জটিল, যেমন এটারি গেম স্ক্রিন থেকে চিত্র। সেই সমস্যাগুলিতে ভাল ফলাফল অর্জনের জন্য প্রায়শই আরও শক্তিশালী মেশিন লার্নিং কৌশল ব্যবহার করতে হয়, যেমন নিউরাল নেটওয়ার্ক। এই আরও উন্নত বিষয়গুলি আমাদের আগামের আরও উন্নত AI কোर्सের বিষয়বস্তু।

---

অস্বীকৃতি: এই নথিটি AI অনুবাদ পরিষেবা Co-op Translator ব্যবহার করে অনূদিত হয়েছে। যদিও আমরা শুদ্ধতার জন্য চেষ্টা করি, অনুগ্রহ করে মনে রাখবেন যে স্বয়ংক্রিয় অনুবাদে ত্রুটি বা অসঙ্গতি থাকতে পারে। মূল নথিটি তার স্বভাষায় কর্তৃত্বপূর্ণ উৎস হিসেবে বিবেচিত হওয়া উচিত। গুরুত্বপূর্ণ তথ্যের জন্য পেশাদার মানব অনুবাদ সুপারিশ করা হয়। এই অনুবাদের ব্যবহারে প্রয়োজনীয় ভুল বোঝাবুঝি বা ভুল ব্যাখ্যার জন্য আমরা দায়বদ্ধ নই।