Ağlar

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

Tanıtım

Bu ortak çalışmada, aracılarınız için özel ağların nasıl tanımlanacağını ele alacağız. Ağlar, aracılar 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: ayrık eylemlerle ortamlar için Qlearning Kullanılan bu ağ her olası eylem için değer tahminlerine bir gözlemi eşler.
  • CriticNetworks: Ayrıca olarak anılacaktır ValueNetworks literatürde, öğrenir bir politikanın beklenen geri dönüşü için bir tahmin içine bazı devlet haritalama bir değer fonksiyonu bir versiyonunu tahmin etmek. Bu ağlar, aracının şu anda içinde bulunduğu durumun ne kadar iyi olduğunu tahmin eder.
  • ActorNetworks: eylemlere gözlemlerinden bir eşleme öğrenin. Bu ağlar genellikle eylemleri oluşturmak için politikalarımız tarafından kullanılır.
  • ActorDistributionNetworks: Benzer ActorNetworks ama bunlar bir politika sonra örnek eylemleri üretmek için bir dağıtım oluşturmak.

Yardımcı Ağlar

  • EncodingNetwork: Kullanıcıların kolayca ağın girişine uygulamak için bir işlem öncesi tabakaların bir eşleme belirlemenizi sağlar.
  • DynamicUnrollLayer: o bir zaman dizisi üzerine uygulanır anda otomatik olarak bölüm sınırları şebekenin durumunu sıfırlar.
  • ProjectionNetwork: gibi Ağlar CategoricalProjectionNetwork veya NormalProjectionNetwork girdileri alıp kategorik, veya Normal dağılımlar üretmek 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 işlemek için kurulmamıştır.

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

Kurmak

Henüz tf-agent'ları yüklemediyseniz, şunu çalıştırın:

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

Ağları Tanımlama

Ağ API'si

TF-Agents biz Keras gelen alt sınıf Ağlar . Onunla şunları yapabiliriz:

  • Hedef ağlar oluştururken gereken kopyalama işlemlerini basitleştirin.
  • Çağrılırken otomatik değişken oluşturma gerçekleştir network.variables() .
  • Ağ input_specs'e göre girdileri doğrulayın.

Kodlama Ağı

Yukarıda belirtildiği gibi, EncodingNetwork bize kolayca bir kodlama oluşturmak için bir ağ girişine uygulamak için ön işlem tabakasının bir eşleme için imkan sağlar.

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

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

Ağları kodlamayla ilgili özel olan şey, girdi ön işlemesinin 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 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())

daha sonra ön işleme arayacaktır:

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

Ancak

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

daha sonra ön işleme arayacaktır:

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

Özel Ağlar

Kendi ağları oluşturmak için yalnızca geçersiz kılmak zorunda kalacak __init__ ve call yöntemlerini. Diyelim yaklaşık öğrendiklerini kullanarak özel bir ağ oluşturmak EncodingNetworks bir resim ve bir vektör içeren gözlemleri alır bir ActorNetwork oluşturun.

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

En bir yaratalım RandomPyEnvironment yapılandırılmış gözlemler oluşturmak ve bizim uygulanmasını doğrulamak için.

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 dikte olarak tanımladığımızdan, bunları işlemek için ön işleme katmanları oluşturmamız gerekiyor.

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, çevreden gözlemleri işleyebiliriz.

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

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