این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.
Switch to English

شبکه های

مشاهده در TensorFlow.org در Google Colab اجرا کنید مشاهده منبع در GitHub بارگیری نوت بوک

مقدمه

در این ستون نحوه تعریف شبکه های سفارشی برای نمایندگان شما را پوشش خواهیم داد. شبکه ها به ما کمک می کنند تا مدلی را که توسط نمایندگان آموزش داده می شود تعریف کنیم. در TF-Agent انواع مختلفی از شبکه ها را پیدا خواهید کرد که در میان عوامل مفید هستند:

شبکه های اصلی

  • QNetwork : این شبکه در Qlearning برای محیطهایی با اقدامات گسسته مورد استفاده قرار می گیرد ، این شبکه یک مشاهده را برای ارزش گذاری تخمین ها برای هر اقدام ممکن نقشه برداری می کند.
  • CriticNetworks : همچنین در ادبیات به عنوان ValueNetworks گفته می شود ، یاد می گیرد که نسخه ای از یک تابع Value را که نقشه برداری از برخی ایالت ها را برآورد می کند برای بازده مورد انتظار یک خط مشی. این شبکه ها تخمین می زنند وضعیت نماینده در حال حاضر در چه وضعیت خوبی است.
  • ActorNetworks : نقشه برداری را از مشاهدات گرفته تا اقدامات یاد بگیرید. این شبکه ها معمولاً توسط خط مشی های ما برای تولید اقدامات استفاده می شوند.
  • ActorDistributionNetworks : مشابه ActorNetworks اما این توزیع ها را ایجاد می کند که یک خط مشی می تواند نمونه هایی را برای تولید اقدامات ایجاد کند.

شبکه های کمکی

  • EncodingNetwork : به کاربران اجازه می دهد تا نقشه های لایه های پیش پردازش را به راحتی تعریف کنند تا روی ورودی شبکه اعمال شود.
  • DynamicUnrollLayer : به طور خودکار وضعیت شبکه را در مرزهای قسمت تنظیم می کند زیرا در یک توالی زمانی اعمال می شود.
  • ProjectionNetwork : شبکه هایی مانند CategoricalProjectionNetwork یا NormalProjectionNetwork ورودی ها را می گیرند و پارامترهای مورد نیاز را تولید می کنند تا توزیع های طبقه ای یا عادی تولید کنند.

همه نمونه ها در TF-Agent ها با شبکه های از پیش تنظیم شده همراه هستند. اما این شبکه ها برای کنترل مشاهدات پیچیده تنظیم نشده اند.

اگر محیطی دارید که بیش از یک مشاهده / عمل را در معرض دید شما قرار می دهد و باید شبکه های خود را سفارشی کنید ، این آموزش برای شما مناسب است!

برپایی

اگر هنوز عوامل 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()
 

تعریف شبکه ها

API شبکه

در TF-Agent ما از زیر مجموعه های Keras Networks استفاده می کنیم . با استفاده از آن می توانیم:

  • عملیات کپی مورد نیاز هنگام ایجاد شبکه های هدف را ساده کنید.
  • هنگام تماس با network.variables() ایجاد متغیر خودکار را انجام دهید network.variables() .
  • ورودی ها را براساس input_ Specs شبکه تأیید کنید.

رمزگذاریNetwork

همانطور که در بالا ذکر شد ، EncodingNetwork به ما امکان می دهد نقشه نقشه ای از لایه های پیش پردازش را به راحتی تعریف کنیم تا از ورودی شبکه برای تولید برخی از رمزگذاری استفاده شود.

EncodingNetwork از لایه های بیشتر اختیاری زیر تشکیل شده است:

  • لایه های پیش پردازش
  • پیشرانش پردازنده
  • Conv2D
  • صاف
  • متراکم

نکته ویژه در مورد رمزگذاری شبکه ها این است که از پیش پردازش ورودی استفاده می شود. پیش پردازش ورودی از طریق امکان پذیر است 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](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 را نادیده 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 ایجاد 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)>,
 ())

این استراتژی مشابه می تواند برای شخصی سازی هر یک از شبکه های اصلی مورد استفاده توسط نمایندگان مورد استفاده قرار گیرد. می توانید هر پردازشی را تعریف کنید و آن را به بقیه شبکه وصل کنید. همانطور که عرف خود را تعریف می کنید ، اطمینان حاصل کنید که تعریف لایه خروجی شبکه مطابقت دارد.