নেটওয়ার্ক

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

ভূমিকা

এই কোল্যাবে আমরা কভার করব কিভাবে আপনার এজেন্টদের জন্য কাস্টম নেটওয়ার্ক সংজ্ঞায়িত করতে হয়। নেটওয়ার্কগুলি আমাদের এজেন্টদের দ্বারা প্রশিক্ষিত মডেলকে সংজ্ঞায়িত করতে সাহায্য করে। TF-এজেন্টগুলিতে আপনি বিভিন্ন ধরণের নেটওয়ার্ক পাবেন যা এজেন্ট জুড়ে দরকারী:

প্রধান নেটওয়ার্ক

  • QNetwork: বিযুক্ত কর্মের পরিবেশের জন্য Qlearning ব্যবহৃত এই নেটওয়ার্কের প্রতিটি সম্ভাব্য ক্রিয়ার জন্য মান অনুমান একটি পর্যবেক্ষণ মানচিত্র তৈরী করে।
  • CriticNetworks: এছাড়াও হিসাবে উল্লেখ করা ValueNetworks সাহিত্যে, শেখে একটি নীতি প্রত্যাশিত রিটার্ন জন্য একটি অনুমান মধ্যে একটি মান ফাংশন কিছু রাষ্ট্র ম্যাপিং কিছু সংস্করণ অনুমান করার জন্য। এই নেটওয়ার্কগুলি অনুমান করে যে এজেন্ট বর্তমানে কতটা ভালো অবস্থায় আছে।
  • ActorNetworks: কাজের পর্যবেক্ষণ থেকে একটি ম্যাপিং উপায় সম্পর্কে জানুন। এই নেটওয়ার্কগুলি সাধারণত আমাদের নীতি দ্বারা অ্যাকশন তৈরি করতে ব্যবহার করা হয়।
  • ActorDistributionNetworks: অনুরূপ ActorNetworks কিন্তু এই একটি বিতরণ যা একটি নীতি কর্ম জেনারেট করতে তারপর নমুনা করতে উৎপন্ন।

হেল্পার নেটওয়ার্ক

  • EncodingNetwork: ব্যবহারকারীরা সহজেই একটি নেটওয়ার্ক এর ইনপুট প্রয়োগ করতে প্রাক প্রক্রিয়াকরণ স্তর একটি ম্যাপিং নির্ধারণ করতে দেয়।
  • DynamicUnrollLayer: স্বয়ংক্রিয়ভাবে যেমন একটি সময় ক্রম উপর প্রয়োগ করা হয় পর্বের গণ্ডি নেটওয়ার্ক রাষ্ট্রীয় পুনরায় সেট করবে।
  • ProjectionNetwork: মত নেটওয়ার্ক CategoricalProjectionNetwork বা NormalProjectionNetwork ইনপুট গ্রহণ করা এবং প্রয়োজনীয় পরামিতি উৎপন্ন শ্রেণীগত, বা স্বাভাবিক ডিস্ট্রিবিউশন তৈরি করতে।

TF-এজেন্টের সমস্ত উদাহরণ পূর্ব-কনফিগার করা নেটওয়ার্কের সাথে আসে। তবে এই নেটওয়ার্কগুলি জটিল পর্যবেক্ষণগুলি পরিচালনা করার জন্য সেটআপ করা হয় না।

আপনার যদি এমন একটি পরিবেশ থাকে যা একাধিক পর্যবেক্ষণ/ক্রিয়া প্রকাশ করে এবং আপনাকে আপনার নেটওয়ার্কগুলি কাস্টমাইজ করতে হবে তাহলে এই টিউটোরিয়ালটি আপনার জন্য!

সেটআপ

আপনি যদি এখনও tf-এজেন্ট ইনস্টল না করে থাকেন, তাহলে চালান:

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

নেটওয়ার্ক সংজ্ঞায়িত করা

নেটওয়ার্ক API

মেমরি-এজেন্ট আমরা Keras থেকে উপশ্রেণী নেটওয়ার্ক । এটি দিয়ে আমরা পারি:

  • টার্গেট নেটওয়ার্ক তৈরি করার সময় প্রয়োজনীয় অনুলিপি অপারেশন সহজ করুন।
  • যখন কলিং স্বয়ংক্রিয় পরিবর্তনশীল সৃষ্টি সঞ্চালন network.variables()
  • নেটওয়ার্ক input_specs এর উপর ভিত্তি করে ইনপুট যাচাই করুন।

এনকোডিং নেটওয়ার্ক

পূর্বেই উল্লেখ করা হয়েছে EncodingNetwork আমাদের সহজে একটি নেটওয়ার্ক এর ইনপুট প্রয়োগ হতে কিছু এনকোডিং জেনারেট করতে প্রাক প্রক্রিয়াকরণ স্তর একটি ম্যাপিং নির্ধারণ করতে দেয়।

EncodingNetwork নিম্নলিখিত বেশিরভাগ ঐচ্ছিক স্তরগুলির সমন্বয়ে গঠিত:

  • প্রিপ্রসেসিং স্তর
  • প্রিপ্রসেসিং কম্বাইনার
  • Conv2D
  • চ্যাপ্টা
  • ঘন

এনকোডিং নেটওয়ার্ক সম্পর্কে বিশেষ জিনিস হল ইনপুট প্রিপ্রসেসিং প্রয়োগ করা হয়। ইনপুট প্রাক-প্রক্রিয়াকরণ মাধ্যমে সম্ভব preprocessing_layers এবং preprocessing_combiner স্তর। এই প্রতিটি একটি নেস্টেড কাঠামো হিসাবে নির্দিষ্ট করা যেতে পারে. তাহলে preprocessing_layers নীড় চেয়ে অগভীর হয় input_tensor_spec , তারপর লেয়ার subnests পাবেন। উদাহরণস্বরূপ, যদি:

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

তারপর প্রিপ্রসেসিং কল করবে:

preprocessed = [preprocessing_layers[0](observations[0]),
                preprocessing_layers[1](observations[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([[4.5753636, 4.946792 , 4.853481 ]], dtype=float32)>,
 ())

এই একই কৌশলটি এজেন্টদের দ্বারা ব্যবহৃত যেকোনো প্রধান নেটওয়ার্ক কাস্টমাইজ করতে ব্যবহার করা যেতে পারে। আপনি যাই হোক না কেন প্রিপ্রসেসিং সংজ্ঞায়িত করতে পারেন এবং এটিকে বাকি নেটওয়ার্কের সাথে সংযুক্ত করতে পারেন। আপনি আপনার নিজস্ব কাস্টম সংজ্ঞায়িত করার সাথে সাথে নেটওয়ার্কের আউটপুট স্তরের সংজ্ঞাগুলি মেলে তা নিশ্চিত করুন৷