Mạng

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải xuống sổ ghi chép

Giới thiệu

Trong chuyên mục này, chúng tôi sẽ trình bày cách xác định mạng tùy chỉnh cho các đại lý của bạn. Các mạng giúp chúng tôi xác định mô hình được đào tạo bởi các đại lý. Trong TF-Agents, bạn sẽ tìm thấy một số loại mạng khác nhau hữu ích cho các đại lý:

Mạng chính

  • QNetwork: Được sử dụng trong Qlearning cho các môi trường với hoạt động rời rạc, mạng này bản đồ một quan sát ước tính giá trị cho mỗi hành động càng tốt.
  • CriticNetworks: Cũng được gọi là ValueNetworks trong văn học, nghe tin để ước tính một số phiên bản của một hàm Value lập bản đồ một số nhà nước thành một ước tính cho lợi nhuận kỳ vọng của một chính sách. Các mạng này ước tính trạng thái hiện tại của đại lý tốt như thế nào.
  • ActorNetworks: Tìm hiểu một ánh xạ từ những quan sát để hành động. Các mạng này thường được các chính sách của chúng tôi sử dụng để tạo ra các hành động.
  • ActorDistributionNetworks: Tương tự như ActorNetworks nhưng những tạo ra một bản phân phối đó một chính sách có thể sau đó mẫu để tạo ra hành động.

Mạng người trợ giúp

  • EncodingNetwork: Cho phép người dùng dễ dàng xác định một ánh xạ của các lớp pre-chế biến để áp dụng cho đầu vào của một mạng.
  • DynamicUnrollLayer: Tự động reset trạng thái của mạng trên ranh giới tập vì nó được áp dụng trên một trình tự thời gian.
  • ProjectionNetwork: Networks như CategoricalProjectionNetwork hoặc NormalProjectionNetwork có đầu vào và tạo ra các thông số cần thiết để tạo ra phạm trù, hoặc phân phối chuẩn.

Tất cả các ví dụ trong TF-Agents đều đi kèm với các mạng được cấu hình sẵn. Tuy nhiên, các mạng này không được thiết lập để xử lý các quan sát phức tạp.

Nếu bạn có một môi trường thể hiện nhiều hơn một quan sát / hành động và bạn cần tùy chỉnh mạng của mình thì hướng dẫn này là dành cho bạn!

Cài đặt

Nếu bạn chưa cài đặt tf-agent, hãy chạy:

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

Xác định mạng

API mạng

Trong TF-Đại lý chúng tôi phân lớp từ Keras Networks . Với nó, chúng tôi có thể:

  • Đơn giản hóa các thao tác sao chép cần thiết khi tạo mạng mục tiêu.
  • Thực hiện sáng tạo biến tự động khi gọi network.variables() .
  • Xác thực đầu vào dựa trên input_spec của mạng.

EncodingNetwork

Như đã đề cập ở trên EncodingNetwork cho phép chúng ta dễ dàng xác định một ánh xạ của các lớp tiền xử lý để áp dụng cho đầu vào của mạng để tạo ra một số mã hóa.

EncodingNetwork bao gồm các lớp chủ yếu là tùy chọn sau:

  • Tiền xử lý các lớp
  • Bộ kết hợp tiền xử lý
  • Conv2D
  • Làm phẳng
  • Ngu độn

Điều đặc biệt của mạng mã hóa là áp dụng tiền xử lý đầu vào. Tiền xử lý đầu vào là có thể qua preprocessing_layers và preprocessing_combiner lớp. Mỗi trong số này có thể được chỉ định như một cấu trúc lồng nhau. Nếu preprocessing_layers tổ là nông hơn input_tensor_spec , sau đó các lớp sẽ nhận được subnests. Ví dụ, nếu:

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

thì tiền xử lý sẽ gọi:

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

Tuy nhiên, nếu

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

thì tiền xử lý sẽ gọi:

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

Mạng tùy chỉnh

Để tạo ra các mạng riêng của bạn, bạn sẽ chỉ phải ghi đè lên __init__ và call phương pháp này. Hãy tạo ra một mạng tùy chỉnh sử dụng những gì chúng ta biết về EncodingNetworks để tạo ra một ActorNetwork mà sẽ đưa các quan sát có chứa một hình ảnh và một vector.

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

Hãy tạo một RandomPyEnvironment để tạo ra quan sát cấu trúc và xác nhận thực hiện của chúng tôi.

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)

Vì chúng tôi đã xác định các quan sát là một mệnh lệnh nên chúng tôi cần tạo các lớp tiền xử lý để xử lý chúng.

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)

Bây giờ chúng ta có mạng lưới tác nhân, chúng ta có thể xử lý các quan sát từ môi trường.

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

Chiến lược tương tự này có thể được sử dụng để tùy chỉnh bất kỳ mạng chính nào được các đại lý sử dụng. Bạn có thể xác định bất kỳ tiền xử lý nào và kết nối nó với phần còn lại của mạng. Khi bạn xác định tùy chỉnh của riêng mình, hãy đảm bảo rằng các định nghĩa lớp đầu ra của mạng khớp với nhau.