{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"gpuType":"T4","authorship_tag":"ABX9TyNkfccbNHhNy78YPugx3bFf"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"code","source":["import os\n","import gc\n","import glob\n","import torch\n","import base64\n","import pygame\n","import argparse\n","import numpy as np\n","import torch.nn as nn\n","import gymnasium as gym\n","import torch.optim as optim\n","import matplotlib.pyplot as plt\n","import torch.nn.functional as F\n","\n","\n","from pathlib import Path\n","from datetime import datetime\n","from collections import deque\n","from IPython.display import HTML\n","from collections import namedtuple\n","from IPython.display import clear_output\n","from torch.distributions import Categorical\n","from torch.utils.tensorboard import SummaryWriter\n","from gym.wrappers.record_video import RecordVideo"],"metadata":{"id":"hQ90ciAqdQxk","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1743707343447,"user_tz":-210,"elapsed":6367,"user":{"displayName":"Nima Shirzady","userId":"04764659690504916110"}},"outputId":"6f23ad5c-f2d5-456d-d3e2-9093a07a7f15"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["pygame 2.6.1 (SDL 2.28.4, Python 3.11.11)\n","Hello from the pygame community. https://www.pygame.org/contribute.html\n"]}]},{"cell_type":"code","source":["def show_video(video_path):\n"," \"\"\"Display a recorded video in Colab.\"\"\"\n"," video_file = glob.glob(video_path + \"/*.mp4\")[0] # Get the first recorded video\n"," video_url = f\"data:video/mp4;base64,{base64.b64encode(open(video_file, 'rb').read()).decode()}\"\n"," return HTML(f'')\n"],"metadata":{"id":"8cdjpJiKab9f"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n","gc.collect()\n","torch.cuda.empty_cache()\n","os.environ['CUDA_LAUNCH_BLOCKING'] = '1' # Used for debugging; CUDA related errors shown immediately.\n","# Seed everything for reproducible results\n","seed = 2024\n","np.random.seed(seed)\n","np.random.default_rng(seed)\n","os.environ['PYTHONHASHSEED'] = str(seed)\n","torch.manual_seed(seed)\n","if torch.cuda.is_available():\n"," torch.cuda.manual_seed(seed)\n"," torch.backends.cudnn.deterministic = True\n"," torch.backends.cudnn.benchmark = False\n"],"metadata":{"id":"RzOmjR7MGLWz"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["class ReplayMemory:\n"," def __init__(self, capacity):\n"," \"\"\"\n"," Experience Replay Memory defined by deques to store transitions/agent experiences\n","\n"," \"\"\"\n","\n"," self.capacity = capacity\n","\n"," self.states = deque(maxlen=capacity)\n"," self.actions = deque(maxlen=capacity)\n"," self.next_states = deque(maxlen=capacity)\n"," self.rewards = deque(maxlen=capacity)\n"," self.dones = deque(maxlen=capacity)\n","\n","\n"," def store(self, state, action, next_state, reward, done):\n"," \"\"\"\n"," Append (store) the transitions to their respective deques\n"," \"\"\"\n","\n"," self.states.append(state)\n"," self.actions.append(action)\n"," self.next_states.append(next_state)\n"," self.rewards.append(reward)\n"," self.dones.append(done)\n","\n","\n"," def sample(self, batch_size):\n"," \"\"\"\n"," Randomly sample transitions from memory, then convert sampled transitions\n"," to tensors and move to device (CPU or GPU).\n"," \"\"\"\n","\n"," indices = np.random.choice(len(self), size=batch_size, replace=False)\n","\n"," states = torch.stack([torch.as_tensor(self.states[i], dtype=torch.float32, device=device) for i in indices]).to(device)\n"," actions = torch.as_tensor([self.actions[i] for i in indices], dtype=torch.long, device=device)\n"," next_states = torch.stack([torch.as_tensor(self.next_states[i], dtype=torch.float32, device=device) for i in indices]).to(device)\n"," rewards = torch.as_tensor([self.rewards[i] for i in indices], dtype=torch.float32, device=device)\n"," dones = torch.as_tensor([self.dones[i] for i in indices], dtype=torch.bool, device=device)\n","\n"," return states, actions, next_states, rewards, dones\n","\n","\n"," def __len__(self):\n"," \"\"\"\n"," To check how many samples are stored in the memory. self.dones deque\n"," represents the length of the entire memory.\n"," \"\"\"\n","\n"," return len(self.dones)\n"],"metadata":{"id":"C0692mQcGU77"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["class DQN_Network(nn.Module):\n"," \"\"\"\n"," The Deep Q-Network (DQN) model for reinforcement learning.\n"," This network consists of Fully Connected (FC) layers with ReLU activation functions.\n"," \"\"\"\n","\n"," def __init__(self, num_actions, input_dim):\n"," \"\"\"\n"," Initialize the DQN network.\n","\n"," Parameters:\n"," num_actions (int): The number of possible actions in the environment.\n"," input_dim (int): The dimensionality of the input state space.\n"," \"\"\"\n","\n"," super(DQN_Network, self).__init__()\n","\n"," self.FC = nn.Sequential(\n"," nn.Linear(input_dim, 12),\n"," nn.ReLU(inplace=True),\n"," nn.Linear(12, 8),\n"," nn.ReLU(inplace=True),\n"," nn.Linear(8, num_actions)\n"," )\n","\n"," # Initialize FC layer weights using He initialization\n"," for layer in [self.FC]:\n"," for module in layer:\n"," if isinstance(module, nn.Linear):\n"," nn.init.kaiming_uniform_(module.weight, nonlinearity='relu')\n","\n","\n"," def forward(self, x):\n"," \"\"\"\n"," Forward pass of the network to find the Q-values of the actions.\n","\n"," Parameters:\n"," x (torch.Tensor): Input tensor representing the state.\n","\n"," Returns:\n"," Q (torch.Tensor): Tensor containing Q-values for each action.\n"," \"\"\"\n","\n"," Q = self.FC(x)\n"," return Q\n"],"metadata":{"id":"FCYb-z21Gdy7"},"execution_count":null,"outputs":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ITicWIe9T_eK"},"outputs":[],"source":["class DQN_Agent:\n"," \"\"\"\n"," DQN Agent Class. This class defines some key elements of the DQN algorithm,\n"," such as the learning method, hard update, and action selection based on the\n"," Q-value of actions or the epsilon-greedy policy.\n"," \"\"\"\n","\n"," def __init__(self, env, epsilon_max, epsilon_min, epsilon_decay,\n"," clip_grad_norm, learning_rate, discount, memory_capacity):\n","\n"," # To save the history of network loss\n"," self.loss_history = []\n"," self.running_loss = 0\n"," self.learned_counts = 0\n","\n"," # RL hyperparameters\n"," self.epsilon_max = epsilon_max\n"," self.epsilon_min = epsilon_min\n"," self.epsilon_decay = epsilon_decay\n"," self.discount = discount\n","\n"," self.action_space = env.action_space\n"," self.action_space.seed(seed) # Set the seed to get reproducible results when sampling the action space\n"," self.observation_space = env.observation_space\n"," self.replay_memory = ReplayMemory(memory_capacity)\n","\n"," # Initiate the network models\n"," self.main_network = DQN_Network(num_actions=self.action_space.n, input_dim=self.observation_space.n).to(device)\n"," self.target_network = DQN_Network(num_actions=self.action_space.n, input_dim=self.observation_space.n).to(device).eval()\n"," self.target_network.load_state_dict(self.main_network.state_dict())\n","\n"," self.clip_grad_norm = clip_grad_norm # For clipping exploding gradients caused by high reward value\n"," self.critertion = nn.MSELoss()\n"," self.optimizer = optim.Adam(self.main_network.parameters(), lr=learning_rate)\n","\n","\n"," def select_action(self, state):\n"," \"\"\"\n"," Selects an action using epsilon-greedy strategy OR based on the Q-values.\n","\n"," Parameters:\n"," state (torch.Tensor): Input tensor representing the state.\n","\n"," Returns:\n"," action (int): The selected action.\n"," \"\"\"\n","\n"," # Exploration: epsilon-greedy\n"," if np.random.random() < self.epsilon_max:\n"," return self.action_space.sample()\n","\n"," # Exploitation: the action is selected based on the Q-values.\n"," with torch.no_grad():\n"," Q_values = self.main_network(state)\n"," action = torch.argmax(Q_values).item()\n","\n"," return action\n","\n","\n"," def learn(self, batch_size, done):\n"," \"\"\"\n"," Train the main network using a batch of experiences sampled from the replay memory.\n","\n"," Parameters:\n"," batch_size (int): The number of experiences to sample from the replay memory.\n"," done (bool): Indicates whether the episode is done or not. If done,\n"," calculate the loss of the episode and append it in a list for plot.\n"," \"\"\"\n","\n"," # Sample a batch of experiences from the replay memory\n"," states, actions, next_states, rewards, dones = self.replay_memory.sample(batch_size)\n","\n","\n"," actions = actions.unsqueeze(1)\n"," rewards = rewards.unsqueeze(1)\n"," dones = dones.unsqueeze(1)\n","\n","\n"," predicted_q = self.main_network(states) # forward pass through the main network to find the Q-values of the states\n"," predicted_q = predicted_q.gather(dim=1, index=actions) # selecting the Q-values of the actions that were actually taken\n","\n"," # Compute the maximum Q-value for the next states using the target network\n"," with torch.no_grad():\n"," next_target_q_value = self.target_network(next_states).max(dim=1, keepdim=True)[0] # not argmax (cause we want the maxmimum q-value, not the action that maximize it)\n","\n","\n"," next_target_q_value[dones] = 0 # Set the Q-value for terminal states to zero\n"," y_js = rewards + (self.discount * next_target_q_value) # Compute the target Q-values\n"," loss = self.critertion(predicted_q, y_js) # Compute the loss\n","\n"," # Update the running loss and learned counts for logging and plotting\n"," self.running_loss += loss.item()\n"," self.learned_counts += 1\n","\n"," if done:\n"," episode_loss = self.running_loss / self.learned_counts # The average loss for the episode\n"," self.loss_history.append(episode_loss) # Append the episode loss to the loss history for plotting\n"," # Reset the running loss and learned counts\n"," self.running_loss = 0\n"," self.learned_counts = 0\n","\n"," self.optimizer.zero_grad() # Zero the gradients\n"," loss.backward() # Perform backward pass and update the gradients\n","\n"," # Clip the gradients to prevent exploding gradients\n"," torch.nn.utils.clip_grad_norm_(self.main_network.parameters(), self.clip_grad_norm)\n","\n"," self.optimizer.step() # Update the parameters of the main network using the optimizer\n","\n","\n"," def hard_update(self):\n"," \"\"\"\n"," Navie update: Update the target network parameters by directly copying\n"," the parameters from the main network.\n"," \"\"\"\n","\n"," self.target_network.load_state_dict(self.main_network.state_dict())\n","\n","\n"," def update_epsilon(self):\n"," \"\"\"\n"," Update the value of epsilon for epsilon-greedy exploration.\n","\n"," This method decreases epsilon over time according to a decay factor, ensuring\n"," that the agent becomes less exploratory and more exploitative as training progresses.\n"," \"\"\"\n","\n"," self.epsilon_max = max(self.epsilon_min, self.epsilon_max * self.epsilon_decay)\n","\n","\n"," def save(self, path):\n"," \"\"\"\n"," Save the parameters of the main network to a file with .pth extention.\n","\n"," \"\"\"\n"," torch.save(self.main_network.state_dict(), path)\n","\n","\n","\n"]},{"cell_type":"code","source":["class Model_TrainTest:\n"," def __init__(self, hyperparams):\n","\n"," # Define RL Hyperparameters\n"," self.train_mode = hyperparams[\"train_mode\"]\n"," self.RL_load_path = hyperparams[\"RL_load_path\"]\n"," self.save_path = hyperparams[\"save_path\"]\n"," self.save_interval = hyperparams[\"save_interval\"]\n","\n"," self.clip_grad_norm = hyperparams[\"clip_grad_norm\"]\n"," self.learning_rate = hyperparams[\"learning_rate\"]\n"," self.discount_factor = hyperparams[\"discount_factor\"]\n"," self.batch_size = hyperparams[\"batch_size\"]\n"," self.update_frequency = hyperparams[\"update_frequency\"]\n"," self.max_episodes = hyperparams[\"max_episodes\"]\n"," self.max_steps = hyperparams[\"max_steps\"]\n"," self.render = hyperparams[\"render\"]\n","\n"," self.epsilon_max = hyperparams[\"epsilon_max\"]\n"," self.epsilon_min = hyperparams[\"epsilon_min\"]\n"," self.epsilon_decay = hyperparams[\"epsilon_decay\"]\n","\n"," self.memory_capacity = hyperparams[\"memory_capacity\"]\n","\n"," self.num_states = hyperparams[\"num_states\"]\n"," self.map_size = hyperparams[\"map_size\"]\n"," self.render_fps = hyperparams[\"render_fps\"]\n","\n"," # Define Env\n"," self.env = gym.make('FrozenLake-v1', map_name=f\"{self.map_size}x{self.map_size}\",\n"," is_slippery=False, max_episode_steps=self.max_steps,\n"," render_mode=\"rgb_array\" if self.render else None)\n"," self.env.metadata['render_fps'] = self.render_fps # For max frame rate make it 0\n"," print(self.render)\n"," if self.render:\n"," video_folder = \"vid\"\n"," os.makedirs(video_folder, exist_ok=True)\n"," self.env = RecordVideo(self.env, video_folder)\n","\n"," # Define the agent class\n"," self.agent = DQN_Agent(env = self.env,\n"," epsilon_max = self.epsilon_max,\n"," epsilon_min = self.epsilon_min,\n"," epsilon_decay = self.epsilon_decay,\n"," clip_grad_norm = self.clip_grad_norm,\n"," learning_rate = self.learning_rate,\n"," discount = self.discount_factor,\n"," memory_capacity = self.memory_capacity)\n","\n","\n"," def state_preprocess(self, state:int, num_states:int):\n"," \"\"\"\n"," Convert an state to a tensor and basically it encodes the state into\n"," an onehot vector. For example, the return can be something like tensor([0,0,1,0,0])\n"," which could mean agent is at state 2 from total of 5 states.\n","\n"," \"\"\"\n"," onehot_vector = torch.zeros(num_states, dtype=torch.float32, device=device)\n"," onehot_vector[state] = 1\n"," return onehot_vector\n","\n","\n"," def train(self):\n"," \"\"\"\n"," Reinforcement learning training loop.\n"," \"\"\"\n","\n"," total_steps = 0\n"," self.reward_history = []\n","\n"," # Training loop over episodes\n"," for episode in range(1, self.max_episodes+1):\n"," state, _ = self.env.reset(seed=seed)\n"," state = self.state_preprocess(state, num_states=self.num_states)\n"," done = False\n"," truncation = False\n"," step_size = 0\n"," episode_reward = 0\n","\n"," while not done and not truncation:\n"," action = self.agent.select_action(state)\n"," next_state, reward, done, truncation, _ = self.env.step(action)\n"," next_state = self.state_preprocess(next_state, num_states=self.num_states)\n","\n"," self.agent.replay_memory.store(state, action, next_state, reward, done)\n","\n"," if len(self.agent.replay_memory) > self.batch_size and sum(self.reward_history) > 0:\n"," self.agent.learn(self.batch_size, (done or truncation))\n","\n"," # Update target-network weights\n"," if total_steps % self.update_frequency == 0:\n"," self.agent.hard_update()\n","\n"," state = next_state\n"," episode_reward += reward\n"," step_size +=1\n"," if step_size > 200:\n"," truncation = True\n","\n"," # Appends for tracking history\n"," self.reward_history.append(episode_reward) # episode reward\n"," total_steps += step_size\n","\n"," # Decay epsilon at the end of each episode\n"," self.agent.update_epsilon()\n","\n"," #-- based on interval\n"," if episode % self.save_interval == 0:\n"," self.agent.save(self.save_path + '_' + f'{episode}' + '.pth')\n"," if episode != self.max_episodes:\n"," self.plot_training(episode)\n"," #print('\\n~~~~~~Interval Save: Model saved.\\n')\n","\n"," result = (f\"Episode: {episode}, \"\n"," f\"Total Steps: {total_steps}, \"\n"," f\"Ep Step: {step_size}, \"\n"," f\"Raw Reward: {episode_reward:.2f}, \"\n"," f\"Epsilon: {self.agent.epsilon_max:.2f}\")\n"," #print(result)\n"," self.plot_training(episode)\n","\n","\n"," def test(self, max_episodes):\n"," \"\"\"\n"," Reinforcement learning policy evaluation.\n"," \"\"\"\n","\n"," # Load the weights of the test_network\n"," self.agent.main_network.load_state_dict(torch.load(self.RL_load_path))\n"," self.agent.main_network.eval()\n","\n"," # Testing loop over episodes\n"," for episode in range(1, max_episodes+1):\n"," state, _ = self.env.reset(seed=seed)\n"," done = False\n"," truncation = False\n"," step_size = 0\n"," episode_reward = 0\n","\n"," while not done and not truncation:\n"," state = self.state_preprocess(state, num_states=self.num_states)\n"," action = self.agent.select_action(state)\n"," next_state, reward, done, _ = self.env.step(action)\n","\n"," state = next_state\n"," episode_reward += reward\n"," step_size += 1\n","\n"," # Print log\n"," result = (f\"Episode: {episode}, \"\n"," f\"Steps: {step_size:}, \"\n"," f\"Reward: {episode_reward:.2f}, \")\n","\n"," #pygame.quit() # close the rendering window\n","\n","\n"," def plot_training(self, episode):\n"," clear_output(wait=True)\n"," # Calculate the Simple Moving Average (SMA) with a window size of 50\n"," sma = np.convolve(self.reward_history, np.ones(50)/50, mode='valid')\n","\n"," plt.figure()\n"," plt.title(\"Rewards\")\n"," plt.plot(self.reward_history, label='Raw Reward', color='#F6CE3B', alpha=1)\n"," plt.plot(sma, label='SMA 50', color='#385DAA')\n"," plt.xlabel(\"Episode\")\n"," plt.ylabel(\"Rewards\")\n"," plt.legend()\n","\n"," # Only save as file if last episode\n"," if episode == self.max_episodes:\n"," plt.savefig('./reward_plot.png', format='png', dpi=600, bbox_inches='tight')\n"," plt.tight_layout()\n"," plt.grid(True)\n"," plt.show()\n"," plt.clf()\n"," plt.close()\n"],"metadata":{"id":"6403NkUVGu7z"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# TODO: Set Hyperparameters\n","def generate_parameters(train_mode):\n"," render = not train_mode\n"," map_size = 8 # 4x4 or 8x8\n"," RL_hyperparams = {\n"," \"train_mode\" : train_mode,\n"," \"RL_load_path\" : f'./final_weights' + '_' + '600' + '.pth',\n"," \"save_path\" : f'./final_weights',\n"," \"save_interval\" : 50,\n","\n"," \"clip_grad_norm\" : 1,\n"," \"learning_rate\" : 3e-4,\n"," \"discount_factor\" : 0.97,\n"," \"batch_size\" : 128,\n"," \"update_frequency\" : 4,\n"," \"max_episodes\" : 600 if train_mode else 5,\n"," \"max_steps\" : 200,\n"," \"render\" : render,\n","\n"," \"epsilon_max\" : 0.3 if train_mode else -1,\n"," \"epsilon_min\" : 0.01,\n"," \"epsilon_decay\" : 0.9998,\n","\n"," \"memory_capacity\" : 1000 if train_mode else 0,\n","\n"," \"map_size\" : map_size,\n"," \"num_states\" : map_size ** 2,\n"," \"render_fps\" : 6,\n"," }\n"," return RL_hyperparams"],"metadata":{"id":"eI1XZ3JIG1fM"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["RL_hyperparams = generate_parameters(train_mode=True)\n","DRL = Model_TrainTest(RL_hyperparams)\n","DRL.train()"],"metadata":{"id":"wi9srHSzMnB0","colab":{"base_uri":"https://localhost:8080/","height":487},"executionInfo":{"status":"ok","timestamp":1743707082710,"user_tz":-210,"elapsed":57323,"user":{"displayName":"Nima Shirzady","userId":"04764659690504916110"}},"outputId":"af34ab15-9537-4a36-f55e-8219851270a5"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":[""],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["RL_hyperparams = generate_parameters(train_mode=False)\n","DRL = Model_TrainTest(RL_hyperparams)\n","DRL.test(max_episodes=1)\n","clear_output(wait=True)\n","# Show the recordied video\n","show_video('vid')"],"metadata":{"id":"Kbr4XPHsJEe5","colab":{"base_uri":"https://localhost:8080/","height":370},"executionInfo":{"status":"ok","timestamp":1743707090846,"user_tz":-210,"elapsed":2152,"user":{"displayName":"Nima Shirzady","userId":"04764659690504916110"}},"outputId":"13921b3b-ab6e-4b86-f518-44f9a7a0f568"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":[""],"text/html":[""]},"metadata":{},"execution_count":13}]},{"cell_type":"code","source":["EPS = 1e-12\n","SavedAction = namedtuple('SavedAction', ['log_prob', 'value'])\n","device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"],"metadata":{"id":"ok3JjDgDIC9F"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["class Policy(nn.Module):\n"," \"\"\"\n"," Implement both policy network and the value network in one model\n"," \"\"\"\n"," def __init__(self, hid_dim=16):\n"," super(Policy, self).__init__()\n"," #Extract the dimensionality of state and action spaces\n"," self.discrete = isinstance(env.action_space, gym.spaces.Discrete)\n"," self.observation_dim = env.observation_space.n\n"," self.action_dim = env.action_space.n if self.discrete else env.action_space.shape[0]\n"," self.hid_dim = args.hid_dim\n"," self.double()\n","\n"," self.input_layer = nn.Sequential(nn.Linear(self.observation_dim, self.hid_dim), nn.ReLU())\n"," self.p_layer1 = nn.Sequential(nn.Linear(self.hid_dim, self.hid_dim), nn.ReLU())\n"," self.p_layer2 = nn.Linear(self.hid_dim, self.action_dim)\n","\n"," self.v_layers = nn.ModuleList(\n"," [nn.Sequential(nn.Linear(self.hid_dim, self.hid_dim), nn.ReLU())\n"," for _ in range(2)])\n"," self.v_output_layer = nn.Linear(self.hid_dim, 1)\n","\n"," # action & reward memory\n"," self.saved_actions = []\n"," self.rewards = []\n","\n"," def forward(self, state):\n"," x = self.input_layer(state)\n"," out = self.p_layer1(x)\n"," out = self.p_layer2(out)\n"," action_prob = F.softmax(out, dim=-1)\n","\n"," for layer in self.v_layers:\n"," value = layer(x)\n"," state_value = self.v_output_layer(value)\n","\n"," return action_prob, state_value\n","\n","\n"," def select_action(self, state):\n"," b = state\n"," state = torch.zeros(1, self.observation_dim)\n"," state[0, b] = 1.0\n"," state = state.float().to(device)\n","\n"," action_prob, state_value = self.forward(state)\n"," dist = Categorical(action_prob) # convert to a distribution\n"," action = dist.sample() # choose action from the distribution\n","\n"," self.saved_actions.append(SavedAction(dist.log_prob(action), state_value)) # save to action buffer\n","\n"," return action.item()\n","\n"," def saved_rewards(self, reward):\n"," self.rewards.append(reward)\n","\n","\n"," def calculate_loss(self, gamma=0.999):\n"," saved_actions = self.saved_actions # list of actions\n"," rewards = self.rewards # list of rewards\n"," policy_losses = []\n"," state_value_list = []\n"," returns = []\n"," adv_list = []\n","\n"," for t in range(len(rewards)-1, -1, -1): # calculate disounted returns in each time step\n"," disc_returns = (returns[0] if len(returns)> 0 else 0)\n"," G_t = gamma * disc_returns + rewards[t]\n"," returns.insert(0, G_t) # insert in the beginning of the list\n"," state_value = saved_actions[t][1]\n"," state_value_list.append(state_value)\n"," adv_list.insert(0, G_t - state_value)\n","\n"," adv_list = torch.tensor(adv_list)\n"," adv_list = (adv_list - adv_list.mean()) / (adv_list.std() + EPS) # for stability\n","\n"," for step in range(len(saved_actions)):\n"," log_prob = saved_actions[step][0]\n"," adv = adv_list[step]\n"," policy_losses.append(adv * log_prob)\n","\n"," value_loss = F.mse_loss(torch.tensor(state_value_list), torch.tensor(returns))\n"," policy_loss = torch.stack(policy_losses, dim=0).sum()\n"," loss = -policy_loss + value_loss\n","\n"," return loss\n","\n"," def clear_memory(self):\n"," # reset rewards and action buffer\n"," del self.rewards[:]\n"," del self.saved_actions[:]\n"],"metadata":{"id":"s7PzaKayIix5"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def train(args):\n"," model = Policy(hid_dim=args.hid_dim).to(device)\n"," optimizer = optim.Adam(model.parameters(), lr=args.lr)\n"," scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=0.9)\n","\n"," ewma_reward = 0 # EWMA reward for tracking the learning progress\n"," reward_history = []\n"," loss_history = []\n","\n"," for episode in range(args.episodes):\n"," # reset environment and episode reward\n"," state = env.reset()\n"," ep_reward = 0\n"," t = 0\n","\n"," steps = 200\n"," for t in range(steps):\n"," action = model.select_action(state=state)\n"," state, reward, done, _ = env.step(action)\n"," model.saved_rewards(reward)\n"," ep_reward += reward\n"," if done: break\n","\n"," loss = model.calculate_loss(gamma=args.gamma)\n"," loss_history.append(loss.item())\n","\n"," optimizer.zero_grad()\n"," loss.backward()\n"," optimizer.step()\n"," scheduler.step()\n","\n"," model.clear_memory()\n","\n"," reward_history.append(ep_reward)\n"," # update EWMA reward and log the results\n"," ewma_reward = 0.05 * ep_reward + (1 - 0.05) * ewma_reward\n"," if (episode) % 50 == 0:\n"," #print(f\"Episode {episode+1}\\tlength: {t+1}\\treward: {ep_reward}\\t ewma reward: {ewma_reward}\")\n"," clear_output(wait=True)\n"," plt.figure()\n"," plt.title(\"Rewards\")\n"," plt.xlabel(\"Episode\")\n"," plt.ylabel(\"Rewards\")\n"," plt.legend()\n"," sma = np.convolve(reward_history, np.ones(50)/50, mode='valid')\n"," plt.title(\"Rewards\")\n"," plt.plot(reward_history, label='Raw Reward', color='#F6CE3B', alpha=1)\n"," plt.plot(sma, label='SMA 50', color='#385DAA')\n"," plt.tight_layout()\n"," plt.grid(True)\n"," plt.show()\n"," plt.clf()\n"," plt.close()\n","\n","\n"," if ewma_reward > env.spec.reward_threshold or episode == args.episodes-1:\n"," if not os.path.isdir(\"./models\"):\n"," os.mkdir(\"./models\")\n"," torch.save(model.state_dict(), f\"./models/{args.env}_baseline.pth\")\n"," break\n","\n"],"metadata":{"id":"gpDowsN7In9K"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def test(model_name):\n"," model = Policy(hid_dim=args.hid_dim).to(device)\n"," model.load_state_dict(torch.load(f\"./models/{model_name}\"))\n","\n"," max_episode_len = 10000\n"," video_folder = \"vid1\"\n"," os.makedirs(video_folder, exist_ok=True)\n"," newenv = RecordVideo(env, video_folder)\n","\n"," state = newenv.reset()\n"," running_reward = 0\n"," for t in range(max_episode_len+1):\n"," action = model.select_action(state)\n"," state, reward, done, info = newenv.step(action)\n"," running_reward += reward\n"," if done:\n"," break\n"," print(f\"Testing: Reward: {running_reward}\")\n"," env.close()\n"],"metadata":{"id":"7T4rbjqxIqzu"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def generate_args(lr, gamma, hidden_dims, step_size):\n"," parser = argparse.ArgumentParser(\"REINFORCE algorithm using baseline\")\n"," parser.add_argument(\"--env\", type=str, default=\"LunarLander-v2\", help=\"Name of the environment\")\n"," parser.add_argument(\"--seed\", type=int, default=10, help=\"Random seed\")\n"," parser.add_argument(\"--lr\", type=float, default=lr, help=\"Learning rate\")\n"," parser.add_argument(\"--step_size\", type=int, default=step_size, help=\"Step size for lr scheduler\")\n"," parser.add_argument(\"--episodes\", type=int, default=1000, help=\"Number of episodes for training\")\n"," parser.add_argument(\"--gamma\", type=float, default=gamma, help=\"Discount factor\")\n"," parser.add_argument(\"--hid_dim\", type=int, default=hidden_dims, help=\"Hidden dimension of the policy network\")\n","\n"," args = parser.parse_args(args=[])\n"," return args"],"metadata":{"id":"_HjDshhmN44Q"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["import gym\n","# TODO: Set Hyperparameters\n","lr = 2e-4 # Learning Rate\n","hidden_dims = 64 # Hidden Layer Dimensions\n","gamma = 0.998 # Learning Rate Decay Factor\n","max_step_size = 200 ### max step size for an episode\n","\n","args = generate_args(lr=lr, hidden_dims=hidden_dims, gamma=gamma, step_size=max_step_size)\n","random_seed = args.seed\n","env = gym.make('FrozenLake-v1', map_name=\"8x8\", is_slippery=False, max_episode_steps=args.step_size, render_mode=\"rgb_array\")\n","\n","env.seed(random_seed)\n","torch.manual_seed(random_seed)\n","\n","train(args)\n","test(f'{args.env}_baseline.pth')"],"metadata":{"id":"FKtxlQ2RlokX","colab":{"base_uri":"https://localhost:8080/","height":559},"executionInfo":{"status":"ok","timestamp":1743708511776,"user_tz":-210,"elapsed":169023,"user":{"displayName":"Nima Shirzady","userId":"04764659690504916110"}},"outputId":"1b5ea886-0ceb-40fc-9ce6-9ca2e4161de0"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":[""],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.11/dist-packages/gym/wrappers/record_video.py:78: UserWarning: \u001b[33mWARN: Overwriting existing videos at /content/vid1 folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001b[0m\n"," logger.warn(\n"]},{"output_type":"stream","name":"stdout","text":["Testing: Reward: 0.0\n"]}]},{"cell_type":"code","source":["test(f'{args.env}_baseline.pth')\n","clear_output(wait=True)\n","# Show the recordied video\n","show_video('vid1')"],"metadata":{"id":"8YSyRZUYLk4j","colab":{"base_uri":"https://localhost:8080/","height":370},"executionInfo":{"status":"ok","timestamp":1743708558304,"user_tz":-210,"elapsed":1127,"user":{"displayName":"Nima Shirzady","userId":"04764659690504916110"}},"outputId":"6aad83bd-4146-4481-8fc6-4fdfa7b3ef1f"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":[""],"text/html":[""]},"metadata":{},"execution_count":12}]}]}