{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "id": "zXysnxJdocoL" }, "outputs": [], "source": [ "%%capture\n", "!pip install mujoco==2.3.3\n" ] }, { "cell_type": "markdown", "metadata": { "id": "pyCx4Tk_GQ4A" }, "source": [ "## **Importing Required Libraries**\n", "\n", "This cell imports all the necessary libraries for implementing **Proximal Policy Optimization (PPO)**. The key components include:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "XXDB_U6DW7Iy" }, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "from torch.distributions import Categorical\n", "from torch.distributions import MultivariateNormal\n", "import torch.nn.functional as F\n", "\n", "import torch.optim as optim\n", "import gymnasium as gym\n", "import numpy as np\n", "import os\n", "import pandas as pd\n", "\n", "import imageio\n", "from base64 import b64encode\n", "from IPython.display import HTML\n", "\n", "\n", "import logging\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "is_ipython = 'inline' in matplotlib.get_backend()\n", "import numpy as np\n", "\n", "if is_ipython:\n", " from IPython import display\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Kp0xLe9kGQ4C" }, "source": [ "## **Logging, Visualization, and Video Playback Functions**\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "b0abphr4kMZ1" }, "outputs": [], "source": [ "logging.getLogger().setLevel(logging.ERROR)\n", "\n", "# set up matplotlib\n", "plt.ion()\n", "plt.xkcd(scale=1, length=100, randomness=2)\n", "matplotlib.rcParams['figure.figsize'] = (12, 6)\n", "\n", "\n", "def plot_rewards(sum_of_rewards, show_result=None , bove = None,dn = None):\n", " plt.figure(1)\n", " rewards = torch.tensor(sum_of_rewards, dtype=torch.float)\n", " if show_result is not None:\n", " plt.title(f'{show_result}')\n", " else:\n", " plt.clf()\n", " plt.title('Training...')\n", " if bove is not None:\n", " plt.xlabel(f'{bove}')\n", " else:\n", " plt.xlabel('Episode')\n", " if dn is not None:\n", " plt.xlabel(f'{dn}')\n", " else:\n", " plt.ylabel('Reward')\n", " plt.plot(rewards.numpy())\n", " # Take 50 episode averages and plot them too\n", " length = len(rewards)\n", " init_len = min(49, length)\n", " init_means = np.cumsum(rewards[:init_len]) / (1 + np.arange(init_len))\n", " if length > 50:\n", " means = rewards.unfold(0, 50, 1).mean(1).view(-1)\n", " means = torch.cat((init_means, means))\n", " else:\n", " means = init_means\n", " plt.plot(means.numpy())\n", "\n", " plt.pause(0.001) # pause a bit so that plots are updated\n", " if is_ipython:\n", " if not show_result:\n", " display.display(plt.gcf())\n", " display.clear_output(wait=True)\n", " else:\n", " display.display(plt.gcf())\n", "\n", "def show_video(path):\n", " mp4 = open(path, 'rb').read()\n", " data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n", " return HTML(\"\"\"\n", " \n", " \"\"\" % data_url)" ] }, { "cell_type": "markdown", "metadata": { "id": "WnKOvNodGQ4C" }, "source": [ "## **Memory Buffer for PPO**\n", "\n", "### **Class: `Memory`**\n", "- A **buffer** for storing experiences during training, used for **PPO (Proximal Policy Optimization) updates**.\n", "- Stores the following per episode:\n", " - `actions`: Actions taken by the agent.\n", " - `states`: Observed states from the environment.\n", " - `logprobs`: Log probabilities of actions (needed for importance sampling in PPO).\n", " - `rewards`: Rewards obtained after taking actions.\n", " - `state_values`: Estimated state values from the critic.\n", "\n", "### **Function: `clear()`**\n", "- Clears the stored experiences before collecting new trajectories.\n", "- Ensures memory is reset between updates to prevent stale data from affecting optimization.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "CZ16f7aiZlul" }, "outputs": [], "source": [ "class Memory:\n", " def __init__(self):\n", " self.actions = []\n", " self.states = []\n", " self.logprobs = []\n", " self.rewards = []\n", " self.state_values = []\n", "\n", " def clear(self):\n", " del self.actions[:]\n", " del self.states[:]\n", " del self.logprobs[:]\n", " del self.rewards[:]\n", " del self.state_values[:]" ] }, { "cell_type": "markdown", "metadata": { "id": "x1AK3ZN2GQ4D" }, "source": [ "## **Actor-Critic Network in PPO**\n", "\n", "This implementation defines two neural networks used in Proximal Policy Optimization (PPO).\n", "\n", "The actor network is responsible for predicting a probability distribution over actions (discrete) or estimating the value for each action (continuous), given the current state, while the critic network evaluates how good the action taken by the actor is, by predicting the reward based on state." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "iQdCusXxBfG-" }, "outputs": [], "source": [ "class Actor(nn.Module):\n", " def __init__(self, state_dim, hidden_size, action_dim):\n", " super(Actor, self).__init__()\n", " # Define the Actor architecture\n", " # TODO\n", "\n", " self.layer1= nn.Linear(state_dim, hidden_size)\n", " self.mid1= nn.Linear(hidden_size, hidden_size)\n", " self.mid2= nn.Linear(hidden_size, hidden_size)\n", "\n", " self.mu= nn.Linear(hidden_size, action_dim)\n", " self.std= nn.Linear(hidden_size, action_dim)\n", "\n", " def forward(self, state):\n", " # In case of continuous environment, we usually\n", " # predict a mean and std for each action and sample\n", " # the action from a normal distribution\n", " # TODO\n", "\n", " if isinstance(state, np.ndarray):\n", " state = torch.from_numpy(state).float().unsqueeze(0)\n", " state = state.to(device)\n", "\n", " X = F.relu(self.layer1(state.float()))\n", " X = F.relu(self.mid1(X))\n", " X = F.relu(self.mid2(X))\n", "\n", " mu = self.mu(X)\n", " std = F.softplus(self.std(X))\n", "\n", " return mu, std\n", "\n", "class Critic(nn.Module):\n", " def __init__(self, state_dim, hidden_size):\n", " super(Critic, self).__init__()\n", " # Define the Critic architecture\n", " # TODO\n", "\n", " self.layer1= nn.Linear(state_dim, hidden_size)\n", " self.mid1= nn.Linear(hidden_size, hidden_size)\n", " self.mid2= nn.Linear(hidden_size, hidden_size)\n", "\n", " self.value= nn.Linear(hidden_size, 1)\n", "\n", " def forward(self, state):\n", " # Predict the value of state\n", " # TODO\n", " if isinstance(state, np.ndarray):\n", " state = torch.from_numpy(state).float().unsqueeze(0)\n", " state = state.to(device)\n", "\n", " X = F.relu(self.layer1(state.float()))\n", " X = F.relu(self.mid1(X))\n", " X = F.relu(self.mid2(X))\n", "\n", " value = self.value(X)\n", " return value\n" ] }, { "cell_type": "markdown", "metadata": { "id": "u041w-VHGQ4D" }, "source": [ "## **Proximal Policy Optimization (PPO) Algorithm Implementation**\n", "\n", "This class implements the **PPO (Proximal Policy Optimization) algorithm**, which is a policy gradient method used in reinforcement learning. It optimizes an actor-critic network while maintaining stability and efficiency.\n", "\n", "### **Key Components:**\n", "1. **Initialization (`__init__`)**:\n", " - Sets hyperparameters (e.g., `gamma`, `eps_clip`, `gae_lambda`).\n", " - Creates **Actor and Critic networks**.\n", " - Defines **Adam optimizers** for both networks.\n", " - Initializes a memory buffer for storing experience.\n", "\n", "2. **Action Selection (`select_action`)**:\n", " - Uses the **Actor network** to predict a mean and standard deviation for the action.\n", " - Samples an action from a normal distribution.\n", " - Stores the action, log probability, and value function output in memory.\n", "\n", "3. **Policy Evaluation (`evaluate`)**:\n", " - Computes the log probability of actions under the current policy.\n", " - Returns entropy (used for exploration encouragement).\n", "\n", "4. **Policy Update (`update`)**:\n", " - Computes **discounted rewards** and **Generalized Advantage Estimation (GAE)**.\n", " - Uses **clipped surrogate objective** to stabilize training.\n", " - Minimizes **actor loss** (policy update) and **critic loss** (value function update).\n", " - Updates networks using **gradient descent**.\n", "\n", "5. **Memory Handling (`push_memory`, `load_memory`, `store_reward`)**:\n", " - Stores and retrieves experience for training updates.\n", " - Resets the memory buffer after each policy update.\n", "\n", "### **Key Features of PPO**\n", "- **Clipping Ratio**: Prevents excessive updates to the policy, improving stability.\n", "- **Advantage Estimation**: Helps in reducing variance in policy updates.\n", "- **Entropy Regularization**: Encourages exploration by adding entropy loss.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "weDfdfeMcgCD" }, "source": [ "## **1. PPO Clipped Loss Function**\n", "The PPO loss function prevents large policy updates by introducing a clipped objective. The ratio of new and old policy probabilities is computed as:\n", "$$\n", "r_t(\\theta) = \\frac{\\pi_{\\theta}(a_t | s_t)}{\\pi_{\\theta_{\\text{old}}}(a_t | s_t)}\n", "$$\n", "where:\n", "- $ \\theta $ are the current policy parameters.\n", "- $\\theta_{\\text{old}} $ are the policy parameters before the update.\n", "\n", "The surrogate loss function is:\n", "$$\n", "L^{\\text{CLIP}}(\\theta) = \\mathbb{E} \\left[ \\min \\left( r_t(\\theta) A_t, \\text{clip}(r_t(\\theta), 1 - \\epsilon, 1 + \\epsilon) A_t \\right) \\right]\n", "$$\n", "where:\n", "- $ A_t $ is the **advantage function**, which measures how much better an action is compared to the expected value of the state.\n", "- $ \\epsilon $ is a small clipping parameter (e.g., **0.2**) that prevents drastic policy updates.\n", "\n", "---\n", "\n", "## **2. Critic Loss Function**\n", "The critic is updated using **Mean Squared Error (MSE)** between the predicted and actual state value:\n", "$$\n", "L_{\\text{critic}} = \\mathbb{E} \\left[ (V(s_t) - R_t)^2 \\right]\n", "$$\n", "\n", "---\n", "\n", "## **3. Total Loss**\n", "The overall loss function is:\n", "$$\n", "L_{\\text{total}} = L^{\\text{CLIP}} + \\beta H - L_{\\text{critic}}\n", "$$\n", "where:\n", "- $ H $ is the **entropy bonus** to encourage exploration.\n", "- $ \\beta $ is a small coefficient (e.g., **0.01**) controlling the strength of the entropy bonus.\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "6UqxHEqF3Ovc" }, "outputs": [], "source": [ "class PPO(nn.Module):\n", " def __init__(self, env, config):\n", " super(PPO, self).__init__()\n", " self.gamma = config.GAMMA\n", " self.eps_clip = config.EPS_CLIP\n", " self.epochs = config.K_EPOCHS\n", " self.gae_lambda = config.GAE\n", " self.hidden_size = config.hidden_size\n", "\n", " self.lr = config.LEARNING_RATE\n", " state_dim = env.observation_space.shape[0]\n", " action_dim = env.action_space.shape[0]\n", "\n", " self.actor = Actor(state_dim, self.hidden_size, action_dim).to(device)\n", " self.critic = Critic(state_dim, self.hidden_size).to(device)\n", "\n", " self.optimizer_actor = optim.Adam(self.actor.parameters(), lr=self.lr)\n", " self.optimizer_critic = optim.Adam(self.critic.parameters(), lr=self.lr)\n", " self.memory = Memory()\n", "\n", " def select_action(self, state):\n", " # Save state, action, log probability and state value of current step in the memory buffer.\n", " # predict the actions by sampling from a normal distribution\n", " # based on the mean and std calculated by actor\n", " #TODO\n", "\n", " mean, std = self.actor(state)\n", " dist_policy = torch.distributions.Normal(mean, std)\n", " action = dist_policy.sample()\n", " log_prob = dist_policy.log_prob(action).sum()\n", "\n", "\n", " value = self.critic(state)\n", "\n", " state = torch.from_numpy(state).float()\n", "\n", " self.push_memory(state, action, log_prob, value)\n", "\n", " return action.squeeze(0).cpu().numpy()\n", "\n", "\n", " def evaluate(self, state, action):\n", " # evaluate the state value of this state and log probability of choosing this action\n", " #TODO\n", "\n", " mean, std = self.actor(state)\n", " state_value = self.critic(state)\n", " dist = torch.distributions.Normal(mean, std)\n", " action_logprobs = dist.log_prob(action.squeeze(1)).sum(1)\n", " entropy = dist.entropy().sum(1)\n", "\n", " return action_logprobs, state_value, entropy\n", "\n", " def update(self):\n", " rewards = []\n", " advantages = []\n", " discounted_reward = 0\n", " gae = 0\n", "\n", "\n", " # load saved states, actions, log probs, and state values\n", " #TODO\n", " old_states, old_actions, old_logprobs, old_state_vals = self.load_memory()\n", "\n", "\n", " # Calculate gae for each time step\n", " #TODO\n", " for r, v, nv in zip(reversed(self.memory.rewards), reversed(self.memory.state_values), reversed(self.memory.state_values[1:] + [0])):\n", " discounted_reward = r + self.gamma * discounted_reward\n", " rewards.insert(0, discounted_reward)\n", "\n", " delta = r + self.gamma * nv - v\n", " gae = delta + self.gamma * self.gae_lambda * gae\n", " advantages.insert(0, gae)\n", "\n", " rewards = torch.tensor(rewards, dtype=torch.float32, device=device)\n", " # rewards = (rewards - rewards.mean()) / (rewards.std() + 1e-8)\n", "\n", " advantages = torch.tensor(advantages, dtype=torch.float32, device=device)\n", " # advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)\n", "\n", "\n", " loss_ac = 0\n", " loss_cri = 0\n", " for _ in range(self.epochs):\n", " # calculate logprobs and state values based on the new policy\n", " #TODO\n", "\n", " logprobs, state_values, entropy = self.evaluate(old_states, old_actions)\n", "\n", " # Calculate the loss function and perform the optimization\n", " #TODO\n", " ratios = torch.exp(logprobs - old_logprobs.detach())\n", " Bound1 = ratios * advantages\n", " Bound2 = torch.clamp(ratios, 1-self.eps_clip, 1+self.eps_clip) * advantages\n", "\n", " loss_actor = -torch.min(Bound1, Bound2) - 0.01 * entropy.mean()\n", " loss_critic = F.mse_loss(state_values.squeeze(1), rewards)\n", "\n", " loss_actor = loss_actor.mean()\n", " loss_critic = loss_critic.mean()\n", "\n", "\n", " self.optimizer_actor.zero_grad()\n", " loss_actor.backward(retain_graph=True)\n", " loss_ac += loss_actor.item()\n", " self.optimizer_actor.step()\n", "\n", " self.optimizer_critic.zero_grad()\n", " loss_critic.backward()\n", " loss_cri += loss_critic.item()\n", " self.optimizer_critic.step()\n", "\n", " # clear the buffer\n", " self.memory.clear()\n", " return loss_ac, loss_cri\n", "\n", " def push_memory(self,state, action, log_prob, value ):\n", " self.memory.states.append(state)\n", " self.memory.actions.append(action)\n", " self.memory.logprobs.append(log_prob)\n", " self.memory.state_values.append(value)\n", "\n", " def load_memory(self):\n", " old_states = torch.stack(self.memory.states).detach()\n", " old_actions = torch.stack(self.memory.actions).detach()\n", " old_logprobs = torch.stack(self.memory.logprobs).detach()\n", " old_state_vals = torch.stack(self.memory.state_values).detach()\n", "\n", " return old_states, old_actions, old_logprobs, old_state_vals\n", "\n", " def store_reward(self, reward):\n", " self.memory.rewards.append(reward)\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "iq8ZxyStGQ4D" }, "source": [ "## **Configuration Settings for PPO Training**\n", "\n", "The `Config` class defines **hyperparameters and settings** for training the PPO agent in a reinforcement learning environment.\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "6KRaYeHb--KF" }, "outputs": [], "source": [ "class Config:\n", " # Environment settings\n", " SEED = 111\n", " MAX_EPISODES = 3000\n", "\n", " # PPO Hyperparameters\n", " K_EPOCHS = 8\n", " EPS_CLIP = 0.2\n", " GAMMA = 0.99\n", " LEARNING_RATE = 3e-4\n", " BETAS = (0.9, 0.99)\n", "\n", " hidden_size= 128\n", "\n", " GAE = 0.95\n", "\n", " DEVICE = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" ] }, { "cell_type": "markdown", "metadata": { "id": "iRL9eIBWGQ4D" }, "source": [ "# **Proximal Policy Optimization (PPO) Training on HalfCheetah-v4 Environment**\n", "\n", "This notebook implements and trains a **Proximal Policy Optimization (PPO)** agent on the **HalfCheetah-v4** environment. The PPO algorithm is an on-policy reinforcement learning method that uses a clipped objective function to update the policy in a stable way." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "-otjxE9T3TED", "outputId": "da27a337-6e36-49ed-f0ea-7422dbaf8bab" }, "outputs": [ { "metadata": { "tags": null }, "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.11/dist-packages/gymnasium/envs/registration.py:519: DeprecationWarning: \u001b[33mWARN: The environment HalfCheetah-v4 is out of date. You should consider upgrading to version `v5`.\u001b[0m\n", " logger.deprecation(\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Episode:0->\t Reward:-353.11921503287857->\t actor loss:43.283726,\t critic loss:8472.291382\n", "Episode:100->\t Reward:-4.710787471336914->\t actor loss:6.558173,\t critic loss:5752.510925\n", "Episode:200->\t Reward:304.76308368718827->\t actor loss:-7.377214,\t critic loss:1205.392349\n", "Episode:300->\t Reward:962.5161206611574->\t actor loss:-14.932134,\t critic loss:8393.146851\n", "Episode:400->\t Reward:66.39925636669393->\t actor loss:3.067793,\t critic loss:3518.440338\n", "Episode:500->\t Reward:1881.5245373585446->\t actor loss:-11.939550,\t critic loss:19842.923096\n", "Episode:600->\t Reward:776.9959141668091->\t actor loss:16.198198,\t critic loss:23994.593750\n", "Episode:700->\t Reward:3098.4890557138738->\t actor loss:-1.450796,\t critic loss:38740.734863\n", "Episode:800->\t Reward:476.68235608534974->\t actor loss:-0.930960,\t critic loss:14401.822754\n", "Episode:900->\t Reward:1996.6314720807995->\t actor loss:16.716158,\t critic loss:21502.105957\n", "Episode:1000->\t Reward:2379.404621944547->\t actor loss:-40.771492,\t critic loss:26813.869385\n", "Episode:1100->\t Reward:2408.2218448057965->\t actor loss:5.414135,\t critic loss:30000.750977\n", "Episode:1200->\t Reward:1999.8807696637869->\t actor loss:80.731308,\t critic loss:58402.709961\n", "Episode:1300->\t Reward:2625.7747615275352->\t actor loss:8.326985,\t critic loss:33155.980713\n", "Episode:1400->\t Reward:1137.9964720321395->\t actor loss:9.664145,\t critic loss:24853.888428\n", "Episode:1500->\t Reward:3404.81338130537->\t actor loss:18.529782,\t critic loss:46972.585938\n", "Episode:1600->\t Reward:3252.9031325123046->\t actor loss:7.481461,\t critic loss:40141.182129\n", "Episode:1700->\t Reward:3229.4382854604078->\t actor loss:-13.125657,\t critic loss:45424.046875\n", "Episode:1800->\t Reward:3738.5573603850407->\t actor loss:-12.542163,\t critic loss:46434.689453\n", "Episode:1900->\t Reward:3435.1954791743724->\t actor loss:-10.664035,\t critic loss:44263.474121\n", "Episode:2000->\t Reward:4197.978374547948->\t actor loss:-53.730054,\t critic loss:65338.890137\n", "Episode:2100->\t Reward:4062.162211802379->\t actor loss:-30.040385,\t critic loss:59078.435547\n", "Episode:2200->\t Reward:4071.617814255435->\t actor loss:-12.564217,\t critic loss:58802.799805\n", "Episode:2300->\t Reward:4169.880238459134->\t actor loss:-38.434661,\t critic loss:59973.611328\n", "Episode:2400->\t Reward:3748.8610121228407->\t actor loss:-6.361153,\t critic loss:58169.186523\n", "Episode:2500->\t Reward:3820.7613404963768->\t actor loss:-27.613124,\t critic loss:57990.867676\n", "Episode:2600->\t Reward:3829.6647247704086->\t actor loss:-7.257152,\t critic loss:55667.030273\n", "Episode:2700->\t Reward:3807.9394364700383->\t actor loss:-43.287239,\t critic loss:58142.958984\n", "Episode:2800->\t Reward:3458.1912594867945->\t actor loss:-13.832948,\t critic loss:43148.455078\n", "Episode:2900->\t Reward:3637.438474175977->\t actor loss:41.038517,\t critic loss:63986.925781\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ ":29: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", " init_means = np.cumsum(rewards[:init_len]) / (1 + np.arange(init_len))\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ] }, "metadata": {} } ], "source": [ "env = gym.make(\"HalfCheetah-v4\")\n", "config = Config()\n", "\n", "agent = PPO(env, config)\n", "\n", "# We need to train for many more steps to achieve acceptable results compared to the last environment\n", "\n", "actor_losses = []\n", "critic_losses = []\n", "rewards_history = []\n", "sum_of_rewards = []\n", "\n", "for episode in range(config.MAX_EPISODES):\n", " state, _ = env.reset()\n", " episode_reward = 0\n", " # write the training loop\n", " #TODO\n", " while True:\n", " action = agent.select_action(state)\n", " next_state, reward, done, terminate, _ = env.step(action)\n", " agent.store_reward(reward)\n", " episode_reward += reward\n", " state = next_state\n", "\n", " if done or terminate:\n", " break\n", "\n", " loss_ac, loss_cri = agent.update()\n", " actor_losses.append(loss_ac)\n", " critic_losses.append(loss_cri)\n", " rewards_history.append(episode_reward)\n", "\n", " if episode % 100 == 0:\n", " print(f'Episode:{episode}->\\t Reward:{rewards_history[-1]}->\\t actor loss:{loss_ac:.6f},\\t critic loss:{loss_cri:.6f}')\n", "\n", "env.close()\n", "\n", "\n", "plot_rewards(rewards_history, show_result='PPO agent in HalfCheetah env')\n" ] }, { "cell_type": "markdown", "metadata": { "id": "wjZfm8xUGQ4E" }, "source": [ "# **Evaluating the PPO Agent in the HalfCheetah-v4 Environment**" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 456 }, "id": "-Bxmb6Z3ooxa", "outputId": "c8cc7230-4385-47e8-f07c-4917186e2967" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "env: MUJOCO_GL=egl\n", "Total Reward: 4011.8243769947403\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ "" ], "text/html": [ "\n", " \n", " " ] }, "metadata": {}, "execution_count": 13 } ], "source": [ "# Create environment\n", "%env MUJOCO_GL=egl\n", "env = gym.make(\"HalfCheetah-v4\", render_mode=\"rgb_array\")\n", "frames = []\n", "\n", "state, info = env.reset()\n", "done = False\n", "total_reward = 0\n", "\n", "# run the learned PPO agent to evaluate it\n", "#TODO\n", "\n", "while not done:\n", " # Take deterministic actions at test time\n", " action = agent.select_action(state)\n", " next_state, reward, terminated, truncated, info = env.step(action)\n", " done = (terminated or truncated)\n", "\n", " # Store frame for video\n", " frames.append(env.render())\n", "\n", " state = next_state\n", " total_reward += reward\n", "\n", "\n", "env.close()\n", "print(f\"Total Reward: {total_reward}\")\n", "\n", "# Save frames as a video\n", "video_path = \"./PPO_evaluation.mp4\"\n", "imageio.mimsave(video_path, frames, fps=25)\n", "\n", "# Display the video\n", "show_video(video_path)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "n586eE68_N37" }, "outputs": [], "source": [] } ], "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.8" } }, "nbformat": 4, "nbformat_minor": 0 }