नेटवर्क

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

परिचय

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

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

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

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

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

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

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

सेट अप

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

pip install tf-agents

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-एजेंटों हम Keras से उपवर्ग नेटवर्क । इसके साथ हम कर सकते हैं:

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

एन्कोडिंग नेटवर्क

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

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

  • प्रीप्रोसेसिंग परतें
  • प्रीप्रोसेसिंग कॉम्बिनर
  • रूपांतरण2डी
  • समतल
  • सघन

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

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

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

preprocessed = [preprocessing_layers[0](observations[0]),
                preprocessing_layers[1](observations[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 एक ActorNetwork कि टिप्पणियों जो एक छवि और एक वेक्टर शामिल लेता है बनाने के लिए।

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([[4.5753636, 4.946792 , 4.853481 ]], dtype=float32)>,
 ())

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