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

नेटवर्क

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

परिचय

इस कोलाब में हम कवर करेंगे कि आपके एजेंटों के लिए कस्टम नेटवर्क कैसे परिभाषित करें। नेटवर्क हमें एजेंटों द्वारा प्रशिक्षित मॉडल को परिभाषित करने में मदद करते हैं। TF-Agent में आपको कई अलग-अलग प्रकार के नेटवर्क मिलेंगे जो एजेंटों के लिए उपयोगी हैं:

मुख्य नेटवर्क

  • QNetwork : असतत कार्यों वाले वातावरण के लिए Qlearning में उपयोग किया जाता है, यह नेटवर्क प्रत्येक संभावित कार्रवाई के लिए अनुमानों का अवलोकन करने के लिए मैप करता है।
  • CriticNetworks : इसके अलावा साहित्य में ValueNetworks रूप में जाना जाता है, एक नीति के अपेक्षित वापसी के लिए एक अनुमान में कुछ राज्य के मानचित्रण के मूल्य फ़ंक्शन के कुछ संस्करण का अनुमान लगाना सीखता है। ये नेटवर्क अनुमान लगाते हैं कि एजेंट वर्तमान में कितना अच्छा राज्य है।
  • ActorNetworks : टिप्पणियों से कार्यों तक की मैपिंग सीखें। ये नेटवर्क आमतौर पर हमारी नीतियों द्वारा कार्यों को उत्पन्न करने के लिए उपयोग किया जाता है।
  • ActorDistributionNetworks: करने के लिए इसी तरह के ActorNetworks लेकिन इन एक वितरण जो एक नीति कार्यों उत्पन्न करने के लिए तो नमूना कर सकते हैं उत्पन्न करते हैं।

हेल्पर नेटवर्क

  • एनकोडिंग नेटवर्क: उपयोगकर्ताओं को नेटवर्क के इनपुट पर लागू करने के लिए पूर्व-प्रसंस्करण परतों की मैपिंग को आसानी से परिभाषित करने की अनुमति देता है।
  • डायनामिकऑनलाइनर : स्वचालित रूप से नेटवर्क की स्थिति को एपिसोड सीमाओं पर रीसेट करता है क्योंकि यह एक समय अनुक्रम पर लागू होता है।
  • ProjectionNetwork: जैसे नेटवर्क CategoricalProjectionNetwork या NormalProjectionNetwork आदानों लेने के लिए और आवश्यक पैरामीटर उत्पन्न स्पष्ट, या सामान्य वितरण उत्पन्न करने के लिए।

टीएफ-एजेंटों में सभी उदाहरण पूर्व-कॉन्फ़िगर नेटवर्क के साथ आते हैं। हालांकि ये नेटवर्क जटिल टिप्पणियों को संभालने के लिए सेटअप नहीं हैं।

यदि आपके पास एक वातावरण है जो एक से अधिक अवलोकन / क्रिया को उजागर करता है और आपको अपने नेटवर्क को अनुकूलित करने की आवश्यकता है तो यह ट्यूटोरियल आपके लिए है!

सेट अप

यदि आपने अभी तक tf- एजेंट स्थापित नहीं किया है, तो चलाएं:

pip install -q --pre tf-agents[reverb]
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.

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

import abc
import tensorflow as tf
import numpy as np

from tf_agents.environments import random_py_environment
from tf_agents.environments import tf_py_environment
from tf_agents.networks import encoding_network
from tf_agents.networks import network
from tf_agents.networks import utils
from tf_agents.specs import array_spec
from tf_agents.utils import common as common_utils
from tf_agents.utils import nest_utils

tf.compat.v1.enable_v2_behavior()
 

परिभाषित करने वाले नेटवर्क

नेटवर्क एपीआई

TF-Agent में हम Keras नेटवर्क से उपवर्ग बनाते हैं। इसके साथ हम कर सकते हैं:

  • लक्ष्य नेटवर्क बनाते समय आवश्यक प्रतिलिपि कार्यों को सरल बनाएं।
  • network.variables() कॉल करते समय स्वचालित चर निर्माण करें।
  • नेटवर्क input_specs के आधार पर मान्य इनपुट।

EncodingNetwork

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

EncodingNetwork निम्नलिखित ज्यादातर वैकल्पिक परतों से बना है:

  • प्रीप्रोसेसिंग परतें
  • कंघी करने का काम
  • Conv2D
  • समतल
  • सघन

एन्कोडिंग नेटवर्क के बारे में विशेष बात यह है कि इनपुट प्रीप्रोसेसिंग लागू किया जाता है। इनपुट प्रीप्रोसेसिंग preprocessing_layers और preprocessing_combiner परतों के माध्यम से संभव है। इनमें से प्रत्येक को एक नेस्टेड संरचना के रूप में निर्दिष्ट किया जा सकता है। यदि preprocessing_layers घोंसला input_tensor_spec से अधिक input_tensor_spec , तो परतों को उप-पुंज मिलेंगे। उदाहरण के लिए, यदि:

 input_tensor_spec = ([TensorSpec(3)] * 2, [TensorSpec(3)] * 5)
preprocessing_layers = (Layer1(), Layer2())
 

फिर प्रीप्रोसेसिंग कॉल करेगा:

 preprocessed = [preprocessing_layers[0](observations[0]),
                preprocessing_layers[1](obsrevations[1])]
 

हालांकि, यदि

 preprocessing_layers = ([Layer1() for _ in range(2)],
                        [Layer2() for _ in range(5)])
 

फिर प्रीप्रोसेसिंग कॉल करेगा:

 preprocessed = [
  layer(obs) for layer, obs in zip(flatten(preprocessing_layers),
                                    flatten(observations))
]
 

कस्टम नेटवर्क

अपने नेटवर्क बनाने के लिए आपको केवल __init__ और call विधियों को ओवरराइड करना होगा। चलिए एक कस्टम नेटवर्क बनाते हैं, जो हमने EncodingNetworks नेटवर्क्स के बारे में सीखा है जो एक एक्टर नेटवर्क बनाने के लिए है जो टिप्पणियों को ले जाता है जिसमें एक छवि और एक वेक्टर होता है।

 class ActorNetwork(network.Network):

  def __init__(self,
               observation_spec,
               action_spec,
               preprocessing_layers=None,
               preprocessing_combiner=None,
               conv_layer_params=None,
               fc_layer_params=(75, 40),
               dropout_layer_params=None,
               activation_fn=tf.keras.activations.relu,
               enable_last_layer_zero_initializer=False,
               name='ActorNetwork'):
    super(ActorNetwork, self).__init__(
        input_tensor_spec=observation_spec, state_spec=(), name=name)

    # For simplicity we will only support a single action float output.
    self._action_spec = action_spec
    flat_action_spec = tf.nest.flatten(action_spec)
    if len(flat_action_spec) > 1:
      raise ValueError('Only a single action is supported by this network')
    self._single_action_spec = flat_action_spec[0]
    if self._single_action_spec.dtype not in [tf.float32, tf.float64]:
      raise ValueError('Only float actions are supported by this network.')

    kernel_initializer = tf.keras.initializers.VarianceScaling(
        scale=1. / 3., mode='fan_in', distribution='uniform')
    self._encoder = encoding_network.EncodingNetwork(
        observation_spec,
        preprocessing_layers=preprocessing_layers,
        preprocessing_combiner=preprocessing_combiner,
        conv_layer_params=conv_layer_params,
        fc_layer_params=fc_layer_params,
        dropout_layer_params=dropout_layer_params,
        activation_fn=activation_fn,
        kernel_initializer=kernel_initializer,
        batch_squash=False)

    initializer = tf.keras.initializers.RandomUniform(
        minval=-0.003, maxval=0.003)

    self._action_projection_layer = tf.keras.layers.Dense(
        flat_action_spec[0].shape.num_elements(),
        activation=tf.keras.activations.tanh,
        kernel_initializer=initializer,
        name='action')

  def call(self, observations, step_type=(), network_state=()):
    outer_rank = nest_utils.get_outer_rank(observations, self.input_tensor_spec)
    # We use batch_squash here in case the observations have a time sequence
    # compoment.
    batch_squash = utils.BatchSquash(outer_rank)
    observations = tf.nest.map_structure(batch_squash.flatten, observations)

    state, network_state = self._encoder(
        observations, step_type=step_type, network_state=network_state)
    actions = self._action_projection_layer(state)
    actions = common_utils.scale_to_spec(actions, self._single_action_spec)
    actions = batch_squash.unflatten(actions)
    return tf.nest.pack_sequence_as(self._action_spec, [actions]), network_state
 

चलो संरचित टिप्पणियों को उत्पन्न करने और हमारे कार्यान्वयन को मान्य करने के लिए एक RandomPyEnvironment बनाएँ।

 action_spec = array_spec.BoundedArraySpec((3,), np.float32, minimum=0, maximum=10)
observation_spec =  {
    'image': array_spec.BoundedArraySpec((16, 16, 3), np.float32, minimum=0,
                                        maximum=255),
    'vector': array_spec.BoundedArraySpec((5,), np.float32, minimum=-100,
                                          maximum=100)}

random_env = random_py_environment.RandomPyEnvironment(observation_spec, action_spec=action_spec)

# Convert the environment to a TFEnv to generate tensors.
tf_env = tf_py_environment.TFPyEnvironment(random_env)
 

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

 preprocessing_layers = {
    'image': tf.keras.models.Sequential([tf.keras.layers.Conv2D(8, 4),
                                        tf.keras.layers.Flatten()]),
    'vector': tf.keras.layers.Dense(5)
    }
preprocessing_combiner = tf.keras.layers.Concatenate(axis=-1)
actor = ActorNetwork(tf_env.observation_spec(), 
                     tf_env.action_spec(),
                     preprocessing_layers=preprocessing_layers,
                     preprocessing_combiner=preprocessing_combiner)
 

अब जब हमारे पास अभिनेता नेटवर्क है तो हम पर्यावरण से टिप्पणियों को संसाधित कर सकते हैं।

 time_step = tf_env.reset()
actor(time_step.observation, time_step.step_type)
 
(<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[5.3831844, 4.975593 , 5.310139 ]], dtype=float32)>,
 ())

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