หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

เครือข่าย

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดสมุดบันทึก

บทนำ

ใน colab นี้เราจะกล่าวถึงวิธีการกำหนดเครือข่ายที่กำหนดเองสำหรับตัวแทนของคุณ เครือข่ายช่วยให้เรากำหนดรูปแบบที่ตัวแทนฝึกอบรม ในตัวแทน TF คุณจะพบเครือข่ายหลายประเภทที่มีประโยชน์ในตัวแทน:

เครือข่ายหลัก

  • QNetwork : ใช้ใน Qlearning สำหรับสภาพแวดล้อมที่มีการกระทำที่ไม่ต่อเนื่องเครือข่ายนี้แมปการสังเกตค่าประมาณสำหรับแต่ละการกระทำที่เป็นไปได้
  • CriticNetworks : เรียกอีกอย่างว่า ValueNetworks ในวรรณคดีเรียนรู้ที่จะประเมินรุ่นของฟังก์ชั่นการทำแผนที่ค่าบางสถานะในการประเมินผลตอบแทนที่คาดหวังของนโยบาย เครือข่ายเหล่านี้ประเมินว่าสถานะของตัวแทนอยู่ในระดับดีเพียงใด
  • ActorNetworks : เรียนรู้การแมปจากการสังเกตไปจนถึงการกระทำ นโยบายของเรามักจะใช้เครือข่ายเหล่านี้เพื่อสร้างการกระทำ
  • ActorDistributionNetworks : คล้ายกับ ActorNetworks แต่สิ่งเหล่านี้สร้างการกระจายซึ่งนโยบายสามารถตัวอย่างเพื่อสร้างการกระทำ

เครือข่ายผู้ช่วยเหลือ

  • EncodingNetwork : ช่วยให้ผู้ใช้กำหนดแผนที่ของเลเยอร์ประมวลผลล่วงหน้าเพื่อนำไปใช้กับอินพุตของเครือข่ายได้อย่างง่ายดาย
  • DynamicUnrollLayer : รีเซ็ตสถานะของเครือข่ายโดยอัตโนมัติตามขอบเขตของตอนเนื่องจากมีการใช้งานตามลำดับเวลา
  • ProjectionNetwork : เครือข่ายเช่น CategoricalProjectionNetwork หรือ NormalProjectionNetwork รับอินพุตและสร้างพารามิเตอร์ที่ต้องการเพื่อสร้าง Categorical หรือการแจกแจงแบบปกติ

ตัวอย่างทั้งหมดใน TF-Agent มาพร้อมกับเครือข่ายที่กำหนดค่าไว้ล่วงหน้า อย่างไรก็ตามเครือข่ายเหล่านี้ไม่ได้ตั้งค่าเพื่อจัดการกับการสังเกตที่ซับซ้อน

หากคุณมีสภาพแวดล้อมที่เปิดเผยมากกว่าหนึ่งการสังเกต / การกระทำและคุณจำเป็นต้องปรับแต่งเครือข่ายของคุณการสอนนี้เหมาะสำหรับคุณ!

ติดตั้ง

หากคุณยังไม่ได้ติดตั้ง tf-agents ให้รัน:

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

การกำหนดเครือข่าย

Network API

ในตัวแทน TF เราแบ่งคลาสย่อยจาก Keras Networks ด้วยเราสามารถ:

  • ลดความซับซ้อนของการทำสำเนาที่จำเป็นเมื่อสร้างเครือข่ายเป้าหมาย
  • ดำเนินการสร้างตัวแปรอัตโนมัติเมื่อเรียก network.variables()
  • ตรวจสอบอินพุตจากเครือข่าย input_specs

EncodingNetwork

ดังกล่าวข้างต้น EncodingNetwork ช่วยให้เราสามารถกำหนดการแมปของเลเยอร์การประมวลผลล่วงหน้าเพื่อนำไปใช้กับอินพุตของเครือข่ายเพื่อสร้างการเข้ารหัสบางอย่าง

EncodingNetwork ประกอบด้วยเลเยอร์เสริมส่วนใหญ่ดังต่อไปนี้:

  • การประมวลผลเลเยอร์ล่วงหน้า
  • ตัวประมวลผลล่วงหน้า
  • Conv2D
  • เรียบ
  • หนาแน่น

สิ่งพิเศษเกี่ยวกับการเข้ารหัสเครือข่ายคือมีการใช้การประมวลผลอินพุตล่วงหน้า ประมวลผลเบื้องต้นการป้อนข้อมูลเป็นไปได้ทาง preprocessing_layers และ preprocessing_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)
 

เนื่องจากเราได้กำหนดข้อสังเกตให้เป็น dict เราจึงต้องสร้างเลเยอร์การประมวลผลล่วงหน้าเพื่อจัดการสิ่งเหล่านี้

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

กลยุทธ์เดียวกันนี้สามารถใช้ปรับแต่งเครือข่ายหลักใด ๆ ที่เอเจนต์ใช้ คุณสามารถกำหนดการประมวลผลล่วงหน้าและเชื่อมต่อกับส่วนที่เหลือของเครือข่าย ในขณะที่คุณกำหนดเองของคุณเองตรวจสอบให้แน่ใจว่าคำจำกัดความเลเยอร์เอาต์พุตของเครือข่ายตรงกัน