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

ಕಾರ್ಟ್‌ಪೋಲ್ ಸ್ಕೇಟಿಂಗ್

ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು ಪರಿಹರಿಸುತ್ತಿದ್ದ ಸಮಸ್ಯೆ ಆಟದ ಸಮಸ್ಯೆಯಂತೆ ಕಾಣಬಹುದು, ನಿಜವಾದ ಜೀವನದ ಸಂದರ್ಭಗಳಿಗೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ ಎಂದು ಭಾಸವಾಗಬಹುದು. ಆದರೆ ಇದು ಸತ್ಯವಲ್ಲ, ಏಕೆಂದರೆ ಅನೇಕ ನಿಜವಾದ ಜಗತ್ತಿನ ಸಮಸ್ಯೆಗಳು ಕೂಡ ಈ ದೃಶ್ಯವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ - ಚೆಸ್ ಅಥವಾ ಗೋ ಆಟವನ್ನೂ ಸೇರಿಸಿ. ಅವುಗಳು ಸಮಾನವಾಗಿವೆ, ಏಕೆಂದರೆ ನಮಗೂ ನಿಯಮಗಳೊಂದಿಗೆ ಒಂದು ಬೋರ್ಡ್ ಇದೆ ಮತ್ತು ವಿಭಜಿತ ಸ್ಥಿತಿ ಇದೆ.

ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್

ಪರಿಚಯ

ಈ ಪಾಠದಲ್ಲಿ ನಾವು 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)

1. ಪ್ರಾರಂಭಿಸಲು, ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ:

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

ಪರಿಸರ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೋಡಲು, 100 ಹಂತಗಳ ಸಣ್ಣ ಅನುಕರಣವನ್ನು ನಡೆಸೋಣ. ಪ್ರತಿ ಹಂತದಲ್ಲಿ, ನಾವು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಕ್ರಿಯೆಯೊಂದನ್ನು ನೀಡುತ್ತೇವೆ - ಈ ಅನುಕರಣದಲ್ಲಿ ನಾವು action_space ನಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ.

1. ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ ಮತ್ತು ಅದು ಏನಾಗುತ್ತದೆ ನೋಡಿ.

   ✅ ನೆನಪಿಡಿ, ಈ ಕೋಡ್ ಅನ್ನು ಸ್ಥಳೀಯ Python ಸ್ಥಾಪನೆಯಲ್ಲಿ ಚಾಲನೆ ಮಾಡುವುದು ಆದ್ಯತೆ! (ಕೋಡ್ ಬ್ಲಾಕ್ 3)

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

   ನೀವು ಈ ಚಿತ್ರಕ್ಕೆ ಸಮಾನವಾದುದನ್ನು ನೋಡಬಹುದು:

   

2. ಅನುಕರಣದ ಸಮಯದಲ್ಲಿ, ನಾವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು ನಿರೀಕ್ಷಣೆಗಳನ್ನು ಪಡೆಯಬೇಕಾಗುತ್ತದೆ. ವಾಸ್ತವದಲ್ಲಿ, ಸ್ಟೆಪ್ ಫಂಕ್ಷನ್ ಪ್ರಸ್ತುತ ನಿರೀಕ್ಷಣೆಗಳನ್ನು, ಬಹುಮಾನ ಕಾರ್ಯವನ್ನು ಮತ್ತು ಅನುಕರಣವನ್ನು ಮುಂದುವರಿಸಲು ಅರ್ಥವಿರುವುದೇ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಡನ್ ಫ್ಲಾಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: (ಕೋಡ್ ಬ್ಲಾಕ್ 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
   

   ಅನುಕರಣದ ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುವ ನಿರೀಕ್ಷಣಾ ವೆಕ್ಟರ್ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ:

   • ಕಾರ್ಟ್‌ನ ಸ್ಥಾನ
   • ಕಾರ್ಟ್‌ನ ವೇಗ
   • ಕಂಬದ ಕೋನ
   • ಕಂಬದ ತಿರುಗುವ ದರ

3. ಆ ಸಂಖ್ಯೆಗಳ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಿರಿ: (ಕೋಡ್ ಬ್ಲಾಕ್ 5)

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

   ನೀವು ಗಮನಿಸಬಹುದು ಪ್ರತಿ ಅನುಕರಣ ಹಂತದಲ್ಲಿ ಬಹುಮಾನ ಮೌಲ್ಯವು ಸದಾ 1 ಆಗಿರುತ್ತದೆ. ಇದಕ್ಕೆ ಕಾರಣ ನಮ್ಮ ಗುರಿ ಸಾಧ್ಯವಾದಷ್ಟು ದೀರ್ಘಕಾಲ ಜೀವಿಸುವುದು, ಅಂದರೆ ಕಂಬವನ್ನು ಸಮತೋಲನದಲ್ಲಿಡುವುದು.

   ✅ ವಾಸ್ತವದಲ್ಲಿ, ಕಾರ್ಟ್‌ಪೋಲ್ ಅನುಕರಣವನ್ನು 100連続 ಪ್ರಯೋಗಗಳಲ್ಲಿ ಸರಾಸರಿ 195 ಬಹುಮಾನವನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಾದರೆ ಅದು ಪರಿಹರಿಸಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.

ಸ್ಥಿತಿ ವಿಭಜನೆ

Q-ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಸ್ಥಿತಿಯಲ್ಲಿ ಏನು ಮಾಡಬೇಕೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುವ Q-ಟೇಬಲ್ ನಿರ್ಮಿಸಬೇಕಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಸ್ಥಿತಿಯು ವಿಭಜಿತ ಆಗಿರಬೇಕು, ಅಂದರೆ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ವಿಭಜಿತ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರಬೇಕು. ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ನಿರೀಕ್ಷಣೆಗಳನ್ನು ಹೇಗೆಂದರೆ ವಿಭಜಿಸಬೇಕು, ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಗಳ ಸಮೂಹಕ್ಕೆ ನಕ್ಷೆ ಮಾಡಬೇಕು.

ಇದಕ್ಕೆ ಕೆಲವು ವಿಧಾನಗಳಿವೆ:

• ಬಿನ್‌ಗಳಿಗೆ ವಿಭಜನೆ. ನಾವು ಒಂದು ಮೌಲ್ಯದ ಅಂತರವನ್ನು ತಿಳಿದಿದ್ದರೆ, ಆ ಅಂತರವನ್ನು ಹಲವಾರು ಬಿನ್‌ಗಳಾಗಿ ವಿಭಜಿಸಬಹುದು, ನಂತರ ಮೌಲ್ಯವನ್ನು ಅದು ಸೇರಿದ ಬಿನ್ ಸಂಖ್ಯೆಯಿಂದ ಬದಲಾಯಿಸಬಹುದು. ಇದನ್ನು numpy digitize ವಿಧಾನ ಬಳಸಿ ಮಾಡಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನಿಖರವಾಗಿ ಸ್ಥಿತಿಯ ಗಾತ್ರವನ್ನು ತಿಳಿದುಕೊಳ್ಳುತ್ತೇವೆ, ಏಕೆಂದರೆ ಅದು ನಾವು ಆಯ್ಕೆಮಾಡಿದ ಬಿನ್‌ಗಳ ಸಂಖ್ಯೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.

✅ ನಾವು ರೇಖೀಯ ಇಂಟರ್‌ಪೋಲೇಶನ್ ಬಳಸಿ ಮೌಲ್ಯಗಳನ್ನು ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಅಂತರಕ್ಕೆ (ಉದಾ. -20 ರಿಂದ 20) ತಂದು, ನಂತರ ಸಂಖ್ಯೆಗಳನ್ನೂ ಸುತ್ತುವರಿದಂತೆ ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ಇದು ಸ್ಥಿತಿಯ ಗಾತ್ರದ ಮೇಲೆ ಸ್ವಲ್ಪ ಕಡಿಮೆ ನಿಯಂತ್ರಣ ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ನಮಗೆ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯಗಳ ನಿಖರ ಶ್ರೇಣಿಗಳು ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ 4 ಮೌಲ್ಯಗಳಲ್ಲಿ 2 ಕ್ಕೆ ಮೇಲ್ಭಾಗ/ಕೆಳಭಾಗ ಮಿತಿ ಇಲ್ಲ, ಇದು ಅನಂತ ಸಂಖ್ಯೆಯ ಸ್ಥಿತಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಎರಡನೇ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುವೆವು. ನೀವು ನಂತರ ಗಮನಿಸಬಹುದು, ನಿರ್ದಿಷ್ಟ ಮೇಲ್ಭಾಗ/ಕೆಳಭಾಗ ಮಿತಿಗಳಿಲ್ಲದಿದ್ದರೂ, ಆ ಮೌಲ್ಯಗಳು ಅಪರೂಪವಾಗಿ ನಿರ್ದಿಷ್ಟ ನಿರ್ದಿಷ್ಟ ಅಂತರದ ಹೊರಗೆ ಹೋಗುತ್ತವೆ, ಆದ್ದರಿಂದ ಅತಿ ಮಿತಿಯ ಸ್ಥಿತಿಗಳು ಬಹಳ ಅಪರೂಪವಾಗಿರುತ್ತವೆ.

1. ಇಲ್ಲಿ ನಮ್ಮ ಮಾದರಿಯಿಂದ ನಿರೀಕ್ಷಣೆಯನ್ನು ತೆಗೆದು 4 ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳ ಟ್ಯೂಪಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಫಂಕ್ಷನ್ ಇದೆ: (ಕೋಡ್ ಬ್ಲಾಕ್ 6)

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

2. ಇನ್ನೊಂದು ವಿಭಜನೆ ವಿಧಾನವನ್ನು ಬಿನ್‌ಗಳ ಬಳಕೆ ಮೂಲಕ ಅನ್ವೇಷಿಸೋಣ: (ಕೋಡ್ ಬ್ಲಾಕ್ 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))
   

3. ಈಗ ಸಣ್ಣ ಅನುಕರಣವನ್ನು ನಡೆಸಿ ಆ ವಿಭಜಿತ ಪರಿಸರ ಮೌಲ್ಯಗಳನ್ನು ಗಮನಿಸೋಣ. ನೀವು 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-ಟೇಬಲ್ ಅನ್ನು 8x8x2 ಆಕಾರದ numpy ಟೆನ್ಸರ್ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುವುದು ಅನುಕೂಲಕರವಾಗಿತ್ತು. ನಾವು ಬಿನ್‌ಗಳ ವಿಭಜನೆ ಬಳಸಿದರೆ, ಸ್ಥಿತಿ ವೆಕ್ಟರ್ ಗಾತ್ರವೂ ತಿಳಿದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದೇ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಸ್ಥಿತಿಯನ್ನು 20x20x10x10x2 ಆಕಾರದ ಅರೇ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸಬಹುದು (ಇಲ್ಲಿ 2 ಕ್ರಿಯೆ ಸ್ಥಳದ ಆಯಾಮ, ಮತ್ತು ಮೊದಲ ಆಯಾಮಗಳು ನಿರೀಕ್ಷಣಾ ಸ್ಥಳದ ಪ್ರತಿ ಪರಿಮಾಣಕ್ಕೆ ನಾವು ಆಯ್ಕೆಮಾಡಿದ ಬಿನ್‌ಗಳ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೆಯಾಗಿವೆ).

ಆದರೆ, ಕೆಲವೊಮ್ಮೆ ನಿರೀಕ್ಷಣಾ ಸ್ಥಳದ ನಿಖರ ಆಯಾಮಗಳು ತಿಳಿದಿರಲಾರವು. discretize ಫಂಕ್ಷನ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ಸ್ಥಿತಿ ನಿರ್ದಿಷ್ಟ ಮಿತಿಗಳೊಳಗಿರುತ್ತದೆ ಎಂದು ನಾವು ಎಂದಿಗೂ ಖಚಿತವಾಗಿರಲಾರವು, ಏಕೆಂದರೆ ಕೆಲವು ಮೂಲ ಮೌಲ್ಯಗಳಿಗೆ ಮಿತಿ ಇಲ್ಲ. ಆದ್ದರಿಂದ, ನಾವು ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು Q-ಟೇಬಲ್ ಅನ್ನು ಡಿಕ್ಷನರಿ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುತ್ತೇವೆ.

1. (ಸ್ಥಿತಿ, ಕ್ರಿಯೆ) ಜೋಡಿಯನ್ನು ಡಿಕ್ಷನರಿ ಕೀ ಆಗಿ ಬಳಸಿ, ಮತ್ತು ಮೌಲ್ಯವು Q-ಟೇಬಲ್ ಎಂಟ್ರಿ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. (ಕೋಡ್ ಬ್ಲಾಕ್ 9)

   Q = {}
   actions = (0,1)
   
   def qvalues(state):
       return [Q.get((state,a),0) for a in actions]
   

   ಇಲ್ಲಿ ನಾವು qvalues() ಎಂಬ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಇದು ನೀಡಲಾದ ಸ್ಥಿತಿಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಸಾಧ್ಯ ಕ್ರಿಯೆಗಳಿಗಾಗಿ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಎಂಟ್ರಿ Q-ಟೇಬಲ್‌ನಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಡೀಫಾಲ್ಟ್ ಆಗಿ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

Q-ಲರ್ನಿಂಗ್ ಪ್ರಾರಂಭಿಸೋಣ

ಈಗ ನಾವು ಪೀಟರ್‌ಗೆ ಸಮತೋಲನ ಕಲಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೇವೆ!

1. ಮೊದಲು, ಕೆಲವು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸೆಟ್ ಮಾಡೋಣ: (ಕೋಡ್ ಬ್ಲಾಕ್ 10)

   # ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು
   alpha = 0.3
   gamma = 0.9
   epsilon = 0.90
   

   ಇಲ್ಲಿ, alpha ಎಂಬುದು ಕಲಿಕೆಯ ದರ ಆಗಿದ್ದು, ಪ್ರತಿ ಹಂತದಲ್ಲಿ Q-ಟೇಬಲ್‌ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯಗಳನ್ನು ಎಷ್ಟು ಮಟ್ಟಿಗೆ ಸರಿಪಡಿಸಬೇಕೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು 1 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ನಂತರ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ alpha ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿದ್ದೇವೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಸರಳತೆಗೆ ನಾವು ಅದನ್ನು ಸ್ಥಿರವಾಗಿರಿಸುವೆವು, ಮತ್ತು ನೀವು ನಂತರ alpha ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯೋಗ ಮಾಡಬಹುದು.

   gamma ಎಂಬುದು ರಿಯಾಯಿತಿ ಕಡಿತಾಂಶ ಆಗಿದ್ದು, ಭವಿಷ್ಯದ ಬಹುಮಾನವನ್ನು ಪ್ರಸ್ತುತ ಬಹುಮಾನಕ್ಕಿಂತ ಎಷ್ಟು ಆದ್ಯತೆ ನೀಡಬೇಕೆಂದು ತೋರಿಸುತ್ತದೆ.

   epsilon ಎಂಬುದು ಅನ್ವೇಷಣೆ/ಶೋಷಣೆ ಅಂಶ ಆಗಿದ್ದು, ನಾವು ಅನ್ವೇಷಣೆಗೆ ಆದ್ಯತೆ ನೀಡಬೇಕೇ ಅಥವಾ ಶೋಷಣೆಗೆ ನೀಡಬೇಕೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ. ನಮ್ಮ ಆಲ್ಗಾರಿದಮ್ನಲ್ಲಿ, ನಾವು epsilon ಶೇಕಡಾವಾರು ಸಂದರ್ಭಗಳಲ್ಲಿ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರ ಮುಂದಿನ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತೇವೆ, ಉಳಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತೇವೆ. ಇದು ನಮಗೆ ಹಿಂದೆ ನೋಡದ ಹುಡುಕಾಟ ಪ್ರದೇಶಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.

   ✅ ಸಮತೋಲನದ ದೃಷ್ಟಿಯಿಂದ - ಯಾದೃಚ್ಛಿಕ ಕ್ರಿಯೆ ಆಯ್ಕೆಮಾಡುವುದು (ಅನ್ವೇಷಣೆ) ತಪ್ಪು ದಿಕ್ಕಿನಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಹೊಡೆತದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಮತ್ತು ಕಂಬವು ಆ "ತಪ್ಪುಗಳಿಂದ" ಸಮತೋಲನವನ್ನು ಹೇಗೆ ಮರುಸ್ಥಾಪಿಸಿಕೊಳ್ಳಬೇಕೆಂದು ಕಲಿಯಬೇಕು.

ಆಲ್ಗಾರಿದಮ್ನ ಸುಧಾರಣೆ

ಹಿಂದಿನ ಪಾಠದಿಂದ ನಮ್ಮ ಆಲ್ಗಾರಿದಮ್ನಲ್ಲಿ ಎರಡು ಸುಧಾರಣೆಗಳನ್ನು ಮಾಡಬಹುದು:

• ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಬಹುಮಾನವನ್ನು ಲೆಕ್ಕಿಸು, ಹಲವಾರು ಅನುಕರಣಗಳ ಮೇಲೆ. ನಾವು ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿ 5000 ಪುನರಾವೃತ್ತಿಗಳಲ್ಲಿ ಮುದ್ರಿಸುವೆವು, ಮತ್ತು ಆ ಅವಧಿಯಲ್ಲಿ ನಮ್ಮ ಸಂಗ್ರಹಿತ ಬಹುಮಾನವನ್ನು ಸರಾಸರಿ ಮಾಡುತ್ತೇವೆ. ಅಂದರೆ, ನಾವು 195 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಂಕಗಳನ್ನು ಪಡೆಯುತ್ತಿದ್ದರೆ - ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು, ಅಗತ್ಯಕ್ಕಿಂತಲೂ ಉತ್ತಮ ಗುಣಮಟ್ಟದೊಂದಿಗೆ.

• ಗರಿಷ್ಠ ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಫಲಿತಾಂಶ Qmax ಅನ್ನು ಲೆಕ್ಕಿಸು, ಮತ್ತು ಆ ಫಲಿತಾಂಶಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ Q-ಟೇಬಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸೋಣ. ತರಬೇತಿ ನಡೆಸುವಾಗ ನೀವು ಗಮನಿಸುವಿರಿ ಕೆಲವೊಮ್ಮೆ ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಫಲಿತಾಂಶ ಕುಸಿಯಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಮತ್ತು ನಾವು ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಗಮನಿಸಿದ ಅತ್ಯುತ್ತಮ ಮಾದರಿಯ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೇವೆ.

1. ಮುಂದಿನ ಚಿತ್ರಣಕ್ಕಾಗಿ ಪ್ರತಿ ಅನುಕರಣದಲ್ಲಿ ಎಲ್ಲಾ ಸಂಗ್ರಹಿತ ಬಹುಮಾನಗಳನ್ನು 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=[]
   

ನೀವು ಆ ಫಲಿತಾಂಶಗಳಿಂದ ಗಮನಿಸಬಹುದಾದವು:

• ನಮ್ಮ ಗುರಿಗೆ ಹತ್ತಿರ. ನಾವು 100+連続 ಅನುಕರಣಗಳಲ್ಲಿ 195 ಸಂಗ್ರಹಿತ ಬಹುಮಾನಗಳನ್ನು ಪಡೆಯುವ ಗುರಿಗೆ ಬಹಳ ಹತ್ತಿರವಿದ್ದೇವೆ, ಅಥವಾ ನಾವು ಅದನ್ನು ನಿಜವಾಗಿಯೂ ಸಾಧಿಸಿದ್ದೇವೆ! ಕಡಿಮೆ ಅಂಕಗಳನ್ನು ಪಡೆದರೂ, ನಾವು ಖಚಿತವಾಗಿಲ್ಲ, ಏಕೆಂದರೆ ನಾವು 5000 ಪ್ರಯೋಗಗಳ ಸರಾಸರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಮತ್ತು ಅಧಿಕೃತ ಮಾನದಂಡದಲ್ಲಿ ಕೇವಲ 100 ಪ್ರಯೋಗಗಳು ಬೇಕಾಗಿವೆ.

• ಬಹುಮಾನ ಕುಸಿಯಲು ಪ್ರಾರಂಭ. ಕೆಲವೊಮ್ಮೆ ಬಹುಮಾನ ಕುಸಿಯಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಅಂದರೆ ನಾವು ಈಗಾಗಲೇ ಕಲಿತ ಮೌಲ್ಯಗಳನ್ನು Q-ಟೇಬಲ್‌ನಲ್ಲಿ ಹಾಳುಮಾಡಬಹುದು, ಅದು ಪರಿಸ್ಥಿತಿಯನ್ನು ಕೆಟ್ಟದಾಗಿಸುತ್ತದೆ.

ಈ ಗಮನಿಕೆ ತರಬೇತಿ ಪ್ರಗತಿಯನ್ನು ಚಿತ್ರಿಸುವಾಗ ಸ್ಪಷ್ಟವಾಗಿ ಕಾಣುತ್ತದೆ.

ತರಬೇತಿ ಪ್ರಗತಿ ಚಿತ್ರಣ

ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಪುನರಾವೃತ್ತಿಯಲ್ಲಿ ಸಂಗ್ರಹಿತ ಬಹುಮಾನ ಮೌಲ್ಯವನ್ನು 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 ಅನ್ನು ನಿಧಾನವಾಗಿ ಹೆಚ್ಚಿಸಲು ಬಯಸಬಹುದು, ಅನ್ವೇಷಣೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಶೋಷಣೆಯನ್ನು ಹೆಚ್ಚು ಮಾಡಲು. ಇದು ಕಡಿಮೆ ಮೌಲ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸಿ 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 ವ್ಯತ್ಯಯದಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ ಎಂದು ನೆನಪಿಡಿ! Qbest ಅನ್ನು Q ಗೆ ನಕಲಿಸಿ ಅದೇ ಉದಾಹರಣೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸಿ.

ಕಾರ್ಯ 4: ಇಲ್ಲಿ ನಾವು ಪ್ರತಿ ಹಂತದಲ್ಲಿಯೂ ಅತ್ಯುತ್ತಮ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಿರಲಿಲ್ಲ, ಬದಲಿಗೆ ಸಂಬಂಧಿತ ಪ್ರಾಬಬಿಲಿಟಿ ವಿತರಣೆ ಪ್ರಕಾರ ಸ್ಯಾಂಪಲ್ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಯಾವಾಗಲೂ ಅತ್ಯುತ್ತಮ Q-ಟೇಬಲ್ ಮೌಲ್ಯ ಹೊಂದಿರುವ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣವಾಗುತ್ತದೆಯೇ? ಇದನ್ನು np.argmax ಫಂಕ್ಷನ್ ಬಳಸಿ ಅತ್ಯಧಿಕ Q-ಟೇಬಲ್ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿರುವ ಕ್ರಿಯೆ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು. ಈ ತಂತ್ರವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ ಮತ್ತು ಅದು ಸಮತೋಲನವನ್ನು ಸುಧಾರಿಸುತ್ತದೆಯೇ ಎಂದು ನೋಡಿ.

ಪೋಸ್ಟ್-ಲೆಕ್ಚರ್ ಕ್ವಿಜ್

ನಿಯೋಜನೆ

ಮೌಂಟನ್ ಕಾರ್ ತರಬೇತಿ

ಸಮಾರೋಪ

ನಾವು ಈಗಾಗಲೇ ಏಜೆಂಟ್‌ಗಳನ್ನು ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ತರಬೇತಿಗೊಳಿಸುವುದನ್ನು ಕಲಿತಿದ್ದೇವೆ, ಅದು ಆಟದ ಇಚ್ಛಿತ ಸ್ಥಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಬಹುಮಾನ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಮತ್ತು ಹುಡುಕಾಟ ಸ್ಥಳವನ್ನು ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ಅನ್ವೇಷಿಸಲು ಅವಕಾಶ ನೀಡುವ ಮೂಲಕ. ನಾವು ಡಿಸ್ಕ್ರೀಟ್ ಮತ್ತು ನಿರಂತರ ಪರಿಸರಗಳ ಪ್ರಕರಣಗಳಲ್ಲಿ Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿಥಮ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಅನ್ವಯಿಸಿದ್ದೇವೆ, ಆದರೆ ಡಿಸ್ಕ್ರೀಟ್ ಕ್ರಿಯೆಗಳೊಂದಿಗೆ.

ಕ್ರಿಯಾ ಸ್ಥಿತಿಯೂ ನಿರಂತರವಾಗಿರುವ ಮತ್ತು ಅವಲೋಕನ ಸ್ಥಳವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿರುವ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವುದು ಕೂಡ ಮುಖ್ಯ, ಉದಾಹರಣೆಗೆ ಅಟಾರಿ ಆಟದ ಪರದೆ ಚಿತ್ರ. ಆ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳಂತಹ ಶಕ್ತಿಶಾಲಿ ಯಂತ್ರ ಕಲಿಕೆ ತಂತ್ರಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಆ ಹೆಚ್ಚು ಪ್ರಗತಿಶೀಲ ವಿಷಯಗಳು ನಮ್ಮ ಮುಂದಿನ ಹೆಚ್ಚಿನ ಪ್ರಗತಿಶೀಲ AI ಕೋರ್ಸ್‌ನ ವಿಷಯವಾಗಿವೆ.

---

ಅಸ್ವೀಕರಣ:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.