شبکه های

حق چاپ 2021 نویسندگان TF-Agents.

معرفی

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

شبکه های اصلی

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

شبکه های کمکی

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

همه نمونه های موجود در TF-Agents با شبکه های از پیش پیکربندی شده ارائه می شوند. با این حال این شبکه ها برای رسیدگی به مشاهدات پیچیده تنظیم نشده اند.

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

برپایی

اگر هنوز tf-agents را نصب نکرده اید، اجرا کنید:

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

تعریف شبکه ها

شبکه API

در TF-نمایندگی ما از Keras زیر مجموعه شبکه . با آن می توانیم:

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

شبکه رمزگذاری

همانطور که در بالا ذکر شده 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](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)>,
 ())

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