agent-code.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QTNU1mwGB1ZD"
      },
      "source": [
        "**Dependencies and setup**\n",
        "\n",
        "This can take a minute or so..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "rA38jtUgtZsG",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!apt update\n",
        "!apt install xvfb -y\n",
        "!pip install 'swig'\n",
        "!pip install 'pyglet==1.5.27'\n",
        "!pip install 'gym[box2d]==0.20.0'\n",
        "!pip install 'pyvirtualdisplay==3.0'\n",
        "\n",
        "import gym\n",
        "import random\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "import sys\n",
        "from pyvirtualdisplay import Display\n",
        "from IPython import display as disp\n",
        "%matplotlib inline\n",
        "\n",
        "display = Display(visible=0,size=(600,600))\n",
        "display.start()\n",
        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
        "\n",
        "plot_interval = 10 # update the plot every N episodes\n",
        "video_every = 50 # videos can take a very long time to render so only do it every N episodes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QEv4ZjXmyrHo"
      },
      "source": [
        "**Prepare the environment and wrap it to capture videos**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "1Xrcek4hxDXl",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "# env = gym.make(\"BipedalWalker-v3\")\n",
        "env = gym.make(\"BipedalWalkerHardcore-v3\") # only attempt this when your agent has solved BipedalWalker-v3\n",
        "env = gym.wrappers.Monitor(env, \"./video\", video_callable=lambda ep_id: ep_id%video_every == 0, force=True)\n",
        "\n",
        "obs_dim = env.observation_space.shape[0]\n",
        "act_dim = env.action_space.shape[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FUw4h980jfnu",
        "outputId": "24fa691a-e2d2-48ac-df6c-4a8852342b09",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The environment has 24 observations and the agent can take 4 actions\n",
            "The device is: cpu\n"
          ]
        }
      ],
      "source": [
        "print('The environment has {} observations and the agent can take {} actions'.format(obs_dim, act_dim))\n",
        "print('The device is: {}'.format(device))\n",
        "\n",
        "if device.type != 'cpu': print('It\\'s recommended to train on the cpu for this')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "EdiJMNiHG1KO",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# The code in this project has been copied and adapted from the following repositories:\n",
        "# https://github.com/honghaow/FORK/blob/master/BipedalWalkerHardcore/TD3_FORK_BipedalWalkerHardcore_Colab.ipynb\n",
        "# https://github.com/honghaow/FORK/blob/master/TD3-FORK/main_td3_fork.py\n",
        "# https://github.com/djbyrne/TD3/blob/master/TD3.ipynb\n",
        "# Individual sections have been referenced where appropriate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "NtCqPvSH2mtW",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Actor and critic classes from https://github.com/djbyrne/TD3/blob/master/TD3.ipynb\n",
        "class Actor(nn.Module):\n",
        "    \"\"\"Initialize parameters and build model.\n",
        "        Args:\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            max_action (float): highest action to take\n",
        "            seed (int): Random seed\n",
        "            h1_units (int): Number of nodes in first hidden layer\n",
        "            h2_units (int): Number of nodes in second hidden layer\n",
        "            \n",
        "        Return:\n",
        "            action output of network with tanh activation\n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self, state_dim, action_dim, max_action):\n",
        "        super(Actor, self).__init__()\n",
        "\n",
        "        self.l1 = nn.Linear(state_dim, 400)\n",
        "        self.l2 = nn.Linear(400, 300)\n",
        "        self.l3 = nn.Linear(300, action_dim)\n",
        "        self.max_action = max_action\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.l1(x))\n",
        "        x = F.relu(self.l2(x))\n",
        "        x = self.max_action * torch.tanh(self.l3(x)) \n",
        "        return x\n",
        "\n",
        "\n",
        "class Critic(nn.Module):\n",
        "    \"\"\"Initialize parameters and build model.\n",
        "        Args:\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            max_action (float): highest action to take\n",
        "            seed (int): Random seed\n",
        "            h1_units (int): Number of nodes in first hidden layer\n",
        "            h2_units (int): Number of nodes in second hidden layer\n",
        "            \n",
        "        Return:\n",
        "            value output of network \n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self, state_dim, action_dim):\n",
        "        super(Critic, self).__init__()\n",
        "\n",
        "        # Q1 architecture\n",
        "        self.l1 = nn.Linear(state_dim + action_dim, 400)\n",
        "        self.l2 = nn.Linear(400, 300)\n",
        "        self.l3 = nn.Linear(300, 1)\n",
        "\n",
        "        # Q2 architecture\n",
        "        self.l4 = nn.Linear(state_dim + action_dim, 400)\n",
        "        self.l5 = nn.Linear(400, 300)\n",
        "        self.l6 = nn.Linear(300, 1)\n",
        "\n",
        "    def forward(self, x, u):\n",
        "        xu = torch.cat([x, u], 1)\n",
        "\n",
        "        x1 = F.relu(self.l1(xu))\n",
        "        x1 = F.relu(self.l2(x1))\n",
        "        x1 = self.l3(x1)\n",
        "\n",
        "        x2 = F.relu(self.l4(xu))\n",
        "        x2 = F.relu(self.l5(x2))\n",
        "        x2 = self.l6(x2)\n",
        "        return x1, x2\n",
        "\n",
        "\n",
        "    def Q1(self, x, u):\n",
        "        xu = torch.cat([x, u], 1)\n",
        "\n",
        "        x1 = F.relu(self.l1(xu))\n",
        "        x1 = F.relu(self.l2(x1))\n",
        "        x1 = self.l3(x1)\n",
        "        return x1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "eUpckOJ_Fo9l",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Both classes from https://github.com/honghaow/FORK/blob/master/TD3-FORK/TD3_FORK.py\n",
        "\n",
        "class Sys_R(nn.Module):\n",
        "\tdef __init__(self,state_dim, action_dim, fc1_units, fc2_units):\n",
        "\t\tsuper(Sys_R, self).__init__()\n",
        "\n",
        "\t\t# Q1 architecture\n",
        "\t\tself.l1 = nn.Linear(2 * state_dim + action_dim, fc1_units)\n",
        "\t\tself.l2 = nn.Linear(fc1_units,fc2_units)\n",
        "\t\tself.l3 = nn.Linear(fc2_units, 1)\n",
        "\n",
        "\n",
        "\tdef forward(self, state,next_state, action):\n",
        "\t\tsa = torch.cat([state,next_state, action], 1)\n",
        "\n",
        "\t\tq1 = F.relu(self.l1(sa))\n",
        "\t\tq1 = F.relu(self.l2(q1))\n",
        "\t\tq1 = self.l3(q1)\n",
        "\t\treturn q1\n",
        "\n",
        "\n",
        "class SysModel(nn.Module):\n",
        "\tdef __init__(self, state_size, action_size, fc1_units, fc2_units):\n",
        "\t\tsuper(SysModel, self).__init__()\n",
        "\t\tself.l1 = nn.Linear(state_size + action_size, fc1_units)\n",
        "\t\tself.l2 = nn.Linear(fc1_units, fc2_units)\n",
        "\t\tself.l3 = nn.Linear(fc2_units, state_size)\n",
        "\n",
        "\tdef forward(self, state, action):\n",
        "\t\t\"\"\"Build a system model to predict the next state at a given state.\"\"\"\n",
        "\t\txa = torch.cat([state, action], 1)\n",
        "\n",
        "\t\tx1 = F.relu(self.l1(xa))\n",
        "\t\tx1 = F.relu(self.l2(x1))\n",
        "\t\tx1 = self.l3(x1)\n",
        "\t\treturn x1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "aGvu4t7D27Zn",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Code based on: \n",
        "# https://github.com/openai/baselines/blob/master/baselines/deepq/replay_buffer.py\n",
        "\n",
        "# Expects tuples of (state, next_state, action, reward, done)\n",
        "class ReplayBuffer(object):\n",
        "    \"\"\"Buffer to store tuples of experience replay\"\"\"\n",
        "    \n",
        "    def __init__(self, max_size=1000000):\n",
        "        \"\"\"\n",
        "        Args:\n",
        "            max_size (int): total amount of tuples to store\n",
        "        \"\"\"\n",
        "        \n",
        "        self.storage = []\n",
        "        self.max_size = max_size\n",
        "        self.ptr = 0\n",
        "\n",
        "    def add(self, data):\n",
        "        \"\"\"Add experience tuples to buffer\n",
        "        \n",
        "        Args:\n",
        "            data (tuple): experience replay tuple\n",
        "        \"\"\"\n",
        "        \n",
        "        if len(self.storage) == self.max_size:\n",
        "            self.storage[int(self.ptr)] = data\n",
        "            self.ptr = (self.ptr + 1) % self.max_size\n",
        "        else:\n",
        "            self.storage.append(data)\n",
        "\n",
        "    def sample(self, batch_size):\n",
        "        \"\"\"Samples a random amount of experiences from buffer of batch size\n",
        "        \n",
        "        Args:\n",
        "            batch_size (int): size of sample\n",
        "        \"\"\"\n",
        "        \n",
        "        ind = np.random.randint(0, len(self.storage), size=batch_size)\n",
        "        states, actions, next_states, rewards, dones = [], [], [], [], []\n",
        "\n",
        "        for i in ind: \n",
        "            s, a, s_, r, d = self.storage[i]\n",
        "            states.append(np.array(s, copy=False))\n",
        "            actions.append(np.array(a, copy=False))\n",
        "            next_states.append(np.array(s_, copy=False))\n",
        "            rewards.append(np.array(r, copy=False))\n",
        "            dones.append(np.array(d, copy=False))\n",
        "\n",
        "        return np.array(states), np.array(actions), np.array(next_states), np.array(rewards).reshape(-1, 1), np.array(dones).reshape(-1, 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "4BPzxKWeALhU",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# From https://github.com/djbyrne/TD3/blob/master/TD3.ipynb and https://github.com/honghaow/FORK/blob/master/BipedalWalkerHardcore/TD3_FORK_BipedalWalkerHardcore_Colab.ipynb\n",
        "class TD3(object):\n",
        "    \"\"\"Agent class that handles the training of the networks and provides outputs as actions\n",
        "    \n",
        "        Args:\n",
        "            state_dim (int): state size\n",
        "            action_dim (int): action size\n",
        "            max_action (float): highest action to take\n",
        "            device (device): cuda or cpu to process tensors\n",
        "            env (env): gym environment to use\n",
        "    \n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self, state_dim, action_dim, max_action, env):\n",
        "        self.actor = Actor(state_dim, action_dim, max_action).to(device) \n",
        "        self.actor_target = Actor(state_dim, action_dim, max_action).to(device) \n",
        "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
        "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=1e-3)\n",
        "\n",
        "        self.critic = Critic(state_dim, action_dim).to(device) \n",
        "        self.critic_target = Critic(state_dim, action_dim).to(device)\n",
        "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
        "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=1e-3)\n",
        "\n",
        "\n",
        "        sys1_units = 400\n",
        "        sys2_units = 300\n",
        "        r1_units = 256\n",
        "        r2_units = 256\n",
        "        self.sysmodel = SysModel(state_dim, action_dim, sys1_units,sys2_units).to(device)\n",
        "        self.sysmodel_optimizer = torch.optim.Adam(self.sysmodel.parameters(), lr=3e-4)\n",
        "        self.sysmodel.apply(self.init_weights)\n",
        "\n",
        "        self.sysr = Sys_R(state_dim, action_dim, r1_units, r2_units).to(device)\n",
        "        self.sysr_optimizer = torch.optim.Adam(self.sysr.parameters(), lr=3e-4)\n",
        "\n",
        "        self.max_action = max_action\n",
        "        self.env = env\n",
        "\n",
        "\n",
        "        self.obs_lower_bound = float(self.env.observation_space.high[0]) #state space upper bound\n",
        "        self.obs_upper_bound = float(self.env.observation_space.low[0])  #state space lower bound\n",
        "\n",
        "        sys_threshold = 0.01 # System threshold l\n",
        "\n",
        "        self.sys_threshold = sys_threshold\n",
        "\n",
        "\n",
        "    def init_weights(self,m):\n",
        "      if type(m) == nn.Linear:\n",
        "        torch.nn.init.xavier_uniform_(m.weight)\n",
        "        m.bias.data.fill_(0.001)\n",
        "           \n",
        "    def select_action(self, state, noise=0.1):\n",
        "        \"\"\"Select an appropriate action from the agent policy\n",
        "        \n",
        "            Args:\n",
        "                state (array): current state of environment\n",
        "                noise (float): how much noise to add to acitons\n",
        "                \n",
        "            Returns:\n",
        "                action (float): action clipped within action range\n",
        "        \n",
        "        \"\"\"\n",
        "        \n",
        "        state = torch.FloatTensor(state.reshape(1, -1)).to(device)\n",
        "        \n",
        "        action = self.actor(state).cpu().data.numpy().flatten()\n",
        "        if noise != 0: \n",
        "            action = (action + np.random.normal(0, noise, size=self.env.action_space.shape[0]))\n",
        "            \n",
        "        return action.clip(self.env.action_space.low, self.env.action_space.high)\n",
        "\n",
        "    \n",
        "    def train(self, replay_buffer, iterations, adaptive_weight, batch_size=100, discount=0.99, tau=0.005, policy_noise=0.2, noise_clip=0.5, policy_freq=2):\n",
        "        \"\"\"Train and update actor and critic networks\n",
        "        \n",
        "            Args:\n",
        "                replay_buffer (ReplayBuffer): buffer for experience replay\n",
        "                iterations (int): how many times to run training\n",
        "                batch_size(int): batch size to sample from replay buffer\n",
        "                discount (float): discount factor\n",
        "                tau (float): soft update for main networks to target networks\n",
        "                \n",
        "            Return:\n",
        "                actor_loss (float): loss from actor network\n",
        "                critic_loss (float): loss from critic network\n",
        "        \n",
        "        \"\"\"\n",
        "        \n",
        "        for it in range(iterations):\n",
        "\n",
        "            # Sample replay buffer \n",
        "            x, y, u, r, d = replay_buffer.sample(batch_size)\n",
        "            state = torch.FloatTensor(x).to(device)\n",
        "            action = torch.FloatTensor(u).to(device)\n",
        "            next_state = torch.FloatTensor(y).to(device)\n",
        "            done = torch.FloatTensor(1 - d).to(device)\n",
        "            reward = torch.FloatTensor(r).to(device)\n",
        "\n",
        "            # Select action according to policy and add clipped noise \n",
        "            noise = torch.FloatTensor(u).data.normal_(0, policy_noise).to(device)\n",
        "            noise = noise.clamp(-noise_clip, noise_clip)\n",
        "            next_action = (self.actor_target(next_state) + noise).clamp(-self.max_action, self.max_action)\n",
        "\n",
        "            # Compute the target Q value\n",
        "            target_Q1, target_Q2 = self.critic_target(next_state, next_action)\n",
        "            target_Q = torch.min(target_Q1, target_Q2)\n",
        "            target_Q = reward + (done * discount * target_Q).detach()\n",
        "\n",
        "            # Get current Q estimates\n",
        "            current_Q1, current_Q2 = self.critic(state, action)\n",
        "\n",
        "            # Compute critic MSE loss\n",
        "            critic_loss = F.mse_loss(current_Q1, target_Q) + F.mse_loss(current_Q2, target_Q) \n",
        "\n",
        "            # Optimize the critic\n",
        "            self.critic_optimizer.zero_grad()\n",
        "            critic_loss.backward()\n",
        "            self.critic_optimizer.step()\n",
        "\n",
        "\n",
        "\n",
        "            #Train system and reward model\n",
        "            predict_next_state = self.sysmodel(state, action)\n",
        "            predict_next_state = predict_next_state.clamp(self.obs_lower_bound, self.obs_upper_bound)\n",
        "            sysmodel_loss = F.smooth_l1_loss(predict_next_state, next_state.detach())\n",
        "\n",
        "            self.sysmodel_optimizer.zero_grad()\n",
        "            sysmodel_loss.backward()\n",
        "            self.sysmodel_optimizer.step()\n",
        "            self.sysmodel_loss = sysmodel_loss.item()\n",
        "\n",
        "\n",
        "            predict_reward = self.sysr(state,next_state,action)\n",
        "            sysr_loss = F.mse_loss(predict_reward, reward.detach())\n",
        "            self.sysr_optimizer.zero_grad()\n",
        "            sysr_loss.backward()\n",
        "            self.sysr_optimizer.step()\n",
        "            self.sysr_loss = sysr_loss.item()\n",
        "\n",
        "            s_flag = 1 if sysmodel_loss.item() < self.sys_threshold else 0\n",
        "\n",
        "\n",
        "            # Delayed policy updates\n",
        "            if it % policy_freq == 0:\n",
        "\n",
        "                # Compute actor loss\n",
        "                actor_loss1 = -self.critic.Q1(state, self.actor(state)).mean()\n",
        "\n",
        "\n",
        "                if s_flag == 1:\n",
        "                  p_next_state = self.sysmodel(state, self.actor(state))\n",
        "                  p_next_state = p_next_state.clamp(self.obs_lower_bound,self.obs_upper_bound)\n",
        "                  actions2 = self.actor(p_next_state.detach())\n",
        "                  \n",
        "                  # TD3-FORK used\n",
        "                  p_next_r = self.sysr(state,p_next_state.detach(),self.actor(state))\n",
        "                  p_next_state2 = self.sysmodel(p_next_state, self.actor(p_next_state.detach()))\n",
        "                  p_next_state2 = p_next_state2.clamp(self.obs_lower_bound,self.obs_upper_bound)\n",
        "                  p_next_r2 = self.sysr(p_next_state.detach(),p_next_state2.detach(),self.actor(p_next_state.detach()))\n",
        "                  actions3 = self.actor(p_next_state2.detach())\n",
        "                  actor_loss2 =  self.critic.Q1(p_next_state2.detach(),actions3)\n",
        "                  actor_loss3 = -(p_next_r + self.discount * p_next_r2 + self.discount ** 2 * actor_loss2).mean()\n",
        "\n",
        "\n",
        "                  actor_loss = (actor_loss1 + adaptive_weight * actor_loss3)\n",
        "\n",
        "\n",
        "                  lmbda = 2.5/actor_loss1.abs().detach()\n",
        "\n",
        "                  actor_loss = -lmbda * actor_loss + F.mse_loss(self.actor(state), action)\n",
        "\n",
        "      \n",
        "                  self.update_sys += 1\n",
        "                else:\n",
        "                  actor_loss = actor_loss1\n",
        "\n",
        "                # Optimize the actor\n",
        "                self.critic_optimizer.zero_grad()\n",
        "                self.sysmodel_optimizer.zero_grad()\n",
        "                self.actor_optimizer.zero_grad()\n",
        "                actor_loss.backward()\n",
        "                \n",
        "                self.actor_optimizer.step()\n",
        "\n",
        "                # Update the frozen target models\n",
        "                for param, target_param in zip(self.critic.parameters(), self.critic_target.parameters()):\n",
        "                    target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)\n",
        "\n",
        "                for param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):\n",
        "                    target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)\n",
        "\n",
        "\n",
        "    def save(self, filename, directory):\n",
        "        torch.save(self.actor.state_dict(), '%s/%s_actor.pth' % (directory, filename))\n",
        "        torch.save(self.critic.state_dict(), '%s/%s_critic.pth' % (directory, filename))\n",
        "\n",
        "\n",
        "    def load(self, filename=\"best_avg\", directory=\"./saves\"):\n",
        "        self.actor.load_state_dict(torch.load('%s/%s_actor.pth' % (directory, filename)))\n",
        "        self.critic.load_state_dict(torch.load('%s/%s_critic.pth' % (directory, filename)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "9CB2hwXZBCn9",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "max_action = float(env.action_space.high[0])\n",
        "\n",
        "# initialise agent\n",
        "agent = TD3(obs_dim, act_dim, max_action, env)\n",
        "done = False\n",
        "# initialise replay buffer\n",
        "replay_buffer = ReplayBuffer()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "-KeVbZmqCReR",
        "outputId": "089f4387-8554-4e50-a305-99355c02f0b4",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# in the submission please use seed 42 for verification\n",
        "seed = 42\n",
        "torch.manual_seed(seed)\n",
        "env.seed(seed)\n",
        "random.seed(seed)\n",
        "np.random.seed(seed)\n",
        "env.action_space.seed(seed)\n",
        "\n",
        "# logging variables\n",
        "ep_reward = 0\n",
        "reward_list = []\n",
        "plot_data = []\n",
        "log_f = open(\"agent-log.txt\",\"w+\")\n",
        "\n",
        "max_episodes = 1800 # use 800 for basic\n",
        "max_timesteps = 2000\n",
        "start_timesteps = 10000 # as stated in paper\n",
        "\n",
        "timestep_count = 0\n",
        "expcount = 0\n",
        "\n",
        "state = env.reset()\n",
        "\n",
        "# The following has been copied and adapted from https://github.com/honghaow/FORK/blob/master/BipedalWalkerHardcore/TD3_FORK_BipedalWalkerHardcore_Colab.ipynb\n",
        "\n",
        "# training procedure:\n",
        "for episode in range(1, max_episodes+1):\n",
        "    ep_reward_list = []\n",
        "    temp_replay_buffer = []\n",
        "    # state = env.reset()\n",
        "    for t in range(max_timesteps):\n",
        "        timestep_count += 1\n",
        "\n",
        "        if timestep_count <= start_timesteps:\n",
        "            # sample random action in observation stage\n",
        "            action = env.action_space.sample()\n",
        "        else:\n",
        "            action = agent.select_action(state)\n",
        "          \n",
        "        next_state, reward, done, _ = env.step(action)\n",
        "\n",
        "        ep_reward += reward\n",
        "\n",
        "        if reward == -100:\n",
        "              add_reward = -1\n",
        "              reward = -5\n",
        "              expcount += 1\n",
        "\n",
        "        else:\n",
        "              add_reward = 0\n",
        "              reward *= 5\n",
        "        temp_replay_buffer.append((state, next_state, action, reward, done))\n",
        "\n",
        "        state = next_state\n",
        "        \n",
        "        # stop iterating when the episode finished\n",
        "        if done or t==(max_timesteps-1):\n",
        "\n",
        "            # My implementation of 5:1 ratio\n",
        "            if add_reward == -1 or ep_reward < 250:        \n",
        "                for temp in temp_replay_buffer:\n",
        "                    for i in range(5):\n",
        "                      replay_buffer.add(temp)\n",
        "            else:\n",
        "                for temp in temp_replay_buffer:\n",
        "                    replay_buffer.add(temp)\n",
        "\n",
        "            # append the episode reward to the reward list\n",
        "            reward_list.append(ep_reward)\n",
        "\n",
        "            # reward list per episode (used for adaptive weight)\n",
        "            ep_reward_list.append(ep_reward)\n",
        "            if timestep_count > start_timesteps:\n",
        "\n",
        "              r_0 = 320 # Base Cumulative Reward r0\n",
        "              w_0 = 0.6 # Base Weight w0\n",
        "              adaptive_weight = np.round((1 - np.clip(np.mean(ep_reward_list[-100:])/r_0, 0, 1)),4) * w_0\n",
        "\n",
        "              agent.train(replay_buffer, t, adaptive_weight)\n",
        "\n",
        "            state = env.reset()\n",
        "            done = False\n",
        "            break\n",
        "\n",
        "\n",
        "\n",
        "    # do NOT change this logging code - it is used for automated marking!\n",
        "    log_f.write('episode: {}, reward: {}\\n'.format(episode, ep_reward))\n",
        "    log_f.flush()\n",
        "    ep_reward = 0\n",
        "    \n",
        "    # print reward data every so often - add a graph like this in your report\n",
        "    if episode % plot_interval == 0:\n",
        "        plot_data.append([episode, np.array(reward_list).mean(), np.array(reward_list).std()])\n",
        "        reward_list = []\n",
        "        # plt.rcParams['figure.dpi'] = 100\n",
        "        plt.plot([x[0] for x in plot_data], [x[1] for x in plot_data], '-', color='tab:grey')\n",
        "        plt.fill_between([x[0] for x in plot_data], [x[1]-x[2] for x in plot_data], [x[1]+x[2] for x in plot_data], alpha=0.2, color='tab:grey')\n",
        "        plt.xlabel('Episode number')\n",
        "        plt.ylabel('Episode reward')\n",
        "        plt.show()\n",
        "        disp.clear_output(wait=True)\n",
        " \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "r0qrehZ95rOZ",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "agent.save(\"./saves\", \"./\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "RL-Assignment-td3fork_bc",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}