इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

TensorFlow.org पर देखें

Google Colab में चलाएं

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

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

परिचय

रीइन्फोर्समेंट लर्निंग एल्गोरिदम रिप्ले बफ़र्स का उपयोग किसी वातावरण में नीति निष्पादित करते समय अनुभव के प्रक्षेपवक्र को संग्रहीत करने के लिए करते हैं। प्रशिक्षण के दौरान, एजेंट के अनुभव को "रीप्ले" करने के लिए प्रक्षेपवक्र के एक सबसेट (या तो एक अनुक्रमिक सबसेट या एक नमूना) के लिए रिप्ले बफ़र्स से पूछताछ की जाती है।

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

सेट अप

यदि आपने पहले से नहीं किया है तो tf-एजेंट स्थापित करें।

pip install tf-agents

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

import tensorflow as tf
import numpy as np

from tf_agents import specs
from tf_agents.agents.dqn import dqn_agent
from tf_agents.drivers import dynamic_step_driver
from tf_agents.environments import suite_gym
from tf_agents.environments import tf_py_environment
from tf_agents.networks import q_network
from tf_agents.replay_buffers import py_uniform_replay_buffer
from tf_agents.replay_buffers import tf_uniform_replay_buffer
from tf_agents.specs import tensor_spec
from tf_agents.trajectories import time_step

रीप्ले बफर एपीआई

रिप्ले बफ़र वर्ग की निम्नलिखित परिभाषाएँ और विधियाँ हैं:

class ReplayBuffer(tf.Module):
  """Abstract base class for TF-Agents replay buffer."""

  def __init__(self, data_spec, capacity):
    """Initializes the replay buffer.

    Args:
      data_spec: A spec or a list/tuple/nest of specs describing
        a single item that can be stored in this buffer
      capacity: number of elements that the replay buffer can hold.
    """

  @property
  def data_spec(self):
    """Returns the spec for items in the replay buffer."""

  @property
  def capacity(self):
    """Returns the capacity of the replay buffer."""

  def add_batch(self, items):
    """Adds a batch of items to the replay buffer."""

  def get_next(self,
               sample_batch_size=None,
               num_steps=None,
               time_stacked=True):
    """Returns an item or batch of items from the buffer."""

  def as_dataset(self,
                 sample_batch_size=None,
                 num_steps=None,
                 num_parallel_calls=None):
    """Creates and returns a dataset that returns entries from the buffer."""


  def gather_all(self):
    """Returns all the items in buffer."""
    return self._gather_all()

  def clear(self):
    """Resets the contents of replay buffer"""

नोट जब पुनरावृत्ति बफर वस्तु आरंभ नहीं हो जाता कि ऐसा करना आवश्यक data_spec तत्वों की है कि यह स्टोर करेगा। करने के लिए यह कल्पना मेल खाती TensorSpec प्रक्षेपवक्र तत्वों है कि बफर में जोड़ दिया जाएगा की। यह कल्पना आम तौर पर एक एजेंट के को देखकर अधिग्रहण किया है agent.collect_data_spec जो परिभाषित करता है आकार, प्रकार, और एजेंट के द्वारा की उम्मीद जब (उस पर और अधिक बाद में) प्रशिक्षण संरचनाओं।

TFUniformReplayBuffer

TFUniformReplayBuffer , सबसे अधिक इस्तेमाल किया TF-एजेंटों में पुनरावृत्ति बफर है इस प्रकार हम यहाँ हमारे ट्यूटोरियल में इसका इस्तेमाल होगा। में TFUniformReplayBuffer समर्थन बफर भंडारण tensorflow चर द्वारा किया जाता है और इस प्रकार गणना ग्राफ का हिस्सा है।

तत्वों के बफर भंडार बैचों और एक अधिकतम क्षमता है max_length बैच प्रति खंड तत्वों। इस प्रकार, कुल बफर क्षमता है batch_size एक्स max_length तत्वों। बफ़र में संग्रहीत सभी तत्वों में एक मिलान डेटा युक्ति होनी चाहिए। जब डेटा संग्रह के लिए रीप्ले बफर का उपयोग किया जाता है, तो युक्ति एजेंट की एकत्रित डेटा युक्ति होती है।

बफर बनाना:

एक बनाने के लिए TFUniformReplayBuffer हम में पारित:

डेटा तत्वों का विवरण जो बफ़र स्टोर करेगा
batch size बफर के बैच का आकार करने के लिए इसी
max_length बैच प्रति खंड तत्वों की संख्या

यहाँ एक बनाने का एक उदाहरण है TFUniformReplayBuffer नमूना डेटा चश्मा, साथ batch_size 32 और max_length 1000।

data_spec =  (
        tf.TensorSpec([3], tf.float32, 'action'),
        (
            tf.TensorSpec([5], tf.float32, 'lidar'),
            tf.TensorSpec([3, 2], tf.float32, 'camera')
        )
)

batch_size = 32
max_length = 1000

replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(
    data_spec,
    batch_size=batch_size,
    max_length=max_length)

बफर को लिखना:

पुनरावृत्ति बफर करने के लिए तत्वों को जोड़ने के लिए, हम का उपयोग add_batch(items) विधि जहां items एक सूची / टपल / मदों की बैच का प्रतिनिधित्व tensors का घोंसला बफर करने के लिए जोड़ा जा रहा है। के प्रत्येक तत्व items एक बाहरी आयाम बराबर होना आवश्यक है batch_size और शेष आयाम मद (पुनरावृत्ति बफर निर्माता को पारित कर दिया डेटा चश्मा के रूप में ही) के डेटा कल्पना का पालन करना होगा।

यहां आइटम के बैच को जोड़ने का एक उदाहरण दिया गया है

action = tf.constant(1 * np.ones(
    data_spec[0].shape.as_list(), dtype=np.float32))
lidar = tf.constant(
    2 * np.ones(data_spec[1][0].shape.as_list(), dtype=np.float32))
camera = tf.constant(
    3 * np.ones(data_spec[1][1].shape.as_list(), dtype=np.float32))

values = (action, (lidar, camera))
values_batched = tf.nest.map_structure(lambda t: tf.stack([t] * batch_size),
                                       values)

replay_buffer.add_batch(values_batched)

बफर से पढ़ना

तीन तरीके से डेटा पढ़ने की हैं TFUniformReplayBuffer :

get_next() - रिटर्न बफर से एक नमूना। नमूना बैच आकार और लौटाए गए टाइमस्टेप्स की संख्या इस पद्धति के तर्कों के माध्यम से निर्दिष्ट की जा सकती है।
as_dataset() - एक के रूप में पुनरावृत्ति बफर रिटर्न tf.data.Dataset । फिर कोई डेटासेट इटरेटर बना सकता है और बफर में आइटम्स के नमूने के माध्यम से पुनरावृति कर सकता है।
gather_all() - आकार के साथ रिटर्न एक टेन्सर के रूप में बफर में सभी आइटम [batch, time, data_spec]

इन विधियों में से प्रत्येक का उपयोग करके रीप्ले बफर से पढ़ने के तरीके के उदाहरण नीचे दिए गए हैं:

# add more items to the buffer before reading
for _ in range(5):
  replay_buffer.add_batch(values_batched)

# Get one sample from the replay buffer with batch size 10 and 1 timestep:

sample = replay_buffer.get_next(sample_batch_size=10, num_steps=1)

# Convert the replay buffer to a tf.data.Dataset and iterate through it
dataset = replay_buffer.as_dataset(
    sample_batch_size=4,
    num_steps=2)

iterator = iter(dataset)
print("Iterator trajectories:")
trajectories = []
for _ in range(3):
  t, _ = next(iterator)
  trajectories.append(t)

print(tf.nest.map_structure(lambda t: t.shape, trajectories))

# Read all elements in the replay buffer:
trajectories = replay_buffer.gather_all()

print("Trajectories from gather all:")
print(tf.nest.map_structure(lambda t: t.shape, trajectories))

WARNING:tensorflow:From /tmp/ipykernel_15476/1348928897.py:7: 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.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/experimental/ops/counter.py:66: scan (from tensorflow.python.data.experimental.ops.scan_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.scan(...) instead
Iterator trajectories:
[(TensorShape([4, 2, 3]), (TensorShape([4, 2, 5]), TensorShape([4, 2, 3, 2]))), (TensorShape([4, 2, 3]), (TensorShape([4, 2, 5]), TensorShape([4, 2, 3, 2]))), (TensorShape([4, 2, 3]), (TensorShape([4, 2, 5]), TensorShape([4, 2, 3, 2])))]
WARNING:tensorflow:From /tmp/ipykernel_15476/1348928897.py:24: ReplayBuffer.gather_all (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=True)` instead.
Trajectories from gather all:
(TensorShape([32, 6, 3]), (TensorShape([32, 6, 5]), TensorShape([32, 6, 3, 2])))

PyUniformReplayBuffer

PyUniformReplayBuffer रूप में एक ही functionaly है TFUniformReplayBuffer लेकिन इसके बजाय tf चर का, अपने डेटा को NumPy सरणी में संग्रहित है। इस बफ़र का उपयोग आउट-ऑफ़-ग्राफ़ डेटा संग्रह के लिए किया जा सकता है। numpy में बैकिंग स्टोरेज होने से कुछ अनुप्रयोगों के लिए डेटा हेरफेर करना आसान हो सकता है (जैसे प्राथमिकताओं को अपडेट करने के लिए इंडेक्सिंग) बिना Tensorflow वेरिएबल का उपयोग किए। हालाँकि, इस कार्यान्वयन से Tensorflow के साथ ग्राफ़ अनुकूलन का लाभ नहीं होगा।

नीचे एक instantiating का एक उदाहरण है PyUniformReplayBuffer एजेंट की नीति प्रक्षेपवक्र चश्मा से:

replay_buffer_capacity = 1000*32 # same capacity as the TFUniformReplayBuffer

py_replay_buffer = py_uniform_replay_buffer.PyUniformReplayBuffer(
    capacity=replay_buffer_capacity,
    data_spec=tensor_spec.to_nest_array_spec(data_spec))

प्रशिक्षण के दौरान रिप्ले बफ़र्स का उपयोग करना

अब जब हम जानते हैं कि रिप्ले बफर कैसे बनाया जाता है, इसमें आइटम लिखे जाते हैं और इससे पढ़ा जाता है, तो हम अपने एजेंटों के प्रशिक्षण के दौरान ट्रैजेक्टोरियों को स्टोर करने के लिए इसका उपयोग कर सकते हैं।

आंकड़ा संग्रहण

सबसे पहले, आइए देखें कि डेटा संग्रह के दौरान रीप्ले बफर का उपयोग कैसे करें।

TF-एजेंटों में हम एक का उपयोग Driver माहौल में (देखें अधिक जानकारी के लिए ड्राइवर ट्यूटोरियल) कलेक्ट अनुभव करने के लिए। एक का उपयोग करने के Driver , हम एक निर्दिष्ट Observer के लिए एक समारोह है कि Driver को निष्पादित करने के जब यह एक प्रक्षेपवक्र प्राप्त करता है।

इस प्रकार, पुनरावृत्ति बफर करने के लिए प्रक्षेपवक्र तत्वों को जोड़ने के लिए, हम कॉल एक पर्यवेक्षक जोड़ने add_batch(items) पुनरावृत्ति बफर पर मदों की एक बैच जोड़ने के लिए।

नीचे के साथ इस का एक उदाहरण है TFUniformReplayBuffer । हम पहले एक वातावरण, एक नेटवर्क और एक एजेंट बनाते हैं। फिर हम एक बनाने TFUniformReplayBuffer । ध्यान दें कि रीप्ले बफर में प्रक्षेपवक्र तत्वों की चश्मा एजेंट के एकत्रित डेटा स्पेक के बराबर होती है। हम तो अपने सेट add_batch ड्राइवर है कि डेटा हमारे प्रशिक्षण के दौरान इकट्ठा करना होगा के लिए पर्यवेक्षक के रूप में विधि:

env = suite_gym.load('CartPole-v0')
tf_env = tf_py_environment.TFPyEnvironment(env)

q_net = q_network.QNetwork(
    tf_env.time_step_spec().observation,
    tf_env.action_spec(),
    fc_layer_params=(100,))

agent = dqn_agent.DqnAgent(
    tf_env.time_step_spec(),
    tf_env.action_spec(),
    q_network=q_net,
    optimizer=tf.compat.v1.train.AdamOptimizer(0.001))

replay_buffer_capacity = 1000

replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(
    agent.collect_data_spec,
    batch_size=tf_env.batch_size,
    max_length=replay_buffer_capacity)

# Add an observer that adds to the replay buffer:
replay_observer = [replay_buffer.add_batch]

collect_steps_per_iteration = 10
collect_op = dynamic_step_driver.DynamicStepDriver(
  tf_env,
  agent.collect_policy,
  observers=replay_observer,
  num_steps=collect_steps_per_iteration).run()

ट्रेन चरण के लिए डेटा पढ़ना

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

प्रशिक्षण लूप में रीप्ले बफर से प्रक्षेपवक्र पर प्रशिक्षित करने का एक उदाहरण यहां दिया गया है:

# Read the replay buffer as a Dataset,
# read batches of 4 elements, each with 2 timesteps:
dataset = replay_buffer.as_dataset(
    sample_batch_size=4,
    num_steps=2)

iterator = iter(dataset)

num_train_steps = 10

for _ in range(num_train_steps):
  trajectories, _ = next(iterator)
  loss = agent.train(experience=trajectories)

WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/util/dispatch.py:206: calling foldr_v2 (from tensorflow.python.ops.functional_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.foldr(fn, elems, back_prop=False)
Use:
results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))