Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Ağlar

TensorFlow.org üzerinde görüntüle Google Colab'da yayınla Kaynağı GitHub'da görüntüle Not defterini indir

Giriş

Bu kolabda temsilcileriniz için özel ağların nasıl tanımlanacağını ele alacağız. Ağlar, temsilciler tarafından eğitilen modeli tanımlamamıza yardımcı olur. TF-Agent'larda, aracılar arasında yararlı olan birkaç farklı ağ türü bulacaksınız:

Ana Ağlar

  • QNetwork : Qlearning'de ayrı eylemleri olan ortamlar için kullanılan bu ağ, bir gözlemi olası her eylem için değer tahminlerine eşler.
  • CriticNetworks : Literatürde ValueNetworks olarak da adlandırılan, bir Value işlevinin bazı durumunu, bir politikanın beklenen dönüşü için bir tahminde eşleştirmeyi öğrenir. Bu ağlar, aracının şu andaki durumunun ne kadar iyi olduğunu tahmin eder.
  • ActorNetworks : Gözlemlerden eylemlere bir eşleme öğrenin. Bu ağlar genellikle eylemler oluşturmak için politikalarımız tarafından kullanılır.
  • ActorDistributionNetworks : ActorNetworks'e benzer, ancak bunlar ilkenin eylemler oluşturmak için ActorNetworks bir dağıtım oluşturur.

Yardımcı Ağlar

  • EncodingNetwork : Kullanıcıların, bir ağ girişine uygulanacak ön işleme katmanlarının eşlemesini kolayca tanımlamasını sağlar.
  • DynamicUnrollLayer : Bölüm sınırlarındaki ağın durumunu, bir zaman dizisine uygulandığından otomatik olarak sıfırlar.
  • ProjectionNetwork : CategoricalProjectionNetwork veya NormalProjectionNetwork gibi ağlar girdi alır ve Kategorik veya Normal dağılımlar oluşturmak için gerekli parametreleri oluşturur.

TF-Agent'lardaki tüm örnekler önceden yapılandırılmış ağlarla birlikte gelir. Ancak bu ağlar karmaşık gözlemleri ele alacak şekilde kurulmamıştır.

Birden fazla gözlem / eylem sunan bir ortamınız varsa ve ağlarınızı özelleştirmeniz gerekiyorsa, bu eğitim tam size göre!

Kurmak

Henüz tf aracıları yüklemediyseniz, çalıştırın:

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

Ağları Tanımlama

Ağ API'sı

TF-Agent'larda Keras Networks'ten alt sınıfımız var. Bununla beraber yapabiliriz:

  • Hedef ağlar oluştururken gereken kopyalama işlemlerini basitleştirin.
  • network.variables() çağırırken otomatik değişken oluşturma işlemini gerçekleştirin.
  • Şebeke giriş_ekneklerine göre girişleri doğrulayın.

EncodingNetwork

Yukarıda belirtildiği gibi, EncodingNetwork , bazı kodlama üretmek için bir ağ girişine uygulanacak ön işleme katmanlarının eşlemesini kolayca tanımlamamıza olanak tanır.

EncodingNetwork aşağıdaki çoğunlukla isteğe bağlı katmanlardan oluşur:

  • Katmanları ön işleme
  • Ön işleme birleştirici
  • Conv2D
  • Düzleştirmek
  • Yoğun

Ağları kodlamanın en önemli özelliği girdi önişleminin uygulanmasıdır. Girdi ön işleme ile mümkündür preprocessing_layers ve preprocessing_combiner tabakalar. Bunların her biri iç içe geçmiş bir yapı olarak belirtilebilir. Eğer preprocessing_layers yuva daha sığ olması input_tensor_spec , daha sonra katmanlar subnests alacak. Örneğin, eğer:

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

ön işleme şu şekilde çağrılacaktır:

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

Ancak

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

ön işleme şu şekilde çağrılacaktır:

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

Özel Ağlar

Kendi ağlarınızı oluşturmak için sadece __init__ ve call yöntemlerini geçersiz __init__ gerekir. EncodingNetworks hakkında öğrendiklerimizi kullanarak bir görüntü ve vektör içeren gözlemler alan bir ActorNetwork oluşturmak için özel bir ağ oluşturalım.

 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
 

Yapısal gözlemler oluşturmak ve uygulamamızı doğrulamak için bir RandomPyEnvironment oluşturalım.

 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)
 

Gözlemleri bir diksiyon olarak tanımladığımızdan, bunları ele almak için önişlem katmanları oluşturmamız gerekir.

 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)
 

Artık aktör ağına sahip olduğumuza göre, gözlemleri çevreden işleyebiliyoruz.

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

Aynı strateji, aracılar tarafından kullanılan ana ağlardan herhangi birini özelleştirmek için kullanılabilir. Hangi önişlemeyi tanımlayabilir ve ağın geri kalanına bağlayabilirsiniz. Kendi özel öğenizi tanımlarken, ağın çıktı katmanı tanımlarının eşleştiğinden emin olun.