Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

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 kustom untuk agen Anda. Jaringan membantu kami menentukan model yang dilatih oleh agen. Di TF-Agents Anda akan menemukan beberapa jenis jaringan yang berguna di seluruh agen:

Jaringan Utama

  • QNetwork : Digunakan dalam Qlearning untuk lingkungan dengan tindakan diskrit, jaringan ini memetakan pengamatan ke estimasi nilai untuk setiap tindakan yang mungkin.
  • CriticNetworks : Juga disebut sebagai ValueNetworks dalam literatur, belajar memperkirakan beberapa versi fungsi Nilai yang memetakan beberapa status menjadi perkiraan pengembalian yang diharapkan dari suatu kebijakan. Jaringan ini memperkirakan seberapa baik agen tersebut saat ini.
  • ActorNetworks : Pelajari pemetaan dari pengamatan hingga tindakan. Jaringan ini biasanya digunakan oleh kebijakan kami untuk menghasilkan tindakan.
  • ActorDistributionNetworks : Mirip dengan ActorNetworks tetapi ini menghasilkan distribusi yang kemudian dapat ActorNetworks oleh kebijakan untuk menghasilkan tindakan.

Jaringan Pembantu

  • EncodingNetwork : Memungkinkan pengguna dengan mudah menentukan pemetaan lapisan pra-pemrosesan untuk diterapkan ke masukan jaringan.
  • DynamicUnrollLayer : Secara otomatis menyetel ulang status jaringan pada batas episode saat diterapkan dalam urutan waktu.
  • ProjectionNetwork : Jaringan seperti CategoricalProjectionNetwork atau NormalProjectionNetwork mengambil input dan menghasilkan parameter yang diperlukan untuk menghasilkan distribusi Categorical, atau Normal.

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

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

Mempersiapkan

Jika Anda belum menginstal tf-agents, jalankan:

pip install -q 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.compat.v1.enable_v2_behavior()

Mendefinisikan Jaringan

API Jaringan

Di TF-Agents kita subclass dari Keras Networks . Dengan itu kita bisa:

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

EncodingNetwork

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

EncodingNetwork terdiri dari sebagian besar lapisan opsional berikut:

  • Memproses ulang lapisan
  • Pemadu pra-pemrosesan
  • Konv2D
  • Meratakan
  • Padat

Hal khusus tentang jaringan encoding adalah bahwa preprocessing input diterapkan. Preprocessing input dimungkinkan melalui preprocessing_layers dan layer preprocessing_combiner . Masing-masing dapat ditetapkan sebagai struktur bertingkat. Jika sarang preprocessing_layers lebih 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](obsrevations[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 mengganti __init__ dan metode call . Mari buat jaringan khusus menggunakan apa yang kita pelajari tentang EncodingNetworks untuk membuat ActorNetwork yang melakukan 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 buat RandomPyEnvironment untuk menghasilkan observasi terstruktur dan memvalidasi implementasi kita.

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 menjadi sebuah 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 kita memiliki jaringan aktor kita 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([[7.026863 , 4.5458393, 4.7681847]], dtype=float32)>,
 ())

Strategi yang sama ini dapat digunakan untuk menyesuaikan jaringan utama mana pun yang digunakan oleh agen. Anda dapat menentukan pra-pemrosesan apa pun dan menghubungkannya ke seluruh jaringan. Saat Anda menentukan kustom Anda sendiri, pastikan definisi lapisan keluaran dari jaringan cocok.