{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "QjFkqyzBFxuJ"
},
"outputs": [],
"source": [
"%%capture\n",
"!pip install mujoco==2.3.3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "cgl1dhmOFhny"
},
"outputs": [],
"source": [
"from torch.optim import Adam\n",
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"from torch.distributions import Normal\n",
"import random\n",
"import numpy as np\n",
"import logging\n",
"import matplotlib\n",
"import matplotlib.pyplot as plt\n",
"import imageio\n",
"from IPython.display import HTML\n",
"from base64 import b64encode\n",
"import gymnasium as gym\n",
"\n",
"\n",
"is_ipython = 'inline' in matplotlib.get_backend()\n",
"if is_ipython:\n",
" from IPython import display\n",
"\n",
"\n",
"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)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "8qtiUS5-BrE5"
},
"outputs": [],
"source": [
"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.ylabel(f'{bove}')\n",
" else:\n",
" plt.xlabel('Episode')\n",
" if dn is not None:\n",
" plt.ylabel(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",
"\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": "awyCG6L8qhN0"
},
"source": [
"## **Replay Memory for Experience Replay**\n",
"\n",
"This class implements a **Replay Buffer**, a crucial component in off-policy reinforcement learning algorithms like DDPG and SAC. The buffer stores past experiences and allows the agent to sample them randomly, breaking correlation between consecutive samples and improving learning stability."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "MutuNBENU9jS"
},
"outputs": [],
"source": [
"class ReplayMemory:\n",
" def __init__(self, capacity, seed):\n",
" random.seed(seed)\n",
" self.capacity = capacity\n",
" self.buffer = []\n",
" self.position = 0\n",
"\n",
" def push(self, state, action, reward, next_state, done):\n",
" if len(self.buffer) < self.capacity:\n",
" self.buffer.append(None)\n",
" self.buffer[self.position] = (state, action, reward, next_state, done)\n",
" self.position = (self.position + 1) % self.capacity\n",
"\n",
" def sample(self, batch_size):\n",
" batch = random.sample(self.buffer, batch_size)\n",
" state, action, reward, next_state, done = map(np.stack, zip(*batch))\n",
" return state, action, reward, next_state, done\n",
"\n",
" def __len__(self):\n",
" return len(self.buffer)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "F1PfnQZWqpgI"
},
"source": [
"## **Neural Networks for DDPG and SAC**\n",
"\n",
"This cell defines key neural networks used in **Deep Deterministic Policy Gradient (DDPG)** and **Soft Actor-Critic (SAC)** algorithms.\n",
"\n",
"\n",
"- **`GaussianPolicy`**: A stochastic policy for SAC, using Gaussian action sampling.\n",
"- **`DeterministicPolicy`**: A deterministic actor for DDPG, applying action bounds."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "UEUENTmKVZTo"
},
"outputs": [],
"source": [
"# Initialize Policy weights\n",
"def weights_init_(m):\n",
" if isinstance(m, nn.Linear):\n",
" torch.nn.init.xavier_uniform_(m.weight, gain=1)\n",
" torch.nn.init.constant_(m.bias, 0)\n",
"\n",
"\n",
"device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\n",
"\n",
"class ValueNetwork(nn.Module):\n",
" def __init__(self, num_inputs, hidden_dim):\n",
" super(ValueNetwork, self).__init__()\n",
"\n",
" self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
" self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
" self.linear3 = nn.Linear(hidden_dim, 1)\n",
"\n",
" self.apply(weights_init_)\n",
"\n",
" def forward(self, state):\n",
" x = F.relu(self.linear1(state))\n",
" x = F.relu(self.linear2(x))\n",
" x = self.linear3(x)\n",
" return x\n",
"\n",
"\n",
"class QNetwork(nn.Module):\n",
"\n",
" def __init__(self, num_inputs, num_actions, hidden_dim):\n",
" super(QNetwork, self).__init__()\n",
"\n",
" # TODO 1 -> Define two separate Q-networks (Q1 and Q2) for twin Q-learning.\n",
"\n",
" # Q1 architecture\n",
" self.linear1 = nn.Linear(num_inputs + num_actions, hidden_dim)\n",
" self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
" self.linear3 = nn.Linear(hidden_dim, 1)\n",
"\n",
" # Q2 architecture\n",
" self.linear4 = nn.Linear(num_inputs + num_actions, hidden_dim)\n",
" self.linear5 = nn.Linear(hidden_dim, hidden_dim)\n",
" self.linear6 = nn.Linear(hidden_dim, 1)\n",
"\n",
" self.apply(weights_init_)\n",
"\n",
" def forward(self, state, action):\n",
" # TODO 2 -> Concatenate state and action as input and compute Q-values for both Q-networks.\n",
"\n",
" xu = torch.cat([state, action], 1)\n",
"\n",
" Q1 = F.relu(self.linear1(xu))\n",
" Q1 = F.relu(self.linear2(Q1))\n",
" Q1 = self.linear3(Q1)\n",
"\n",
" Q2 = F.relu(self.linear4(xu))\n",
" Q2 = F.relu(self.linear5(Q2))\n",
" Q2 = self.linear6(Q2)\n",
" return Q1, Q2\n",
"\n",
"\n",
"LOG_SIG_MAX = 2\n",
"LOG_SIG_MIN = -20\n",
"epsilon = 1e-6\n",
"\n",
"class GaussianPolicy(nn.Module):\n",
" def __init__(self, num_inputs, num_actions, hidden_dim, action_space):\n",
" super(GaussianPolicy, self).__init__()\n",
"\n",
" self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
" self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
"\n",
" self.mean_linear = nn.Linear(hidden_dim, num_actions)\n",
" self.log_std_linear = nn.Linear(hidden_dim, num_actions)\n",
"\n",
" self.apply(weights_init_)\n",
"\n",
" # TODO 3 -> Compute action scaling and shifting factors based on the environment's action space.\n",
" self.action_scale = torch.FloatTensor(\n",
" (action_space.high - action_space.low) / 2.)\n",
" self.action_bias = torch.FloatTensor(\n",
" (action_space.high + action_space.low) / 2.)\n",
"\n",
" def forward(self, state):\n",
" x = F.relu(self.linear1(state))\n",
" x = F.relu(self.linear2(x))\n",
" mean = self.mean_linear(x)\n",
" log_std = self.log_std_linear(x)\n",
" log_std = torch.clamp(log_std, min=LOG_SIG_MIN, max=LOG_SIG_MAX)\n",
" return mean, log_std\n",
"\n",
" def sample(self, state):\n",
" # TODO 4 -> Use the reparameterization trick to sample from the Gaussian policy and apply action bounds.\n",
" mean, log_std = self.forward(state)\n",
" std = log_std.exp()\n",
" normal = Normal(mean, std)\n",
" x_t = normal.rsample() # for reparameterization trick (mean + std * N(0,1))\n",
"\n",
" y_t = torch.tanh(x_t)\n",
" action = y_t * self.action_scale.to(y_t.device) + self.action_bias.to(y_t.device)\n",
" log_prob = normal.log_prob(x_t)\n",
" # Enforcing Action Bound\n",
" log_prob -= torch.log(self.action_scale.to(y_t.device) * (1 - y_t.pow(2)) + epsilon)\n",
" log_prob = log_prob.sum(1, keepdim=True)\n",
" mean = torch.tanh(mean) * self.action_scale.to(y_t.device) + self.action_bias.to(y_t.device)\n",
" return action, log_prob, mean\n",
"\n",
"\n",
"\n",
"class DeterministicPolicy(nn.Module):\n",
" def __init__(self, num_inputs, num_actions, hidden_dim, action_space=None):\n",
" super(DeterministicPolicy, self).__init__()\n",
" self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
" self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
"\n",
" self.mean = nn.Linear(hidden_dim, num_actions)\n",
" self.noise = torch.Tensor(num_actions)\n",
"\n",
" self.apply(weights_init_)\n",
"\n",
"\n",
" # TODO 5 -> Compute action scaling and shifting factors for deterministic policy.\n",
"\n",
" # action rescaling\n",
" self.action_scale = torch.FloatTensor(\n",
" (action_space.high - action_space.low) / 2.)\n",
" self.action_bias = torch.FloatTensor(\n",
" (action_space.high + action_space.low) / 2.)\n",
"\n",
" def forward(self, state):\n",
" x = F.relu(self.linear1(state))\n",
" x = F.relu(self.linear2(x))\n",
" mean = torch.tanh(self.mean(x)) * self.action_scale + self.action_bias\n",
" return mean\n",
"\n",
" def sample(self, state):\n",
"\n",
" # TODO 6 -> Generate an action by adding noise to the deterministic policy for exploration.\n",
" mean = self.forward(state)\n",
" noise = self.noise.normal_(0., std=0.1)\n",
" noise = noise.clamp(-0.25, 0.25)\n",
" action = mean + noise\n",
" return action, torch.tensor(0.), mean\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YDBqjWgeq_ic"
},
"source": [
"## **Soft Actor-Critic (SAC) Implementation - Explanation of the Cell**\n",
"\n",
"This cell implements the **Soft Actor-Critic (SAC) algorithm**, a state-of-the-art off-policy reinforcement learning method for continuous control. The key idea behind SAC is to maximize both the **expected reward** and the **entropy** of the policy, promoting exploration and robustness.\n",
"\n",
"### **Main Components in This Cell**\n",
"1. **Hyperparameters & Configuration** \n",
" - The algorithm's key parameters such as **discount factor** ($\\gamma$), **soft update factor** ($\\tau$), and **entropy coefficient** ($\\alpha$) are set from the `config` dictionary.\n",
" - **Entropy tuning** is optionally enabled to adjust $\\alpha$ dynamically.\n",
"\n",
"2. **Critic (Q-Networks)**\n",
" - Two separate **Q-networks** (`self.critic` and `self.critic_target`) estimate the action-value function.\n",
" - Using **twin Q-learning** (two critics) reduces overestimation bias.\n",
"\n",
"3. **Actor (Policy Network)**\n",
" - **Gaussian policy** is used when `policy_type=\"Gaussian\"`, meaning actions are sampled from a probability distribution instead of being deterministic.\n",
" - The policy is trained to maximize both expected rewards and entropy.\n",
" - If the deterministic version (DDPG-like) is used, entropy is ignored ($\\alpha = 0$).\n",
"\n",
"4. **Action Selection (`select_action`)**\n",
" - If `evaluate=False`, actions are sampled from the stochastic policy.\n",
" - If `evaluate=True`, deterministic actions are chosen for testing.\n",
"\n",
"5. **Parameter Update (`update_parameters`)**\n",
" - **Sample a batch** from replay memory.\n",
" - Compute **target Q-values** using the **minimum of the two Q-networks**.\n",
" - Update **critic networks** by minimizing Bellman loss.\n",
" - Update **policy** using the entropy-regularized objective.\n",
" - If entropy tuning is enabled, update **$\\alpha$** using.\n",
" - Periodically **soft update** the target Q-network.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "V_DNPHq2Vwex"
},
"outputs": [],
"source": [
"class SAC(object):\n",
" def __init__(self, num_inputs, action_space, config):\n",
"\n",
" self.gamma = config['gamma']\n",
" self.tau = config['tau']\n",
" self.alpha = config['alpha']\n",
"\n",
" self.policy_type = config[\"policy\"]\n",
" self.target_update_interval = config[\"target_update_interval\"]\n",
" self.automatic_entropy_tuning = config['automatic_entropy_tuning']\n",
"\n",
" self.device = torch.device(\"cuda\" if config['cuda'] else \"cpu\")\n",
"\n",
" self.critic = QNetwork(num_inputs, action_space.shape[0], config['hidden_size']).to(device=self.device)\n",
" self.critic_optim = Adam(self.critic.parameters(), lr=config['lr'])\n",
"\n",
" self.critic_target = QNetwork(num_inputs, action_space.shape[0], config[\"hidden_size\"]).to(self.device)\n",
" self.hard_update(self.critic_target, self.critic)\n",
"\n",
" if self.policy_type == \"Gaussian\":\n",
" # Target Entropy = −dim(A) (e.g. , -6 for HalfCheetah-v2) as given in the paper\n",
"\n",
" # TODO 7: Compute the target entropy for the Gaussian policy and initialize log_alpha for automatic entropy tuning.\n",
" if self.automatic_entropy_tuning is True:\n",
" self.target_entropy = -torch.prod(torch.Tensor(action_space.shape).to(self.device)).item()\n",
" self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
" self.alpha_optim = Adam([self.log_alpha], lr=config['lr'])\n",
"\n",
" # TODO 7: The target entropy is typically set to -|A| (where A is the action space dimension), and log_alpha is initialized for optimization.\n",
"\n",
"\n",
" self.policy = GaussianPolicy(num_inputs, action_space.shape[0], config[\"hidden_size\"], action_space).to(self.device)\n",
" self.policy_optim = Adam(self.policy.parameters(), lr=config[\"lr\"])\n",
"\n",
" else:\n",
" self.alpha = 0\n",
" self.automatic_entropy_tuning = False\n",
" self.policy = DeterministicPolicy(num_inputs, action_space.shape[0], config[\"hidden_size\"], action_space).to(self.device)\n",
" self.policy_optim = Adam(self.policy.parameters(), lr=config['lr'])\n",
"\n",
" def select_action(self, state, evaluate=False):\n",
" state = torch.FloatTensor(state).to(self.device).unsqueeze(0)\n",
" if evaluate is False:\n",
" # TODO 8: Decide whether to sample from the policy or use the deterministic policy based on the evaluate flag.\n",
" action, _, _ = self.policy.sample(state)\n",
" else:\n",
" # TODO 8: When evaluating, we typically use the deterministic policy, while during training, we use the exploration-based policy (stochastic).\n",
" _, _, action = self.policy.sample(state)\n",
" return action.detach().cpu().numpy()[0]\n",
"\n",
" def update_parameters(self, memory, batch_size, updates):\n",
" # Sample a batch from memory\n",
" state_batch, action_batch, reward_batch, next_state_batch, mask_batch = memory.sample(batch_size=batch_size)\n",
"\n",
" state_batch = torch.FloatTensor(state_batch).to(self.device)\n",
" next_state_batch = torch.FloatTensor(next_state_batch).to(self.device)\n",
" action_batch = torch.FloatTensor(action_batch).to(self.device)\n",
" reward_batch = torch.FloatTensor(reward_batch).to(self.device).unsqueeze(1)\n",
" mask_batch = torch.FloatTensor(mask_batch).to(self.device).unsqueeze(1)\n",
"\n",
" with torch.no_grad():\n",
" next_state_action, next_state_log_pi, _ = self.policy.sample(next_state_batch)\n",
" qf1_next_target, qf2_next_target = self.critic_target(next_state_batch, next_state_action)\n",
" min_qf_next_target = torch.min(qf1_next_target, qf2_next_target) - self.alpha * next_state_log_pi\n",
" next_q_value = reward_batch + mask_batch * self.gamma * (min_qf_next_target)\n",
"\n",
"\n",
" # TODO 9: Compute the Q-value loss using the Bellman backup and target Q-values.\n",
"\n",
" qf1, qf2 = self.critic(state_batch, action_batch) # Two Q-functions to mitigate positive bias in the policy improvement step\n",
" qf1_loss = F.mse_loss(qf1, next_q_value) # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]\n",
" qf2_loss = F.mse_loss(qf2, next_q_value) # JQ = 𝔼(st,at)~D[0.5(Q2(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]\n",
" qf_loss = qf1_loss + qf2_loss\n",
"\n",
" # TODO 9: The loss is typically the mean squared error between the Q-value predicted by the critic and the target Q-value.\n",
"\n",
"\n",
" self.critic_optim.zero_grad()\n",
" qf_loss.backward()\n",
" self.critic_optim.step()\n",
"\n",
" pi, log_pi, _ = self.policy.sample(state_batch)\n",
"\n",
" # TODO 10: Compute the policy loss by taking the minimum of the two Q-values and using the entropy bonus term.\n",
"\n",
" qf1_pi, qf2_pi = self.critic(state_batch, pi)\n",
" min_qf_pi = torch.min(qf1_pi, qf2_pi)\n",
"\n",
" policy_loss = ((self.alpha * log_pi) - min_qf_pi).mean() # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))]\n",
"\n",
" self.policy_optim.zero_grad()\n",
" policy_loss.backward()\n",
" self.policy_optim.step()\n",
"\n",
"\n",
"\n",
" if self.automatic_entropy_tuning:\n",
" # TODO 12: Compute the loss for tuning the entropy coefficient α.\n",
"\n",
" alpha_loss = -(self.log_alpha * (log_pi + self.target_entropy).detach()).mean()\n",
"\n",
" self.alpha_optim.zero_grad()\n",
" alpha_loss.backward()\n",
" self.alpha_optim.step()\n",
"\n",
" self.alpha = self.log_alpha.exp()\n",
" alpha_tlogs = self.alpha.clone()\n",
"\n",
" # TODO 12: The alpha loss encourages the entropy to be close to the target entropy, optimizing the entropy coefficient automatically.\n",
"\n",
" else:\n",
" alpha_loss = torch.tensor(0.).to(self.device)\n",
" alpha_tlogs = torch.tensor(self.alpha)\n",
"\n",
"\n",
" if updates % self.target_update_interval == 0:\n",
" self.soft_update(self.critic_target, self.critic, self.tau)\n",
"\n",
" return qf1_loss.item(), qf2_loss.item(), policy_loss.item(), alpha_loss.item(), alpha_tlogs.item()\n",
"\n",
"\n",
" # Hard and Soft updates\n",
"\n",
" # TODO 13: Implement soft update for target networks using Polyak averaging.\n",
"\n",
" def soft_update(self,target, source, tau):\n",
" for target_param, param in zip(target.parameters(), source.parameters()):\n",
" target_param.data.copy_(target_param.data * (1.0 - tau) + param.data * tau)\n",
"\n",
" # TODO 13: Soft update blends the target network with the source network using a factor tau, updating target gradually.\n",
"\n",
"\n",
" def hard_update(self,target, source):\n",
" for target_param, param in zip(target.parameters(), source.parameters()):\n",
" target_param.data.copy_(param.data)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B3BJrAAkrDUX"
},
"source": [
"## **Environment Setup and Initialization for SAC**\n",
"\n",
"This cell sets up the environment and initializes the components needed to train the **Soft Actor-Critic (SAC)** agent.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "QdbiGFaAX_HF",
"outputId": "95236e95-15cb-4d2a-fcd3-215ae1de577e"
},
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"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"
]
}
],
"source": [
"# Configuration dictionary\n",
"config = {\n",
" \"env_name\": \"HalfCheetah-v4\",\n",
" \"policy\": \"Gaussian\",\n",
" \"gamma\": 0.99,\n",
" \"tau\": 0.005,\n",
" \"lr\": 0.0003,\n",
" \"alpha\": 0.2,\n",
" \"seed\":123456,\n",
" \"automatic_entropy_tuning\": True,\n",
" \"batch_size\": 256,\n",
" \"num_steps\": 1000001,\n",
" \"hidden_size\": 256,\n",
" \"updates_per_step\": 1,\n",
" \"start_steps\": 10000,\n",
" \"target_update_interval\": 1,\n",
" \"replay_size\": 1000000,\n",
" \"cuda\": False,\n",
" \"eval_interval\": 1,\n",
"}\n",
"\n",
"# Setup environment\n",
"env = gym.make(config[\"env_name\"])\n",
"env.action_space.seed(config[\"seed\"])\n",
"\n",
"# Set random seeds\n",
"torch.manual_seed(config[\"seed\"])\n",
"np.random.seed(config[\"seed\"])\n",
"\n",
"# Initialize agent\n",
"agent = SAC(env.observation_space.shape[0], env.action_space, config)\n",
"\n",
"# Initialize replay memory\n",
"memory = ReplayMemory(config[\"replay_size\"], config[\"seed\"])\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qSXlzKnlrG5X"
},
"source": [
"## **Training Loop for SAC Agent**\n",
"\n",
"This cell contains the **training loop** for the Soft Actor-Critic (SAC) agent. The loop runs for a set number of episodes, where in each episode, the agent interacts with the environment, collects experiences, and updates its parameters."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"id": "Y10BjpyhRX6C",
"outputId": "98467cce-be00-4d8f-cb20-4d14e4ec0658"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Episode: 0, reward: -2.8\n",
"Episode: 10, reward: -244.64\n",
"Episode: 20, reward: 412.95\n",
"Episode: 30, reward: 2484.63\n",
"Episode: 40, reward: 640.33\n",
"Episode: 50, reward: 3311.83\n",
"Episode: 60, reward: 3361.75\n",
"Episode: 70, reward: 3865.17\n",
"Episode: 80, reward: 4781.73\n",
"Episode: 90, reward: 4827.5\n",
"Episode: 100, reward: 5407.28\n",
"Episode: 110, reward: 5438.73\n",
"Episode: 120, reward: 5728.08\n",
"Episode: 130, reward: 5813.89\n",
"Episode: 140, reward: 6467.77\n",
"Episode: 150, reward: 6621.14\n",
"Episode: 160, reward: 6922.29\n",
"Episode: 170, reward: 6789.09\n",
"Episode: 180, reward: 6683.9\n",
"Episode: 190, reward: 7205.18\n",
"Episode: 200, reward: 7304.92\n",
"Episode: 210, reward: 7548.83\n",
"Episode: 220, reward: 7603.66\n",
"Episode: 230, reward: 7959.79\n",
"Episode: 240, reward: 7951.3\n",
"Episode: 250, reward: 8350.87\n",
"Episode: 260, reward: 8489.5\n",
"Episode: 270, reward: 8736.74\n",
"Episode: 280, reward: 8982.55\n",
"Episode: 290, reward: 8853.27\n",
"Episode: 300, reward: 8831.01\n",
"Episode: 310, reward: 9325.09\n",
"Episode: 320, reward: 8919.14\n",
"Episode: 330, reward: 9437.97\n",
"Episode: 340, reward: 9443.11\n",
"Episode: 350, reward: 9362.37\n",
"Episode: 360, reward: 9179.19\n",
"Episode: 370, reward: 9228.32\n",
"Episode: 380, reward: 9509.56\n",
"Episode: 390, reward: 9551.06\n",
"Episode: 400, reward: 9782.56\n",
"Episode: 410, reward: 9721.58\n",
"Episode: 420, reward: 9498.18\n",
"Episode: 430, reward: 9729.5\n",
"Episode: 440, reward: 9772.37\n",
"Episode: 450, reward: 9898.26\n",
"Episode: 460, reward: 9872.57\n",
"Episode: 470, reward: 10146.1\n",
"Episode: 480, reward: 9951.09\n",
"Episode: 490, reward: 9844.75\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
":21: 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": [
"# Training Loop\n",
"total_numsteps = 0\n",
"updates = 0\n",
"reward_history = []\n",
"Max_episodes = 500\n",
"criteria = 0\n",
"max_reward = -1000\n",
"for i_episode in range(Max_episodes):\n",
" episode_steps = 0\n",
" done = False\n",
" state, _ = env.reset()\n",
"\n",
" while not done:\n",
" if config['start_steps'] > total_numsteps:\n",
" action = env.action_space.sample() # Sample random action\n",
" else:\n",
" action = agent.select_action(state) # Sample action from policy\n",
"\n",
" if len(memory) > config['batch_size']:\n",
" critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha = agent.update_parameters(memory, config['batch_size'], updates)\n",
" updates += 1\n",
"\n",
" next_state, reward, done, truncated, _ = env.step(action) # Step\n",
" episode_steps += 1\n",
" total_numsteps +=1\n",
" done = done or truncated\n",
"\n",
" # Ignore the \"done\" signal if it comes from hitting the time horizon.\n",
"\n",
" mask = 1 if episode_steps == env._max_episode_steps else float(not done)\n",
"\n",
" memory.push(state, action, reward, next_state, mask) # Append transition to memory\n",
"\n",
" state = next_state\n",
"\n",
" # TODO 14: Evaluate the policy at regular intervals and log the average reward.\n",
" if i_episode % config['eval_interval'] == 0:\n",
" eval_episodes = 1\n",
" avg_reward= 0\n",
" for _ in range(eval_episodes):\n",
" state,_ = env.reset()\n",
" episode_reward = 0\n",
" done = False\n",
" while not done:\n",
" action = agent.select_action(state, evaluate=True)\n",
" next_state, reward, done, truncated, _ = env.step(action)\n",
" episode_reward += reward\n",
" state = next_state\n",
" done = done or truncated\n",
"\n",
" avg_reward += episode_reward\n",
" avg_reward /= eval_episodes\n",
" reward_history.append(avg_reward)\n",
" #ToDo\n",
" if i_episode % 10 == 0:\n",
" print(\"Episode: {}, reward: {}\".format(i_episode, round(avg_reward, 2)))\n",
"\n",
" if avg_reward < max_reward:\n",
" criteria +=1\n",
" if criteria == 50:\n",
" break\n",
" else:\n",
" criteria = 0\n",
"\n",
" max_reward = max(reward_history)\n",
"\n",
"env.close()\n",
"\n",
"\n",
"plot_rewards(reward_history, show_result='SAC algorithm in HalfCheetah Env')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "64hZeCpwigKx",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 511
},
"outputId": "dae41bba-a0b8-4d86-d795-499fbf3c0587"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"env: MUJOCO_GL=egl\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"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": [
"Total Reward: 9974.970109678905\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
],
"text/html": [
"\n",
" \n",
" "
]
},
"metadata": {},
"execution_count": 9
}
],
"source": [
"%env MUJOCO_GL=egl\n",
"\n",
"env = gym.make(\"HalfCheetah-v4\", render_mode=\"rgb_array\")\n",
"state, _ = env.reset()\n",
"frames = []\n",
"\n",
"done = False\n",
"total_reward = 0\n",
"\n",
"# run the policy in the environment in a loop\n",
"while not done:\n",
" frames.append(env.render())\n",
" action = agent.select_action(state, evaluate=True)\n",
" next_state, reward, done, truncated, _ = env.step(action)\n",
" total_reward += reward\n",
" state = next_state\n",
" done = done or truncated\n",
"\n",
"env.close()\n",
"print(f'Total Reward: {total_reward}')\n",
"\n",
"imageio.mimsave('./eval_SAC.mp4', frames, fps=25)\n",
"show_video('./eval_SAC.mp4')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0DtLwfE7rrvi"
},
"source": [
"# Initialize DDPG"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "NFjPRvvttgDf"
},
"outputs": [],
"source": [
"# Configuration dictionary\n",
"config = {\n",
" \"env_name\": \"HalfCheetah-v4\",\n",
" \"policy\": \"DDPG\",\n",
" \"gamma\": 0.99,\n",
" \"tau\": 0.005,\n",
" \"lr\": 0.0003,\n",
" \"alpha\": 0.2,\n",
" \"seed\":123456,\n",
" \"automatic_entropy_tuning\": False,\n",
" \"batch_size\": 256,\n",
" \"num_steps\": 1000001,\n",
" \"hidden_size\": 256,\n",
" \"updates_per_step\": 1,\n",
" \"start_steps\": 10000,\n",
" \"target_update_interval\": 1,\n",
" \"replay_size\": 1000000,\n",
" \"cuda\": False,\n",
" \"eval_interval\": 1,\n",
"}\n",
"\n",
"# Setup environment\n",
"env = gym.make(config[\"env_name\"])\n",
"env.action_space.seed(config[\"seed\"])\n",
"\n",
"# Set random seeds\n",
"torch.manual_seed(config[\"seed\"])\n",
"np.random.seed(config[\"seed\"])\n",
"\n",
"# Initialize agent\n",
"agent = SAC(env.observation_space.shape[0], env.action_space, config)\n",
"\n",
"# Initialize replay memory\n",
"memory = ReplayMemory(config[\"replay_size\"], config[\"seed\"])\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "doHf6n49rxSx"
},
"source": [
"# Train DDPG here"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "GGE0pNJvtf7M",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"outputId": "c5d7e8bd-092e-43b6-f333-3e9e6cc7d7ad"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Episode: 0, reward: -519.0\n",
"Episode: 10, reward: -482.07\n",
"Episode: 20, reward: -16.22\n",
"Episode: 30, reward: 682.04\n",
"Episode: 40, reward: 424.27\n",
"Episode: 50, reward: 2864.43\n",
"Episode: 60, reward: 2658.1\n",
"Episode: 70, reward: 3546.19\n",
"Episode: 80, reward: 3951.2\n",
"Episode: 90, reward: 3909.01\n",
"Episode: 100, reward: 4348.87\n",
"Episode: 110, reward: 4551.24\n",
"Episode: 120, reward: 4836.21\n",
"Episode: 130, reward: 5140.08\n",
"Episode: 140, reward: 4735.28\n",
"Episode: 150, reward: 5446.12\n",
"Episode: 160, reward: 5344.45\n",
"Episode: 170, reward: 5960.17\n",
"Episode: 180, reward: 5944.52\n",
"Episode: 190, reward: 6051.0\n",
"Episode: 200, reward: 6047.67\n",
"Episode: 210, reward: 5390.63\n",
"Episode: 220, reward: 6550.61\n",
"Episode: 230, reward: 6252.72\n",
"Episode: 240, reward: 6611.05\n",
"Episode: 250, reward: 6741.35\n",
"Episode: 260, reward: 6595.6\n",
"Episode: 270, reward: 6599.2\n",
"Episode: 280, reward: 6735.41\n",
"Episode: 290, reward: 6674.79\n",
"Episode: 300, reward: 7063.28\n",
"Episode: 310, reward: 6654.65\n",
"Episode: 320, reward: 6896.17\n",
"Episode: 330, reward: 7152.4\n",
"Episode: 340, reward: 7067.73\n",
"Episode: 350, reward: 7170.19\n",
"Episode: 360, reward: 7229.45\n",
"Episode: 370, reward: 7372.74\n",
"Episode: 380, reward: 7201.47\n",
"Episode: 390, reward: 7546.57\n",
"Episode: 400, reward: 7438.39\n",
"Episode: 410, reward: 7223.79\n",
"Episode: 420, reward: 7491.74\n",
"Episode: 430, reward: 7608.13\n",
"Episode: 440, reward: 7539.62\n",
"Episode: 450, reward: 7600.49\n",
"Episode: 460, reward: 7754.38\n",
"Episode: 470, reward: 7614.39\n",
"Episode: 480, reward: 7665.24\n",
"Episode: 490, reward: 7782.37\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
":21: 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": [
"# Training Loop\n",
"total_numsteps = 0\n",
"updates = 0\n",
"reward_history = []\n",
"Max_episodes = 500\n",
"criteria = 0\n",
"max_reward = -1000\n",
"for i_episode in range(Max_episodes):\n",
" episode_steps = 0\n",
" done = False\n",
" state, _ = env.reset()\n",
"\n",
" while not done:\n",
" if config['start_steps'] > total_numsteps:\n",
" action = env.action_space.sample() # Sample random action\n",
" else:\n",
" action = agent.select_action(state) # Sample action from policy\n",
"\n",
" if len(memory) > config['batch_size']:\n",
" critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha = agent.update_parameters(memory, config['batch_size'], updates)\n",
" updates += 1\n",
"\n",
" next_state, reward, done, truncated, _ = env.step(action) # Step\n",
" episode_steps += 1\n",
" total_numsteps +=1\n",
" done = done or truncated\n",
"\n",
" # Ignore the \"done\" signal if it comes from hitting the time horizon.\n",
"\n",
" mask = 1 if episode_steps == env._max_episode_steps else float(not done)\n",
"\n",
" memory.push(state, action, reward, next_state, mask) # Append transition to memory\n",
"\n",
" state = next_state\n",
"\n",
" # TODO 15: Evaluate the policy at regular intervals and log the average reward.\n",
" if i_episode % config['eval_interval'] == 0:\n",
" eval_episodes = 1\n",
" avg_reward= 0\n",
" for _ in range(eval_episodes):\n",
" state,_ = env.reset()\n",
" episode_reward = 0\n",
" done = False\n",
" while not done:\n",
" action = agent.select_action(state, evaluate=True)\n",
" next_state, reward, done, truncated, _ = env.step(action)\n",
" episode_reward += reward\n",
" state = next_state\n",
" done = done or truncated\n",
"\n",
" avg_reward += episode_reward\n",
" avg_reward /= eval_episodes\n",
" reward_history.append(avg_reward)\n",
" #ToDo\n",
" if i_episode % 10 == 0:\n",
" print(\"Episode: {}, reward: {}\".format(i_episode, round(avg_reward, 2)))\n",
"\n",
" if avg_reward < max_reward:\n",
" criteria +=1\n",
" if criteria == 50:\n",
" break\n",
" else:\n",
" criteria = 0\n",
"\n",
" max_reward = max(reward_history)\n",
"\n",
"env.close()\n",
"\n",
"\n",
"plot_rewards(reward_history, show_result='DDPG algorithm in HalfCheetah Env')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "uxaVYo21reYx",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 511
},
"outputId": "311ca027-815c-4c4f-9061-18918bbd23c8"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"env: MUJOCO_GL=egl\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"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": [
"Total Reward: 7683.819250105212\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
""
],
"text/html": [
"\n",
" \n",
" "
]
},
"metadata": {},
"execution_count": 12
}
],
"source": [
"%env MUJOCO_GL=egl\n",
"\n",
"env = gym.make(\"HalfCheetah-v4\", render_mode=\"rgb_array\")\n",
"state, _ = env.reset()\n",
"frames = []\n",
"\n",
"done = False\n",
"total_reward = 0\n",
"\n",
"# run the policy in the environment in a loop\n",
"while not done:\n",
" frames.append(env.render())\n",
" action = agent.select_action(state, evaluate=True)\n",
" next_state, reward, done, truncated, _ = env.step(action)\n",
" total_reward += reward\n",
"\n",
" state = next_state\n",
" done = done or truncated\n",
"\n",
"env.close()\n",
"print(f'Total Reward: {total_reward}')\n",
"\n",
"imageio.mimsave('./eval_DDPG.mp4', frames, fps=25)\n",
"show_video('./eval_DDPG.mp4')"
]
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "Lok-D2ED3cje"
},
"execution_count": null,
"outputs": []
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}