דף זה תורגם על ידי Cloud Translation API.
Switch to English

מיניאטור SAC עם ממשק API של שחקן-לומד

זכויות יוצרים 2021 מחברי TF-Agents.

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה במקור ב- GitHub הורד מחברת

מבוא

דוגמה זו מראה כיצד להכשיר סוכן ביקורת של שחקן רך בסביבת המיניטאור .

אם עבדת באמצעות ה- DQN Colab זה אמור להרגיש מוכר מאוד. שינויים בולטים כוללים:

  • החלפת הסוכן מ- DQN ל- SAC.
  • אימונים על מיניטאור שהיא סביבה הרבה יותר מורכבת מ- CartPole. סביבת המיניטאור שואפת להכשיר רובוט מרובע להתקדם.
  • שימוש ב- API של TF-Agents Actor-Learner ללימוד חיזוק מבוזר.

ה- API תומך הן באיסוף נתונים מבוזרים באמצעות מאגר הפעלה חווייתי ומיכל משתנה (שרת פרמטרים) והן בהדרכה מבוזרת על פני מספר מכשירים. ה- API נועד להיות מאוד פשוט ומודולרי. אנו משתמשים ב- Reverb הן עבור מאגר הפעלה חוזרת והן עבור מיכל משתנה ו- TF DistributionStrategy API לאימונים מבוזרים על GPUs ו- TPU.

אם לא התקנת את התלות הבאות, הפעל:

sudo apt-get install -y xvfb ffmpeg
pip install -q 'imageio==2.4.0'
pip install -q matplotlib
pip install -q tf-agents[reverb]
pip install -q 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-Agents באמצעות suites . יש לנו suites שונות לטעינת סביבות ממקורות כגון OpenAI Gym, Atari, DM Control וכו ', שקיבלו שם סביבת מחרוזות.

עכשיו בואו נטען את סביבת Minituar מחבילת Pybullet.

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

current_dir=/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/pybullet_envs/bullet
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/pybullet_data

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: WARN: Box bound precision lowered by casting to float32
  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))

png

בסביבה זו המטרה היא שהסוכן יכשיר מדיניות שתשלוט ברובוט המיניטאור ותעבור אותו קדימה במהירות האפשרית. פרקים נמשכים 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] . אלה זוויות המנוע הרצויות.

בדרך כלל אנו יוצרים שתי סביבות: אחת לאיסוף נתונים במהלך האימון ואחת להערכה. הסביבות כתובות בפיתון טהור ומשתמשות במערכים קהים, אותם ממשק ה- API של השחקן לומד צורכת ישירות.

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

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

אסטרטגיית הפצה

אנו משתמשים ב- API של DistributionStrategy כדי לאפשר הפעלת חישוב צעדים ברכבת על פני מספר מכשירים כגון GPUs או TPU מרובים באמצעות מקביליות נתונים. שלב הרכבת:

  • מקבל קבוצה של נתוני אימון
  • מפצל אותו על פני המכשירים
  • מחשב את הצעד קדימה
  • מצטבר ומחשב את ה- MEAN של ההפסד
  • מחשבת את הצעד לאחור ומבצעת עדכון משתנה שיפוע

עם ממשק ה- API של TF-Agents Learner ו- DistributionStrategy API זה די קל לעבור בין הפעלת שלב הרכבת על GPUs (באמצעות MirroredStrategy) ל- TPU (באמצעות TPUStrategy) מבלי לשנות את כל לוגיקת האימונים שלמטה.

הפעלת ה- GPU

אם אתה רוצה לנסות לרוץ על GPU, תחילה תצטרך להפעיל GPUs עבור המחשב הנייד:

  • נווט לערוך → הגדרות מחברת
  • בחר GPU מהתפריט הנפתח Hardware Accelerator

בוחרים אסטרטגיה

השתמש strategy_utils כדי ליצור אסטרטגיה. מתחת למכסה המנוע, מעביר את הפרמטר:

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() , כפי שתראה בהמשך.

סוֹכֵן

כדי ליצור סוכן SAC, ראשית עלינו ליצור את הרשתות שהוא יאמן. SAC הוא סוכן מבקר שחקנים, ולכן נצטרך שתי רשתות.

המבקר יתן לנו הערכות ערך עבור 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 ינבא פרמטרים להפצה מרובת משתנים ActorNetwork . לאחר מכן תידגם חלוקה זו, המותנית בתצפית הנוכחית, בכל פעם שנצטרך לייצר פעולות.

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.compat.v1.train.AdamOptimizer(
            learning_rate=actor_learning_rate),
        critic_optimizer=tf.compat.v1.train.AdamOptimizer(
            learning_rate=critic_learning_rate),
        alpha_optimizer=tf.compat.v1.train.AdamOptimizer(
            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()

הפעל מחדש את המאגר

על מנת לעקוב אחר הנתונים שנאספו מהסביבה, נשתמש ב- Reverb , מערכת הפעלה חוזרת יעילה, ניתנת להרחבה ונוחה לשימוש על ידי Deepmind. הוא מאחסן נתוני ניסיון שנאספו על ידי השחקנים ונצרכים על ידי הלומד במהלך האימון.

במדריך זה, זה פחות חשוב מ- max_size - אך בסביבה מבוזרת עם איסוף max_size async, סביר להניח שתרצה להתנסות עם rate_limiters.SampleToInsertRatio , תוך שימוש ב- samples_per_insert איפשהו בין 2 ל 1000. לדוגמא:

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

חיץ tf_agent.collect_data_spec החוזר בנוי באמצעות מפרט המתאר את הטנזורים tf_agent.collect_data_spec להיות מאוחסנים, אותם ניתן להשיג מהסוכן באמצעות tf_agent.collect_data_spec .

מכיוון שסוכן SAC זקוק לתצפית הנוכחית וגם הבאה כדי לחשב את האובדן, הגדרנו 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)

כעת אנו מייצרים מערך נתונים של TensorFlow ממאגר ההפעלה החוזר. נעביר את זה ללומד כדי לדגום חוויות לאימון.

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

מדיניות

ב- TF-Agents, מדיניות מייצגת את הרעיון הסטנדרטי של מדיניות ב- RL: נתון time_step לייצר פעולה או התפלגות על פעולות. השיטה העיקרית היא policy_step = policy.step(time_step) כאשר policy_step הוא שם tuple 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 כדי ליצור מדיניות שתבחר באופן אקראי פעולה לכל שלב_פעולה.

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)

WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/linalg/linear_operator_diag.py:175: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.
Instructions for updating:
Do not pass `graph_parents`.  They will  no longer be used.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/linalg/linear_operator_diag.py:175: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.
Instructions for updating:
Do not pass `graph_parents`.  They will  no longer be used.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7f1dff58ef60>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7f1dff33efd0>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7f1dff58ef60>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7f1dff217cc0>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7f1dff58ef60>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7f1dff139e80>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7f1dff58ef60>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7f1d8b16ea90>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
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.
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: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.
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

INFO:tensorflow:Assets written to: /tmp/policies/greedy_policy/assets
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7f1dff58ef60>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7f1d8af23be0>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
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.
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:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tf_agents/train/learner.py:122: 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.6/site-packages/tf_agents/train/learner.py:122: 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

מדדים והערכה

שינינו את שחקן actor.eval_metrics עם השחקן 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.346627, AverageEpisodeLength = 86.349998

עיין במודול המדדים למידע סטנדרטי אחר של מדדים שונים.

הכשרת הסוכן

לולאת ההדרכה כוללת גם איסוף נתונים מהסביבה וגם אופטימיזציה של רשתות הסוכן. בדרך נעריך מדי פעם את מדיניות הסוכן כדי לראות מה שלומנו.

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

step = 5000: loss = -56.69059753417969
step = 10000: AverageReturn = -0.472410, AverageEpisodeLength = 164.899994
step = 10000: loss = -54.17033004760742
step = 15000: loss = -28.52847671508789
step = 20000: AverageReturn = -0.172086, AverageEpisodeLength = 93.349998
step = 20000: loss = -20.480314254760742
step = 25000: loss = -12.228870391845703
step = 30000: AverageReturn = -0.775230, AverageEpisodeLength = 251.449997
step = 30000: loss = -7.371895790100098
step = 35000: loss = -5.757593154907227
step = 40000: AverageReturn = -1.189717, AverageEpisodeLength = 330.600006
step = 40000: loss = -2.23077654838562
step = 45000: loss = -2.0682435035705566
step = 50000: AverageReturn = -1.436991, AverageEpisodeLength = 592.700012
step = 50000: loss = 2.793757438659668
step = 55000: loss = 0.9165877103805542
step = 60000: AverageReturn = -1.421196, AverageEpisodeLength = 630.849976
step = 60000: loss = -1.5204321146011353
step = 65000: loss = 1.119447112083435
step = 70000: AverageReturn = -0.937966, AverageEpisodeLength = 574.400024
step = 70000: loss = 4.193424224853516
step = 75000: loss = 4.100306034088135
step = 80000: AverageReturn = 0.252701, AverageEpisodeLength = 527.799988
step = 80000: loss = -1.2829862833023071
step = 85000: loss = -3.3187692165374756
step = 90000: AverageReturn = 1.051066, AverageEpisodeLength = 614.000000
step = 90000: loss = -0.4716823101043701
step = 95000: loss = 0.616091251373291
step = 100000: AverageReturn = 0.888614, AverageEpisodeLength = 376.600006
step = 100000: loss = -0.057090915739536285

רְאִיָה

עלילות

אנו יכולים לתכנן תשואה ממוצעת לעומת צעדים גלובליים כדי לראות את ביצועי הסוכן שלנו. Minitaur , פונקציית התגמול מבוססת על כמה רחוק המיניטאור הולך ב -1000 צעדים ומעניש את הוצאת האנרגיה.

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

(-1.5613936901092529, 1.175468635559082)

png

סרטונים

מועיל לדמיין את ביצועיו של סוכן על ידי עיבוד הסביבה בכל שלב. לפני שנעשה זאת, בואו ניצור תחילה פונקציה להטמעת סרטונים בקולבה זו.

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)