Master 3 of 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ca992d43",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "33edb923",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import gym\n",
    "import random\n",
    "import copy\n",
    "from collections import deque\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "633b2f0c",
   "metadata": {},
   "source": [
    "# Actor critic methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "97108ce1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(self, scaling, state_size, hidden_size, action_size):\n",
    "        super(Actor, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_size, hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc3 = nn.Linear(hidden_size, action_size)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.fc1(state))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        return torch.tanh(self.fc3(x)) * scaling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "07c2bac4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_size, hidden_size, action_size):\n",
    "        super(Critic, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_size + action_size, hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc3 = nn.Linear(hidden_size, 1)\n",
    "    \n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388590c8",
   "metadata": {},
   "source": [
    "## TD3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2cfeee",
   "metadata": {},
   "source": [
    "### Defining the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "284a1997",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TD3_Agent():\n",
    "    def __init__(self, scaling, render, buffer_size, batch_size, gamma, tau, sigma,\n",
    "                state_size, hidden_size, action_size, actor_lr, critic_lr):\n",
    "        \n",
    "        self.scaling = scaling\n",
    "        self.render = render\n",
    "        self.buffer_size = buffer_size\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.sigma = sigma\n",
    "\n",
    "        self.state_size = state_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.action_size = action_size\n",
    "        self.actor_lr = actor_lr\n",
    "        self.critic_lr = critic_lr\n",
    "        \n",
    "        # Create actor network, 2 critic networks, their target copies, and their optimisers\n",
    "        self.actor = Actor(scaling, state_size, hidden_size, action_size)\n",
    "        self.critic = Critic(state_size, hidden_size, action_size)\n",
    "        self.critic2 = Critic(state_size, hidden_size, action_size)\n",
    "        self.target_actor = copy.deepcopy(self.actor)\n",
    "        self.target_critic = copy.deepcopy(self.critic)\n",
    "        self.target_critic2 = copy.deepcopy(self.critic2)\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr = actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr = critic_lr)\n",
    "        self.critic_optimizer2 = torch.optim.Adam(self.critic2.parameters(), lr = critic_lr)\n",
    "        \n",
    "        self.state_memory = []\n",
    "        self.next_state_memory = []\n",
    "        self.action_memory = []\n",
    "        self.reward_memory = []\n",
    "        self.terminal_memory = []\n",
    "        self.memory_counter = 0\n",
    "        \n",
    "    def train(self):\n",
    "        state = env.reset()\n",
    "        ep_reward = 0\n",
    "        num_step = 0\n",
    "        terminal = False\n",
    "        \n",
    "        while not terminal:\n",
    "            \n",
    "            if self.render:\n",
    "                env.render()\n",
    "                \n",
    "            tensor_state = torch.from_numpy(state).float()            \n",
    "            action = self.actor(tensor_state)\n",
    "            action = torch.add(action, torch.from_numpy(np.random.normal(0, self.sigma, self.action_size)))\n",
    "            action = action.detach().numpy()\n",
    "            next_state, reward, terminal, _ = env.step(action)\n",
    "            ep_reward += reward\n",
    "\n",
    "            if self.memory_counter < self.buffer_size: \n",
    "                self.state_memory.append(state)\n",
    "                self.next_state_memory.append(next_state)\n",
    "                self.action_memory.append(action)\n",
    "                self.reward_memory.append(reward)\n",
    "                self.terminal_memory.append(1 - terminal)\n",
    "            else:     \n",
    "                index = self.memory_counter % self.buffer_size\n",
    "                self.state_memory[index] = state\n",
    "                self.next_state_memory[index] = next_state\n",
    "                self.action_memory[index] = action\n",
    "                self.reward_memory[index] = reward\n",
    "                self.terminal_memory[index] = 1 - terminal\n",
    "            self.memory_counter += 1    \n",
    "            \n",
    "            if self.memory_counter >= self.batch_size: \n",
    "                batch = random.sample(range(len(self.state_memory)), self.batch_size) \n",
    "                states = []\n",
    "                next_states = []\n",
    "                actions = []\n",
    "                rewards = []\n",
    "                terminals = []\n",
    "                \n",
    "                for item in batch:\n",
    "                    states.append(self.state_memory[item])\n",
    "                    next_states.append(self.next_state_memory[item])\n",
    "                    actions.append(self.action_memory[item])\n",
    "                    rewards.append(self.reward_memory[item]) \n",
    "                    terminals.append(self.terminal_memory[item])\n",
    "                \n",
    "                states = np.array(states)\n",
    "                next_states = np.array(next_states)\n",
    "                actions = np.array(actions)\n",
    "                states = torch.tensor(states)\n",
    "                next_states = torch.tensor(next_states)\n",
    "                actions = torch.tensor(actions)\n",
    "                states = states.to(torch.float32) \n",
    "                actions = actions.to(torch.float32) \n",
    "                next_states = next_states.to(torch.float32) \n",
    "                    \n",
    "                # Calculate policy noise then clip this noise\n",
    "                # Add this policy noise to the actions that are selected by the actor network when given the next state\n",
    "                target_actions = self.target_actor(next_states)\n",
    "                actions_copy = copy.deepcopy(actions)\n",
    "                noise = actions_copy.data.normal_(0, self.sigma * 2)\n",
    "                noise = noise.clamp(-self.sigma * 5, self.sigma * 5)      \n",
    "                target_actions = target_actions + noise\n",
    "                \n",
    "                # Calculate the actual next state Q values for each target critic network\n",
    "                # Choose the smaller of these two next state Q values\n",
    "                # Use this to calculate the value of actual current state Q values\n",
    "                a = self.target_critic(next_states, target_actions)\n",
    "                b = self.target_critic2(next_states, target_actions)\n",
    "                next_Qtargets = torch.min(a,b) \n",
    "                Qtargets = []\n",
    "                for i in range(self.batch_size):\n",
    "                    Qtargets.append(rewards[i] + self.gamma * next_Qtargets[i] * terminals[i])\n",
    "                Qtargets = torch.tensor(Qtargets)\n",
    "                Qtargets = Qtargets.view(self.batch_size, 1)\n",
    "                \n",
    "                # Perform gradient descent on the first critic network             \n",
    "                Qexpected = self.critic(states, actions)\n",
    "                critic_loss = nn.MSELoss()(Qexpected, Qtargets)\n",
    "                self.critic_optimizer.zero_grad()\n",
    "                critic_loss.backward()\n",
    "                self.critic_optimizer.step()\n",
    "                \n",
    "                # Perform gradient descent on the second critic network       \n",
    "                Qexpected2 = self.critic2(states, actions)\n",
    "                critic_loss2 = nn.MSELoss()(Qexpected2, Qtargets)\n",
    "                self.critic_optimizer2.zero_grad()\n",
    "                critic_loss2.backward()\n",
    "                self.critic_optimizer2.step()\n",
    "                \n",
    "                # Perform gradient ascent on the actor network every 2 steps\n",
    "                if num_step % 2 == 0:\n",
    "                    actions_predicted = self.actor(states)\n",
    "                    actor_loss = -self.critic(states, actions_predicted)\n",
    "                    actor_loss = torch.mean(actor_loss)\n",
    "                    self.actor_optimizer.zero_grad()\n",
    "                    actor_loss.backward()\n",
    "                    self.actor_optimizer.step()\n",
    "                \n",
    "                # Update all target networks\n",
    "                with torch.no_grad():\n",
    "                    for target_parameter, parameter in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "                        target_parameter.copy_((target_parameter * (1 - self.tau)) + (parameter * self.tau))                    \n",
    "\n",
    "                with torch.no_grad():\n",
    "                    for target_parameter, parameter in zip(self.target_critic2.parameters(), self.critic2.parameters()):\n",
    "                        target_parameter.copy_((target_parameter * (1 - self.tau)) + (parameter * self.tau)) \n",
    "                \n",
    "                with torch.no_grad():\n",
    "                    for target_parameter, parameter in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "                        target_parameter.copy_((target_parameter * (1 - self.tau)) + (parameter * self.tau))      \n",
    "                \n",
    "            state = next_state\n",
    "            num_step += 1\n",
    "            \n",
    "        if self.render:\n",
    "            env.close()\n",
    "            \n",
    "        return ep_reward\n",
    "    \n",
    "    def test(self):\n",
    "        \n",
    "        scores = []\n",
    "        \n",
    "        for i in range(100):\n",
    "            state = env.reset()\n",
    "            terminal = False\n",
    "            ep_reward = 0\n",
    "\n",
    "            while not terminal:\n",
    "                tensor_state = torch.from_numpy(state).float()\n",
    "                action = self.actor(tensor_state)\n",
    "                action = action.detach().numpy()\n",
    "                next_state, reward, terminal, _ = env.step(action)\n",
    "                ep_reward += reward \n",
    "                state = next_state\n",
    "                \n",
    "            scores.append(ep_reward)\n",
    "        \n",
    "        print('Mean score:', np.mean(scores))\n",
    "        x = [i for i in range(1, len(scores)+1)]\n",
    "        plt.plot(x, scores)\n",
    "        plt.ylabel('Score')\n",
    "        plt.xlabel('Episodes')\n",
    "        plt.show()\n",
    "\n",
    "    def visualise(self):\n",
    "        for i in range(10):\n",
    "            state = env.reset()\n",
    "            terminal = False\n",
    "            ep_reward = 0\n",
    "\n",
    "            while not terminal:\n",
    "                env.render()\n",
    "                tensor_state = torch.from_numpy(state).float()\n",
    "                action = self.actor(tensor_state)\n",
    "                action = action.detach().numpy()\n",
    "                next_state, reward, terminal, _ = env.step(action)\n",
    "                ep_reward += reward \n",
    "                state = next_state\n",
    "\n",
    "            print('Episode reward:', ep_reward)\n",
    "            env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dea40bb3",
   "metadata": {},
   "source": [
    "### BipedalWalker-v3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9e627635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*************************************************************\n",
      "Agent 1\n",
      "Episode: 100 Score: -110.447 \t Mean score over last 100 episodes: -107.410\n",
      "Episode: 200 Score: -89.333 \t Mean score over last 100 episodes: -94.266\n",
      "Episode: 300 Score: -91.820 \t Mean score over last 100 episodes: -106.959\n",
      "Episode: 400 Score: -114.438 \t Mean score over last 100 episodes: -85.677\n",
      "Episode: 500 Score: -68.846 \t Mean score over last 100 episodes: -75.447\n",
      "Episode: 600 Score: 119.878 \t Mean score over last 100 episodes: 15.889\n",
      "Episode: 700 Score: 253.343 \t Mean score over last 100 episodes: 192.544\n",
      "Episode: 800 Score: 262.838 \t Mean score over last 100 episodes: 228.503\n",
      "Episode: 900 Score: 271.146 \t Mean score over last 100 episodes: 266.990\n",
      "Episode: 1000 Score: 279.750 \t Mean score over last 100 episodes: 269.734\n",
      "Episode: 1100 Score: 276.433 \t Mean score over last 100 episodes: 276.367\n",
      "Episode: 1200 Score: 278.496 \t Mean score over last 100 episodes: 268.108\n",
      "Episode: 1300 Score: 280.214 \t Mean score over last 100 episodes: 267.311\n",
      "Episode: 1400 Score: 282.830 \t Mean score over last 100 episodes: 274.544\n",
      "Episode: 1500 Score: 86.941 \t Mean score over last 100 episodes: 281.026\n",
      "Episode: 1600 Score: 284.068 \t Mean score over last 100 episodes: 277.879\n",
      "Episode: 1700 Score: 288.174 \t Mean score over last 100 episodes: 284.949\n",
      "Episode: 1800 Score: -101.817 \t Mean score over last 100 episodes: 196.870\n",
      "Episode: 1900 Score: 290.613 \t Mean score over last 100 episodes: 266.285\n",
      "Episode: 2000 Score: 292.358 \t Mean score over last 100 episodes: 292.234\n",
      "Episode: 2100 Score: 295.125 \t Mean score over last 100 episodes: 287.382\n",
      "Episode: 2200 Score: 289.816 \t Mean score over last 100 episodes: 292.621\n",
      "Episode: 2300 Score: 291.156 \t Mean score over last 100 episodes: 287.223\n",
      "Episode: 2400 Score: 293.659 \t Mean score over last 100 episodes: 287.957\n",
      "Episode: 2500 Score: 292.570 \t Mean score over last 100 episodes: 294.179\n",
      "Episode: 2600 Score: 290.288 \t Mean score over last 100 episodes: 286.418\n",
      "Episode: 2700 Score: 293.234 \t Mean score over last 100 episodes: 290.560\n",
      "Episode: 2800 Score: 291.350 \t Mean score over last 100 episodes: 283.620\n",
      "Episode: 2900 Score: 284.212 \t Mean score over last 100 episodes: 286.000\n",
      "Episode: 3000 Score: 287.608 \t Mean score over last 100 episodes: 276.017\n",
      "*********************************\n",
      "Agent 1 complete \t Mean score of agent: 202.048\n",
      "BipedalWalker-v3 finished in 3000 episodes \t Mean score over last 100 episodes: 276.017\n",
      "*********************************\n",
      "Agent 1 scores during training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 1 mean score of last 100 episodes during training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 1 scores during testing\n",
      "Mean score: 288.388414526982\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "environment = 'BipedalWalker-v3'\n",
    "env = gym.make(environment)\n",
    "\n",
    "if environment == 'Pendulum-v1':\n",
    "    scaling = 2\n",
    "    solved = -100\n",
    "elif environment =='BipedalWalker-v3' or 'BipedalWalkerHardcore-v3':\n",
    "    scaling = 1\n",
    "    solved = 300 \n",
    "\n",
    "previous = 100\n",
    "print_every = 100\n",
    "agents = 1\n",
    "\n",
    "for i in range(1, agents + 1): \n",
    "    print('*************************************************************')\n",
    "    print('Agent {}'.format(i))\n",
    "\n",
    "    walker_TD3 = TD3_Agent(scaling = scaling, render = False, buffer_size = 500000, batch_size = 64, gamma = 0.99, tau = 0.005, sigma = 0.1,\n",
    "                state_size = env.observation_space.shape[0], hidden_size = 64, action_size = env.action_space.shape[0], actor_lr = 0.0004, critic_lr = 0.0004)\n",
    "    agent_scores = [0]\n",
    "    agent_moving_means = [0]\n",
    "    episode = 1\n",
    "\n",
    "    while (agent_moving_means[-1] < solved or episode <= previous) and episode < 3001:\n",
    "\n",
    "        ep_reward = walker_TD3.train()\n",
    "\n",
    "        if episode == 1: \n",
    "            agent_scores[0] = ep_reward\n",
    "            agent_moving_means[0] = ep_reward\n",
    "        else:\n",
    "            agent_scores.append(ep_reward)\n",
    "            agent_moving_means.append(np.mean(agent_scores[-previous:])) \n",
    "\n",
    "        if episode % print_every == 0:\n",
    "            print('Episode: {} Score: {:.3f} \\t Mean score over last {} episodes: {:.3f}'.format(episode, ep_reward, previous, agent_moving_means[-1])) \n",
    "\n",
    "        episode += 1\n",
    "\n",
    "    episode -= 1\n",
    "    print('*********************************')\n",
    "    print('Agent {} complete \\t Mean score of agent: {:.3f}'.format(i, np.mean(agent_scores))) \n",
    "    print('{} finished in {} episodes \\t Mean score over last {} episodes: {:.3f}'.format(environment, episode, previous, agent_moving_means[-1]))\n",
    "    print('*********************************')\n",
    "\n",
    "    x = [i for i in range(1, len(agent_scores) + 1)]\n",
    "    print('Agent {} scores during training'.format(i))\n",
    "    plt.plot(x, agent_scores)\n",
    "    plt.ylabel('Score')\n",
    "    plt.xlabel('Episodes')              \n",
    "    plt.show()\n",
    "\n",
    "    x = [i for i in range(1, len(agent_moving_means) + 1)]\n",
    "    print('Agent {} mean score of last {} episodes during training'.format(i, previous))\n",
    "    plt.plot(x, agent_moving_means)\n",
    "    plt.ylabel('Mean score of last {} episodes'.format(previous))       \n",
    "    plt.xlabel('Episodes')\n",
    "    plt.show()\n",
    "    \n",
    "    print('Agent {} scores during testing'.format(i))\n",
    "    walker_TD3.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2e3beeaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:48:55.169 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff357320f20>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:48:55.170 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff372739ca0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:48:55.172 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff366524ea0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:48:55.174 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff372726ae0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 293.18009381252654\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:01.709 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c089760>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:01.712 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff35c016ba0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:01.718 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c00cea0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:01.724 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c036b20>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 289.5185655902517\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:08.633 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35313b9c0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:08.637 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3573cd0e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:08.645 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35733d8e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:08.651 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3531604e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 288.91200917984776\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:14.933 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35b66b120>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:14.933 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3727814e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:14.937 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff372708c30>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:14.944 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3564e9450>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 289.45285019371664\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:21.590 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3581ebca0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:21.591 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3581a2260>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:21.593 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3581a1060>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:21.595 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35819e220>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 289.07290917625164\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:27.973 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35cb67160>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:27.977 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3581a56e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:27.984 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff358161be0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:27.990 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35813b1a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 287.0350361518123\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:34.536 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35819e4d0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:34.539 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff358188760>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:34.547 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff358181820>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:34.552 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff358148220>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 286.4980818300712\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:40.879 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35815bd60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:40.883 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff358152860>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:40.892 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3581c5220>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:40.898 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3581c0de0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 288.79157871969534\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:47.863 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35ad1e8e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:47.865 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff35ad7eca0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:47.871 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35ad7b660>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:47.874 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35addb9e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 290.0827999945851\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:49:55.220 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff37194eea0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:55.221 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff35c053240>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:55.224 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c04a020>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:49:55.226 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c0482a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: 290.660254714617\n"
     ]
    }
   ],
   "source": [
    "environment = 'BipedalWalker-v3'\n",
    "env = gym.make(environment)\n",
    "walker_TD3.visualise()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "868098be",
   "metadata": {},
   "source": [
    "### BipedalWalkerHardcore-v3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b773b8e9",
   "metadata": {},
   "source": [
    "##### Testing the last trained agent on BipedalWalkerHardcore-v3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3adf98f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores during testing\n",
      "Mean score: -93.24818283115924\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "environment = 'BipedalWalkerHardcore-v3'\n",
    "env = gym.make(environment)\n",
    "\n",
    "scores = []\n",
    "\n",
    "for i in range(100):\n",
    "    state = env.reset()\n",
    "    terminal = False\n",
    "    ep_reward = 0\n",
    "\n",
    "    while not terminal:\n",
    "        tensor_state = torch.from_numpy(state).float()\n",
    "        action = walker_TD3.actor(tensor_state)\n",
    "        action = action.detach().numpy()\n",
    "        next_state, reward, terminal, _ = env.step(action)\n",
    "        ep_reward += reward \n",
    "        state = next_state\n",
    "\n",
    "    scores.append(ep_reward)\n",
    "\n",
    "print('Scores during testing')\n",
    "print('Mean score:', np.mean(scores))\n",
    "x = [i for i in range(1, len(scores)+1)]\n",
    "plt.plot(x, scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episodes')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bcd1a5b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:50:47.540 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff358132f60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:47.543 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360f06f00>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:47.553 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff36bb25c60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:47.559 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d09ba0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -77.95429367213791\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:50:58.587 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35f9dca90>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:58.589 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360d0c160>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:58.595 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d0f5f0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:50:58.600 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff357729ad0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -85.42166184642974\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:00.967 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360f0a4e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:00.968 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360f101a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:00.974 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360f10930>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:00.978 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d16950>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -55.696593533239025\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:05.383 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360e1f7e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:05.384 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff35f9147e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:05.391 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff359deeaa0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:05.400 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d11c60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -85.50256008219424\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:07.462 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff359d6e0e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:07.463 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff359d657e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:07.468 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff359d66a60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:07.472 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff359dba6a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -61.4331786130168\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:11.412 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360e1c1c0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:11.413 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360e26760>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:11.418 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d21410>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:11.422 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d22190>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -67.42225657970025\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:14.626 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35c00daa0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:14.627 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff35b68fd20>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:14.631 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35b686de0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:14.634 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35b683ce0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -70.72093409796305\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:17.744 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d1aa80>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:17.745 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360d2beb0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:17.749 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d2c640>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:17.752 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d2d3c0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -87.7380984782707\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:19.728 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff35f9cda40>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:19.729 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff355b0f500>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:19.733 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff355b0f7b0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:19.736 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff355b09e60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -173.42195493940287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-05 16:51:47.134 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff342f0b4f0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:47.134 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360d2f850>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:47.137 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d2ffe0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-05 16:51:47.140 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360f2c3c0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -182.08500477828005\n"
     ]
    }
   ],
   "source": [
    "environment = 'BipedalWalkerHardcore-v3'\n",
    "env = gym.make(environment)\n",
    "walker_TD3.visualise()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0190d438",
   "metadata": {},
   "source": [
    "#### Continue training the most recent TD3 BipedalWalker-v3 agent on BipedalWalkerHardcore-v3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5a815a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*************************************************************\n",
      "Agent 1\n",
      "Episode: 100 Score: -25.954 \t Mean score over last 100 episodes: -115.034\n",
      "Episode: 200 Score: -87.094 \t Mean score over last 100 episodes: -126.511\n",
      "Episode: 300 Score: -99.587 \t Mean score over last 100 episodes: -140.087\n",
      "Episode: 400 Score: -152.907 \t Mean score over last 100 episodes: -161.388\n",
      "Episode: 500 Score: -178.533 \t Mean score over last 100 episodes: -175.320\n",
      "Episode: 600 Score: -157.546 \t Mean score over last 100 episodes: -162.516\n",
      "Episode: 700 Score: -201.446 \t Mean score over last 100 episodes: -184.528\n",
      "Episode: 800 Score: -167.059 \t Mean score over last 100 episodes: -178.601\n",
      "Episode: 900 Score: -176.357 \t Mean score over last 100 episodes: -182.537\n",
      "Episode: 1000 Score: -201.526 \t Mean score over last 100 episodes: -179.289\n",
      "Episode: 1100 Score: -158.669 \t Mean score over last 100 episodes: -163.779\n",
      "Episode: 1200 Score: -164.865 \t Mean score over last 100 episodes: -166.858\n",
      "Episode: 1300 Score: -184.371 \t Mean score over last 100 episodes: -180.112\n",
      "Episode: 1400 Score: -191.128 \t Mean score over last 100 episodes: -179.733\n",
      "Episode: 1500 Score: -199.054 \t Mean score over last 100 episodes: -178.056\n",
      "Episode: 1600 Score: -176.606 \t Mean score over last 100 episodes: -178.558\n",
      "Episode: 1700 Score: -202.103 \t Mean score over last 100 episodes: -179.918\n",
      "Episode: 1800 Score: -178.236 \t Mean score over last 100 episodes: -183.104\n",
      "Episode: 1900 Score: -172.061 \t Mean score over last 100 episodes: -191.533\n",
      "Episode: 2000 Score: -188.258 \t Mean score over last 100 episodes: -189.860\n",
      "Episode: 2100 Score: -211.451 \t Mean score over last 100 episodes: -193.099\n",
      "Episode: 2200 Score: -206.211 \t Mean score over last 100 episodes: -200.239\n",
      "Episode: 2300 Score: -178.683 \t Mean score over last 100 episodes: -180.284\n",
      "Episode: 2400 Score: -181.982 \t Mean score over last 100 episodes: -195.586\n",
      "Episode: 2500 Score: -213.684 \t Mean score over last 100 episodes: -163.006\n",
      "Episode: 2600 Score: -202.673 \t Mean score over last 100 episodes: -187.305\n",
      "Episode: 2700 Score: -207.858 \t Mean score over last 100 episodes: -202.176\n",
      "Episode: 2800 Score: -213.134 \t Mean score over last 100 episodes: -199.472\n",
      "Episode: 2900 Score: -214.613 \t Mean score over last 100 episodes: -214.088\n",
      "Episode: 3000 Score: -184.720 \t Mean score over last 100 episodes: -199.310\n",
      "*********************************\n",
      "Agent 1 complete \t Mean score of agent: -177.729\n",
      "BipedalWalkerHardcore-v3 finished in 3000 episodes \t Mean score over last 100 episodes: -199.310\n",
      "*********************************\n",
      "Agent 1 scores during training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 1 mean score of last 100 episodes during training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores during testing\n",
      "Mean score: -174.87711348909954\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create deep copy to not overwrite walker_TD3\n",
    "hardcore_adapt_TD3 = copy.deepcopy(walker_TD3)\n",
    "\n",
    "if environment == 'Pendulum-v1':\n",
    "    scaling = 2\n",
    "    solved = -100\n",
    "elif environment =='BipedalWalker-v3' or 'BipedalWalkerHardcore-v3':\n",
    "    scaling = 1\n",
    "    solved = 300 \n",
    "\n",
    "previous = 100\n",
    "print_every = 100\n",
    "\n",
    "print('*************************************************************')\n",
    "print('Agent 1')\n",
    "\n",
    "agent_scores = [0]\n",
    "agent_moving_means = [0]\n",
    "episode = 1\n",
    "\n",
    "while (agent_moving_means[-1] < solved or episode <= previous) and episode < 3001:\n",
    "\n",
    "    ep_reward = hardcore_adapt_TD3.train()\n",
    "\n",
    "    if episode == 1: \n",
    "        agent_scores[0] = ep_reward\n",
    "        agent_moving_means[0] = ep_reward\n",
    "    else:\n",
    "        agent_scores.append(ep_reward)\n",
    "        agent_moving_means.append(np.mean(agent_scores[-previous:])) \n",
    "\n",
    "    if episode % print_every == 0:\n",
    "        print('Episode: {} Score: {:.3f} \\t Mean score over last {} episodes: {:.3f}'.format(episode, ep_reward, previous, agent_moving_means[-1])) \n",
    "\n",
    "    episode += 1\n",
    "\n",
    "episode -= 1\n",
    "print('*********************************')\n",
    "print('Agent 1 complete \\t Mean score of agent: {:.3f}'.format(np.mean(agent_scores))) \n",
    "print('{} finished in {} episodes \\t Mean score over last {} episodes: {:.3f}'.format(environment, episode, previous, agent_moving_means[-1]))\n",
    "print('*********************************')\n",
    "\n",
    "x = [i for i in range(1, len(agent_scores) + 1)]\n",
    "print('Agent 1 scores during training')\n",
    "plt.plot(x, agent_scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episodes')              \n",
    "plt.show()\n",
    "\n",
    "x = [i for i in range(1, len(agent_moving_means) + 1)]\n",
    "print('Agent 1 mean score of last {} episodes during training'.format(previous))\n",
    "plt.plot(x, agent_moving_means)\n",
    "plt.ylabel('Mean score of last {} episodes'.format(previous))       \n",
    "plt.xlabel('Episodes')\n",
    "plt.show()\n",
    "\n",
    "print('Scores during testing')\n",
    "hardcore_adapt_TD3.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1d67cffe",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:13:21.683 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339c7d360>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:21.684 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3390ec760>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:21.687 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3390d9860>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:21.690 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339351ea0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -171.27851557538852\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:13:45.962 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339f62b20>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:45.963 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3393ef860>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:45.967 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff33901c5d0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:13:45.970 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3390fd9a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -183.41718249282653\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:14:07.647 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360f27ae0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:07.649 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3390c01a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:07.651 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339c816a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:07.654 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff33915a9e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -170.16165324722886\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:14:27.569 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360f24d20>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:27.569 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff3397278e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:27.572 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff363d214e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:27.575 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339f699c0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -171.3538439348933\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:14:49.705 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3397384e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:49.706 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff339f10ba0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:49.709 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339f0ccd0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:14:49.711 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff33a231be0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -201.93234045945272\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:15:09.979 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339ab0420>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:09.980 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff339afebe0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:09.982 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339a4a7a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:09.984 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339a45920>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -202.25014071281845\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:15:27.232 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339ad3fa0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:27.232 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff360e28830>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:27.234 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360e2fc90>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:27.238 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360e30160>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -200.42952011093266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:15:44.482 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339bd86a0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:44.482 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff33a6cd460>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:44.485 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff33a6fe1e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:15:44.487 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360d78620>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -183.14145414035278\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:16:03.827 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339c7a560>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:03.831 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff33a1bf460>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:03.838 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff33a1fbc60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:03.845 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3394db5e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -184.232114501269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-06 07:16:29.994 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff360e1afd0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:29.995 python[1109:8020] Warning: Expected min height of view: (<NSButton: 0x7ff359d179e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:29.997 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff3391a31e0>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n",
      "2022-05-06 07:16:30.005 python[1109:8020] Warning: Expected min height of view: (<NSPopoverTouchBarItemButton: 0x7ff339772e60>) to be less than or equal to 30 but got a height of 32.000000. This error will be logged once per view in violation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode reward: -202.77484273287382\n"
     ]
    }
   ],
   "source": [
    "environment = 'BipedalWalkerHardcore-v3'\n",
    "env = gym.make(environment)\n",
    "hardcore_adapt_TD3.visualise()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}