Jaringan

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

pengantar

Dalam colab ini, kami akan membahas cara menentukan jaringan khusus untuk agen Anda. Jaringan membantu kami menentukan model yang dilatih oleh agen. Di TF-Agents Anda akan menemukan beberapa jenis jaringan berbeda yang berguna di seluruh agen:

Jaringan Utama

  • QNetwork: Digunakan dalam Qlearning untuk lingkungan dengan tindakan diskrit, jaringan ini peta pengamatan perkiraan nilai untuk setiap tindakan yang mungkin.
  • CriticNetworks: Juga disebut sebagai ValueNetworks dalam literatur, Belajar untuk memperkirakan beberapa versi dari Nilai fungsi pemetaan beberapa negara ke perkiraan untuk pengembalian yang diharapkan dari sebuah kebijakan. Jaringan ini memperkirakan seberapa baik keadaan agen saat ini.
  • ActorNetworks: Belajar pemetaan dari pengamatan tindakan. Jaringan ini biasanya digunakan oleh kebijakan kami untuk menghasilkan tindakan.
  • ActorDistributionNetworks: Mirip dengan ActorNetworks tetapi ini menghasilkan distribusi yang kebijakan dapat kemudian sampel untuk menghasilkan tindakan.

Jaringan Pembantu

  • EncodingNetwork: Memungkinkan pengguna untuk dengan mudah menentukan pemetaan pra-pengolahan lapisan untuk diterapkan ke input jaringan.
  • DynamicUnrollLayer: Secara otomatis me-reset negara jaringan pada batas-batas episode seperti yang diaplikasikan di atas urutan waktu.
  • ProjectionNetwork: Jaringan seperti CategoricalProjectionNetwork atau NormalProjectionNetwork mengambil input dan menghasilkan parameter yang diperlukan untuk menghasilkan kategoris, atau distribusi normal.

Semua contoh di TF-Agents hadir dengan jaringan yang telah dikonfigurasi sebelumnya. Namun jaringan ini tidak diatur untuk menangani pengamatan yang kompleks.

Jika Anda memiliki lingkungan yang memperlihatkan lebih dari satu pengamatan/tindakan dan Anda perlu menyesuaikan jaringan Anda, maka tutorial ini cocok untuk Anda!

Mempersiapkan

Jika Anda belum menginstal tf-agents, jalankan:

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

Mendefinisikan Jaringan

API Jaringan

Dalam TF-Agen kami subclass dari Keras Networks . Dengan itu kita dapat:

  • Sederhanakan operasi penyalinan yang diperlukan saat membuat jaringan target.
  • Lakukan variabel penciptaan otomatis saat memanggil network.variables() .
  • Validasi input berdasarkan input_specs jaringan.

Jaringan Pengkodean

Seperti disebutkan di atas EncodingNetwork memungkinkan kita untuk dengan mudah menentukan pemetaan lapisan pra-pengolahan untuk diterapkan ke masukan jaringan untuk menghasilkan beberapa encoding.

EncodingNetwork terdiri dari sebagian besar lapisan opsional berikut:

  • Lapisan pra-pemrosesan
  • Penggabung pra-pemrosesan
  • konv2D
  • Meratakan
  • Padat

Hal khusus tentang jaringan pengkodean adalah bahwa pra-pemrosesan input diterapkan. Preprocessing masukan adalah mungkin melalui preprocessing_layers dan preprocessing_combiner lapisan. Masing-masing dapat ditentukan sebagai struktur bersarang. Jika preprocessing_layers sarang adalah dangkal dari input_tensor_spec , maka lapisan akan mendapatkan subnests. Misalnya, jika:

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

maka preprocessing akan memanggil:

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

Namun jika

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

maka preprocessing akan memanggil:

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

Jaringan Kustom

Untuk membuat jaringan Anda sendiri, Anda hanya perlu menimpa __init__ dan call metode. Mari kita membuat jaringan kustom menggunakan apa yang kita pelajari tentang EncodingNetworks untuk membuat ActorNetwork yang mengambil pengamatan yang berisi gambar dan vektor.

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

Mari kita membuat RandomPyEnvironment untuk menghasilkan pengamatan terstruktur dan memvalidasi implementasi kami.

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)

Karena kita telah mendefinisikan observasi sebagai dict, kita perlu membuat layer preprocessing untuk menanganinya.

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)

Sekarang kami memiliki jaringan aktor, kami dapat memproses pengamatan dari lingkungan.

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)>,
 ())

Strategi yang sama dapat digunakan untuk menyesuaikan salah satu jaringan utama yang digunakan oleh agen. Anda dapat menentukan prapemrosesan apa pun dan menghubungkannya ke seluruh jaringan. Saat Anda menentukan kustom Anda sendiri, pastikan definisi lapisan keluaran dari jaringan cocok.