वातावरण

कॉपीराइट 2021 टीएफ-एजेंट लेखक।

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

परिचय

रीइन्फोर्समेंट लर्निंग (आरएल) का लक्ष्य ऐसे एजेंटों को डिजाइन करना है जो पर्यावरण के साथ बातचीत करके सीखते हैं। मानक आरएल सेटिंग में, एजेंट हर कदम पर एक अवलोकन प्राप्त करता है और एक कार्रवाई चुनता है। कार्रवाई पर्यावरण पर लागू होती है और पर्यावरण एक इनाम और एक नया अवलोकन देता है। एजेंट पुरस्कारों के योग को अधिकतम करने के लिए कार्रवाइयों को चुनने के लिए एक नीति तैयार करता है, जिसे रिटर्न के रूप में भी जाना जाता है।

TF-Agents में, वातावरण को Python या TensorFlow में लागू किया जा सकता है। पायथन वातावरण आमतौर पर लागू करना, समझना और डिबग करना आसान होता है, लेकिन TensorFlow वातावरण अधिक कुशल होते हैं और प्राकृतिक समानांतरकरण की अनुमति देते हैं। सबसे आम वर्कफ़्लो पायथन में एक वातावरण को लागू करना है और हमारे एक रैपर का उपयोग करके इसे स्वचालित रूप से TensorFlow में परिवर्तित करना है।

आइए पहले पायथन के वातावरण को देखें। TensorFlow वातावरण एक बहुत ही समान API का अनुसरण करता है।

सेट अप

यदि आपने अभी तक tf-एजेंट या जिम स्थापित नहीं किया है, तो दौड़ें:

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 : यह एक नाव वर्तमान समय कदम पर इनाम के लिए अगली बार कदम रिश्तेदार पर इनाम वजन करने के लिए कितना प्रतिनिधित्व करता है।

ये एक नामित टपल में बांटा गया है 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() या reset() सीधे। इसके बजाय उन्हें ओवरराइड _step() और _reset() तरीकों। इन तरीकों से लौटे समय चरणों कैश की गई और के माध्यम से संपर्क में आएंगे current_time_step()

observation_spec और action_spec तरीकों में से एक घोंसला वापसी (Bounded)ArraySpecs कि क्रमशः नाम, आकार, डेटाप्रकार और टिप्पणियों और कार्यों की सीमाओं का वर्णन।

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

मानक वातावरण का उपयोग करना

TF एजेंटों अंतर्निहित OpenAI जिम, DeepMind नियंत्रण और अटारी जैसे कई मानक वातावरण के लिए रैपर, ताकि वे हमारे पालन py_environment.PyEnvironment इंटरफ़ेस। इन लिपटे हुए वातावरण को हमारे पर्यावरण सूट का उपयोग करके आसानी से लोड किया जा सकता है। आइए 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)})

अपना खुद का पायथन पर्यावरण बनाना

कई ग्राहकों के लिए, एक सामान्य उपयोग मामला TF-Agents में उनकी समस्या के लिए एक मानक एजेंट (एजेंट/ देखें) को लागू करना है। ऐसा करने के लिए, उन्हें अपनी समस्या को पर्यावरण के रूप में तैयार करना होगा। तो आइए देखें कि पायथन में पर्यावरण को कैसे लागू किया जाए।

मान लें कि हम एक एजेंट को निम्नलिखित (ब्लैक जैक प्रेरित) कार्ड गेम खेलने के लिए प्रशिक्षित करना चाहते हैं:

1. खेल 1...10 क्रमांकित ताश के पत्तों के एक अनंत डेक का उपयोग करके खेला जाता है।
2. हर मोड़ पर एजेंट 2 काम कर सकता है: एक नया यादृच्छिक कार्ड प्राप्त करें, या वर्तमान दौर को रोकें।
3. लक्ष्य यह है कि राउंड के अंत में अपने कार्डों का योग जितना संभव हो उतना करीब 21 प्राप्त करें, बिना आगे बढ़े।

खेल का प्रतिनिधित्व करने वाला एक वातावरण इस तरह दिख सकता है:

1. क्रियाएँ: हमारे पास 2 कार्य हैं। क्रिया 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)

आइए सुनिश्चित करें कि हमने उपरोक्त परिवेश को परिभाषित करते हुए सब कुछ सही ढंग से किया है। अपना स्वयं का वातावरण बनाते समय आपको यह सुनिश्चित करना चाहिए कि उत्पन्न किए गए अवलोकन और समय_चरण आपके विनिर्देशों में परिभाषित सही आकार और प्रकारों का पालन करते हैं। इनका उपयोग TensorFlow ग्राफ़ उत्पन्न करने के लिए किया जाता है और अगर हम उन्हें गलत पाते हैं तो डिबग करने के लिए कठिन समस्याएं पैदा कर सकते हैं।

हमारे पर्यावरण को मान्य करने के लिए हम कार्यों को उत्पन्न करने के लिए एक यादृच्छिक नीति का उपयोग करेंगे और हम यह सुनिश्चित करने के लिए 5 एपिसोड से अधिक पुनरावृति करेंगे कि चीजें इरादे के अनुसार काम कर रही हैं। यदि हमें एक टाइम_स्टेप प्राप्त होता है जो पर्यावरण विनिर्देशों का पालन नहीं करता है, तो एक त्रुटि उत्पन्न होती है।

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] । यदि हम इस वातावरण पर डीक्यूएन जैसे असतत एक्शन एजेंट को प्रशिक्षित करना चाहते हैं, तो हमें एक्शन स्पेस को अलग करना (मात्राबद्ध) करना होगा। यह वास्तव में क्या है 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 वातावरण

TF वातावरण के लिए इंटरफ़ेस में परिभाषित किया गया है environments/tf_environment.TFEnvironment और बहुत अजगर वातावरण के समान दिखता है। TF वातावरण कुछ तरीकों से Python envs से भिन्न होता है:

• वे सरणियों के बजाय टेंसर ऑब्जेक्ट उत्पन्न करते हैं
• TF वातावरण स्पेक्स की तुलना में उत्पन्न टेंसर में एक बैच आयाम जोड़ता है।

पायथन वातावरण को 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 वापस आती है और वातावरण initializes यदि आवश्यक हो तो।

reset() विधि बलों पर्यावरण और रिटर्न CURRENT_STEP में रीसेट।

तो action पिछले पर निर्भर नहीं करता time_step एक tf.control_dependency की जरूरत है Graph मोड।

अभी के लिए, हमें कैसे को देखो TFEnvironments बनाई गई हैं।

अपना खुद का TensorFlow परिवेश बनाना

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

TensorFlow में एक पायथन पर्यावरण लपेटना

हम आसानी से उपयोग कर एक 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