This page was translated by the Cloud Translation API.
Switch to English

এসএসি minitaur

কপিরাইট 2018 মেমরি-এজেন্ট রচয়িতা।

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

ভূমিকা

নিচের উদাহরনের মাধ্যমে দেখানো একটি ট্রেন কিভাবে নরম অভিনেতার ক্রিটিক উপর এজেন্ট Minitaur মেমরি-এজেন্ট লাইব্রেরি ব্যবহার পরিবেশ।

আপনি মাধ্যমে কাজ করে থাকেন তাহলে DQN Colab এই খুব পরিচিত মনে করা উচিত নয়। উল্লেখযোগ্য পরিবর্তনগুলি অন্তর্ভুক্ত:

  • DQN থেকে এসএসি করতে এজেন্ট পরিবর্তন।
  • Minitaur উপর প্রশিক্ষণ CartPole তুলনায় অনেক বেশি জটিল পরিবেশ পারে। Minitaur পরিবেশ লক্ষ্য একটি চতুষ্পদ প্রাণী রোবট প্রশিক্ষণের অগ্রসর।
  • আমরা ইনিশিয়াল তথ্য সংগ্রহ সম্পাদন করার জন্য একটা র্যান্ডম নীতি ব্যবহার করবেন না।

আপনি নিম্নলিখিত নির্ভরতা ইনস্টল না করে থাকেন, সঞ্চালন করুন:

sudo apt-get install -y xvfb ffmpeg
pip install -q 'gym==0.10.11'
pip install -q 'imageio==2.4.0'
pip install -q matplotlib
pip install -q PILLOW
pip install -q --pre tf-agents[reverb]
pip install -q 'pybullet==2.4.2'



ffmpeg is already the newest version (7:3.4.8-0ubuntu0.2).
xvfb is already the newest version (2:1.19.6-1ubuntu4.4).
The following packages were automatically installed and are no longer required:
  dconf-gsettings-backend dconf-service dkms freeglut3 freeglut3-dev
  glib-networking glib-networking-common glib-networking-services
  gsettings-desktop-schemas libcairo-gobject2 libcolord2 libdconf1
  libegl1-mesa libepoxy0 libglu1-mesa libglu1-mesa-dev libgtk-3-0
  libgtk-3-common libice-dev libjansson4 libjson-glib-1.0-0
  libjson-glib-1.0-common libproxy1v5 librest-0.7-0 libsm-dev
  libsoup-gnome2.4-1 libsoup2.4-1 libxi-dev libxmu-dev libxmu-headers
  libxnvctrl0 libxt-dev linux-gcp-headers-5.0.0-1026
  linux-headers-5.0.0-1026-gcp linux-image-5.0.0-1026-gcp
  linux-modules-5.0.0-1026-gcp pkg-config policykit-1-gnome python3-xkit
  screen-resolution-extra xserver-xorg-core-hwe-18.04
Use 'sudo apt autoremove' to remove them.
0 upgraded, 0 newly installed, 0 to remove and 90 not upgraded.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.

সেটআপ

আমরা প্রথমে যে আমরা প্রয়োজন এবং নিশ্চিত যে মেমরি-থেকে V2 আচরণ সক্ষম যেমন colab সর্বত্র উৎসুক মোডে পুনরুক্তি করতে সহজ হয় বিভিন্ন সরঞ্জাম আমদানি করবে।

 from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import base64
import imageio
import IPython
import matplotlib
import matplotlib.pyplot as plt
import PIL.Image

import tensorflow as tf
tf.compat.v1.enable_v2_behavior()

from tf_agents.agents.ddpg import critic_network
from tf_agents.agents.sac import sac_agent
from tf_agents.drivers import dynamic_step_driver
from tf_agents.environments import suite_pybullet
from tf_agents.environments import tf_py_environment
from tf_agents.eval import metric_utils
from tf_agents.metrics import tf_metrics
from tf_agents.networks import actor_distribution_network
from tf_agents.networks import normal_projection_network
from tf_agents.policies import greedy_policy
from tf_agents.policies import random_tf_policy
from tf_agents.replay_buffers import tf_uniform_replay_buffer
from tf_agents.trajectories import trajectory
from tf_agents.utils import common

 

Hyperparameters

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

# use "num_iterations = 1e6" for better results,
# 1e5 is just so this doesn't take too long. 
num_iterations = 100000 # @param {type:"integer"}

initial_collect_steps = 10000 # @param {type:"integer"} 
collect_steps_per_iteration = 1 # @param {type:"integer"}
replay_buffer_capacity = 1000000 # @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"}
gradient_clipping = None # @param

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

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

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

পরিবেশ

আরএল মধ্যে পরিবেশ রয়েছে যা আমরা সমাধান করার চেষ্টা করছেন কাজ বা সমস্যা প্রতিনিধিত্ব করে। স্ট্যান্ডার্ড পরিবেশের সহজে ব্যবহার মেমরি-এজেন্ট এবং তৈরি করা যেতে পারে suites । আমরা বিভিন্ন আছে suites যেমন OpenAI জিম, Atari -এ, ডিএম নিয়ন্ত্রণ, ইত্যাদি উৎস থেকে পরিবেশের লোড একটি স্ট্রিং পরিবেশ নাম দেওয়া জন্য।

এখন Pybullet সংকলন থেকে Minituar পরিবেশ লোড করা যাক।

 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
options= 

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: WARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.
  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))

PNG

এই পরিবেশে লক্ষ্য এজেন্ট এমন একটি নীতি Minitaur রোবট নিয়ন্ত্রণ এবং এটি এগিয়ে যতটা সম্ভব দ্রুত সরানো হবে প্রশিক্ষণের জন্য। পর্বগুলি 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)

আমরা যেমন পর্যবেক্ষণ দেখতে পারেন মোটামুটি জটিল। আমরা কোণ, বেগ এবং সব মোটর জন্য torques প্রতিনিধিত্বমূলক 28 মান recieve। বিনিময়ে পরিবেশের মধ্যে কর্মের জন্য 8 মান প্রত্যাশিত [-1, 1] । এই আকাঙ্ক্ষিত মোটর কোণ আছে।

সাধারণত আমরা দুটি পরিবেশের তৈরি করুন: প্রশিক্ষণের জন্য এক ও মূল্যায়ন জন্য। সর্বাধিক পরিবেশের বিশুদ্ধ পাইথন লেখা হয়, কিন্তু তারা সহজে ব্যবহার TensorFlow রূপান্তরিত করা যেতে পারে TFPyEnvironment মোড়কের। মূল পরিবেশ এর API- numpy অ্যারে ব্যবহার করে, TFPyEnvironment এই / থেকে পরিবর্তন করে Tensors আপনাকে জন্য আরও সহজে ইন্টারঅ্যাক্ট TensorFlow নীতি ও এজেন্টদের সঙ্গে।

 train_py_env = suite_pybullet.load(env_name)
eval_py_env = suite_pybullet.load(env_name)

train_env = tf_py_environment.TFPyEnvironment(train_py_env)
eval_env = tf_py_environment.TFPyEnvironment(eval_py_env)
 
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/pybullet_data
options= 
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/pybullet_data
options= 

প্রতিনিধি

একটি এসএসি এজেন্ট তৈরি করতে হলে, আমরা প্রথমে নেটওয়ার্ক এটি শেখাতে হবে তৈরি করতে হবে। তাই আমরা দুটি নেটওয়ার্কের প্রয়োজন হবে এসএসি, একটি অভিনেতা-সমালোচক এজেন্ট।

সমালোচক জন্য আমাদের সাথে মান অনুমান দেব Q(s,a) । অর্থাৎ ইনপুট হিসাবে একটি পর্যবেক্ষণ এবং একটি কর্ম recieve হবে, এবং এটা আমাদের কীভাবে কর্ম প্রদত্ত রাজ্যের জন্য ছিল ভালো একটি অনুমান দেব।

 observation_spec = train_env.observation_spec()
action_spec = train_env.action_spec()
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)
 

আমরা একটি প্রশিক্ষণের জন্য এই সমালোচক ব্যবহার করবে actor নেটওয়ার্কের যা আমাদের একটি পর্যবেক্ষণ দেওয়া ক্রিয়া জেনারেট করতে অনুমতি দেবে।

ActorNetwork একটি সাধারণ বন্টনের জন্য পরামিতি ভবিষ্যদ্বাণী করা হবে। এই বন্টন তারপর নমুনা হবে, বর্তমান পর্যবেক্ষণের ওপর নিয়ন্ত্রিত যখনই আমরা ক্রিয়া উৎপন্ন করা প্রয়োজন।

 def normal_projection_net(action_spec,init_means_output_factor=0.1):
  return normal_projection_network.NormalProjectionNetwork(
      action_spec,
      mean_transform=None,
      state_dependent_std=True,
      init_means_output_factor=init_means_output_factor,
      std_transform=sac_agent.std_clip_transform,
      scale_distribution=True)


actor_net = actor_distribution_network.ActorDistributionNetwork(
    observation_spec,
    action_spec,
    fc_layer_params=actor_fc_layer_params,
    continuous_projection_net=normal_projection_net)
 

হাতে এই নেটওয়ার্কের সঙ্গে আমরা এখন এজেন্ট instantiate পারবেন না।

 global_step = tf.compat.v1.train.get_or_create_global_step()
tf_agent = sac_agent.SacAgent(
    train_env.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.compat.v1.losses.mean_squared_error,
    gamma=gamma,
    reward_scale_factor=reward_scale_factor,
    gradient_clipping=gradient_clipping,
    train_step_counter=global_step)
tf_agent.initialize()
 

নীতিসমূহ

মেমরি-এজেন্ট, নীতি আরএল মধ্যে নীতি মান ধারণা প্রতিনিধিত্ব: একটি প্রদত্ত time_step একটি কর্ম বা কর্মের উপর একটি বিতরণ উত্পাদন। প্রধান পদ্ধতি policy_step = policy.step(time_step) যেখানে policy_step একটি নামাঙ্কিত tuple হয় PolicyStep(action, state, info)policy_step.action হয় action পরিবেশ প্রয়োগ করা, state stateful (RNN) নীতি ও প্রতিমন্ত্রী প্রতিনিধিত্ব করে info যেমন কর্ম লগ সম্ভাব্যতা যেমন অক্জিলিয়ারী তথ্য থাকতে পারে।

প্রধান নীতি (agent.policy) এবং আচরণগত নীতি তথ্য সংগ্রহ (agent.collect_policy) জন্য ব্যবহৃত হয়: এজেন্ট দুই নীতি ধারণ করে। মূল্যায়ন / স্থাপনার জন্য, আমরা GreedyPolicy সঙ্গে প্রধান নীতি মোড়কে গড় ব্যবস্থা গ্রহণ ()।

 eval_policy = greedy_policy.GreedyPolicy(tf_agent.policy)
collect_policy = tf_agent.collect_policy
 

মেট্রিক্স ও মূল্যায়ন

সবচেয়ে সাধারণ মেট্রিক একটি নীতি নির্ণয় করতে ব্যবহার করা গড় দিকেই প্রত্যাবর্তন হবে। রিটার্ন একটি পর্বে জন্য একটা পরিবেশে একটি নীতি চালানোর সময় প্রাপ্ত পুরস্কারের সমষ্টি, এবং আমরা সাধারণত কয়েক পর্বের উপর এই গড়। নিম্নরূপ আমরা গড় রিটার্ন মেট্রিক গনা পারবেন না।

 def compute_avg_return(environment, policy, num_episodes=5):

  total_return = 0.0
  for _ in range(num_episodes):

    time_step = environment.reset()
    episode_return = 0.0

    while not time_step.is_last():
      action_step = policy.action(time_step)
      time_step = environment.step(action_step.action)
      episode_return += time_step.reward
    total_return += episode_return

  avg_return = total_return / num_episodes
  return avg_return.numpy()[0]


compute_avg_return(eval_env, eval_policy, num_eval_episodes)

# Please also see the metrics module for standard implementations of different
# metrics.
 
-0.022013525

রিপ্লে বাফার

অর্ডার ডেটা পরিবেশ থেকে সংগৃহীত ট্র্যাক রাখতে করার জন্য, আমরা TFUniformReplayBuffer ব্যবহার করবে। এই রিপ্লে বাফার tensors এই সঞ্চিত হবে, যা ব্যবহার করে এজেন্ট থেকে প্রাপ্ত করা যাবে বর্ণনা চশমা ব্যবহার করে নির্মিত হয় tf_agent.collect_data_spec

 replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(
    data_spec=tf_agent.collect_data_spec,
    batch_size=train_env.batch_size,
    max_length=replay_buffer_capacity)
 

সবচেয়ে এজেন্ট জন্য, collect_data_spec একটি হল Trajectory পর্যবেক্ষণ, কর্ম ধারণকারী tuple নামে, পুরস্কৃত ইত্যাদি

তথ্য সংগ্রহ

এখন আমরা সঙ্গে রিপ্লে বাফার বীজ সংগ্রহ অভিজ্ঞতা একজন চালক তৈরি করবে। ড্রাইভার collecter এটি একটি সহজ উপায় সঙ্গে আমাদের প্রদান n পদক্ষেপ বা একটি পরিবেশ একটি নির্দিষ্ট নীতি ব্যবহার করে উপর পর্ব।

 initial_collect_driver = dynamic_step_driver.DynamicStepDriver(
        train_env,
        collect_policy,
        observers=[replay_buffer.add_batch],
        num_steps=initial_collect_steps)
initial_collect_driver.run()
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tf_agents/drivers/dynamic_step_driver.py:203: calling while_loop_v2 (from tensorflow.python.ops.control_flow_ops) with back_prop=False is deprecated and will be removed in a future version.
Instructions for updating:
back_prop=False is deprecated. Consider using tf.stop_gradient instead.
Instead of:
results = tf.while_loop(c, b, vars, back_prop=False)
Use:
results = tf.nest.map_structure(tf.stop_gradient, tf.while_loop(c, b, vars))

(TimeStep(step_type=<tf.Tensor: shape=(1,), dtype=int32, numpy=array([1], dtype=int32)>, reward=<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.00101085], dtype=float32)>, discount=<tf.Tensor: shape=(1,), dtype=float32, numpy=array([1.], dtype=float32)>, observation=<tf.Tensor: shape=(1, 28), dtype=float32, numpy=
 array([[  1.308478  ,   2.166422  ,   1.5081352 ,   2.0260656 ,
           2.1123457 ,   1.114552  ,   1.5866141 ,   1.524472  ,
           6.9441314 ,   6.6945276 ,  -7.403659  , -20.185253  ,
          -4.8489103 ,  -1.2003611 , -19.449749  , -16.223652  ,
           4.2634044 ,   0.371617  ,  -0.92654324,  -3.8810008 ,
          -5.7       ,   3.10348   ,  -2.9569836 ,   3.916052  ,
           0.0551226 ,   0.10631521,  -0.09753982,   0.9880003 ]],
       dtype=float32)>),
 ())

রিপ্লে বাফার থেকে নমুনা তথ্য জন্য, আমরা একটি তৈরি করবে tf.data পাইপলাইন যা আমরা পরে প্রশিক্ষণ জন্য এজেন্টকে ভোজন পারবেন না। আমরা নির্দিষ্ট করতে পারেন sample_batch_size রিপ্লে বাফার থেকে নমুনা আইটেম সংখ্যা কনফিগার করতে। আমরা সমান্তরাল কল ও পূর্বআনয়ন ব্যবহার করে তথ্য পাইপলাইন নিখুত পারবেন না।

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

 # Dataset generates trajectories with shape [Bx2x...]
dataset = replay_buffer.as_dataset(
    num_parallel_calls=3, sample_batch_size=batch_size, num_steps=2).prefetch(3)

iterator = iter(dataset)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/autograph/operators/control_flow.py:1004: ReplayBuffer.get_next (from tf_agents.replay_buffers.replay_buffer) is deprecated and will be removed in a future version.
Instructions for updating:
Use `as_dataset(..., single_deterministic_pass=False) instead.

এজেন্ট প্রশিক্ষণ

প্রশিক্ষণ লুপ উভয় পরিবেশ থেকে তথ্য সংগ্রহ ও এজেন্টের নেটওয়ার্ক নিখুঁত জড়িত। পথ ধরে, আমরা মাঝে মাঝে দেখতে আমরা কেমন করছি এজেন্ট নীতির মূল্যায়ন করবো।

 collect_driver = dynamic_step_driver.DynamicStepDriver(
    train_env,
    collect_policy,
    observers=[replay_buffer.add_batch],
    num_steps=collect_steps_per_iteration)
 
 
try:
  %%time
except:
  pass

# (Optional) Optimize by wrapping some of the code in a graph using TF function.
tf_agent.train = common.function(tf_agent.train)
collect_driver.run = common.function(collect_driver.run)

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

# Evaluate the agent's policy once before training.
avg_return = compute_avg_return(eval_env, eval_policy, num_eval_episodes)
returns = [avg_return]

for _ in range(num_iterations):

  # Collect a few steps using collect_policy and save to the replay buffer.
  collect_driver.run()

  # Sample a batch of data from the buffer and update the agent's network.
  experience, unused_info = next(iterator)
  train_loss = tf_agent.train(experience)

  step = tf_agent.train_step_counter.numpy()

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

  if step % eval_interval == 0:
    avg_return = compute_avg_return(eval_env, eval_policy, num_eval_episodes)
    print('step = {0}: Average Return = {1}'.format(step, avg_return))
    returns.append(avg_return)
 
WARNING:absl:Need to use a loss function that computes losses per sample, ex: replace losses.mean_squared_error with tf.math.squared_difference. Invalid value passed for `per_example_loss`. Expected a tensor tensor with at least rank 1, received: Tensor("critic_loss/add_1:0", shape=(), dtype=float32)
WARNING:absl:Need to use a loss function that computes losses per sample, ex: replace losses.mean_squared_error with tf.math.squared_difference. Invalid value passed for `per_example_loss`. Expected a tensor tensor with at least rank 1, received: Tensor("critic_loss/add_1:0", shape=(), dtype=float32)

step = 5000: loss = -63.16588592529297
step = 10000: loss = -61.471351623535156
step = 10000: Average Return = 0.07441557198762894
step = 15000: loss = -31.185678482055664
step = 20000: loss = -18.064279556274414
step = 20000: Average Return = -0.12959735095500946
step = 25000: loss = -15.05502986907959
step = 30000: loss = -12.023421287536621
step = 30000: Average Return = -1.4209648370742798
step = 35000: loss = -5.994253635406494
step = 40000: loss = -3.944823741912842
step = 40000: Average Return = -0.6664859652519226
step = 45000: loss = 0.3637888431549072
step = 50000: loss = -3.2982077598571777
step = 50000: Average Return = 0.0521695651113987
step = 55000: loss = -2.7744715213775635
step = 60000: loss = 1.7074693441390991
step = 60000: Average Return = -0.3222312033176422
step = 65000: loss = -1.8334136009216309
step = 70000: loss = -1.4784929752349854
step = 70000: Average Return = 0.6373701095581055
step = 75000: loss = 0.48983949422836304
step = 80000: loss = 1.5974589586257935
step = 80000: Average Return = 0.1859637051820755
step = 85000: loss = -5.309885501861572
step = 90000: loss = 0.42465153336524963
step = 90000: Average Return = 0.8508636951446533
step = 95000: loss = -6.7512335777282715
step = 100000: loss = 1.8088481426239014
step = 100000: Average Return = 0.24124357104301453

কল্পনা

প্লট

আমরা আমাদের এজেন্ট কর্মক্ষমতা দেখতে গড় রিটার্ন বিশ্বব্যাপী পদক্ষেপ বনাম চক্রান্ত পারবেন না। ইন 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.5345562636852264, 0.9644551217556)

PNG

ভিডিও

এটা প্রতিটি পদে পদে পরিবেশ রেন্ডারিং করে এজেন্ট কর্মক্ষমতা মনশ্চক্ষুতে সহায়ক। আগে আমরা তা করতে, আমাদের প্রথমে এই colab এম্বেড ভিডিওতে একটি ফাংশন তৈরি করা যাক।

 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)
 

নিম্নলিখিত কোড কয়েকটি এপিসোড এর এজেন্ট এর নীতি visualizes:

 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_py_env.render())
    while not time_step.is_last():
      action_step = tf_agent.policy.action(time_step)
      time_step = eval_env.step(action_step.action)
      video.append_data(eval_py_env.render())

embed_mp4(video_filename)