Trang này được dịch bởi Cloud Translation API.
Switch to English

Mạng

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải vở

Giới thiệu

Trong colab này, chúng tôi sẽ đề cập đến 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 Đại lý TF, bạn sẽ tìm thấy một số loại mạng khác nhau hữu ích giữa các đại lý:

Mạng chính

  • QNetwork : Được sử dụng trong Qlearning cho các môi trường có các hành động riêng biệt, mạng này ánh xạ một quan sát đến các ước tính giá trị cho từng hành động có thể.
  • CriticNetworks : Còn được gọi là ValueNetworks trong tài liệu, học cách ước tính một số phiên bản của hàm Giá trị ánh xạ một số trạng thái thành ước tính cho lợi nhuận dự kiến ​​của chính sách. Các mạng này ước tính mức độ tốt của trạng thái hiện tại.
  • ActorNetworks : Tìm hiểu ánh xạ từ các quan sát đến hành động. Các mạng này thường được sử dụng bởi các chính sách của chúng tôi để tạo hành động.
  • ActorDistributionNetworks : Tương tự như ActorNetworks nhưng chúng tạo ra một phân phối mà sau đó chính sách có thể lấy mẫu để tạo hành động.

Mạng trợ giúp

  • EncodingNetwork : Cho phép người dùng dễ dàng xác định ánh xạ các lớp tiền xử lý để áp dụng cho đầu vào của mạng.
  • DynamicUnrollLayer : Tự động đặt lại trạng thái của mạng trên các ranh giới tập khi nó được áp dụng theo 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 hiển thị nhiều hơn một quan sát / hành động và bạn cần tùy chỉnh các mạng của mình thì hướng dẫn này là dành cho bạn!

Thiết lập

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

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

Xác định mạng

API mạng

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

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

Mã hóa mạng

Như đã đề cập ở trên, EncodingNetwork cho phép chúng ta dễ dàng xác định á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:

  • Các lớp tiền xử lý
  • Bộ tiền xử lý
  • Conv2D
  • Làm phẳng
  • Ngu độn

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

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

sau đó tiền xử lý sẽ gọi:

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

Tuy nhiên, nếu

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

sau đó 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 các mạng của riêng bạn, bạn sẽ chỉ phải ghi đè các phương thức __init__call . Hãy tạo một mạng tùy chỉnh bằng cách sử dụng những gì chúng ta đã học về EncodingNetworks để tạo ActorNetwork có các quan sát có chứa hình ảnh và vectơ.

 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 các quan sát có cấu trúc và xác thực việc 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 lệnh, chúng tôi cần tạo các lớp tiền xử lý để xử lý các quan sát này.

 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 diễn viê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([[5.3831844, 4.975593 , 5.310139 ]], 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 sử dụng bởi các tác nhân. Bạn có thể xác định bất cứ điều gì tiền xử lý 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 các định nghĩa lớp đầu ra của mạng khớp.