अभिनेता-लर्नर एपीआई के साथ सैक मिनीटॉर

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

TensorFlow.org पर देखें

Google Colab में चलाएं

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

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

परिचय

इस उदाहरण से पता चलता है कि कैसे एक प्रशिक्षित करने के लिए शीतल अभिनेता समालोचक पर एजेंट Minitaur वातावरण।

आप के माध्यम से काम किया है DQN Colab इस बहुत परिचित महसूस करना चाहिए। उल्लेखनीय परिवर्तनों में शामिल हैं:

• एजेंट को DQN से SAC में बदलना।
• मिनिटौर पर प्रशिक्षण जो कार्टपोल की तुलना में कहीं अधिक जटिल वातावरण है। मिनिटौर पर्यावरण का लक्ष्य एक चौगुनी रोबोट को आगे बढ़ने के लिए प्रशिक्षित करना है।
• वितरित सुदृढीकरण सीखने के लिए टीएफ-एजेंट अभिनेता-लर्नर एपीआई का उपयोग करना।

एपीआई एक अनुभव रिप्ले बफर और वैरिएबल कंटेनर (पैरामीटर सर्वर) और कई उपकरणों में वितरित प्रशिक्षण का उपयोग करके वितरित डेटा संग्रह दोनों का समर्थन करता है। एपीआई को बहुत ही सरल और मॉड्यूलर बनाया गया है। हम उपयोग गूंज दोनों पुनरावृत्ति बफर और वैरिएबल कंटेनर और के लिए TF DistributionStrategy एपीआई GPUs और tpus पर वितरित प्रशिक्षण के लिए।

यदि आपने निम्नलिखित निर्भरताएँ स्थापित नहीं की हैं, तो चलाएँ:

sudo apt-get update
sudo apt-get install -y xvfb ffmpeg
pip install 'imageio==2.4.0'
pip install matplotlib
pip install tf-agents[reverb]
pip install pybullet

सेट अप

पहले हम उन विभिन्न उपकरणों को आयात करेंगे जिनकी हमें आवश्यकता है।

import base64
import imageio
import IPython
import matplotlib.pyplot as plt
import os
import reverb
import tempfile
import PIL.Image

import tensorflow as tf

from tf_agents.agents.ddpg import critic_network
from tf_agents.agents.sac import sac_agent
from tf_agents.agents.sac import tanh_normal_projection_network
from tf_agents.environments import suite_pybullet
from tf_agents.metrics import py_metrics
from tf_agents.networks import actor_distribution_network
from tf_agents.policies import greedy_policy
from tf_agents.policies import py_tf_eager_policy
from tf_agents.policies import random_py_policy
from tf_agents.replay_buffers import reverb_replay_buffer
from tf_agents.replay_buffers import reverb_utils
from tf_agents.train import actor
from tf_agents.train import learner
from tf_agents.train import triggers
from tf_agents.train.utils import spec_utils
from tf_agents.train.utils import strategy_utils
from tf_agents.train.utils import train_utils

tempdir = tempfile.gettempdir()

हाइपरपैरामीटर

env_name = "MinitaurBulletEnv-v0" # @param {type:"string"}

# Use "num_iterations = 1e6" for better results (2 hrs)
# 1e5 is just so this doesn't take too long (1 hr)
num_iterations = 100000 # @param {type:"integer"}

initial_collect_steps = 10000 # @param {type:"integer"}
collect_steps_per_iteration = 1 # @param {type:"integer"}
replay_buffer_capacity = 10000 # @param {type:"integer"}

batch_size = 256 # @param {type:"integer"}

critic_learning_rate = 3e-4 # @param {type:"number"}
actor_learning_rate = 3e-4 # @param {type:"number"}
alpha_learning_rate = 3e-4 # @param {type:"number"}
target_update_tau = 0.005 # @param {type:"number"}
target_update_period = 1 # @param {type:"number"}
gamma = 0.99 # @param {type:"number"}
reward_scale_factor = 1.0 # @param {type:"number"}

actor_fc_layer_params = (256, 256)
critic_joint_fc_layer_params = (256, 256)

log_interval = 5000 # @param {type:"integer"}

num_eval_episodes = 20 # @param {type:"integer"}
eval_interval = 10000 # @param {type:"integer"}

policy_save_interval = 5000 # @param {type:"integer"}

पर्यावरण

RL में परिवेश उस कार्य या समस्या का प्रतिनिधित्व करते हैं जिसे हम हल करने का प्रयास कर रहे हैं। स्टैंडर्ड वातावरण आसानी से उपयोग कर रहा TF-एजेंटों में बनाया जा सकता suites । हम अलग-अलग है suites ऐसे OpenAI जिम, अटारी, डीएम नियंत्रण, आदि जैसे स्रोतों से वातावरण लोड हो रहा है, एक स्ट्रिंग पर्यावरण नाम दिया है।

अब पाइबुलेट सूट से मिनिटुअर वातावरण को लोड करते हैं।

env = suite_pybullet.load(env_name)
env.reset()
PIL.Image.fromarray(env.render())

pybullet build time: Oct 11 2021 20:59:00
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/gym/spaces/box.py:74: UserWarning: WARN: Box bound precision lowered by casting to float32
  "Box bound precision lowered by casting to {}".format(self.dtype)
current_dir=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_envs/bullet
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data

इस माहौल में लक्ष्य एजेंट के लिए एक नीति को प्रशिक्षित करना है जो मिनिटौर रोबोट को नियंत्रित करेगा और इसे जितनी जल्दी हो सके आगे बढ़ाए। एपिसोड 1000 चरणों तक चलते हैं और वापसी पूरे एपिसोड में पुरस्कारों का योग होगी।

जानकारी पर आइए नज़र पर्यावरण एक के रूप में प्रदान करता है observation जो नीति उत्पन्न करने के लिए प्रयोग करेंगे actions ।

print('Observation Spec:')
print(env.time_step_spec().observation)
print('Action Spec:')
print(env.action_spec())

Observation Spec:
BoundedArraySpec(shape=(28,), dtype=dtype('float32'), name='observation', minimum=[  -3.1515927   -3.1515927   -3.1515927   -3.1515927   -3.1515927
   -3.1515927   -3.1515927   -3.1515927 -167.72488   -167.72488
 -167.72488   -167.72488   -167.72488   -167.72488   -167.72488
 -167.72488     -5.71        -5.71        -5.71        -5.71
   -5.71        -5.71        -5.71        -5.71        -1.01
   -1.01        -1.01        -1.01     ], maximum=[  3.1515927   3.1515927   3.1515927   3.1515927   3.1515927   3.1515927
   3.1515927   3.1515927 167.72488   167.72488   167.72488   167.72488
 167.72488   167.72488   167.72488   167.72488     5.71        5.71
   5.71        5.71        5.71        5.71        5.71        5.71
   1.01        1.01        1.01        1.01     ])
Action Spec:
BoundedArraySpec(shape=(8,), dtype=dtype('float32'), name='action', minimum=-1.0, maximum=1.0)

अवलोकन काफी जटिल है। हम सभी मोटरों के लिए कोणों, वेगों और टोक़ों का प्रतिनिधित्व करने वाले 28 मान प्राप्त करते हैं। बदले में पर्यावरण के बीच कार्यों के लिए 8 मान उम्मीद [-1, 1] । ये वांछित मोटर कोण हैं।

आमतौर पर हम दो वातावरण बनाते हैं: एक प्रशिक्षण के दौरान डेटा एकत्र करने के लिए और दूसरा मूल्यांकन के लिए। वातावरण शुद्ध पायथन में लिखा गया है और numpy arrays का उपयोग करता है, जिसे अभिनेता लर्नर एपीआई सीधे उपभोग करता है।

collect_env = suite_pybullet.load(env_name)
eval_env = suite_pybullet.load(env_name)

urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data

वितरण रणनीति

हम डेटा समांतरता का उपयोग करते हुए कई GPU या TPU जैसे कई उपकरणों में ट्रेन चरण गणना को चलाने में सक्षम करने के लिए वितरण रणनीति एपीआई का उपयोग करते हैं। ट्रेन कदम:

• प्रशिक्षण डेटा का एक बैच प्राप्त करता है
• इसे सभी उपकरणों में विभाजित करता है
• आगे के चरण की गणना करता है
• हानि के माध्य को एकत्रित और परिकलित करता है
• बैकवर्ड स्टेप की गणना करता है और एक ग्रेडिएंट वेरिएबल अपडेट करता है

टीएफ-एजेंट्स लर्नर एपीआई और डिस्ट्रीब्यूशनस्ट्रेटी एपीआई के साथ नीचे दिए गए किसी भी प्रशिक्षण तर्क को बदले बिना जीपीयू (मिररडस्ट्रेटी का उपयोग करके) से टीपीयू (टीपीयूस्ट्रेटी का उपयोग करके) पर ट्रेन स्टेप चलाने के बीच स्विच करना काफी आसान है।

GPU को सक्षम करना

यदि आप GPU पर चलने का प्रयास करना चाहते हैं, तो आपको पहले नोटबुक के लिए GPU सक्षम करना होगा:

• संपादित करने के लिए नेविगेट करें → नोटबुक सेटिंग्स
• हार्डवेयर एक्सेलेरेटर ड्रॉप-डाउन से GPU चुनें

रणनीति चुनना

का प्रयोग करें strategy_utils एक रणनीति उत्पन्न करने के लिए। हुड के तहत, पैरामीटर पास करना:

• use_gpu = False रिटर्न tf.distribute.get_strategy() , जो CPU का उपयोग करता है
• use_gpu = True रिटर्न tf.distribute.MirroredStrategy() है, जो सभी GPUs है कि एक मशीन पर TensorFlow लिए दिखाई दे रहे हैं का उपयोग करता है

use_gpu = True

strategy = strategy_utils.get_strategy(tpu=False, use_gpu=use_gpu)

INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

सभी चर और एजेंटों के तहत बनाई जाने की जरूरत है strategy.scope() , जैसा कि आप नीचे देख सकते हैं।

एजेंट

एक सैक एजेंट बनाने के लिए, हमें पहले नेटवर्क बनाने की जरूरत है जिसे वह प्रशिक्षित करेगा। सैक एक अभिनेता-आलोचक एजेंट है, इसलिए हमें दो नेटवर्क की आवश्यकता होगी।

आलोचक के लिए हमें मूल्य अनुमान दे देंगे Q(s,a) । यही है, यह इनपुट के रूप में एक अवलोकन और एक क्रिया प्राप्त करेगा, और यह हमें एक अनुमान देगा कि दिए गए राज्य के लिए वह कार्रवाई कितनी अच्छी थी।

observation_spec, action_spec, time_step_spec = (
      spec_utils.get_tensor_specs(collect_env))

with strategy.scope():
  critic_net = critic_network.CriticNetwork(
        (observation_spec, action_spec),
        observation_fc_layer_params=None,
        action_fc_layer_params=None,
        joint_fc_layer_params=critic_joint_fc_layer_params,
        kernel_initializer='glorot_uniform',
        last_kernel_initializer='glorot_uniform')

हम एक प्रशिक्षित करने के लिए इस आलोचक का उपयोग करेगा actor नेटवर्क है जो हमें एक अवलोकन दिया कार्यों उत्पन्न करने के लिए अनुमति देगा।

ActorNetwork एक tanh-कुचल के लिए मानकों का पूर्वानुमान लगाने लगेगा MultivariateNormalDiag वितरण। जब भी हमें क्रियाओं को उत्पन्न करने की आवश्यकता होगी, इस वितरण को नमूना, वर्तमान अवलोकन पर वातानुकूलित किया जाएगा।

with strategy.scope():
  actor_net = actor_distribution_network.ActorDistributionNetwork(
      observation_spec,
      action_spec,
      fc_layer_params=actor_fc_layer_params,
      continuous_projection_net=(
          tanh_normal_projection_network.TanhNormalProjectionNetwork))

हाथ में इन नेटवर्क के साथ अब हम एजेंट को इंस्टेंट कर सकते हैं।

with strategy.scope():
  train_step = train_utils.create_train_step()

  tf_agent = sac_agent.SacAgent(
        time_step_spec,
        action_spec,
        actor_network=actor_net,
        critic_network=critic_net,
        actor_optimizer=tf.keras.optimizers.Adam(
            learning_rate=actor_learning_rate),
        critic_optimizer=tf.keras.optimizers.Adam(
            learning_rate=critic_learning_rate),
        alpha_optimizer=tf.keras.optimizers.Adam(
            learning_rate=alpha_learning_rate),
        target_update_tau=target_update_tau,
        target_update_period=target_update_period,
        td_errors_loss_fn=tf.math.squared_difference,
        gamma=gamma,
        reward_scale_factor=reward_scale_factor,
        train_step_counter=train_step)

  tf_agent.initialize()

फिर से खेलना बफर

आदेश वातावरण से एकत्र किए गए आंकड़ों का ट्रैक रखने के लिए, हम का उपयोग करेगा गूंज , Deepmind द्वारा एक कुशल, एक्स्टेंसिबल, और आसान से उपयोग पुनरावृत्ति प्रणाली। यह अभिनेताओं द्वारा एकत्र किए गए अनुभव डेटा को संग्रहीत करता है और प्रशिक्षण के दौरान शिक्षार्थी द्वारा उपभोग किया जाता है।

इस ट्यूटोरियल में, इस से कम महत्वपूर्ण है max_size - लेकिन async संग्रह और प्रशिक्षण के साथ एक वितरित की स्थापना में, तो आप शायद के साथ प्रयोग करना चाहते हैं rate_limiters.SampleToInsertRatio , उदाहरण के लिए 2 और 1000 के बीच एक samples_per_insert कहीं का उपयोग कर:

rate_limiter=reverb.rate_limiters.SampleToInsertRatio(samples_per_insert=3.0, min_size_to_sample=3, error_buffer=3.0)

table_name = 'uniform_table'
table = reverb.Table(
    table_name,
    max_size=replay_buffer_capacity,
    sampler=reverb.selectors.Uniform(),
    remover=reverb.selectors.Fifo(),
    rate_limiter=reverb.rate_limiters.MinSize(1))

reverb_server = reverb.Server([table])

[reverb/cc/platform/tfrecord_checkpointer.cc:150]  Initializing TFRecordCheckpointer in /tmp/tmpl579aohk.
[reverb/cc/platform/tfrecord_checkpointer.cc:386] Loading latest checkpoint from /tmp/tmpl579aohk
[reverb/cc/platform/default/server.cc:71] Started replay server on port 15652

पुनरावृत्ति बफर tensors कि संग्रहीत करने के लिए कर रहे हैं, जो का उपयोग कर एजेंट से प्राप्त किया जा सकता का वर्णन चश्मा का उपयोग कर निर्माण किया है tf_agent.collect_data_spec ।

चूंकि सैक एजेंट दोनों वर्तमान और अगले अवलोकन हानि की गणना करने की जरूरत है, हम सेट sequence_length=2 ।

reverb_replay = reverb_replay_buffer.ReverbReplayBuffer(
    tf_agent.collect_data_spec,
    sequence_length=2,
    table_name=table_name,
    local_server=reverb_server)

अब हम Reverb रीप्ले बफर से एक TensorFlow डेटासेट जेनरेट करते हैं। हम इसे शिक्षार्थी को प्रशिक्षण के अनुभवों के नमूने के लिए देंगे।

dataset = reverb_replay.as_dataset(
      sample_batch_size=batch_size, num_steps=2).prefetch(50)
experience_dataset_fn = lambda: dataset

नीतियों

TF-एजेंटों में, नीतियों आर एल में नीतियों के मानक धारणा का प्रतिनिधित्व करते हैं: किसी दिए गए time_step एक कार्रवाई या कार्यों पर एक वितरण का उत्पादन। मुख्य विधि है policy_step = policy.step(time_step) जहां policy_step एक नामित टपल है PolicyStep(action, state, info) । policy_step.action है action पर्यावरण के लिए लागू किया जाना है, state स्टेटफुल (RNN) की नीतियों और के लिए राज्य का प्रतिनिधित्व करता info इस तरह के कार्यों के लॉग संभावनाओं के रूप में सहायक जानकारी हो सकती है।

एजेंटों में दो नीतियां होती हैं:

• agent.policy - मुख्य नीति है कि मूल्यांकन और तैनाती के लिए प्रयोग किया जाता है।
• agent.collect_policy - एक दूसरा नीति है कि डेटा संग्रह के लिए प्रयोग किया जाता है।

tf_eval_policy = tf_agent.policy
eval_policy = py_tf_eager_policy.PyTFEagerPolicy(
  tf_eval_policy, use_tf_function=True)

tf_collect_policy = tf_agent.collect_policy
collect_policy = py_tf_eager_policy.PyTFEagerPolicy(
  tf_collect_policy, use_tf_function=True)

नीतियां एजेंटों से स्वतंत्र रूप से बनाई जा सकती हैं। उदाहरण के लिए, का उपयोग tf_agents.policies.random_py_policy एक नीति है जो बेतरतीब ढंग से प्रत्येक time_step के लिए एक कार्य का चयन करेंगे बनाने के लिए।

random_policy = random_py_policy.RandomPyPolicy(
  collect_env.time_step_spec(), collect_env.action_spec())

अभिनेताओं

अभिनेता एक नीति और एक पर्यावरण के बीच बातचीत का प्रबंधन करता है।

• अभिनेता घटकों (के रूप में पर्यावरण का एक उदाहरण शामिल py_environment ) और नीति चर की एक प्रति।
• प्रत्येक अभिनेता कार्यकर्ता नीति चर के स्थानीय मूल्यों को देखते हुए डेटा संग्रह चरणों का एक क्रम चलाता है।
• चर अपडेट कॉल करने से पहले स्पष्ट रूप से प्रशिक्षण लिपि में वैरिएबल कंटेनर ग्राहक उदाहरण का उपयोग किया जाता है actor.run()
• मनाया गया अनुभव प्रत्येक डेटा संग्रह चरण में रिप्ले बफर में लिखा जाता है।

जैसे ही अभिनेता डेटा संग्रह चरण चलाते हैं, वे पर्यवेक्षक को (राज्य, क्रिया, इनाम) के प्रक्षेपवक्र पास करते हैं, जो उन्हें रीवरब रीप्ले सिस्टम को कैश और लिखता है।

हम फ्रेम के लिए प्रक्षेप पथ भंडारण कर रहे हैं [(t0, t1) (T1, T2) (t2, T3), ...] क्योंकि stride_length=1 ।

rb_observer = reverb_utils.ReverbAddTrajectoryObserver(
  reverb_replay.py_client,
  table_name,
  sequence_length=2,
  stride_length=1)

हम यादृच्छिक नीति के साथ एक अभिनेता बनाते हैं और रिप्ले बफर को सीड करने के लिए अनुभव एकत्र करते हैं।

initial_collect_actor = actor.Actor(
  collect_env,
  random_policy,
  train_step,
  steps_per_run=initial_collect_steps,
  observers=[rb_observer])
initial_collect_actor.run()

प्रशिक्षण के दौरान अधिक अनुभव एकत्र करने के लिए एक अभिनेता को एकत्रित नीति के साथ तत्काल करें।

env_step_metric = py_metrics.EnvironmentSteps()
collect_actor = actor.Actor(
  collect_env,
  collect_policy,
  train_step,
  steps_per_run=1,
  metrics=actor.collect_metrics(10),
  summary_dir=os.path.join(tempdir, learner.TRAIN_DIR),
  observers=[rb_observer, env_step_metric])

एक अभिनेता बनाएं जिसका उपयोग प्रशिक्षण के दौरान नीति का मूल्यांकन करने के लिए किया जाएगा। हम में पारित actor.eval_metrics(num_eval_episodes) बाद में मैट्रिक्स लॉग इन करें।

eval_actor = actor.Actor(
  eval_env,
  eval_policy,
  train_step,
  episodes_per_run=num_eval_episodes,
  metrics=actor.eval_metrics(num_eval_episodes),
  summary_dir=os.path.join(tempdir, 'eval'),
)

शिक्षार्थियों

लर्नर कंपोनेंट में एजेंट होता है और रिप्ले बफर से अनुभव डेटा का उपयोग करके पॉलिसी वैरिएबल में ग्रेडिएंट स्टेप अपडेट करता है। एक या अधिक प्रशिक्षण चरणों के बाद, शिक्षार्थी चर मानों के एक नए सेट को चर कंटेनर में धकेल सकता है।

saved_model_dir = os.path.join(tempdir, learner.POLICY_SAVED_MODEL_DIR)

# Triggers to save the agent's policy checkpoints.
learning_triggers = [
    triggers.PolicySavedModelTrigger(
        saved_model_dir,
        tf_agent,
        train_step,
        interval=policy_save_interval),
    triggers.StepPerSecondLogTrigger(train_step, interval=1000),
]

agent_learner = learner.Learner(
  tempdir,
  train_step,
  tf_agent,
  experience_dataset_fn,
  triggers=learning_triggers,
  strategy=strategy)

WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_probability/python/distributions/distribution.py:342: calling MultivariateNormalDiag.__init__ (from tensorflow_probability.python.distributions.mvn_diag) with scale_identity_multiplier is deprecated and will be removed after 2020-01-01.
Instructions for updating:
`scale_identity_multiplier` is deprecated; please combine it into `scale_diag` directly instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_probability/python/distributions/distribution.py:342: calling MultivariateNormalDiag.__init__ (from tensorflow_probability.python.distributions.mvn_diag) with scale_identity_multiplier is deprecated and will be removed after 2020-01-01.
Instructions for updating:
`scale_identity_multiplier` is deprecated; please combine it into `scale_diag` directly instead.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fe64b86ce90>". Calling saved_model.distribution() will raise the following assertion error: missing a required argument: 'distribution'
2021-12-01 12:19:19.139118: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fe64b86ce90>". Calling saved_model.distribution() will raise the following assertion error: missing a required argument: 'distribution'
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fe64b86ce90>". Calling saved_model.distribution() will raise the following assertion error: missing a required argument: 'distribution'
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/policies/policy/assets
INFO:tensorflow:Assets written to: /tmp/policies/policy/assets
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fe64b86ce90>". Calling saved_model.distribution() will raise the following assertion error: missing a required argument: 'distribution'
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/policies/collect_policy/assets
INFO:tensorflow:Assets written to: /tmp/policies/collect_policy/assets
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/policies/greedy_policy/assets
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/saved_model/nested_structure_coder.py:561: UserWarning: Encoding a StructuredValue with type tf_agents.policies.greedy_policy.DeterministicWithLogProb_ACTTypeSpec; loading this StructuredValue will require that this type be imported and registered.
  "imported and registered." % type_spec_class_name)
INFO:tensorflow:Assets written to: /tmp/policies/greedy_policy/assets
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tf_agents/train/learner.py:151: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tf_agents/train/learner.py:151: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function

मेट्रिक्स और मूल्यांकन

हम साथ eval अभिनेता instantiated actor.eval_metrics जो नीति मूल्यांकन के दौरान सबसे अधिक इस्तेमाल किया मैट्रिक्स बनाता है ऊपर,:

• औसत रिटर्न। वापसी एक एपिसोड के लिए एक वातावरण में पॉलिसी चलाते समय प्राप्त पुरस्कारों का योग है, और हम आमतौर पर इसे कुछ एपिसोड में औसत करते हैं।
• औसत एपिसोड की लंबाई।

हम इन मेट्रिक्स को उत्पन्न करने के लिए अभिनेता चलाते हैं।

def get_eval_metrics():
  eval_actor.run()
  results = {}
  for metric in eval_actor.metrics:
    results[metric.name] = metric.result()
  return results

metrics = get_eval_metrics()

def log_eval_metrics(step, metrics):
  eval_results = (', ').join(
      '{} = {:.6f}'.format(name, result) for name, result in metrics.items())
  print('step = {0}: {1}'.format(step, eval_results))

log_eval_metrics(0, metrics)

step = 0: AverageReturn = -0.963870, AverageEpisodeLength = 204.100006

की जाँच करें मैट्रिक्स मॉड्यूल विभिन्न मीट्रिक के अन्य मानक कार्यान्वयन के लिए।

एजेंट को प्रशिक्षण

प्रशिक्षण लूप में पर्यावरण से डेटा एकत्र करना और एजेंट के नेटवर्क को अनुकूलित करना दोनों शामिल हैं। रास्ते में, हम कभी-कभी एजेंट की नीति का मूल्यांकन करके देखेंगे कि हम कैसे कर रहे हैं।

try:
  %%time
except:
  pass

# Reset the train step
tf_agent.train_step_counter.assign(0)

# Evaluate the agent's policy once before training.
avg_return = get_eval_metrics()["AverageReturn"]
returns = [avg_return]

for _ in range(num_iterations):
  # Training.
  collect_actor.run()
  loss_info = agent_learner.run(iterations=1)

  # Evaluating.
  step = agent_learner.train_step_numpy

  if eval_interval and step % eval_interval == 0:
    metrics = get_eval_metrics()
    log_eval_metrics(step, metrics)
    returns.append(metrics["AverageReturn"])

  if log_interval and step % log_interval == 0:
    print('step = {0}: loss = {1}'.format(step, loss_info.loss.numpy()))

rb_observer.close()
reverb_server.stop()

[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
[reverb/cc/client.cc:163] Sampler and server are owned by the same process (14227) so Table uniform_table is accessed directly without gRPC.
step = 5000: loss = -50.77360153198242
step = 10000: AverageReturn = -0.734191, AverageEpisodeLength = 299.399994
step = 10000: loss = -57.17308044433594
step = 15000: loss = -31.02552032470703
step = 20000: AverageReturn = -1.243302, AverageEpisodeLength = 432.200012
step = 20000: loss = -20.673084259033203
step = 25000: loss = -12.919441223144531
step = 30000: AverageReturn = -0.205654, AverageEpisodeLength = 280.049988
step = 30000: loss = -5.420497417449951
step = 35000: loss = -4.320608139038086
step = 40000: AverageReturn = -1.193502, AverageEpisodeLength = 378.000000
step = 40000: loss = -4.375732421875
step = 45000: loss = -3.0430049896240234
step = 50000: AverageReturn = -1.299686, AverageEpisodeLength = 482.549988
step = 50000: loss = -0.8907612562179565
step = 55000: loss = 1.2096503973007202
step = 60000: AverageReturn = -0.949927, AverageEpisodeLength = 365.899994
step = 60000: loss = 1.8157628774642944
step = 65000: loss = -4.9070353507995605
step = 70000: AverageReturn = -0.644635, AverageEpisodeLength = 506.399994
step = 70000: loss = -0.33166465163230896
step = 75000: loss = -0.41273507475852966
step = 80000: AverageReturn = 0.331935, AverageEpisodeLength = 604.299988
step = 80000: loss = 1.5354682207107544
step = 85000: loss = -2.058459997177124
step = 90000: AverageReturn = 0.292840, AverageEpisodeLength = 520.450012
step = 90000: loss = 1.2136361598968506
step = 95000: loss = -1.810737133026123
step = 100000: AverageReturn = 0.835265, AverageEpisodeLength = 515.349976
step = 100000: loss = -2.6997461318969727
[reverb/cc/platform/default/server.cc:84] Shutting down replay server

VISUALIZATION

भूखंडों

हम अपने एजेंट के प्रदर्शन को देखने के लिए औसत रिटर्न बनाम वैश्विक कदमों की साजिश कर सकते हैं। में Minitaur , इनाम समारोह कितनी दूर minitaur 1000 चरणों में चलता है और ऊर्जा व्यय penalizes पर आधारित है।

steps = range(0, num_iterations + 1, eval_interval)
plt.plot(steps, returns)
plt.ylabel('Average Return')
plt.xlabel('Step')
plt.ylim()

(-1.4064332604408265, 0.9420127034187317)

वीडियो

प्रत्येक चरण पर परिवेश का प्रतिपादन करके किसी एजेंट के प्रदर्शन की कल्पना करना सहायक होता है। ऐसा करने से पहले, आइए पहले इस कोलाब में वीडियो एम्बेड करने के लिए एक फ़ंक्शन बनाएं।

def embed_mp4(filename):
  """Embeds an mp4 file in the notebook."""
  video = open(filename,'rb').read()
  b64 = base64.b64encode(video)
  tag = '''
  <video width="640" height="480" controls>
    <source src="data:video/mp4;base64,{0}" type="video/mp4">
  Your browser does not support the video tag.
  </video>'''.format(b64.decode())

  return IPython.display.HTML(tag)

निम्नलिखित कोड कुछ एपिसोड के लिए एजेंट की नीति की कल्पना करता है:

num_episodes = 3
video_filename = 'sac_minitaur.mp4'
with imageio.get_writer(video_filename, fps=60) as video:
  for _ in range(num_episodes):
    time_step = eval_env.reset()
    video.append_data(eval_env.render())
    while not time_step.is_last():
      action_step = eval_actor.policy.action(time_step)
      time_step = eval_env.step(action_step.action)
      video.append_data(eval_env.render())

embed_mp4(video_filename)