이 페이지는 Cloud Translation API를 통해 번역되었습니다.
Switch to English

네트워크

TensorFlow.org에서보기 Google Colab에서 실행 GitHub에서 소스보기 노트북 다운로드

소개

이 colab에서는 에이전트에 대한 사용자 정의 네트워크를 정의하는 방법을 다룹니다. 네트워크는 상담원이 훈련 한 모델을 정의하는 데 도움이됩니다. TF-Agent에는 에이전트에 유용한 여러 가지 유형의 네트워크가 있습니다.

주요 네트워크

  • QNetwork : 개별 동작이있는 환경에 대한 Qlearning에서 사용되는이 네트워크는 관측 값을 각 가능한 동작에 대한 값 추정값에 매핑합니다.
  • CriticNetworks : 문헌에서 ValueNetworks 라고도하며 일부 상태를 정책의 예상 리턴에 대한 추정치에 맵핑하는 일부 버전의 Value 함수를 추정하는 방법을 학습합니다. 이 네트워크는 상담원의 현재 상태가 얼마나 좋은지 추정합니다.
  • ActorNetworks : 관찰에서 행동으로의 매핑을 배웁니다. 이러한 네트워크는 일반적으로 Google 정책에서 조치를 생성하는 데 사용됩니다.
  • ActorDistributionNetworks : 유사 ActorNetworks 있지만 이러한 정책이 다음 샘플 작업을 생성 할 수 분포를 생성합니다.

헬퍼 네트워크

  • EncodingNetwork : 사용자는 네트워크의 입력에 적용 할 전처리 레이어의 매핑을 쉽게 정의 할 수 있습니다.
  • DynamicUnrollLayer : 시간 순서에 따라 적용되는 에피소드 경계에서 네트워크 상태를 자동으로 재설정합니다.
  • ProjectionNetwork : CategoricalProjectionNetwork 또는 NormalProjectionNetwork 와 같은 네트워크는 입력을 받아 범주 또는 정규 분포를 생성하는 데 필요한 매개 변수를 생성합니다.

TF-Agent의 모든 예는 사전 구성된 네트워크와 함께 제공됩니다. 그러나 이러한 네트워크는 복잡한 관측을 처리하도록 설정되지 않았습니다.

둘 이상의 관찰 / 조치를 노출하는 환경이 있고 네트워크를 사용자 정의해야하는 경우이 학습서가 적합합니다.

설정

tf-agent를 아직 설치하지 않은 경우 다음을 실행하십시오.

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

네트워크 정의

네트워크 API

TF-Agent에서 Keras Networks의 서브 클래스입니다. 그것으로 우리는 할 수 있습니다 :

  • 대상 네트워크를 만들 때 필요한 복사 작업을 단순화합니다.
  • network.variables() 호출 할 때 자동 변수 작성을 수행하십시오.
  • 네트워크 input_spec을 기반으로 입력을 확인합니다.

인코딩 네트워크

위에서 언급했듯이 EncodingNetwork 사용하면 네트워크의 입력에 적용하여 일부 인코딩을 생성하기 위해 사전 처리 계층의 매핑을 쉽게 정의 할 수 있습니다.

EncodingNetwork는 다음과 같은 선택적 레이어로 구성됩니다.

  • 전처리 레이어
  • 전처리 결합기
  • 전환
  • 반음 낮추다
  • 밀집한

네트워크 인코딩의 특별한 점은 입력 전처리가 적용된다는 것입니다. 입력 전처리는 preprocessing_layerspreprocessing_combiner 레이어를 통해 가능합니다. 이들 각각은 중첩 구조로 지정할 수 있습니다. preprocessing_layers 네스트가 input_tensor_spec 보다 얕 으면 레이어에 서브 네츠가 생깁니다. 예를 들어,

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

전처리는 다음을 호출합니다.

 preprocessed = [preprocessing_layers[0](observations[0]),
                preprocessing_layers[1](obsrevations[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([[5.3831844, 4.975593 , 5.310139 ]], dtype=float32)>,
 ())

이 같은 전략을 사용하여 에이전트가 사용하는 기본 네트워크를 사용자 정의 할 수 있습니다. 전처리를 정의하고 나머지 네트워크에 연결할 수 있습니다. 사용자 정의를 정의 할 때 네트워크의 출력 계층 정의가 일치하는지 확인하십시오.