זכויות יוצרים 2021 מחברי TF-Agents.
![]() | ![]() | ![]() | ![]() |
מבוא
דוגמה זו מראה כיצד להכשיר סוכן ביקורת של שחקן רך בסביבת המיניטאור .
אם עבדת באמצעות ה- 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'))
בסביבה זו המטרה היא שהסוכן יכשיר מדיניות שתשלוט ברובוט המיניטאור ותעבור אותו קדימה במהירות האפשרית. פרקים נמשכים 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 = False
מחזירtf.distribute.get_strategy()
, המשתמש במעבד -
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()
, כפי שתראה בהמשך.
סוֹכֵן
כדי ליצור סוכן 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)
סרטונים
מועיל לדמיין את ביצועיו של סוכן על ידי עיבוד הסביבה בכל שלב. לפני שנעשה זאת, בואו ניצור תחילה פונקציה להטמעת סרטונים בקולבה זו.
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)