38 KiB

Raw Permalink Blame History

ਕਾਰਟਪੋਲ ਸਕੇਟਿੰਗ

ਪਿਛਲੇ ਪਾਠ ਵਿਚ ਅਸੀਂ ਜਿਹੜਾ ਸਮੱਸਿਆ ਸੁਲਝਾਈ, ਉਹ ਇੱਕ ਖਿਡੌਣਾ ਸਮੱਸਿਆ ਲੱਗ ਸਕਦੀ ਹੈ, ਜੋ ਅਸਲੀ ਜ਼ਿੰਦਗੀ ਦੇ ਦ੍ਰਿਸ਼ਾਂਤਾਂ ਲਈ ਵਾਸਤਵਿਕ ਤੌਰ 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਹੁੰਦੀ। ਪਰ ਅਜਿਹਾ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਅਸਲੀ ਦੁਨੀਆ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਵੀ ਇਸ ਦ੍ਰਿਸ਼ਾਂਤ ਨੂੰ ਸਾਂਝਾ ਕਰਦੀਆਂ ਹਨ - ਜਿਵੇਂ ਕਿ ਚੈਸ ਜਾਂ ਗੋ ਖੇਡਣਾ। ਇਹ ਸਮਾਨ ਹਨ, ਕਿਉਂਕਿ ਸਾਡੇ ਕੋਲ ਵੀ ਇੱਕ ਬੋਰਡ ਹੁੰਦਾ ਹੈ ਜਿਸਦੇ ਨਿਯਮ ਹੋਂਦੇ ਹਨ ਅਤੇ ਇੱਕ ਵਿਭਾਜਿਤ ਸਥਿਤੀ ਹੁੰਦੀ ਹੈ।

ਪੂਰਵ-ਭਾਸ਼ਣ ਕੁਇਜ਼

ਪਰਿਚਯ

ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ Q-ਲਰਨਿੰਗ ਦੇ ਇੱਕੋ ਜਿਹੇ ਨਿਯਮਾਂ ਨੂੰ ਇੱਕ ਅਜਿਹੇ ਸਮੱਸਿਆ 'ਤੇ ਲਾਗੂ ਕਰਾਂਗੇ ਜਿਸ ਦੀ ਸਥਿਤੀ ਲਗਾਤਾਰ ਹੈ, ਅਰਥਾਤ ਇੱਕ ਸਥਿਤੀ ਜੋ ਇੱਕ ਜਾਂ ਵਧੇਰੇ ਵਾਸਤਵਿਕ ਸੰਖਿਆਵਾਂ ਨਾਲ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਸਿਆ ਨਾਲ ਨਿਪਟਾਂਗੇ:

ਸਮੱਸਿਆ: ਜੇਪੀਟਰ ਭੇਡੀਆ ਤੋਂ ਬਚਨਾ ਚਾਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਸਨੂੰ ਤੇਜ਼ ਹਿਲਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਅਸੀਂ ਵੇਖਾਂਗੇ ਕਿ ਜੇਪੀਟਰ ਕਿਵੇਂ ਸਕੇਟਿੰਗ ਸਿਖ ਸਕਦਾ ਹੈ, ਖ਼ਾਸ ਕਰਕੇ ਸੰਤੁਲਨ ਬਣਾਈ ਰੱਖਣ ਲਈ, Q-ਲਰਨਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ।

ਜੇਪੀਟਰ ਅਤੇ ਉਸਦੇ ਦੋਸਤ ਭੇਡੀਆ ਤੋਂ ਬਚਣ ਲਈ ਰਚਨਾਤਮਕ ਬਣਦੇ ਹਨ! ਚਿੱਤਰ ਜੇਨ ਲੂਪਰ ਵੱਲੋਂ

ਅਸੀਂ ਸੰਤੁਲਨ ਬਣਾਉਣ ਦੀ ਸਧਾਰਣ ਵਰਜਨ ਨੂੰ ਵਰਤਾਂਗੇ ਜਿਸਨੂੰ ਕਾਰਟਪੋਲ ਸਮੱਸਿਆ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਕਾਰਟਪੋਲ ਸੰਸਾਰ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਅੱਡਾ ਸਲਾਇਡਰ ਹੁੰਦਾ ਹੈ ਜੋ ਖੱਬੇ ਜਾਂ ਸੱਜੇ ਹਿਲ ਸਕਦਾ ਹੈ, ਅਤੇ ਉਦੇਸ਼ ਹੈ ਕਿ ਸਲਾਇਡਰ ਦੇ ਉੱਤੇ ਇੱਕ ਲੰਬਕ ਲੰਬਾ ਖੰਭ ਸੰਤੁਲਨ ਵਿੱਚ ਰੱਖਣਾ।

ਜ਼ਰੂਰੀਆਂ ਚੀਜ਼ਾਂ

ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਲਾਇਬਰੇਰੀ OpenAI Gym ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਵੱਖ-ਵੱਖ ਪਰੀਵਰਤਨਾਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ। ਤੁਸੀਂ ਇਸ ਪਾਠ ਦਾ ਕੋਡ ਲੋਕਲ (ਜਿਵੇਂ Visual Studio Code ਤੋਂ) ਚਲਾ ਸਕਦੇ ਹੋ, ਜਿਸ ਦੌਰਾਨ ਨਕਲ ਇਕ ਨਵੀਂ ਵਿਂਡੋ ਵਿੱਚ ਖੁਲ ਜਾਵੇਗੀ। ਜਦੋਂ ਕੋਡ ਆਨਲਾਈਨ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੋਡ ਵਿੱਚ ਕੁਝ ਤਬਦੀਲੀਆਂ ਕਰਨੀਆਂ ਪੈ ਸਕਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਇਥੇ ਦਰਸਾਇਆ ਗਿਆ ਹੈ।

OpenAI Gym

ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਖੇਡ ਦੇ ਨਿਯਮ ਅਤੇ ਸਥਿਤੀ ਸਾਡੇ ਆਪਣੇ ਬਣਾਏ ਹੋਏ Board ਕਲਾਸ ਦੁਆਰਾ ਦਿੱਤੀ ਗਈ ਸੀ। ਇੱਥੇ ਅਸੀਂ ਇੱਕ ਖ਼ਾਸ ਨਕਲ ਪਰੀਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਜੋ ਸੰਤੁਲਨ ਲੰਬਕ ਪਿੱਛੇ ਦੀ ਭੌਤਿਕ ਵਿਗਿਆਨਕ ਨਕਲ ਕਰੇਗਾ। ਤਾਕਤਵਰ ਪਰਸ਼ਿੱਖਣ ਲਈ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਨਕਲ ਪਰੀਵਰਤਨਾਂ ਵਿੱਚੋਂ ਇੱਕ, Gym ਹੈ, ਜੋ OpenAI ਵੱਲੋਂ ਸੰਭਾਲੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਜੀਮ ਦਾ ਵਰਤੋਂ ਕਰਕੇ ਅਸੀਂ ਕਾਰਟਪੋਲ ਨਕਲ ਤੋਂ ਲੈ ਕੇ ਐਟਾਰੀ ਖੇਡਾਂ ਤੱਕ ਵੱਖ-ਵੱਖ ਪਰੀਵਰਤਨਾਂ ਬਣਾਉਣ ਲਈ ਯੋਗ ਹਾਂ।

ਨੋਟ: ਤੁਸੀਂ OpenAI Gym ਤੋਂ ਮੌਜੂਦ ਹੋਰ ਪਰੀਵਰਤਨ ਇਥੇ ਦੇਖ ਸਕਦੇ ਹੋ।

ਪਹਿਲਾਂ, ਆਓ ਜੀਮ ਇੰਸਟਾਲ ਕਰੀਏ ਅਤੇ ਲੋੜੀਂਦੇ ਲਾਇਬਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੀਏ (ਕੋਡ ਬਲਾਕ 1):

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

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

ਅਭਿਆਸ - ਕਾਰਟਪੋਲ ਪਰੀਵਰਤਨ ਸ਼ੁਰੂਆਤ

ਕਾਰਟਪੋਲ ਸੰਤੁਲਨ ਸਮੱਸਿਆ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਸਦੇ ਅਨੁਕੂਲ ਪਰੀਵਰਤਨ ਨੂੰ ਸ਼ੁਰੂਆਤ ਕਰਨੀ ਹੋਵੇਗੀ। ਹਰ ਪਰੀਵਰਤਨ ਨਾਲ ਸਬੰਧਤ ਹੁੰਦਾ ਹੈ:

ਅਵਲੋਕਨ ਸਪੇਸ, ਜੋ ਉਹ ਜਾਣਕਾਰੀ ਦੀ ਸੰਰਚਨਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਅਸੀਂ ਪਰੀਵਰਤਨ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਕਾਰਟਪੋਲ ਸਮੱਸਿਆ ਲਈ ਅਸੀਂ ਖੰਭ ਦੀ ਪੋਜ਼ੀਸ਼ਨ, ਗਤੀ, ਅਤੇ ਕੁਝ ਹੋਰ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।
ਕਾਰਵਾਈ ਸਪੇਸ, ਜੋ ਸੰਭਾਵਤ ਕਾਰਵਾਈਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਸਾਡੀ ਸਥਿਤੀ ਵਿੱਚ ਕਾਰਵਾਈ ਸਪੇਸ ਵਿਭਾਜਿਤ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਦੋ ਕਾਰਵਾਈਆਂ ਹਨ - ਖੱਬੇ ਅਤੇ ਸੱਜੇ। (ਕੋਡ ਬਲਾਕ 2)

ਸ਼ੁਰੂਆਤ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਟਾਈਪ ਕਰੋ:

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

ਦੇਖਣ ਲਈ ਕਿ ਪਰੀਵਰਤਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਆਓ 100 ਕਦਮਾਂ ਦੀ ਛੋਟੀ ਨਕਲ ਚਲਾਈਏ। ਹਰ ਕਦਮ ਤੇ, ਅਸੀਂ ਕਿਸੇ ਵੀ ਵਰਤੀ ਜਾਣ ਵਾਲੀ ਕਾਰਵਾਈ ਦਿੰਦੇ ਹਾਂ - ਇਸ ਨਕਲ ਵਿੱਚ ਅਸੀਂ ਬਸ ਕਿਸੇ තියੇ ਕਾਰਵਾਈ ਨੂੰ action_space ਵਿੱਚੋਂ ਯਾਦ੍ਰਚਿਤ ਚੋਣ ਕਰਦੇ ਹਾਂ।

ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਵੇਖੋ ਕਿ ਇਹ ਕਿੱਥੇ ਲੈ ਜਾਂਦਾ ਹੈ।

✅ ਯਾਦ ਰੱਖੋ ਕਿ ਇਸ ਕੋਡ ਨੂੰ ਲੋਕਲ Python ਇੰਸਟਾਲੇਸ਼ਨ 'ਤੇ ਚਲਾਉਣਾ ਪਸੰਦੀਦਾ ਹੈ! (ਕੋਡ ਬਲਾਕ 3)
```
env.reset()

for i in range(100):
   env.render()
   env.step(env.action_space.sample())
env.close()
```
ਤੁਸੀਂ ਇਸ ਚਿੱਤਰ ਵਾਂਗ ਕੁਝ ਵੇਖਨਾ ਚਾਹੀਦਾ ਹੈ:
ਨਕਲ ਦੌਰਾਨ, ਅਸੀਂ ਕੁਝ ਅਵਲੋਕਨ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਇਹ ਫੈਸਲਾ ਕਰੀਏ ਕਿ ਕਿਵੇਂ ਕਾਰਵਾਈ ਕਰਨੀ ਹੈ। ਅਸਲ ਵਿੱਚ, ਸਟੈਪ ਫੰਕਸ਼ਨ ਵਰਤਮਾਨ ਅਵਲੋਕਨ, ਇਨਾਮ ਫੰਕਸ਼ਨ, ਅਤੇ ਡਨ ਝੰਡਾ (ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ ਨਕਲ ਜਾਰੀ ਰੱਖਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਨਹੀਂ) ਪਰਤਾਉਂਦਾ ਹੈ: (ਕੋਡ ਬਲਾਕ 4)
```
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()
```
ਤੁਸੀਂ ਨੋਟਬੁਕ ਆਊਟਪੁਟ ਵਿੱਚ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦੇਖੋਗੇ:
```
[ 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
```
ਹਰ ਸਟੈਪ ਤੇ ਪਰਤਾਇਆ ਗਿਆ ਅਵਲੋਕਨ ਵੈਕਟਰ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ ਹੋਂਦਾ ਹੈ:
- ਕਾਰਟ ਦੀ ਪੋਜ਼ੀਸ਼ਨ
- ਕਾਰਟ ਦੀ ਗਤੀ
- ਖੰਭ ਦਾ ਕੋਣ
- ਖੰਭ ਦੀ ਘੁੰਮਣ ਦੀ ਦਰ
ਇਨ੍ਹਾਂ ਨੰਬਰਾਂ ਦਾ ਘੱਟੋ-ਘੱਟ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਲਵੇਂ: (ਕੋਡ ਬਲਾਕ 5)
```
print(env.observation_space.low)
print(env.observation_space.high)
```
ਤੁਸੀਂ ਇਹ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਹਰ ਸਟੈਪ ਤੇ ਇਨਾਮ ਦਾ ਮੁੱਲ ਸਦਾ 1 ਹੁੰਦਾ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਸਾਡਾ ਇਸ ਗੋਲ ਹੈ ਕਿ ਜਿੰਨਾ ਹੋ ਸਕੇ ਉਨ੍ਹਾਂ ਨਤਿਆਂ ਤਕ ਜੀਉਣਾ, ਅਰਥਾਤ ਖੰਭ ਨੂੰ ਸਭ ਤੋਂ ਲੰਮੇ ਸਮੇਂ ਲਈ ਲੰਬਕ ਸਥਿਤੀ ਵਿੱਚ ਰੱਖਣਾ।

✅ ਦਰਅਸਲ, ਜੇਕਰ ਅਸੀਂ 100 ਲਗਾਤਾਰ ਕੋਸ਼ਿਸ਼ਾਂ ਤੇ 195 ਦਾ ਔਸਤ ਇਨਾਮ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਸਫਲ ਹੋ ਜਾਂਦੇ ਹਾਂ, ਤਾਂ ਕਾਰਟਪੋਲ ਨਕਲ ਨੂੰ ਹੱਲ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

ਸਥਿਤੀ ਨੂੰ ਵਿਭਾਜਿਤ ਕਰਨਾ

Q-ਲਰਨਿੰਗ ਵਿੱਚ, ਸਾਨੂੰ Q-ਟੇਬਲ ਬਣਾਣੀ ਪੈਂਦੀ ਹੈ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਹਰ ਸਥਿਤੀ 'ਤੇ ਕੀ ਕਰਨਾ ਹੈ। ਇਹ ਕਰਨ ਲਈ, ਸਥਿਤੀ ਵਿਭਾਜਿਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਬੇਹਤਰ ਇਹ ਕਿ ਇਸ ਵਿੱਚ ਖ਼ਤਮ ਹੋਏ ਨਿਰਧਾਰਤ ਮੁੱਲ ਹੋਣ। ਇਸ ਲਈ, ਸਾਨੂੰ ਆਪਣੇ ਅਵਲੋਕਨਾਂ ਨੂੰ ਕਿਸੇ ਤਰੀਕੇ ਨਾਲ ਵਿਭਾਜਿਤ ਕਰਨਾ ਪਵੇਗਾ, ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਖ਼ਤਮ ਹੋਏ ਸਥਿਤੀਆਂ ਦੇ ਸੈੱਟ ਨਾਲ ਮੇਲ ਕਰਨਾ ਪਵੇਗਾ।

ਇਸ ਦੇ ਕੁਝ ਤਰੀਕੇ ਹਨ:

ਬਿਨਾਂ ਵਿੱਚ ਵੰਡੋ। ਜੇਕਰ ਅਸੀਂ ਕਿਸੇ ਮੁੱਲ ਦੀ ਸੀਮਾ ਜਾਣਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਇਸ ਸੀਮਾ ਨੂੰ ਕਈ ਬਿਨਾਂ ਵਿੱਚ ਵੰਡ ਸਕਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਮੁੱਲ ਨੂੰ ਉਸ ਬਿਨ ਨੰਬਰ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਉਹ ਆਉਂਦਾ ਹੈ। ਇਹ numpy ਦੇ digitize ਮੈਥਡ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਸਾਨੂੰ ਸਥਿਤੀ ਦਾ ਆਕਾਰ ਪਤਾ ਚੱਲ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਉਨ੍ਹਾਂ ਬਿਨਾਂ ਦੀ ਗਿਣਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜੋ ਅਸੀਂ ਡਿਜੀਟਾਈਜ਼ੇਸ਼ਨ ਲਈ ਚੁਣਦੇ ਹਾਂ।

✅ ਅਸੀਂ ਲੀਨੀਅਰ ਇੰਟਰਪੋਲੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਕੇ ਮੁੱਲਾਂ ਨੂੰ ਕਿਸੇ ਖ਼ਤਮ ਸਮੇਂਅਤਰਾਲ (ਮਿਸਾਲ ਵਜੋਂ -20 ਤੋਂ 20) ਵਿੱਚ ਲਿਆ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਨੰਬਰਾਂ ਨੂੰ ਗੋਲ ਕਰਕੇ ਪੂਰਨ ਅੰਕਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹਾਂ। ਇਸ ਨਾਲ ਸਥਿਤੀ ਦੇ ਆਕਾਰ 'ਤੇ ਕੁਝ ਘੱਟ ਨਿਯੰਤਰਣ ਮਿਲਦਾ ਹੈ, ਖ਼ਾਸ ਕਰਕੇ ਜੇ ਅਸੀਂ ਇਪੁੱਟ ਮੁੱਲਾਂ ਦੀ ਸਹੀ ਸੀਮਾਵਾਂ ਨਹੀਂ ਜਾਣਦੇ। ਉਦਾਹਰਨ ਵਜੋਂ, ਸਾਡੇ 4 ਮੁੱਲਾਂ ਵਿੱਚੋਂ 2 ਦੀ ਕੋਈ ਉੱਪਰੀ ਜਾਂ ਹੇਠਲੀ ਸੀਮਾ ਨਹੀਂ ਹੈ, ਜਿਸ ਨਾਲ ਅਨੰਤ ਸਥਿਤੀਆਂ ਦਾ ਨਤੀਜਾ ਨਿਕਲ ਸਕਦਾ ਹੈ।

ਸਾਡੇ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਦੂਜਾ ਤਰੀਕਾ ਚੁਣਾਂਗੇ। ਜਿਵੇਂ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਦੇਖੋਗੇ, ਅਣਨਿਰਧਾਰਤ ਉੱਪਰੀ/ਹੇਠਲੀ ਸੀਮਾਵਾਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਮੁੱਲ ਕ੍ਰਮਾਂਕਿਤ ਸਮੇਂਅਤਰਾਲ ਤੋਂ ਬਾਹਰ ਬਹੁਤ ਘੱਟ ਵਾਰੀ ਲੈਂਦੇ ਹਨ, ਇਸ ਕਰਕੇ ਅਤਿਵਾਦੀ ਮੁੱਲਾਂ ਵਾਲੀਆਂ ਸਥਿਤੀਆਂ ਬਹੁਤ ਕਮ ਮਿਲਣਗੀਆਂ।

ਇਹ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਸਾਡੇ ਮਾਡਲ ਤੋਂ ਇੱਕ ਅਵਲੋਕਨ ਲਵੇਗਾ ਅਤੇ 4 ਪੂਰਨ ਅੰਕਾਂ ਵੱਲੋਂ ਇੱਕ ਟਿਊਪਲ ਦਿਓਂਦਾ ਹੈ: (ਕੋਡ ਬਲਾਕ 6)
```
def discretize(x):
    return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
```

ਆਓ ਇੱਕ ਹੋਰ ਵਿਭਾਜਨ ਤਰੀਕੇ ਦੀ ਜਾਂਚ ਕਰੀਏ ਜੋ ਬਿਨਾਂ ਨਾਲ ਵਰਤਦਾ ਹੈ: (ਕੋਡ ਬਲਾਕ 7)

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 ਬਿਨ ਨੰਬਰ ਪਰਤਾਉਂਦਾ ਹੈ, ਜੋ 0-ਅਧਾਰਿਤ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ ਇਨਪੁੱਟ ਚਲ ਵਾਲਿਆਂ ਮੁੱਲਾਂ ਲਈ ਜੋ 0 ਦੇ ਆਸਪਾਸ ਹਨ, ਇਹ ਮੱਧ ਵਾਲੇ ਅੰਤਰਾਲ (10) ਤੋਂ ਨੰਬਰ ਪਰਤਾਉਂਦਾ ਹੈ। discretize 'ਚ ਅਸੀਂ ਆਉਟਪੁੱਟ ਮੁੱਲਾਂ ਦੀ ਸੀਮਾ ਦੀ ਪਰਵਾਹ ਨਹੀਂ ਕੀਤੀ ਸੀ, ਇਸ ਲਈ ਉਹ ਨਕਾਰਾਤਮਕ ਵੀ ਹੋ ਸਕਦੇ ਹਨ, ਇਸ ਕਰਕੇ ਸਥਿਤੀ ਵਾਲੇ ਮੁੱਲ ਸ਼ਿਫਟ ਨਹੀਂ ਹੁੰਦੇ ਅਤੇ 0 ਦਾ ਅਰਥ 0 ਹੁੰਦਾ ਹੈ। (ਕੋਡ ਬਲਾਕ 8)
```
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-ਟੇਬਲ ਦੀ ਸੰਰਚਨਾ

ਸਾਡੇ ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਸਥਿਤੀ 0 ਤੋਂ 8 ਤੱਕ ਦੀਆਂ ਸੰਖਿਆਵਾਂ ਦਾ ਸਧਾਰਣ ਜੋੜਾ ਸੀ, ਇਸ ਲਈ Q-ਟੇਬਲ ਨੂੰ ਇੱਕ numpy ਟੈਨਸਰ ਦੇ ਰੂਪ ਵਿੱਚ ਜਿਸਦਾ ਆਕਾਰ 8x8x2 ਸੀ ਦਰਸਾਉਣਾ ਆਸਾਨ ਸੀ। ਜੇ ਅਸੀਂ ਬਿਨਾਂ ਵਿਭਾਜਨ ਵਰਤਦੇ ਹਾਂ, ਤਾਂ ਸਾਡੇ ਸਥਿਤੀ ਵੈਕਟਰ ਦਾ ਆਕਾਰ ਵੀ ਪਤਾ ਹੋਵੇਗਾ, ਇਸ ਲਈ ਅਸੀਂ ਉਹੀ ਤਰੀਕਾ ਵਰਤ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਥਿਤੀ ਨੂੰ ਇੱਕ ਐਰੇ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾ ਸਕਦੇ ਹਾਂ ਜਿਸਦਾ ਆਕਾਰ 20x20x10x10x2 ਹੋਵੇਗਾ (ਇੱਥੇ 2 ਕਾਰਵਾਈ ਸਪੇਸ ਦਾ ਆਯਾਮ ਹੈ, ਅਤੇ ਪਹਿਲੇ ਆਯਾਮ ਜੋ ਉਨ੍ਹਾਂ ਪਰਮੀਟਰਾਂ ਲਈ ਚੁਣੀ ਗਈ ਬਿਨਾਂ ਦੀ ਗਿਣਤੀ ਨਾਲ ਮੈਚ ਕਰਦੇ ਹਨ ਜੋ ਅਵਲੋਕਨ ਸਪੇਸ ਵਿੱਚ ਹਨ)।

ਹਾਲਾਂਕਿ, ਕਈ ਵਾਰ ਅਵਲੋਕਨ ਸਪੇਸ ਦੇ ਨਿਰਧਾਰਤ ਆਕਾਰ ਪਤਾ ਨਹੀਂ ਹੁੰਦੇ। ਜੇਕਰ ਅਸੀਂ discretize ਫੰਕਸ਼ਨ ਵਰਤਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਕਦੇ ਵੀ ਇਹ ਨਿਸ਼ਚਿਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਕਿ ਸਾਡੀ ਸਥਿਤੀ ਕਿਸੇ ਸੀਮਤ ਹਦ ਵਿੱਚ ਰਹਿੰਦੀ ਹੈ, ਕਿਉਂਕਿ ਕੁਝ ਮੂਲ ਮੁੱਲ ਅਣਬਾਧਤ ਹਨ। ਇਸ ਲਈ, ਅਸੀਂ ਥੋੜਾ ਵੱਖਰਾ ਤਰੀਕਾ ਵਰਤਾਂਗੇ ਅਤੇ Q-ਟੇਬਲ ਨੂੰ ਇੱਕ ਸ਼ਬਦ-ਕੋਸ਼ (ਡਿਕਸ਼ਨਰੀ) ਵਜੋਂ ਦਰਸਾਉਂਗੇ।

ਜੋੜਾ (ਸਥਿਤੀ, ਕਾਰਵਾਈ) ਡਿਕਸ਼ਨਰੀ ਦੀ ਕੁੰਜੀ ਵਜੋਂ ਵਰਤੋਂ, ਅਤੇ ਮੁੱਲ Q-ਟੇਬਲ ਪ੍ਰਵੇਸ਼ ਮੁੱਲ ਹੋਵੇਗਾ। (ਕੋਡ ਬਲਾਕ 9)
```
Q = {}
actions = (0,1)

def qvalues(state):
    return [Q.get((state,a),0) for a in actions]
```
ਇੱਥੇ ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ qvalues() ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਜੋ ਦਿੱਤੀ ਸਥਿਤੀ ਲਈ Q-ਟੇਬਲ ਦੀਆਂ ਸਾਰੀਆਂ ਸੰਭਾਵਤ ਕਾਰਵਾਈਆਂ වල Q-ਟੇਬਲ ਮੁੱਲਾਂ ਦੀ ਲਿਸਟ ਪਰਤਾਉਂਦਾ ਹੈ। ਜੇ ਇਨਟਰੀ Q-ਟੇਬਲ ਵਿੱਚ ਮੌਜੂਦ ਨਾ ਹੋਵੇ, ਤਾਂ ਅਸੀਂ 0 ਨੂੰ ਡਿਫੌਲਟ ਵਜੋਂ ਵਾਪਸ ਕਰਾਂਗੇ।

ਚਲੋ Q-ਲਰਨਿੰਗ ਸ਼ੁਰੂ ਕਰੀਏ

ਹੁਣ ਅਸੀਂ ਜੇਪੀਟਰ ਨੂੰ ਸੰਤੁਲਨ ਸਿੱਖਾਉਣ ਲਈ ਤਿਆਰ ਹਾਂ!

ਪਹਿਲਾਂ ਕੁਝ ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਸੈੱਟ ਕਰੋ: (ਕੋਡ ਬਲਾਕ 10)
```
# ਹਾਈਪਰਪੈਰਾਮੀਟਰ
alpha = 0.3
gamma = 0.9
epsilon = 0.90
```
ਇੱਥੇ, alpha ਇੱਕ ਲਰਨਿੰਗ ਰੇਟ ਹੈ ਜੋ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਾਡੇ Q-ਟੇਬਲ ਦੇ ਮੌਜੂਦਾ ਮੁੱਲ ਕਿਸ ਹੱਦ ਤੱਕ ਹਰ ਕਦਮ 'ਤੇ ਸਮਾਇਕਿਤ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ। ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ ਅਸੀਂ 1 ਤੋਂ ਸ਼ੁਰੂ ਕੀਤਾ ਅਤੇ ਫਿਰ alpha ਨੂੰ ਘਟਾਇਆ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ ਇਸਨੂੰ ਸਧਾਰਣਤਾ ਲਈ ਕੁਟੁੰਬਤ ਰੱਖਾਂਗੇ, ਅਤੇ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ alpha ਮੁੱਲਾਂ ਦੇ ਨਾਲ ਟੈਸਟ ਕਰ ਸਕਦੇ ਹੋ।

gamma ਇੱਕ ਛੂਟ ਦਰ ਹੈ ਜੋ ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਨੂੰ ਭਵਿੱਖ ਦੇ ਇਨਾਮ ਨੂੰ ਮੌਜੂਦਾ ਇਨਾਮ ਦੇ ਮੁਕਾਬਲੇ ਵਿੱਚ ਕਿੰਨਾ ਤਰਜੀਹ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ।

epsilon ਇੱਕ ਪੜਤਾਲ/ਫਾਇਦਾ ਉਠਾਉਣ ਵਾਲਾ ਕਾਰਕ ਹੈ ਜੋ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਾਨੂੰ ਪੜਤਾਲ ਨੂੰ ਫਾਇਦਾ ਉਠਾਉਣ ਨਾਲ ਜਾਂ ਵਿਰੋਧ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਸਾਡੀ ਅਲਗੋਰਿਦਮ ਵਿੱਚ, ਅਸੀਂ epsilon ਪ੍ਰਤੀਸ਼ਤ ਮਾਮਲਿਆਂ ਵਿੱਚ ਅਗਲੀ ਕਾਰਵਾਈ Q-ਟੇਬਲ ਮੁੱਲਾਂ ਅਨੁਸਾਰ ਚੁਣਦੇ ਹਾਂ, ਅਤੇ ਬਾਕੀ ਮਾਮਲਿਆਂ ਵਿੱਚ ਕੋਈ ਬੇਤਰਤੀਬ ਕਾਰਵਾਈ ਕਰਦੇ ਹਾਂ। ਇਹ ਸਾਨੂੰ ਖੋਜ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਕਦੇ ਨਾ ਦੇਖੇ ਖੋਜ ਖੇਤਰਾਂ ਦੀ।

✅ ਸੰਤੁਲਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ - ਬੇਤਰਤੀਬ ਕਾਰਵਾਈ (ਪੜਤਾਲ) ਨੂੰ ਗਲਤ ਦਿਸ਼ਾ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬ ਮਾਰ ਦਾ ਕੰਮ ਮਿਲਦਾ ਹੈ, ਜਿਸਨੂੰ ਖੰਭ ਨੂੰ ਉਹਨਾਂ "ਗਲਤੀਆਂ" ਤੋਂ ਬਾਅਦ ਸੰਤੁਲਨ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸਿੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

ਅਲਗੋਰਿਦਮ ਸੁਧਾਰੋ

ਅਸੀਂ ਆਪਣੇ ਪਿਛਲੇ ਪਾਠ ਦੇ ਅਲਗੋਰਿਦਮ ਵਿੱਚ ਦੋ ਸੁਧਾਰ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ:

ਔਸਤ ਕੁੱਲ ਇਨਾਮ ਦੀ ਗਣਨਾ ਕਰਨੀ, ਕਈ ਨਕਲ ਦੇ ਰੂਪ ਵਿੱਚ। ਅਸੀਂ ਹਰ 5000 ਦੁਹਰਾਵਾਂ 'ਤੇ ਪ੍ਰਗਟਾਵੀਂ ਤੇਜ਼ੀ ਛਾਪਾਂਗੇ, ਅਤੇ ਇਸ ਸਮੇਂ ਦੀਆਂ ਦੌਰਾਨ ਆਪਣਾ ਕੁੱਲ ਇਨਾਮ ਗਿਣਤੀ ਵਿੱਚ ਆਵਰਤ ਕਰਾਂਗੇ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜੇ ਅਸੀਂ 195 ਤੋਂ ਵੱਧ ਮਿਲਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਮੰਨ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਕੋਈ ਲੋੜ ਤੋਂ ਵੱਧ ਇਨਾਮ ਨਾਲ ਵੀ।
ਵੱਧ ਤੋਂ ਵੱਧ ਔਸਤ ਕੁੱਲ ਨਤੀਜੇ ਦੀ ਗਣਨਾ, Qmax, ਅਤੇ ਅਸੀਂ ਉਸ ਨਤੀਜੇ ਨਾਲ ਸਬੰਧਿਤ Q-ਟੇਬਲ ਸੰਭਾਲਾਂਗੇ। ਜਦੋਂ ਤੁਸੀਂ ਟਰੇਨਿੰਗ ਚਲਾਵੋਗੇ, ਤਾਂ ਅਸੀਂ ਦਿੱਖਾਂਗੇ ਕਿ ਕਈ ਵਾਰ ਔਸਤ ਕੁੱਲ ਇਨਾਮ ਡਿੱਗਣਾ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਉਹ Q-ਟੇਬਲ ਮੁੱਲ ਜੀਨਿਆਂ ਨਾਲ ਸਰਵੋਤਮ ਮਾਡਲ ਟਰੇਨਿੰਗ ਦੌਰਾਨ ਵੇਖਿਆ ਗਿਆ ਸੀ, ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।

ਹਰ ਨਕਲ ਵਿੱਚ ਸਾਰੇ ਕੁੱਲ ਇਨਾਮ rewards ਵੈਕਟਰ ਵਿੱਚ ਇਕੱਠੇ ਕਰੋ ਤਾ ਕਿ ਅੱਗੇ ਚਾਰਟਿੰਗ ਲਈ ਵਰਤ ਸਕੀਏ। (ਕੋਡ ਬਲਾਕ 11)

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=[]

ਤੁਹਾਨੂੰ ਇਹ ਨਤੀਜੇ ਵਿੱਚੋਂ ਇਹ ਗੱਲਾਂ ਨਜ਼ਰ ਆ ਸਕਦੀਆਂ ਹਨ:

ਸਾਡੇ ਟੀਚੇ ਦੇ ਨੇੜੇ। ਅਸੀਂ 195 ਕੁੱਲ ਇਨਾਮ 100+ ਲਗਾਤਾਰ ਸਿਮੂਲੇਸ਼ਨਾਂ ਬਰਾਬਰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਟੀਚੇ ਦੇ ਬਹੁਤ ਨੇੜੇ ਹਾਂ, ਜਾਂ ਸਾਇਦ ਇਸਨੂੰ ਹਾਸਲ ਕਰ ਲਿਆ ਹੋਵੇ! ਜੇ ਅਸੀਂ ਘੱਟ ਮੁੱਲ ਲੈਂਦੇ ਹਾਂ, ਤਾਂ ਵੀ ਸਮੱਸਿਆ ਨਹੀਂ ਕਿਉਂਕਿ ਅਸੀਂ 5000 ਦੌਰਾਂ ਉੱਤੇ ਗਣਨਾ ਕਰ ਰਹੇ ਹਾਂ, ਜਦਕਿ 100 ਦੌਰਾਂ ਦੀ ਹੀ ਸੰਸਥਾਵਿਕ ਲੋੜ ਹੈ।
ਇਨਾਮ ਡਿੱਗਣਾ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ। ਕਈ ਵਾਰ ਇਨਾਮ ਘੱਟ ਹੋਣ ਲੱਗਦਾ ਹੈ, ਜੋ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਸਿੱਖੇ ਮੁੱਲਾਂ ਨੂੰ ਉਹ ਮੁੱਲ ਜੋ ਹਾਲਤ ਨੂੰ ਖ਼ਰਾਬ ਕਰਦੇ ਹਨ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹਾਂ।

ਇਹ ਨਜ਼ਾਰਾ ਟਰੇਨਿੰਗ ਪ੍ਰਗਟਾਵੀਂ ਨੂੰ ਚਾਰਟ ਕਰਨ ਤੇ ਵਧੇਰੇ ਸਪਸ਼ਟ ਮੁੱਲਦਾ ਹੈ।

ਟਰੇਨਿੰਗ ਪ੍ਰਗਟਾਵੀਂ ਦੀ ਚਾਰਟਿੰਗ

ਟਰੇਨਿੰਗ ਦੌਰਾਨ, ਅਸੀਂ ਹਰ ਇਤਰਾਵਾਂ ਉੱਤੇ ਕੁਲ ਇਨਾਮ ਮੁੱਲ rewards ਵੈਕਟਰ ਵਿੱਚ ਇਕੱਤਰ ਕੀਤਾ। ਇਹ ਅਇਜ਼ਾ ਦਿਖਾਈ ਦੇਂਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇਸਨੂੰ ਇਤਰਾਵਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਖਿਲਾਫ਼ ਚਾਰਟ ਕਰਦੇ ਹਾਂ:

plt.plot(rewards)

ਇਸ ਗ੍ਰਾਫ ਤੋਂ, ਅਸੀਂ ਕੁਝ ਨਹੀਂ ਕਹਿ ਸਕਦੇ, ਕਿਉਂਕਿ ਸਟੋਕਾਸਟਿਕ ਟਰੇਨਿੰਗ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪ੍ਰਕਿਰਤੀ ਕਾਰਨ ਟਰੇਨਿੰਗ ਸੈਸ਼ਨ ਦੀ ਲੰਬਾਈ ਬਹੁਤ ਵੱਖਰੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਗ੍ਰਾਫ ਨੂੰ ਸਮਝਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਸੈਰੀਜ਼ ਦੇ ਪ੍ਰਯੋਗਾਂ ਉੱਤੇ ਚਲਦਾ ਔਸਤ ਨਿਕਾਲ ਸਕਦੇ ਹਾਂ, ਕਹਿਣ ਲਈ 100। ਇਹ ਆਸਾਨੀ ਨਾਲ np.convolve ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: (ਕੋਡ ਬਲਾਕ 12)

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

plt.plot(running_average(rewards,100))

ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਬਦਲਣਾ

ਟਰੇਨਿੰਗ ਨੂੰ ਵਧੇਰੇ ਸਥਿਰ ਬਣਾਉਣ ਲਈ ਇਹ ਸਮਝਦਾਰੀ ਹੈ ਕਿ ਸਾਡੇ ਕੁਝ ਹਾਈਪਰਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸੰਸਾਰ ਨਾਲ ਢਾਲਾ ਜਾਵੇ। ਖ਼ਾਸ ਤੌਰ 'ਤੇ:

ਲਰਨਿੰਗ ਟੇਜ਼ੀ ਲਈ, alpha, ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ 1 ਦੇ ਨੇੜੇ ਮੁੱਲਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਪੈਮਾਨੇ ਨੂੰ ਘਟਾਉਂਦੇ ਜਾਵਾਂਗੇ। ਸਮਿਆਂ ਦੇ ਨਾਲ, ਅਸੀਂ Q-ਟੇਬਲ ਵਿੱਚ ਚੰਗੀਆਂ ਸੰਭਾਵਨਾ ਵਾਲੀਆਂ ਮੁੱਲਾਂ ਲਈ ਪਹੁੰਚਦੇ ਹਾਂ, ਇਸ ਲਈ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਥੋੜਾ ਬਦਲਦੇ ਹਾਂ, ਬਿਲਕੁਲ ਬਦਲ ਕਰ ਨਹੀਂ।
ਅਪਸੀਲਨ ਵਧਾਓ। ਅਸੀਂ epsilon ਨੂੰ ਹੌਲੀ-ਹੌਲੀ ਵਧਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਘੱਟ ਖੋਜ ਹੋਵੇ ਅਤੇ ਵੱਧ ਫਾਇਦਾ ਉਠਾਉਣ ਹੋਵੇ। ਸੰਭਵ ਹੈ ਕਿ ਅਸੀਂ epsilon ਨੂੰ ਘੱਟ ਮੁੱਲ ਤੋਂ ਸ਼ੁਰੂ ਕਰੀਏ ਅਤੇ ਲਗਭਗ 1 ਤੱਕ ਵਧਾਈਏ।

ਕਾਰਜ 1: ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਮੁੱਲਾਂ ਨਾਲ ਖੇਡੋ ਅਤੇ ਵੇਖੋ ਕਿ ਤੁਸੀਂ ਵੱਧ ਕੁੱਲ ਇਨਾਮ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਨਹੀਂ। ਕੀ ਤੁਸੀਂ 195 ਤੋਂ ਵੱਧ ਪ੍ਰਾਪਤ ਕਰ ਰਹੇ ਹੋ?

ਟਾਸਕ 2: ਸਮੱਸਿਆ ਨੂੰ ਆਧਿਕਾਰਿਕ ਤੌਰ 'ਤੇ ਹੱਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ 100 ਲਗਾਤਾਰ ਦੌੜਾਂ ਵਿੱਚ 195 ਔਸਤ ਇਨਾਮ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਨੂੰ ਟਰੇਨਿੰਗ ਦੌਰਾਨ ਮਾਪੋ ਅਤੇ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਤੁਸੀਂ ਆਧਿਕਾਰਿਕ ਤੌਰ 'ਤੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਲਿਆ ਹੈ!

ਨਤੀਜਾ ਕਾਰਜ ਵਿੱਚ ਵੇਖਣਾ

ਇਹ ਵਾਕਈ ਦਿਲਚਸਪ ਹੋਵੇਗਾ ਦੇਖਣਾ ਕਿ ਟਰੇਨ ਕੀਤਾ ਮਾਡਲ ਕਿਵੇਂ ਵਰਤਦਾ ਹੈ। ਆਓ ਸਿਮੁਲੇਸ਼ਨ ਚਲਾਈਏ ਅਤੇ ਟਰੇਨਿੰਗ ਦੌਰਾਨ ਵਰਤੇ ਗਏ ਕਾਰਵਾਈ ਚੋਣ ਰਣਨੀਤੀ ਨੂੰ ਫੋਲੋ ਕਰੀਏ, Q-ਟੇਬਲ ਵਿੱਚ ਪ੍ਰਸਾਧਿਤ ਸੰਭਾਵਨਾ ਵਿਕਰਾਲਯ ਅਨੁਸਾਰ ਨਮੂਨਾ ਲਵਦੇ ਹੋਏ: (ਕੋਡ ਬਲਾਕ 13)

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()

ਤੁਹਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ ਵੇਖਣ ਨੂੰ ਮਿਲਣਾ ਚਾਹੀਦਾ ਹੈ:

🚀ਚੈਲੇਂਜ

ਟਾਸਕ 3: ਇੱਥੇ, ਅਸੀਂ Q-ਟੇਬਲ ਦੀ ਅਖੀਰਲੀ ਕਾਪੀ ਦਾਖਲ ਕਰ ਰਹੇ ਸੀ, ਜੋ ਸਭ ਤੋਂ ਵਧੀਆ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਯਾਦ ਰੱਖੋ ਕਿ ਅਸੀਂ ਸਭ ਤੋਂ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਵਾਲੀ Q-ਟੇਬਲ ਨੂੰ Qbest ਵੈਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਹੈ! ਸਭ ਤੋਂ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਵਾਲੀ Q-ਟੇਬਲ ਨੂੰ Qbest ਤੋਂ Q ਵਿੱਚ ਕਾਪੀ ਕਰਕੇ ਉਸੇ ਉਦਾਹਰਨ ਨੂੰ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਅਤੇ ਵੇਖੋ ਕਿ ਤੁਹਾਨੂੰ ਫਰਕ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ।

ਟਾਸਕ 4: ਇੱਥੇ ਅਸੀਂ ਹਰ ਕਦਮ 'ਤੇ ਸਬ ਤੋਂ ਵਧੀਆ ਕਾਰਵਾਈ ਨਹੀਂ ਚੁਣੀ, ਪਰ ਸੰਭਾਵਨਾ ਵਿਕਰਾਲਯ ਅਨੁਸਾਰ ਨਮੂਨਾ ਲਿਆ। ਕੀ ਹਮੇਸ਼ਾਂ ਸਭ ਤੋਂ ਵਧੀਆ ਕਾਰਵਾਈ ਚੁਣਨਾ, ਜਿਸ ਦਾ Q-ਟੇਬਲ ਵੈਲਯੂ ਸਭ ਤੋਂ ਵੱਧ ਹੈ, ਵਧੀਆ ਹੋਵੇਗਾ? ਇਹ np.argmax ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਸਭ ਤੋਂ ਵੱਧ Q-ਟੇਬਲ ਵੈਲਯੂ ਨਾਲ ਸੰਬੰਧਿਤ ਕਾਰਵਾਈ ਨੰਬਰ ਪਤਾ ਕਰਦਾ ਹੈ। ਇਸ ਰਣਨੀਤੀ ਨੂੰ ਲਾਗੂ ਕਰੋ ਅਤੇ ਵੇਖੋ ਕਿ ਕੀ ਇਹ ਸੰਤੁਲਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ।

ਪੋਸਟ-ਲੇਕਚਰ ਕ੍ਵਿਜ਼

ਅਸਾਈਨਮੈਂਟ

ਮਾਊਂਟੇਨ ਕਾਰ ਦੀ ਟ੍ਰੇਨਿੰਗ

ਨਤੀਜਾ

ਅਸੀਂ ਹੁਣ ਸਿੱਖ ਚੁੱਕੇ ਹਾਂ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਏਜੰਟਾਂ ਨੂੰ ਚੰਗੇ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸਿਖਾਣਾ ਹੈ ਸਿਰਫ਼ ਉਨ੍ਹਾਂ ਨੂੰ ਇੱਕ ਇਨਾਮ ਫੰਕਸ਼ਨ ਦੇ ਕੇ ਜੋ ਖੇਡ ਦੀ ਚਾਹੀਦੀ ਹੈ ਹਾਲਤ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਸੂਝ-ਬੂਝ ਨਾਲ ਖੋਜ ਕਰਨ ਦਾ ਮੌਕਾ ਦੇ ਕੇ। ਅਸੀਂ ਕਿਊ-ਲਰਨਿੰਗ ਐਲਗੋਰਿਥਮ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਅਲੱਗ-ਅਲੱਗ ਡਿਸਕਰੀਟ ਅਤੇ ਲਗਾਤਾਰ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਹੈ, ਪਰ ਡਿਸਕਰੀਟ ਕਾਰਵਾਈਆਂ ਨਾਲ।

ਇਹ ਵੀ ਜਰੂਰੀ ਹੈ ਕਿ ਅਸੀਂ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਦਾ ਅਧਿਐਨ ਕਰੀਏ ਜਿੱਥੇ ਕਾਰਵਾਈ ਹਾਲਤ ਵੀ ਲਗਾਤਾਰ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਨਿਰੀਖਣ ਅਖੰਡ ਜਿਆਦਾ ਜਟਿਲ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਐਟਾਰੀ ਖੇਡ ਸਕਰੀਨ ਤੋਂ ਲਿਆ ਇਮেজ। ਉਸ ਤਰ੍ਹਾਂ ਦੀ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਅਕਸਰ ਅਸੀਂ ਵਧੀਆ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਹੋਰ ਮਜ਼ਬੂਤ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਤਕਨਾਲੋਜੀਆਂ ਵਰਤਣੀ ਪੈਂਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਨਿਊਰਲ ਨੈੱਟਵਰਕ। ਇਹ ਹੋਰ ਉੱਚ ਜਟਿਲ ਵਿਸ਼ਿਆਂ ਸਾਡੇ ਆਗਲੇ ਉੱਚ ਪੱਧਰੀ ਏਆਈ ਕੋਰਸ ਦਾ ਵਿਸ਼ਾ ਹਨ।

ਅਸਵੀਕਾਰੋਪਣ: ਇਸ ਦਸਤਾਵੇਜ਼ ਦਾ ਅਨੁਵਾਦ ਏਆਈ ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾਵਾਂ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਰੱਖੋ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸਮੱਤਿਆਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਕ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਰੂਰੀ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੇ ਉਪਯੋਗ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆਵਾਂ ਲਈ ਜਵਾਬਦੇਹ ਨਹੀਂ ਹਾਂ।

38 KiB Raw Permalink Blame History