সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

অভিনেতা-সমালোচক পদ্ধতির সাথে কার্টপোল বাজানো

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

এই টিউটোরিয়ালটি প্রমান বাস্তবায়ন কিভাবে অভিনেতার-সমালোচক TensorFlow ব্যবহার করে এজেন্ট প্রশিক্ষণের পদ্ধতি খুলুন এআই জিম CartPole-V0 পরিবেশ। পাঠক সঙ্গে কিছু পরিচিত আছে অধিকৃত হয় নীতি গ্রেডিয়েন্ট পদ্ধতি শক্তিবৃদ্ধি শেখার।

অভিনেতা-সমালোচক পদ্ধতি

অভিনেতা-সমালোচক পদ্ধতি সময়গত পার্থক্য (টিডি) লার্নিং পদ্ধতি যে মান ফাংশন নীতি ফাংশন স্বাধীন প্রতিনিধিত্ব করে।

একটি নীতি ফাংশন (বা নীতি) প্রদত্ত অবস্থার উপর ভিত্তি করে এজেন্ট গ্রহণ করতে পারে এমন কর্মের উপর একটি সম্ভাব্যতা বন্টন প্রদান করে। একটি মান ফাংশন একটি এজেন্টের জন্য প্রত্যাশিত রিটার্ন নির্ধারণ করে যা একটি প্রদত্ত অবস্থা থেকে শুরু করে এবং একটি নির্দিষ্ট নীতি অনুসারে কাজ করে।

অভিনেতা-সমালোচক পদ্ধতিতে, নীতি অভিনেতা যে একটি রাষ্ট্র প্রদত্ত সম্ভব ক্রিয়াকলাপের একটি সেট প্রস্তাব হিসাবে উল্লেখ করা হয়, এবং আনুমানিক মূল্য ফাংশন সমালোচক, যা অভিনেতা দেওয়া নীতি উপর ভিত্তি করে কর্তৃক গৃহীত কর্ম মূল্যায়ন হিসাবে উল্লেখ করা হয় .

এই টিউটোরিয়াল এ উভয় অভিনেতাসমালোচক দুই আউটপুট সঙ্গে এক স্নায়ুর নেটওয়ার্ক ব্যবহার প্রতিনিধিত্ব করা হবে না।

CartPole-v0

ইন CartPole-v0 পরিবেশ , একটি মেরু একটি কার্টে frictionless ট্র্যাক বরাবর চলন্ত সংযুক্ত আছে। মেরুটি সোজা শুরু হয় এবং এজেন্টের লক্ষ্য হল কার্টে -1 বা +1 বল প্রয়োগ করে এটিকে পড়ে যাওয়া থেকে রোধ করা। প্রতিবার মেরুটি সোজা রাখার জন্য +1 এর একটি পুরষ্কার দেওয়া হয়৷ একটি পর্ব শেষ হয় যখন (1) মেরুটি উল্লম্ব থেকে 15 ডিগ্রির বেশি বা (2) কার্টটি কেন্দ্র থেকে 2.4 ইউনিটের বেশি সরে যায়।

Cartpole-v0 পরিবেশে প্রশিক্ষিত অভিনেতা-সমালোচক মডেল

সমস্যাটি "সমাধান" বলে বিবেচিত হয় যখন পর্বের জন্য মোট পুরস্কার 100টি পরপর ট্রায়ালে 195 এ পৌঁছায়।

সেটআপ

প্রয়োজনীয় প্যাকেজ আমদানি করুন এবং বিশ্বব্যাপী সেটিংস কনফিগার করুন।

pip install gym
pip install pyglet
# Install additional packages for visualization
sudo apt-get install -y xvfb python-opengl > /dev/null 2>&1
pip install pyvirtualdisplay > /dev/null 2>&1
pip install git+https://github.com/tensorflow/docs > /dev/null 2>&1
import collections
import gym
import numpy as np
import statistics
import tensorflow as tf
import tqdm

from matplotlib import pyplot as plt
from tensorflow.keras import layers
from typing import Any, List, Sequence, Tuple


# Create the environment
env = gym.make("CartPole-v0")

# Set seed for experiment reproducibility
seed = 42
env.seed(seed)
tf.random.set_seed(seed)
np.random.seed(seed)

# Small epsilon value for stabilizing division operations
eps = np.finfo(np.float32).eps.item()

মডেল

অভিনেতাসমালোচক এক স্নায়ুর নেটওয়ার্ক ক্রিয়াটি সম্ভাব্যতা ও সমালোচক মান যথাক্রমে উত্পন্ন ব্যবহার অনুকরণে করা হবে না। এই টিউটোরিয়ালটি মডেলকে সংজ্ঞায়িত করতে মডেল সাবক্লাসিং ব্যবহার করে।

ফরওয়ার্ড পাস সময়, মডেল ইনপুট এবং ইচ্ছা আউটপুট উভয় কর্ম সম্ভাব্যতা ও সমালোচক মান হিসাবে রাজ্যের নিতে হবে \(V\), যা মডেল রাষ্ট্র-নির্ভরশীল মান ফাংশন । লক্ষ্য একটি মডেল যা একটি নীতি উপর ভিত্তি করে তা চয়ন কর্ম প্রশিক্ষণ হয় \(\pi\) সম্ভব বলে আশা করা যে আগমন

Cartpole-v0-এর জন্য, রাষ্ট্রের প্রতিনিধিত্বকারী চারটি মান রয়েছে: যথাক্রমে কার্ট অবস্থান, কার্ট-বেগ, মেরু কোণ এবং মেরু বেগ। এজেন্ট কার্টটিকে যথাক্রমে বাম (0) এবং ডানে (1) ঠেলে দুটি পদক্ষেপ নিতে পারে।

পড়ুন OpenAI জিম এর CartPole-v0 উইকি পাতা আরও তথ্যের জন্য।

class ActorCritic(tf.keras.Model):
  """Combined actor-critic network."""

  def __init__(
      self, 
      num_actions: int, 
      num_hidden_units: int):
    """Initialize."""
    super().__init__()

    self.common = layers.Dense(num_hidden_units, activation="relu")
    self.actor = layers.Dense(num_actions)
    self.critic = layers.Dense(1)

  def call(self, inputs: tf.Tensor) -> Tuple[tf.Tensor, tf.Tensor]:
    x = self.common(inputs)
    return self.actor(x), self.critic(x)
num_actions = env.action_space.n  # 2
num_hidden_units = 128

model = ActorCritic(num_actions, num_hidden_units)

প্রশিক্ষণ

এজেন্টকে প্রশিক্ষণ দিতে, আপনি এই পদক্ষেপগুলি অনুসরণ করবেন:

  1. প্রতি পর্বে প্রশিক্ষণের তথ্য সংগ্রহ করতে পরিবেশে এজেন্ট চালান।
  2. প্রতিটি সময় ধাপে প্রত্যাশিত রিটার্ন গণনা করুন।
  3. সম্মিলিত অভিনেতা-সমালোচক মডেলের জন্য ক্ষতি গণনা করুন।
  4. গ্রেডিয়েন্ট গণনা করুন এবং নেটওয়ার্ক প্যারামিটার আপডেট করুন।
  5. 1-4 পুনরাবৃত্তি করুন যতক্ষণ না হয় সাফল্যের মাপকাঠি বা সর্বোচ্চ পর্বে পৌঁছানো হয়।

1. প্রশিক্ষণের তথ্য সংগ্রহ করা

তত্ত্বাবধানে শেখার মতো, অভিনেতা-সমালোচক মডেলকে প্রশিক্ষণ দেওয়ার জন্য, আপনার প্রশিক্ষণের ডেটা থাকতে হবে। যাইহোক, এই ধরনের তথ্য সংগ্রহ করার জন্য, মডেলটিকে পরিবেশে "চালান" করতে হবে।

প্রতিটি পর্বের জন্য প্রশিক্ষণের তথ্য সংগ্রহ করা হয়। তারপর প্রতিটি ধাপে, মডেলের ফরোয়ার্ড পাস পরিবেশের অবস্থার উপর চালিত হবে যাতে মডেলের ওজন দ্বারা নির্ধারিত বর্তমান নীতির উপর ভিত্তি করে অ্যাকশন সম্ভাব্যতা এবং সমালোচক মান তৈরি করা হয়।

পরবর্তী ক্রিয়াটি মডেল দ্বারা উত্পন্ন ক্রিয়া সম্ভাব্যতা থেকে নমুনা করা হবে, যা তারপর পরিবেশে প্রয়োগ করা হবে, যার ফলে পরবর্তী অবস্থা এবং পুরষ্কার তৈরি করা হবে।

এই প্রক্রিয়া বাস্তবায়িত হয় run_episode ফাংশন, যা TensorFlow অপারেশন ব্যবহার যাতে এটি পরে দ্রুত প্রশিক্ষণের জন্য একটি TensorFlow গ্রাফ মধ্যে কম্পাইল করা যেতে পারে। লক্ষ্য করুন tf.TensorArray গুলি পরিবর্তনশীল দৈর্ঘ্য অ্যারে উপর টেন্সর পুনরাবৃত্তির সমর্থন করার জন্য ব্যবহার করা হয়।

# Wrap OpenAI Gym's `env.step` call as an operation in a TensorFlow function.
# This would allow it to be included in a callable TensorFlow graph.

def env_step(action: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
  """Returns state, reward and done flag given an action."""

  state, reward, done, _ = env.step(action)
  return (state.astype(np.float32), 
          np.array(reward, np.int32), 
          np.array(done, np.int32))


def tf_env_step(action: tf.Tensor) -> List[tf.Tensor]:
  return tf.numpy_function(env_step, [action], 
                           [tf.float32, tf.int32, tf.int32])
def run_episode(
    initial_state: tf.Tensor,  
    model: tf.keras.Model, 
    max_steps: int) -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
  """Runs a single episode to collect training data."""

  action_probs = tf.TensorArray(dtype=tf.float32, size=0, dynamic_size=True)
  values = tf.TensorArray(dtype=tf.float32, size=0, dynamic_size=True)
  rewards = tf.TensorArray(dtype=tf.int32, size=0, dynamic_size=True)

  initial_state_shape = initial_state.shape
  state = initial_state

  for t in tf.range(max_steps):
    # Convert state into a batched tensor (batch size = 1)
    state = tf.expand_dims(state, 0)

    # Run the model and to get action probabilities and critic value
    action_logits_t, value = model(state)

    # Sample next action from the action probability distribution
    action = tf.random.categorical(action_logits_t, 1)[0, 0]
    action_probs_t = tf.nn.softmax(action_logits_t)

    # Store critic values
    values = values.write(t, tf.squeeze(value))

    # Store log probability of the action chosen
    action_probs = action_probs.write(t, action_probs_t[0, action])

    # Apply action to the environment to get next state and reward
    state, reward, done = tf_env_step(action)
    state.set_shape(initial_state_shape)

    # Store reward
    rewards = rewards.write(t, reward)

    if tf.cast(done, tf.bool):
      break

  action_probs = action_probs.stack()
  values = values.stack()
  rewards = rewards.stack()

  return action_probs, values, rewards

2. প্রত্যাশিত রিটার্ন গণনা করা

প্রতিটি timestep জন্য পুরষ্কার ক্রম \(t\), \(\{r_{t}\}^{T}_{t=1}\) এক পর্বের সময় সংগৃহীত প্রত্যাশিত আয় একটা ক্রম রূপান্তরিত হয় \(\{G_{t}\}^{T}_{t=1}\) যা পুরস্কারের সমষ্টি বর্তমান timestep থেকে নেওয়া হয় \(t\) করার \(T\) এবং প্রতিটি পুরস্কার একটি ব্যাখ্যা মূলকভাবে ক্ষয়িষ্ণু ছাড় ফ্যাক্টর সাথে গুণ করা হয় \(\gamma\):

\[G_{t} = \sum^{T}_{t'=t} \gamma^{t'-t}r_{t'}\]

যেহেতু \(\gamma\in(0,1)\), আরও জানতে বর্তমান timestep থেকে কম ওজন দেওয়া হয় প্রতিদান দিয়ে থাকেন।

স্বজ্ঞাতভাবে, প্রত্যাশিত রিটার্ন সহজভাবে বোঝায় যে এখন পুরষ্কারগুলি পরে পুরষ্কারের চেয়ে ভাল৷ গাণিতিক অর্থে, এটি নিশ্চিত করা হয় যে পুরষ্কারের যোগফল একত্রিত হয়।

প্রশিক্ষণ স্থিতিশীল করার জন্য, ফলাফলের ক্রমটিও প্রমিত করা হয় (অর্থাৎ শূন্য গড় এবং একক মান বিচ্যুতি)।

def get_expected_return(
    rewards: tf.Tensor, 
    gamma: float, 
    standardize: bool = True) -> tf.Tensor:
  """Compute expected returns per timestep."""

  n = tf.shape(rewards)[0]
  returns = tf.TensorArray(dtype=tf.float32, size=n)

  # Start from the end of `rewards` and accumulate reward sums
  # into the `returns` array
  rewards = tf.cast(rewards[::-1], dtype=tf.float32)
  discounted_sum = tf.constant(0.0)
  discounted_sum_shape = discounted_sum.shape
  for i in tf.range(n):
    reward = rewards[i]
    discounted_sum = reward + gamma * discounted_sum
    discounted_sum.set_shape(discounted_sum_shape)
    returns = returns.write(i, discounted_sum)
  returns = returns.stack()[::-1]

  if standardize:
    returns = ((returns - tf.math.reduce_mean(returns)) / 
               (tf.math.reduce_std(returns) + eps))

  return returns

3. অভিনেতা-সমালোচক ক্ষতি

যেহেতু একটি হাইব্রিড অভিনেতা-সমালোচক মডেল ব্যবহার করা হয়, নির্বাচিত ক্ষতি ফাংশন হল অভিনেতা এবং প্রশিক্ষণের জন্য সমালোচকের ক্ষতির সংমিশ্রণ, যা নীচে দেখানো হয়েছে:

\[L = L_{actor} + L_{critic}\]

অভিনেতার ক্ষতি

অভিনেতা ক্ষতি উপর ভিত্তি করে তৈরি একটি রাষ্ট্র নির্ভরশীল বেসলাইন হিসাবে সমালোচক সঙ্গে নীতি গ্রেডিয়েন্ট এবং একক-নমুনা (প্রতি-পর্ব) অনুমান সঙ্গে নির্ণিত।

\[L_{actor} = -\sum^{T}_{t=1} \log\pi_{\theta}(a_{t} | s_{t})[G(s_{t}, a_{t}) - V^{\pi}_{\theta}(s_{t})]\]

কোথায়:

  • \(T\): পর্ব প্রতি timesteps সংখ্যা, যা প্রতি পর্বের বিভিন্ন রকমের হতে পারে
  • \(s_{t}\): timestep এ রাষ্ট্র \(t\)
  • \(a_{t}\): timestep এ মনোনীত কর্ম \(t\) দেওয়া রাষ্ট্র \(s\)
  • \(\pi_{\theta}\): নীতি (অভিনেতা) দ্বারা স্থিতিমাপ হয় \(\theta\)
  • \(V^{\pi}_{\theta}\): VALUE ফাংশন (সমালোচক) ও দ্বারা স্থিতিমাপ হয় \(\theta\)
  • \(G = G_{t}\): একটি প্রদত্ত রাষ্ট্রের জন্য প্রত্যাশিত রিটার্ন, timestep এ কর্ম যুগল \(t\)

যোগফলের সাথে একটি নেতিবাচক শব্দ যোগ করা হয় কারণ ধারণাটি হল সম্মিলিত ক্ষতি কমিয়ে উচ্চ পুরষ্কার প্রদানকারী ক্রিয়াকলাপের সম্ভাবনাকে সর্বাধিক করা।


সুবিধা

\(G - V\) আমাদের শব্দটি \(L_{actor}\) তৈয়ার বলা হয় সুবিধা , যা নির্দেশ করছে কিভাবে অনেক ভালো একটি কর্ম নীতি অনুযায়ী নির্বাচিত একটি র্যান্ডম কর্ম উপর একটি বিশেষ অবস্থা দেওয়া হয় \(\pi\) যে রাষ্ট্র জন্য।

যদিও এটি একটি বেসলাইন বাদ দেওয়া সম্ভব, এটি প্রশিক্ষণের সময় উচ্চ পার্থক্য হতে পারে। এবং সমালোচক নির্বাচন সম্পর্কে চমৎকার জিনিস \(V\) একটি বেসলাইন হিসাবে এটি সম্ভব বন্ধ হতে প্রশিক্ষিত হয় \(G\), একটি নিম্ন ভ্যারিয়েন্স নেতৃস্থানীয়।

উপরন্তু, সমালোচক ব্যতীত, অ্যালগরিদম প্রত্যাশিত রিটার্নের উপর ভিত্তি করে একটি নির্দিষ্ট অবস্থার উপর গৃহীত ক্রিয়াকলাপের সম্ভাবনা বাড়ানোর চেষ্টা করবে, যা কর্মের মধ্যে আপেক্ষিক সম্ভাবনা একই থাকলে তা খুব একটা পার্থক্য করতে পারে না।

উদাহরণস্বরূপ, ধরুন যে একটি প্রদত্ত রাষ্ট্রের জন্য দুটি কর্ম একই প্রত্যাশিত রিটার্ন প্রদান করবে। সমালোচক ছাড়া, অ্যালগরিদম এই উদ্দেশ্য উপর ভিত্তি করে কর্মের সম্ভাব্যতা বাড়াতে চেষ্টা করবে \(J\)। সমালোচক সঙ্গে, এটা কোন সুবিধা (যে সেখানে আউট চালু হতে পারে\(G - V = 0\)) এবং এইভাবে কোন লাভ ক্রিয়া 'সম্ভাব্যতা বেড়ে যাওয়ার ক্ষেত্রে অর্জন করে চলেছে এবং অ্যালগরিদম শুন্যতে গ্রেডিয়েন্ট নির্ধারণ করবে।


সমালোচক ক্ষতি

প্রশিক্ষণ \(V\) যেমন পাসে সম্ভব \(G\) নিম্নলিখিত ক্ষতি ফাংশন সঙ্গে একটি রিগ্রেশন সমস্যা হিসাবে সেট আপ করা যেতে পারে:

\[L_{critic} = L_{\delta}(G, V^{\pi}_{\theta})\]

যেখানে \(L_{\delta}\) হয় হুবার ক্ষতি , যা কম ছক-ত্রুটি হ্রাস চেয়ে তথ্য outliers সংবেদনশীল হয়।

huber_loss = tf.keras.losses.Huber(reduction=tf.keras.losses.Reduction.SUM)

def compute_loss(
    action_probs: tf.Tensor,  
    values: tf.Tensor,  
    returns: tf.Tensor) -> tf.Tensor:
  """Computes the combined actor-critic loss."""

  advantage = returns - values

  action_log_probs = tf.math.log(action_probs)
  actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)

  critic_loss = huber_loss(values, returns)

  return actor_loss + critic_loss

4. পরামিতি আপডেট করার জন্য প্রশিক্ষণের ধাপ সংজ্ঞায়িত করা

উপরের সমস্ত ধাপগুলিকে একটি প্রশিক্ষণের ধাপে একত্রিত করা হয়েছে যা প্রতিটি পর্বে চালানো হয়। ক্ষতি ফাংশন অগ্রসর হওয়ার সকল পদক্ষেপ সঙ্গে মৃত্যুদন্ড কার্যকর করা হয় tf.GradientTape স্বয়ংক্রিয় বিভেদ সক্ষম প্রসঙ্গ।

মডেল প্যারামিটারে গ্রেডিয়েন্ট প্রয়োগ করতে এই টিউটোরিয়াল অ্যাডাম অপ্টিমাইজার ব্যবহার করে।

Undiscounted পুরস্কারের সমষ্টি, episode_reward , এছাড়াও এই ধাপে নির্ণয় করা হয়। সাফল্যের মাপকাঠি পূরণ হলে মূল্যায়ন করার জন্য এই মানটি পরে ব্যবহার করা হবে।

tf.function প্রসঙ্গ প্রয়োগ করা হয় train_step ফাংশন যাতে এটি একটি callable TensorFlow গ্রাফ, যা প্রশিক্ষণ 10x speedup হতে পারে মধ্যে কম্পাইল করা যেতে পারে।

optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)


@tf.function
def train_step(
    initial_state: tf.Tensor, 
    model: tf.keras.Model, 
    optimizer: tf.keras.optimizers.Optimizer, 
    gamma: float, 
    max_steps_per_episode: int) -> tf.Tensor:
  """Runs a model training step."""

  with tf.GradientTape() as tape:

    # Run the model for one episode to collect training data
    action_probs, values, rewards = run_episode(
        initial_state, model, max_steps_per_episode) 

    # Calculate expected returns
    returns = get_expected_return(rewards, gamma)

    # Convert training data to appropriate TF tensor shapes
    action_probs, values, returns = [
        tf.expand_dims(x, 1) for x in [action_probs, values, returns]] 

    # Calculating loss values to update our network
    loss = compute_loss(action_probs, values, returns)

  # Compute the gradients from the loss
  grads = tape.gradient(loss, model.trainable_variables)

  # Apply the gradients to the model's parameters
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  episode_reward = tf.math.reduce_sum(rewards)

  return episode_reward

5. প্রশিক্ষণ লুপ চালান

সাফল্যের মাপকাঠি বা পর্বের সর্বোচ্চ সংখ্যায় না পৌঁছানো পর্যন্ত প্রশিক্ষণের ধাপটি চালানোর মাধ্যমে প্রশিক্ষণ কার্যকর করা হয়।

পর্বের পুরস্কারের একটি চলমান রেকর্ড একটি সারিতে রাখা হয়। একবার 100টি ট্রায়ালে পৌঁছে গেলে, সারির বাঁদিকে (টেইল) শেষে সবচেয়ে পুরনো পুরস্কারটি সরানো হয় এবং নতুনটি মাথায় (ডানদিকে) যোগ করা হয়। কম্পিউটেশনাল দক্ষতার জন্য পুরস্কারের একটি চলমান সমষ্টিও বজায় রাখা হয়।

আপনার রানটাইমের উপর নির্ভর করে, প্রশিক্ষণ এক মিনিটেরও কম সময়ে শেষ হতে পারে।

%%time

min_episodes_criterion = 100
max_episodes = 10000
max_steps_per_episode = 1000

# Cartpole-v0 is considered solved if average reward is >= 195 over 100 
# consecutive trials
reward_threshold = 195
running_reward = 0

# Discount factor for future rewards
gamma = 0.99

# Keep last episodes reward
episodes_reward: collections.deque = collections.deque(maxlen=min_episodes_criterion)

with tqdm.trange(max_episodes) as t:
  for i in t:
    initial_state = tf.constant(env.reset(), dtype=tf.float32)
    episode_reward = int(train_step(
        initial_state, model, optimizer, gamma, max_steps_per_episode))

    episodes_reward.append(episode_reward)
    running_reward = statistics.mean(episodes_reward)

    t.set_description(f'Episode {i}')
    t.set_postfix(
        episode_reward=episode_reward, running_reward=running_reward)

    # Show average episode reward every 10 episodes
    if i % 10 == 0:
      pass # print(f'Episode {i}: average reward: {avg_reward}')

    if running_reward > reward_threshold and i >= min_episodes_criterion:  
        break

print(f'\nSolved at episode {i}: average reward: {running_reward:.2f}!')
Episode 361:   4%|▎         | 361/10000 [01:16<34:10,  4.70it/s, episode_reward=182, running_reward=195]
Solved at episode 361: average reward: 195.14!
CPU times: user 2min 50s, sys: 40.3 s, total: 3min 30s
Wall time: 1min 16s

ভিজ্যুয়ালাইজেশন

প্রশিক্ষণের পরে, পরিবেশে মডেলটি কীভাবে কাজ করে তা কল্পনা করা ভাল। আপনি মডেলটির একটি পর্বের একটি GIF অ্যানিমেশন তৈরি করতে নীচের ঘরগুলি চালাতে পারেন৷ মনে রাখবেন যে Colab-এ পরিবেশের ছবি সঠিকভাবে রেন্ডার করতে OpenAI জিমের জন্য অতিরিক্ত প্যাকেজ ইনস্টল করতে হবে।

# Render an episode and save as a GIF file

from IPython import display as ipythondisplay
from PIL import Image
from pyvirtualdisplay import Display


display = Display(visible=0, size=(400, 300))
display.start()


def render_episode(env: gym.Env, model: tf.keras.Model, max_steps: int): 
  screen = env.render(mode='rgb_array')
  im = Image.fromarray(screen)

  images = [im]

  state = tf.constant(env.reset(), dtype=tf.float32)
  for i in range(1, max_steps + 1):
    state = tf.expand_dims(state, 0)
    action_probs, _ = model(state)
    action = np.argmax(np.squeeze(action_probs))

    state, _, done, _ = env.step(action)
    state = tf.constant(state, dtype=tf.float32)

    # Render screen every 10 steps
    if i % 10 == 0:
      screen = env.render(mode='rgb_array')
      images.append(Image.fromarray(screen))

    if done:
      break

  return images


# Save GIF image
images = render_episode(env, model, max_steps_per_episode)
image_file = 'cartpole-v0.gif'
# loop=0: loop forever, duration=1: play each frame for 1ms
images[0].save(
    image_file, save_all=True, append_images=images[1:], loop=0, duration=1)
import tensorflow_docs.vis.embed as embed
embed.embed_file(image_file)

gif

পরবর্তী পদক্ষেপ

এই টিউটোরিয়ালটি দেখানো হয়েছে কিভাবে Tensorflow ব্যবহার করে অভিনেতা-সমালোচক পদ্ধতি বাস্তবায়ন করতে হয়।

পরবর্তী পদক্ষেপ হিসাবে, আপনি OpenAI জিমে একটি ভিন্ন পরিবেশে একটি মডেল প্রশিক্ষণের চেষ্টা করতে পারেন।

অভিনেতা-সমালোচক পদ্ধতি এবং Cartpole-v0 সমস্যা সম্পর্কিত অতিরিক্ত তথ্যের জন্য, আপনি নিম্নলিখিত সংস্থানগুলি উল্লেখ করতে পারেন:

TensorFlow-এ আরও শক্তিবৃদ্ধি শেখার উদাহরণের জন্য, আপনি নিম্নলিখিত সংস্থানগুলি পরীক্ষা করতে পারেন: