এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

পরিবেশ

TensorFlow.org এ দেখুন GitHub এ উৎস দেখুন নোটবুক ডাউনলোড করুন

ভূমিকা

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

টিএফ-এজেন্টে, পরিবেশ পাইথন বা টেনসরফ্লোতে প্রয়োগ করা যেতে পারে। পাইথন পরিবেশগুলি সাধারণত বাস্তবায়ন, বোঝা এবং ডিবাগ করা সহজ, কিন্তু টেন্সরফ্লো পরিবেশগুলি আরও দক্ষ এবং প্রাকৃতিক সমান্তরালতার অনুমতি দেয়। সবচেয়ে সাধারণ ওয়ার্কফ্লো হল পাইথনে একটি পরিবেশ বাস্তবায়ন করা এবং স্বয়ংক্রিয়ভাবে এটিকে টেনসরফ্লোতে রূপান্তর করার জন্য আমাদের একটি রেপার ব্যবহার করা।

আসুন প্রথমে পাইথন পরিবেশ দেখি। TensorFlow এনভায়রনমেন্ট একটি খুব অনুরূপ API অনুসরণ করে।

সেটআপ

আপনি যদি এখনও টিএফ-এজেন্ট বা জিম ইনস্টল না করেন তবে চালান:

pip install "gym>=0.21.0"
pip install tf-agents
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import abc
import tensorflow as tf
import numpy as np

from tf_agents.environments import py_environment
from tf_agents.environments import tf_environment
from tf_agents.environments import tf_py_environment
from tf_agents.environments import utils
from tf_agents.specs import array_spec
from tf_agents.environments import wrappers
from tf_agents.environments import suite_gym
from tf_agents.trajectories import time_step as ts

পাইথন পরিবেশ

পাইথন পরিবেশের একটি আছে step(action) -> next_time_step পদ্ধতি পরিবেশ একটি কর্ম প্রযোজ্য, এবং পরবর্তী পদক্ষেপ সম্পর্কে নিম্নলিখিত তথ্য ফেরৎ যে:

  1. observation : এই পরিবেশ বলে যে এজেন্ট পরবর্তী ধাপে তার কি একশনে যাওয়া মান্য করতে পারেন অংশ।
  2. reward : এজেন্ট একাধিক পদক্ষেপ জুড়ে এই পুরস্কারের সমষ্টি বাড়ানোর লক্ষ্যে শেখার হয়।
  3. step_type : পরিবেশ সঙ্গে পারস্পরিক ক্রিয়ার সাধারণত একটি ক্রম / পর্ব অংশ। যেমন দাবা খেলায় একাধিক চাল। step_type হতে পারে পারেন FIRST , MID বা LAST ইঙ্গিত এই সময় পদক্ষেপ একটি ক্রম, প্রথম অন্তর্বর্তী বা শেষ পদক্ষেপ কিনা।
  4. discount : এটি একটি ভাসা বর্তমান সময় পদে পদে পুরস্কার পরের বার পদক্ষেপ আপেক্ষিক এ পুরস্কার ওজন কত প্রতিনিধিত্বমূলক হয়।

এই একটি নামে tuple ভাগে ভাগ করা হয় TimeStep(step_type, reward, discount, observation)

ইন্টারফেস যে সব পাইথন পরিবেশের বাস্তবায়ন করতে হবে হয় environments/py_environment.PyEnvironment । প্রধান পদ্ধতি হল:

class PyEnvironment(object):

  def reset(self):
    """Return initial_time_step."""
    self._current_time_step = self._reset()
    return self._current_time_step

  def step(self, action):
    """Apply action and return new time_step."""
    if self._current_time_step is None:
        return self.reset()
    self._current_time_step = self._step(action)
    return self._current_time_step

  def current_time_step(self):
    return self._current_time_step

  def time_step_spec(self):
    """Return time_step_spec."""

  @abc.abstractmethod
  def observation_spec(self):
    """Return observation_spec."""

  @abc.abstractmethod
  def action_spec(self):
    """Return action_spec."""

  @abc.abstractmethod
  def _reset(self):
    """Return initial_time_step."""

  @abc.abstractmethod
  def _step(self, action):
    """Apply action and return new time_step."""

ছাড়াও step() পদ্ধতি, পরিবেশের একটি প্রদান reset() পদ্ধতি যে একটি নতুন ক্রম শুরু ইনিশিয়াল উপলব্ধ TimeStep । সেটিতে কল করার প্রয়োজন নেই reset পদ্ধতি স্পষ্টভাবে। আমরা অনুমান করি যে পরিবেশগুলি স্বয়ংক্রিয়ভাবে পুনরায় সেট হয়, যখন তারা একটি পর্বের শেষে আসে বা যখন step () কে প্রথমবার বলা হয়।

লক্ষ্য করুন উপশ্রেণী বাস্তবায়ন না step() বা reset() সরাসরি। তার বদলে ওভাররাইড _step() এবং _reset() পদ্ধতি। এই পদ্ধতি থেকে প্রত্যাগত সময় পদক্ষেপ ক্যাশে মাধ্যমে প্রকাশ করা হবে current_time_step()

observation_spec এবং action_spec পদ্ধতির একটি নীড় আসতে (Bounded)ArraySpecs যে যথাক্রমে নাম, আকৃতি, ডাটাটাইপ ও পর্যবেক্ষণের এবং কর্ম রেঞ্জ বর্ণনা করে।

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

স্ট্যান্ডার্ড পরিবেশ ব্যবহার করে

মেমরি এজেন্ট বিল্ট-ইন করেছে OpenAI জিম, DeepMind-নিয়ন্ত্রণ ও Atari -এ মত অনেক মান পরিবেশের জন্য চাদরে, যাতে তারা আমাদের অনুসরণ py_environment.PyEnvironment ইন্টারফেস। এই আবৃত evironments সহজেই আমাদের পরিবেশ স্যুট ব্যবহার করে লোড করা যাবে। আসুন OpenAI জিম থেকে CartPole পরিবেশ লোড করি এবং অ্যাকশন এবং time_step_spec দেখি।

environment = suite_gym.load('CartPole-v0')
print('action_spec:', environment.action_spec())
print('time_step_spec.observation:', environment.time_step_spec().observation)
print('time_step_spec.step_type:', environment.time_step_spec().step_type)
print('time_step_spec.discount:', environment.time_step_spec().discount)
print('time_step_spec.reward:', environment.time_step_spec().reward)
action_spec: BoundedArraySpec(shape=(), dtype=dtype('int64'), name='action', minimum=0, maximum=1)
time_step_spec.observation: BoundedArraySpec(shape=(4,), dtype=dtype('float32'), name='observation', minimum=[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38], maximum=[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38])
time_step_spec.step_type: ArraySpec(shape=(), dtype=dtype('int32'), name='step_type')
time_step_spec.discount: BoundedArraySpec(shape=(), dtype=dtype('float32'), name='discount', minimum=0.0, maximum=1.0)
time_step_spec.reward: ArraySpec(shape=(), dtype=dtype('float32'), name='reward')

এতে দেখা যায় যে পরিবেশ ধরনের ক্রিয়া আশা int64 মধ্যে [0, 1] এবং আয় TimeSteps যেখানে পর্যবেক্ষণ একটি হয় float32 দৈর্ঘ্য 4 এবং ডিসকাউন্ট ফ্যাক্টর এর ভেক্টর একটি হল float32 [0.0, 1.0] এ। এখন, একটি নির্দিষ্ট পদক্ষেপ নিতে চেষ্টা করা যাক (1,) একটি সম্পূর্ণ পর্বের জন্য।

action = np.array(1, dtype=np.int32)
time_step = environment.reset()
print(time_step)
while not time_step.is_last():
  time_step = environment.step(action)
  print(time_step)
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.0138565 , -0.03582913,  0.04861612, -0.03755046], dtype=float32),
 'reward': array(0., dtype=float32),
 'step_type': array(0, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.01313992,  0.15856317,  0.0478651 , -0.3145069 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.01631118,  0.35297176,  0.04157497, -0.5917188 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.02337062,  0.54748774,  0.02974059, -0.87102115], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.03432037,  0.74219286,  0.01232017, -1.1542072 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.04916423,  0.93715197, -0.01076398, -1.4430016 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.06790727,  1.1324048 , -0.03962401, -1.7390285 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.09055536,  1.327955  , -0.07440457, -2.04377   ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.11711447,  1.523758  , -0.11527998, -2.3585167 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([ 0.14758962,  1.7197047 , -0.16245031, -2.6843033 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(0., dtype=float32),
 'observation': array([ 0.18198372,  1.9156038 , -0.21613638, -3.0218334 ], dtype=float32),
 'reward': array(1., dtype=float32),
 'step_type': array(2, dtype=int32)})

আপনার নিজস্ব পাইথন পরিবেশ তৈরি করা

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

ধরা যাক আমরা একজন এজেন্টকে নিম্নলিখিত (ব্ল্যাক জ্যাক অনুপ্রাণিত) কার্ড গেম খেলতে প্রশিক্ষণ দিতে চাই:

  1. গেমটি 1 ... 10 সংখ্যার কার্ডের অসীম ডেক ব্যবহার করে খেলা হয়।
  2. প্রতিটি মোড়ে এজেন্ট 2 টি কাজ করতে পারে: একটি নতুন র্যান্ডম কার্ড পান, অথবা বর্তমান রাউন্ড বন্ধ করুন।
  3. লক্ষ্য হল আপনার কার্ডের সমষ্টি যতটা সম্ভব রাউন্ডের শেষে যতটা সম্ভব 21 এর কাছাকাছি, না গিয়েই।

একটি পরিবেশ যা গেমটি উপস্থাপন করে তা এইরকম দেখতে পারে:

  1. ক্রিয়া: আমাদের ২ টি কাজ আছে। অ্যাকশন 0: একটি নতুন কার্ড পান এবং অ্যাকশন 1: বর্তমান রাউন্ডটি বন্ধ করুন।
  2. পর্যবেক্ষণ: বর্তমান রাউন্ডে কার্ডের যোগফল।
  3. পুরস্কার: উদ্দেশ্য হল যতটা সম্ভব 21 এর কাছাকাছি না যাওয়া, তাই আমরা রাউন্ড শেষে নিম্নলিখিত পুরস্কার ব্যবহার করে এটি অর্জন করতে পারি: sum_of_cards - 21 যদি sum_of_cards <= 21, অন্যথায় -21
class CardGameEnv(py_environment.PyEnvironment):

  def __init__(self):
    self._action_spec = array_spec.BoundedArraySpec(
        shape=(), dtype=np.int32, minimum=0, maximum=1, name='action')
    self._observation_spec = array_spec.BoundedArraySpec(
        shape=(1,), dtype=np.int32, minimum=0, name='observation')
    self._state = 0
    self._episode_ended = False

  def action_spec(self):
    return self._action_spec

  def observation_spec(self):
    return self._observation_spec

  def _reset(self):
    self._state = 0
    self._episode_ended = False
    return ts.restart(np.array([self._state], dtype=np.int32))

  def _step(self, action):

    if self._episode_ended:
      # The last action ended the episode. Ignore the current action and start
      # a new episode.
      return self.reset()

    # Make sure episodes don't go on forever.
    if action == 1:
      self._episode_ended = True
    elif action == 0:
      new_card = np.random.randint(1, 11)
      self._state += new_card
    else:
      raise ValueError('`action` should be 0 or 1.')

    if self._episode_ended or self._state >= 21:
      reward = self._state - 21 if self._state <= 21 else -21
      return ts.termination(np.array([self._state], dtype=np.int32), reward)
    else:
      return ts.transition(
          np.array([self._state], dtype=np.int32), reward=0.0, discount=1.0)

আসুন আমরা নিশ্চিত করি যে আমরা উপরের পরিবেশকে সঠিকভাবে সংজ্ঞায়িত করে সবকিছু করেছি। আপনার নিজের পরিবেশ তৈরি করার সময় আপনাকে অবশ্যই নিশ্চিত করতে হবে যে পর্যবেক্ষণ এবং time_steps আপনার চশমায় সংজ্ঞায়িত সঠিক আকার এবং প্রকার অনুসরণ করে। এগুলি টেন্সরফ্লো গ্রাফ তৈরি করতে ব্যবহৃত হয় এবং সেগুলি ভুল হলে ডিবাগ করা কঠিন হতে পারে।

আমাদের পরিবেশকে যাচাই করার জন্য আমরা কর্ম তৈরি করতে একটি এলোমেলো নীতি ব্যবহার করব এবং জিনিসগুলি উদ্দেশ্য অনুযায়ী কাজ করছে তা নিশ্চিত করার জন্য আমরা 5 টিরও বেশি পর্ব পুনরাবৃত্তি করব। একটি ত্রুটি উত্থাপিত হয় যদি আমরা একটি time_step পাই যা পরিবেশগত বৈশিষ্ট্য অনুসরণ করে না।

environment = CardGameEnv()
utils.validate_py_environment(environment, episodes=5)

এখন যেহেতু আমরা জানি যে পরিবেশটি উদ্দেশ্য অনুযায়ী কাজ করছে, আসুন একটি নির্দিষ্ট নীতি ব্যবহার করে এই পরিবেশটি চালাই: 3 টি কার্ডের জন্য জিজ্ঞাসা করুন এবং তারপর রাউন্ডটি শেষ করুন।

get_new_card_action = np.array(0, dtype=np.int32)
end_round_action = np.array(1, dtype=np.int32)

environment = CardGameEnv()
time_step = environment.reset()
print(time_step)
cumulative_reward = time_step.reward

for _ in range(3):
  time_step = environment.step(get_new_card_action)
  print(time_step)
  cumulative_reward += time_step.reward

time_step = environment.step(end_round_action)
print(time_step)
cumulative_reward += time_step.reward
print('Final Reward = ', cumulative_reward)
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([0], dtype=int32),
 'reward': array(0., dtype=float32),
 'step_type': array(0, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([9], dtype=int32),
 'reward': array(0., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(1., dtype=float32),
 'observation': array([12], dtype=int32),
 'reward': array(0., dtype=float32),
 'step_type': array(1, dtype=int32)})
TimeStep(
{'discount': array(0., dtype=float32),
 'observation': array([21], dtype=int32),
 'reward': array(0., dtype=float32),
 'step_type': array(2, dtype=int32)})
TimeStep(
{'discount': array(0., dtype=float32),
 'observation': array([21], dtype=int32),
 'reward': array(0., dtype=float32),
 'step_type': array(2, dtype=int32)})
Final Reward =  0.0

পরিবেশ মোড়ক

একটি পরিবেশ মোড়ক একটি পাইথন পরিবেশ নেয় এবং পরিবেশের একটি পরিবর্তিত সংস্করণ প্রদান করে। উভয় মূল পরিবেশ ও পরিবর্তিত পরিবেশের দৃষ্টান্ত হয় py_environment.PyEnvironment , এবং একাধিক চাদরে একসঙ্গে শৃঙ্খলিত করা যেতে পারে।

কিছু সাধারণ চাদরে খুঁজে পাওয়া যেতে পারে environments/wrappers.py । উদাহরণ স্বরূপ:

  1. ActionDiscretizeWrapper : পরিবর্তিত একটি বিযুক্ত কর্ম স্থান থেকে একটি ক্রমাগত কর্ম স্থান।
  2. RunStats : ধরা যেমন নেয়া ব্যবস্থার নম্বর হিসাবে পরিবেশের পরিসংখ্যান রান পর্বের সংখ্যা সম্পন্ন ইত্যাদি
  3. TimeLimit : ধাপের একটি নির্দিষ্ট নম্বরের পরে পর্বের বন্ধ।

উদাহরণ 1: অ্যাকশন ডিস্ক্রেটিজ রেপার

InvertedPendulum একটি PyBullet পরিবেশের সীমার মধ্যে একটানা কর্ম কবুল করেন [-2, 2] । যদি আমরা এই পরিবেশে DQN এর মতো একটি বিচ্ছিন্ন কর্ম এজেন্টকে প্রশিক্ষণ দিতে চাই, তাহলে আমাদের অ্যাকশন স্পেসকে বিচ্ছিন্ন (পরিমাপ) করতে হবে। এটি ঠিক কি ActionDiscretizeWrapper আছে। তুলনা করুন action_spec আগে ও মোড়ানো পরে:

env = suite_gym.load('Pendulum-v1')
print('Action Spec:', env.action_spec())

discrete_action_env = wrappers.ActionDiscretizeWrapper(env, num_actions=5)
print('Discretized Action Spec:', discrete_action_env.action_spec())
Action Spec: BoundedArraySpec(shape=(1,), dtype=dtype('float32'), name='action', minimum=-2.0, maximum=2.0)
Discretized Action Spec: BoundedArraySpec(shape=(), dtype=dtype('int32'), name='action', minimum=0, maximum=4)

আবৃত discrete_action_env একটি দৃষ্টান্ত হল py_environment.PyEnvironment এবং একটি নিয়মিত পাইথন পরিবেশ মত সারিয়ে তোলা যায়।

TensorFlow পরিবেশ

মেমরি পরিবেশের জন্য ইন্টারফেসে সংজ্ঞায়িত করা হয় environments/tf_environment.TFEnvironment ও খুব পাইথন পরিবেশের সেটির মতো। টিএফ এনভায়রনমেন্টগুলি কয়েকটি উপায়ে পাইথন এনভিএস থেকে আলাদা:

  • তারা অ্যারের পরিবর্তে টেন্সর বস্তু তৈরি করে
  • টিএফ পরিবেশগুলি স্পেসের সাথে তুলনা করার সময় উত্পন্ন টেন্সরগুলিতে একটি ব্যাচ মাত্রা যুক্ত করে।

পাইথন পরিবেশকে TFEnvs এ রূপান্তরিত করার ফলে টেন্সরফ্লো অপারেশন সমান্তরাল হতে পারে। উদাহরণস্বরূপ, এক একটি সংজ্ঞায়িত করতে পারে collect_experience_op যে পরিবেশ থেকে সংগ্রহ ডেটা এবং একটি যোগ replay_buffer , এবং একটি train_op থেকে সার্চ replay_buffer এবং এজেন্ট রেলগাড়ি, এবং TensorFlow প্রাকৃতিকভাবে সমান্তরাল তাদের চালানো।

class TFEnvironment(object):

  def time_step_spec(self):
    """Describes the `TimeStep` tensors returned by `step()`."""

  def observation_spec(self):
    """Defines the `TensorSpec` of observations provided by the environment."""

  def action_spec(self):
    """Describes the TensorSpecs of the action expected by `step(action)`."""

  def reset(self):
    """Returns the current `TimeStep` after resetting the Environment."""
    return self._reset()

  def current_time_step(self):
    """Returns the current `TimeStep`."""
    return self._current_time_step()

  def step(self, action):
    """Applies the action and returns the new `TimeStep`."""
    return self._step(action)

  @abc.abstractmethod
  def _reset(self):
    """Returns the current `TimeStep` after resetting the Environment."""

  @abc.abstractmethod
  def _current_time_step(self):
    """Returns the current `TimeStep`."""

  @abc.abstractmethod
  def _step(self, action):
    """Applies the action and returns the new `TimeStep`."""

current_time_step() পদ্ধতি বর্তমান time_step ফেরৎ এবং পরিবেশ সূচনা প্রয়োজনে।

reset() পদ্ধতি বাহিনীর পরিবেশ ও আয় CURRENT_STEP একটি পুনরায় সেট করুন।

যদি action পূর্ববর্তী উপর নির্ভর করে না time_step একটি tf.control_dependency প্রয়োজন হয় Graph মোড।

এখনকার জন্য, কীভাবে তাকান TFEnvironments নির্মিত হয়।

আপনার নিজস্ব TensorFlow পরিবেশ তৈরি করা

পাইথনে পরিবেশ তৈরির চেয়ে এটি আরও জটিল, তাই আমরা এটিকে এই কোলাবে আবৃত করব না। একটি উদাহরণ পাওয়া যায় এখানে । আরো সাধারণ ব্যবহারের ক্ষেত্রে পাইথন আপনার পরিবেশ বাস্তবায়ন এবং আমাদের ব্যবহার TensorFlow মধ্যে এটি মোড়ানো হয় TFPyEnvironment মোড়কের (নিচে দেখুন)।

টেনসরফ্লোতে একটি পাইথন পরিবেশ মোড়ানো

আমরা সহজে ব্যবহার করে একটি TensorFlow পরিবেশের মধ্যে কোনো পাইথন পরিবেশ মোড়ানো পারেন TFPyEnvironment মোড়কের।

env = suite_gym.load('CartPole-v0')
tf_env = tf_py_environment.TFPyEnvironment(env)

print(isinstance(tf_env, tf_environment.TFEnvironment))
print("TimeStep Specs:", tf_env.time_step_spec())
print("Action Specs:", tf_env.action_spec())
True
TimeStep Specs: TimeStep(
{'discount': BoundedTensorSpec(shape=(), dtype=tf.float32, name='discount', minimum=array(0., dtype=float32), maximum=array(1., dtype=float32)),
 'observation': BoundedTensorSpec(shape=(4,), dtype=tf.float32, name='observation', minimum=array([-4.8000002e+00, -3.4028235e+38, -4.1887903e-01, -3.4028235e+38],
      dtype=float32), maximum=array([4.8000002e+00, 3.4028235e+38, 4.1887903e-01, 3.4028235e+38],
      dtype=float32)),
 'reward': TensorSpec(shape=(), dtype=tf.float32, name='reward'),
 'step_type': TensorSpec(shape=(), dtype=tf.int32, name='step_type')})
Action Specs: BoundedTensorSpec(shape=(), dtype=tf.int64, name='action', minimum=array(0), maximum=array(1))

উল্লেখ্য চশমা ধরনের এখন আছেন: (Bounded)TensorSpec

ব্যবহারের উদাহরণ

সহজ উদাহরণ

env = suite_gym.load('CartPole-v0')

tf_env = tf_py_environment.TFPyEnvironment(env)
# reset() creates the initial time_step after resetting the environment.
time_step = tf_env.reset()
num_steps = 3
transitions = []
reward = 0
for i in range(num_steps):
  action = tf.constant([i % 2])
  # applies the action and returns the new TimeStep.
  next_time_step = tf_env.step(action)
  transitions.append([time_step, action, next_time_step])
  reward += next_time_step.reward
  time_step = next_time_step

np_transitions = tf.nest.map_structure(lambda x: x.numpy(), transitions)
print('\n'.join(map(str, np_transitions)))
print('Total reward:', reward.numpy())
[TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.0078796 , -0.04736348, -0.04966116,  0.04563603]],
      dtype=float32),
 'reward': array([0.], dtype=float32),
 'step_type': array([0], dtype=int32)}), array([0], dtype=int32), TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.00882687, -0.24173944, -0.04874843,  0.32224613]],
      dtype=float32),
 'reward': array([1.], dtype=float32),
 'step_type': array([1], dtype=int32)})]
[TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.00882687, -0.24173944, -0.04874843,  0.32224613]],
      dtype=float32),
 'reward': array([1.], dtype=float32),
 'step_type': array([1], dtype=int32)}), array([1], dtype=int32), TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.01366166, -0.04595843, -0.04230351,  0.01459712]],
      dtype=float32),
 'reward': array([1.], dtype=float32),
 'step_type': array([1], dtype=int32)})]
[TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.01366166, -0.04595843, -0.04230351,  0.01459712]],
      dtype=float32),
 'reward': array([1.], dtype=float32),
 'step_type': array([1], dtype=int32)}), array([0], dtype=int32), TimeStep(
{'discount': array([1.], dtype=float32),
 'observation': array([[-0.01458083, -0.24044897, -0.04201157,  0.2936384 ]],
      dtype=float32),
 'reward': array([1.], dtype=float32),
 'step_type': array([1], dtype=int32)})]
Total reward: [3.]

পুরো পর্ব

env = suite_gym.load('CartPole-v0')
tf_env = tf_py_environment.TFPyEnvironment(env)

time_step = tf_env.reset()
rewards = []
steps = []
num_episodes = 5

for _ in range(num_episodes):
  episode_reward = 0
  episode_steps = 0
  while not time_step.is_last():
    action = tf.random.uniform([1], 0, 2, dtype=tf.int32)
    time_step = tf_env.step(action)
    episode_steps += 1
    episode_reward += time_step.reward.numpy()
  rewards.append(episode_reward)
  steps.append(episode_steps)
  time_step = tf_env.reset()

num_steps = np.sum(steps)
avg_length = np.mean(steps)
avg_reward = np.mean(rewards)

print('num_episodes:', num_episodes, 'num_steps:', num_steps)
print('avg_length', avg_length, 'avg_reward:', avg_reward)
num_episodes: 5 num_steps: 131
avg_length 26.2 avg_reward: 26.2