level2_youngdriver.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![McLaren Maze Race Banner](media/banner.png)\n",
    "\n",
    "# Welcome to Young Driver - level 2 of the McLaren Maze Race!\n",
    "\n",
    "In this level, things take a serious step up from the Learner Driver level. Firstly the mazes are a lot larger and more complex than those you have encoutnered so far. In particular, they contain choices of direction at certain turns; one direction is correct and one leads to a dead end. Let's take a look at one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5b242713aeba4a20979886cb03047c5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib widget\n",
    "from imports import * \n",
    "\n",
    "track = TrackStore.load_track(level=Level.Young, index=1)  # provide the level and, optionally, an index. If no index\n",
    "                                                             # is provided a random track will be loaded.\n",
    "track.plot_track();                      # a useful method to display the track"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that some of the turns have only one way to go but several of them have two. A simple starting strategy would be to just choose a direction randomly. If we get it wrong then the driver will need to learn to brake to a halt then turn around and head back in the other direction. To build a true race-winning AI, however, we will need to figure out a way of choosing the right direction - more on this later!\n",
    "\n",
    "### Safety Car\n",
    "Now let's consider the second challenge of level 2: safety cars. No driver is allowed out on track without understanding the rules of the safety car. In our Maze Race, the rules are as follows:\n",
    "- A safety car can be deployed by Race Control at any point\n",
    "- Drivers will be notified that a safety car is active via the `TrackState.safety_car_active` variable passed to the `Driver.make_a_move` method\n",
    "- When the safety car is active no driver may exceed the safety car speed\n",
    "- Any driver who does exceed this speed will be given a penalty that increases in severity each turn the driver breaks the speed limit\n",
    "- The safety car will be withdrawn after a certain number of moves\n",
    "- Feedback on whether the current car speed is acceptable will be given to the driver via the `ActionResult.safety_car_speed_exceeded` field passed to the driver after each move\n",
    "- Critically, **the driver is not told what the safety car speed is!** The AI must work out what this is by itself.\n",
    "- Furthermore, **the safety car speed will be different each time it is deployed**. Driver's which can quickly figure out the right speed to drive at will gain a benefit- The current penalty level a driver is at is reported to the driver in the `ActionResult.safety_car_penalty_level` field. A wise driver will adapt their behaviour depending on the current penalty level.\n",
    "\n",
    "The safety car rules need to be taken seriously. The penalties will quickly build up and ruin our driver's chances if our AI doesn't adapt to the deployment of a safety car. A simple way of handling the safety car would be to add the deployment status to our state vector, i.e.,\n",
    "<p style=\"text-align: center;\"> state = [rounded speed, distance ahead, safety car deployed]</p>\n",
    "\n",
    "However, this has some big downsides. Firstly, it increases the size of the state space: the Q table will now have 3 dimensions and the driver has to learn what to do in every state with and without the safety car deployed. Secondly, as the safety car speed changes each time it is deployed our Q table would be incorrect for a new safety car and we would need to learn everything again. This won't give us the rapid adaptation that we need.\n",
    "\n",
    "Instead, let's introduce a single new variable that our AI needs to learn: `safety_car_speed`. Then in `make_a_move`, if the safety car is deployed and we are going above this speed, we know we need to brake. \n",
    "\n",
    "    def make_a_move(self, car_state: CarState, track_state: TrackState):\n",
    "        if track_state.safety_car_active:\n",
    "            if car_state.speed > self.safety_car_speed:     # safety car active and we are above speed\n",
    "                return Action.LightBrake                    # ignore everything else and LightBrake\n",
    "\n",
    "        # Safety car not active, or we are under the speed already - use Q table to determine action\n",
    "        return super().make_a_move(car_state, track_state)\n",
    "\n",
    "But how can we learn what the speed is? Well the simplest approach is to start with it set to an arbitrary value, then, if we receive a safety car penalty we can decrease the learnt `safety_car_speed` to the speed we were travelling when we were penalised. Conversely, if we didn't receive any penalty then we know that this is a safe speed.\n",
    "\n",
    "    if previous_track_state.safety_car_active:\n",
    "        if result.safety_car_speed_exceeded:  # we ended up going too fast so safe speed must be below current speed\n",
    "            self.safety_car_speed = min(self.safety_car_speed, new_car_state.speed - 1)\n",
    "        else:                                 # our current speed is safe so safe speed must be higher\n",
    "            self.safety_car_speed = max(self.safety_car_speed, new_car_state.speed + 1)\n",
    "\n",
    "This approach can definitely be improved though. For example, if we are currently under the safe speed then we ignore the safety car and take an action as normal, an action that could easily push us back over the speed limit. It also doesn't allow the AI to choose whether to apply heavy or light braking, something that can make a big difference depending on the driver's current speed. This approach doesn't take the penalty level into account. Whilst the penalty is low, it might be worthwhile for the driver to try and push the speed higher to try and find the limit whereas if the penalty level is high it would probably be better for the driver to play it safe and decrease speed significantly. It is up to you to take up this challenge and build a better AI!\n",
    "\n",
    "For now, let's try it out by making use of the `safety_car_sim`. This trains the driver on a simple straight and then turns the safety car on to see how the driver reacts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from drivers.youngdriver import YoungDriver\n",
    "\n",
    "driver_name = 'Laniel'\n",
    "set_seed(0)\n",
    "car = Car.get_car_for_level(Level.Young)    # do this explicitly now for random seed control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running safety car sim...\n",
      "Safety car deployed for 50 turns at 100 speed\n",
      "\tDecreasing estimate of safety car speed to  109.0\n",
      "\tCar speed of 118.97572783105288 above current safety car estimate of 108.97572783105288 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  96.6\n",
      "\tCar speed of 106.64583009627147 above current safety car estimate of 96.64583009627147 so applying the brakes.\n",
      "Safety car speed estimate of  96.6 already below car speed of  125.7\n",
      "\tCar speed of 125.73448547481658 above current safety car estimate of 96.64583009627147 so applying the brakes.\n",
      "Safety car speed estimate of  96.6 already below car speed of  112.7\n",
      "\tCar speed of 112.7041525161371 above current safety car estimate of 96.64583009627147 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  91.0\n",
      "\tCar speed of 101.02420148627266 above current safety car estimate of 91.02420148627266 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  91.6\n",
      "Safety car speed estimate of  91.6 already below car speed of  108.6\n",
      "\tCar speed of 108.63763992227742 above current safety car estimate of 91.55468727718551 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  98.4\n",
      "Safety car speed estimate of  98.4 already below car speed of  127.3\n",
      "\tCar speed of 127.25661149257263 above current safety car estimate of 98.37911673600381 so applying the brakes.\n",
      "Safety car speed estimate of  98.4 already below car speed of  114.1\n",
      "\tCar speed of 114.06853494635207 above current safety car estimate of 98.37911673600381 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  92.2\n",
      "\tCar speed of 102.24718788435264 above current safety car estimate of 92.24718788435264 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  92.7\n",
      "Safety car speed estimate of  92.7 already below car speed of  122.4\n",
      "\tCar speed of 122.37307633517632 above current safety car estimate of 92.65093104049238 so applying the brakes.\n",
      "Safety car speed estimate of  92.7 already below car speed of  109.7\n",
      "\tCar speed of 109.69109872335699 above current safety car estimate of 92.65093104049238 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  99.3\n",
      "Safety car speed estimate of  99.3 already below car speed of  128.1\n",
      "\tCar speed of 128.061656747808 above current safety car estimate of 99.3234016784997 so applying the brakes.\n",
      "Safety car speed estimate of  99.3 already below car speed of  114.8\n",
      "\tCar speed of 114.7901503638392 above current safety car estimate of 99.3234016784997 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  92.9\n",
      "\tCar speed of 102.89401960886592 above current safety car estimate of 92.89401960886592 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  93.2\n",
      "Safety car speed estimate of  93.2 already below car speed of  122.9\n",
      "\tCar speed of 122.8673802512113 above current safety car estimate of 93.23072918462542 so applying the brakes.\n",
      "Safety car speed estimate of  93.2 already below car speed of  110.1\n",
      "\tCar speed of 110.13417608381025 above current safety car estimate of 93.23072918462542 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  99.7\n",
      "Safety car speed estimate of  99.7 already below car speed of  128.4\n",
      "\tCar speed of 128.40025311851522 above current safety car estimate of 99.72056128209131 so applying the brakes.\n",
      "Safety car speed estimate of  99.7 already below car speed of  115.1\n",
      "\tCar speed of 115.09365673173411 above current safety car estimate of 99.72056128209131 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  93.2\n",
      "\tCar speed of 103.16607248161338 above current safety car estimate of 93.16607248161338 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  93.5\n",
      "Safety car speed estimate of  93.5 already below car speed of  123.1\n",
      "\tCar speed of 123.0752810007746 above current safety car estimate of 93.4745882050588 so applying the brakes.\n",
      "Safety car speed estimate of  93.5 already below car speed of  110.3\n",
      "\tCar speed of 110.32053130448432 above current safety car estimate of 93.4745882050588 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  99.9\n",
      "Safety car speed estimate of  99.9 already below car speed of  128.5\n",
      "\tCar speed of 128.54266436994553 above current safety car estimate of 99.88760381726942 so applying the brakes.\n",
      "Safety car speed estimate of  99.9 already below car speed of  115.2\n",
      "\tCar speed of 115.22130937484633 above current safety car estimate of 99.88760381726942 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  93.3\n",
      "\tCar speed of 103.28049600594782 above current safety car estimate of 93.28049600594782 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  93.6\n",
      "Safety car speed estimate of  93.6 already below car speed of  123.2\n",
      "\tCar speed of 123.16272259342004 above current safety car estimate of 93.57715359345899 so applying the brakes.\n",
      "Safety car speed estimate of  93.6 already below car speed of  110.4\n",
      "\tCar speed of 110.3989109992558 above current safety car estimate of 93.57715359345899 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  100.0\n",
      "Safety car speed estimate of  100.0 already below car speed of  128.6\n",
      "\tCar speed of 128.60256154040718 above current safety car estimate of 99.95786073238968 so applying the brakes.\n",
      "Safety car speed estimate of  100.0 already below car speed of  115.3\n",
      "\tCar speed of 115.27499917847898 above current safety car estimate of 99.95786073238968 so applying the brakes.\n",
      "\tDecreasing estimate of safety car speed to  93.3\n",
      "\tCar speed of 103.32862173529189 above current safety car estimate of 93.32862173529189 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  93.6\n",
      "Safety car speed estimate of  93.6 already below car speed of  123.2\n",
      "\tCar speed of 123.19949991211868 above current safety car estimate of 93.62029187425333 so applying the brakes.\n",
      "Safety car speed estimate of  93.6 already below car speed of  110.4\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4824c68102594762a13c8a0cb7916f1e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complete\n"
     ]
    }
   ],
   "source": [
    "driver = YoungDriver(driver_name, random_action_probability=1, random_action_decay=0.99, max_distance=1, batch_learn=False)\n",
    "\n",
    "# Run the safety car sim\n",
    "set_seed(0)\n",
    "car_speed, safety_car_estimate, safety_car_true, safety_car_penalty = safety_car_sim(driver, level=Level.Young)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the driver is able to estimate the safety car speed to a reasonable accuracy quite quickly. The AI will slow the car down if it is travelling faster than the estimated safety car speed, however, as soon as the driver is below the required speed it accelerates again and so keeps incurring a penalty. To improve this we need some way of predicting whether we are going to break the speed cap next turn if we apply an action - we will introduce this at the next level. For the moment, we could add a margin to the safety car limit and prevent the driver from acelerating within this; or perhaps you can think of something better? We leave this in your hands!\n",
    "\n",
    "### Learning to navigate\n",
    "Now we have some sort of strategy in place for the safety car, let's return to the problem of figuring out which way to turn at a branch point. Making a wrong turn and ending up in a dead end isn't a race ending mistake because, once we have turned around, we will be facing the right direction and will be swiftly back on track. Still, the time lost taking a dead end route might cost you victory.\n",
    "\n",
    "Our problem is that the state doesn't give us enough information to work out which is the correct direction - we only get the length of the straight to the left and the right. If we are to be able to do better than random guessing there needs to be some structure in the distribution of correct turn directions that we can learn and exploit. A common approach in this situation is to create some exploratory plots to see if we can find any relationshio that we can use. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "50435abf4e824340a4305c2e0bf690da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "left_turn_positions = []\n",
    "right_turn_positions = []\n",
    "for track in TrackStore.load_all_tracks(level=Level.Young):\n",
    "    for position, turn_action in track.correct_turns.items():\n",
    "        if Action.TurnLeft == turn_action:\n",
    "            left_turn_positions.append((position.row, position.column))\n",
    "        else:\n",
    "            right_turn_positions.append((position.row, position.column))\n",
    "left_turn_positions = np.array(left_turn_positions)\n",
    "right_turn_positions = np.array(right_turn_positions)\n",
    "            \n",
    "fig = plt.figure()\n",
    "plt.plot(left_turn_positions[:, 1], left_turn_positions[:, 0], 'r+')\n",
    "plt.plot(right_turn_positions[:, 1], right_turn_positions[:, 0], 'g+')\n",
    "plt.legend(['Left turns', 'Right turns'], fontsize=14);\n",
    "fig.gca().invert_yaxis()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the correct direction to turn is stongly clustered across all the tracks - the turns in one area of the maze are always in the the same direction. We can't guarantee that the exact mapping from position to turn direction will be the same at different levels and in the Challenge (hint - it won't) so we need our AI driver to be able to learn and adapt as it sees where the correct turns are. The easiest way of implementing this is to use a *nearest neighbour* model. For this, we need to record the position of each correct turn. Helpfully, after each race our driver is given the positions of all the correct turns to learn from, so we can implement our learning like this,\n",
    "\n",
    "    def update_after_race(self, correct_turns: Dict[Position, Action]):\n",
    "        # Called after the race by RaceControl\n",
    "        self.correct_turns.update(correct_turns)            # dictionary mapping Position -> TurnLeft or TurnRight\n",
    "\n",
    "\n",
    "Then when we have to make a decision we will look for the closest turn we have previously recorded and choose the same action as that:\n",
    "\n",
    "    def _choose_turn_direction(self, track_state: TrackState):\n",
    "        # Check if we need to make a decision about which way to turn\n",
    "        if track_state.distance_left > 0 and track_state.distance_right > 0:  # both options available, need to decide\n",
    "            if len(self.correct_turns) > 0:\n",
    "                # Find the closest turn we have seen previously and turn in the same direction\n",
    "                distances = np.array([track_state.position.distance_to(turn_position)\n",
    "                                      for turn_position in self.correct_turns])           # Euclidean distance\n",
    "                i_closest = np.argmin(distances)\n",
    "                return list(self.correct_turns.values())[i_closest]\n",
    "            else:  # First race, no data yet so choose randomly\n",
    "                return np.random.choice([Action.TurnLeft, Action.TurnRight])\n",
    "\n",
    "Let's test this out by running our driver over a number of tracks to populate our correct turns list, and then watching the driver over a final track."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x500 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Safety car deployed for 12 turns at 100 speed\n",
      "\tCar speed of  144.0 exceeds safety car, penalty is now 1\n",
      "\tDecreasing estimate of safety car speed to  134.0\n",
      "\tCar speed of 144.00249415430264 above current safety car estimate of 134.00249415430264 so applying the brakes.\n",
      "\tCar speed of  129.1 exceeds safety car, penalty is now 2\n",
      "\tDecreasing estimate of safety car speed to  119.1\n",
      "\tCar speed of 129.078979427019 above current safety car estimate of 119.078979427019 so applying the brakes.\n",
      "\tCar speed of  115.7 exceeds safety car, penalty is now 3\n",
      "\tDecreasing estimate of safety car speed to  105.7\n",
      "\tCar speed of 115.70204410534487 above current safety car estimate of 105.70204410534487 so applying the brakes.\n",
      "\tCar speed of  103.7 exceeds safety car, penalty is now 4\n",
      "\tDecreasing estimate of safety car speed to  93.7\n",
      "\tCar speed of 103.71141040609275 above current safety car estimate of 93.71141040609275 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  94.0\n",
      "\tCar speed of  115.3 exceeds safety car, penalty is now 5\n",
      "Safety car speed estimate of  94.0 already below car speed of  115.3\n",
      "\tCar speed of 115.27848398716375 above current safety car estimate of 93.96341072961326 so applying the brakes.\n",
      "\tCar speed of  103.3 exceeds safety car, penalty is now 6\n",
      "\tDecreasing estimate of safety car speed to  93.3\n",
      "\tCar speed of 103.3317454002754 above current safety car estimate of 93.3317454002754 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  93.6\n",
      "\tCar speed of  123.2 exceeds safety car, penalty is now 7\n",
      "Safety car speed estimate of  93.6 already below car speed of  123.2\n",
      "Safety car no longer active\n",
      "Safety car deployed for 12 turns at 135 speed\n",
      "\tIncreasing estimate of safety car speed to  105.6\n",
      "\tIncreasing estimate of safety car speed to  124.6\n",
      "\tCar speed of  149.6 exceeds safety car, penalty is now 8\n",
      "Safety car speed estimate of  124.6 already below car speed of  149.6\n",
      "\tCar speed of 149.62190960082 above current safety car estimate of 124.61269068816011 so applying the brakes.\n",
      "\tIncreasing estimate of safety car speed to  135.1\n",
      "Safety car no longer active\n",
      "Race completed\n"
     ]
    }
   ],
   "source": [
    "driver = YoungDriver(driver_name)\n",
    "season = Season(Level.Young)\n",
    "set_seed(1)\n",
    "driver, *_ = season.race(driver=driver, track_indices=range(23))          # run over several tracks to train\n",
    "set_seed(1)\n",
    "driver, *_ = season.race(driver=driver, track_indices=[23], plot=True)    # watch the next track\n",
    "print('Race completed')\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, our AI made the right turn almost every time. If you check the places where the AI made a wrong turn against the scatter plot above you will usually see that they lie near the boundary between a left and right turn region. As we don't know the exact boundaries of the regions (which might be more complex in the online Challenge) and the driver will start off knowing nothing, there is always a possibility that the AI will make a wrong turn. This means that we need to be able to handle going down a dead end branch. We do have a way of measuring our confidence in a particular turn though - if a branch is very close in position to a branch we have seen before we can be pretty confident of the correct direction. However, if the the branch position is far away from all other points, or if it is close to both turn left and turn right points, then it is more likely that our choice will be wrong. We leave it up to you to find a way to use this if you want to!\n",
    "\n",
    "## State Space\n",
    "It looks like our driver is still crashing even after racing on a number of different tracks. This suggests that our AI hasn't converged to a good solution yet and is still learning. Preventing the car from crashing is the first thing that the driver learns because crashing has such a high penalty. If the driver does crash it usually means that the driver has come across a state that it has rarely visited before and so it hasn't learnt how to avoid crashing. This suggests that the AI might not have explored the state space very well - there might be a lot of states where the AI has very little experience. We can investigate this by looking at the `state_counts` variable in our driver class, which records the number of times the AI has visited each state. Let's first check how many states our driver has visited relative to the total number of states in the space. Recall that our state is made up of two variables: the (rounded) car speed and the distance ahead of the car to the end of the straight. With speed rounding set to 10 and a max speed of 300, there are 31 different values that speed can take in our state. The total state space size is thus 31 times the longest straight that our driver has come across:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total state space has 1488 states in it.\n",
      "Driver has visited 333 states, 22.4%\n"
     ]
    }
   ],
   "source": [
    "max_num_states = 31 * max(state[1] for state in driver.state_counts.keys())\n",
    "num_visited = len(driver.state_counts)\n",
    "print(f'Total state space has {max_num_states} states in it.')\n",
    "print(f'Driver has visited {num_visited} states, {num_visited / max_num_states * 100:.1f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the majority of the state space hasn't been visited at all. We can check the number of times each of states that the AI has been to have been visited:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4536e4727d8e4dccbf486583646e5970",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n, e = np.histogram(list(driver.state_counts.values()), [0, 10, 50, 100, 200, 300])\n",
    "fig = plt.figure()\n",
    "x = np.arange(len(n))\n",
    "plt.bar(x, n / np.sum(n) * 100)\n",
    "fig.gca().set_xticks(x)\n",
    "fig.gca().set_xticklabels(['1-10', '10-50', '50-100', '100-200', '200+'])\n",
    "plt.ylabel('Percentage of visited states', fontsize=16);\n",
    "plt.xlabel('Number of times visited state', fontsize=16);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The histogram suggests that most of the states that are visited are visited less than 10 times. So on top of only exploring a few states of the states that the AI does visit it spends the majority of time in just a handful of states. Now, this might not be a problem if the AI has correctly identifed these states as being the only important ones but given our driver still experiences the occaisional crash we suspect that it is missing some important states. \n",
    "\n",
    "Ideally we would keep racing on more tracks but the season only has 24 tracks in it. This means we need to improve our AI's learning efficiency so that it can improve quicker. One way to improve state space coverage is with a better exploration algorithm. For example, rather than just randomly choosing an action from time-to-time, we could boost the chance of choosing actions that we have never (or rarely) tried in a particular state. Another step that might help is to reduce the number of states. We can reduce the state space size by increasing the level of rounding on the car speed and by saturating the distance ahead. Increasing the car rounding means our AI can't apply some finer speed control but that might be outweighed by better learning. The distance ahead of the car probably only matters when the driver is getting close to the end of the straight. When there is still enough space ahead of the driver to enable the AI to brake for the corner then it can just ignore the actual distance. This means we could reduce the state space by collapsing all distances above a certain value to this max distance.\n",
    "\n",
    "### Learning Rate\n",
    "If we reduce the state space like this then we need to consider the *learning rate* parameter. The learning rate controls how we combine new knowledge with the knowledge we have already accrued. Up to now we have been using a learning rate of 1, which means that, for each state, we throw away any Q value that we have previously learnt and replace it with the newly calculated value. This is the right strategy to take if the true Q value of a state is fixed, in which case the new value is the best estimate of the true Q value. However, if we have a large amount of speed rounding then it is likely the maximum safe cornering speed will fall somewhere in the middle of the speed range in a single state. This means that the same state and action can lead to different rewards. \n",
    "\n",
    "![Conflicting rewards](media/conflicting_rewards.PNG)\n",
    "\n",
    "If the learning rate is set to 1 then the AI will only really remember whatever happened the last time it was in the state. This can lead to the driver oscillating controls: \"the state is fine\", \"the state is too fast\", \"the state is fine\", etc. We want our driver to remember that the state can lead to a crash even if it didn't happen the last time. This can be done with the learning rate. \n",
    "\n",
    "<p style=\"text-align: center;\">Q value   =   learning rate  *  new Q value  +  ( 1 - learning rate )  *  old Q value </p>\n",
    "\n",
    "For example, if the learning rate is set to 0.5 the new Q value for a state and action pair will be set to a 50/50 combination of the old value and the new value. Thus, a small learning rate value gives the AI a long 'memory' but makes it slow to adapt to new situations, whereas a learning rate close to 1 means the AI adapts very quickly by forgetting previous rewards.\n",
    "\n",
    "Let's create a driver with a higher speed rounding, distance saturation, and a lower learning rate and test it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x500 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Safety car deployed for 12 turns at 100 speed\n",
      "\tCar speed of 237.03175374777135 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  212.5 exceeds safety car, penalty is now 1\n",
      "Safety car speed estimate of  100.9 already below car speed of  212.5\n",
      "\tCar speed of 212.46727041251484 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  190.4 exceeds safety car, penalty is now 2\n",
      "Safety car speed estimate of  100.9 already below car speed of  190.4\n",
      "\tCar speed of 190.44849596219615 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  170.7 exceeds safety car, penalty is now 3\n",
      "Safety car speed estimate of  100.9 already below car speed of  170.7\n",
      "\tCar speed of 170.71160910497684 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  153.0 exceeds safety car, penalty is now 4\n",
      "Safety car speed estimate of  100.9 already below car speed of  153.0\n",
      "\tCar speed of 153.02012933194897 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  137.2 exceeds safety car, penalty is now 5\n",
      "Safety car speed estimate of  100.9 already below car speed of  137.2\n",
      "\tCar speed of 137.16208348998424 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  122.9 exceeds safety car, penalty is now 6\n",
      "Safety car speed estimate of  100.9 already below car speed of  122.9\n",
      "\tCar speed of 122.94746599319049 above current safety car estimate of 100.85493858083538 so applying the brakes.\n",
      "\tCar speed of  110.2 exceeds safety car, penalty is now 7\n",
      "\tDecreasing estimate of safety car speed to  100.2\n",
      "\tCar speed of 110.20596224211283 above current safety car estimate of 100.20596224211283 so applying the brakes.\n",
      "Safety car no longer active\n"
     ]
    }
   ],
   "source": [
    "driver = YoungDriver(driver_name, speed_rounding=40, max_distance=8, learning_rate=0.25)\n",
    "\n",
    "season = Season(Level.Young)\n",
    "set_seed(1)\n",
    "driver, *_ = season.race(driver=driver, track_indices=range(23))          # run over several tracks to train\n",
    "set_seed(1)\n",
    "driver, *_ = season.race(driver=driver, track_indices=[23], plot=True)    # watch the next track\n",
    "plt.close()    # cell keeps running for a while otherwise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That seems to have improved performance and reduced crashes. But is it overall faster? One way of testing this is to put the drivers head-to-head in a championship, similar to how the online challenge will be run. The drivers race the same mazes at the same time (with the same safety cars, etc). At the end of each race the drivers are cassified according to their race times, with the fastest race time winning and being assigned position 1. At the end of the season's races the drivers' positions are added up and the driver with the smallest total score (i.e. best average finishing position) is the champion.\n",
    "\n",
    "Of course, our drivers are affected by random choices so to perform a thorough comparison we need to run the championship several times. We can do this like so (this will take a couple of minutes to run):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3917158c2fa84856ac174fb7aa62314f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "drivers = [\n",
    "    YoungDriver('base_driver'),\n",
    "    YoungDriver('small_state_space', speed_rounding=40, max_distance=8, learning_rate=0.25)\n",
    "    ]\n",
    "\n",
    "num_repeats = 20\n",
    "championship = Championship(drivers, Level.Young)\n",
    "championship_results, race_results, race_times = championship.run_championship(num_repeats=num_repeats)\n",
    "\n",
    "# Plot the results as a coloured heatmap. \n",
    "# > colour represents championship position\n",
    "# > transparency indicates the percentage of times a driver scored a particular position\n",
    "# > dark green squares are best!\n",
    "# > sums across rows can > 100% due to seasons ending as draws\n",
    "plot_multiple_championship_results(championship_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the driver with the reduced state space wins more often (note, the percentages are normalised for each driver). You might like to extend the driver list to test out various parameterisations and see if you can improve the driver AI even more!\n",
    "\n",
    "# We hope to see you in Level 3: Rookie Driver\n",
    "This is the end of the Young Driver level. In the next level, Rookie Driver, we will introduce a completely different reinforecement learning algorithm based on a model that will give us a step forward in performance. We also add in DRS! We hope to see you there."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Playground\n",
    "If you want to play around with the driver class in this notebook, this class might be helpful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class MyYoungDriver(YoungDriver):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        \n",
    "    def make_a_move(self, car_state: CarState, track_state: TrackState):\n",
    "        return super().make_a_move(car_state, track_state)\n",
    "        \n",
    "    def _choose_randomly(self, available_actions: List[Action]):\n",
    "        super()._choose_randomly(available_actions)\n",
    "    \n",
    "    def update_with_action_results(self, previous_car_state: CarState, previous_track_state: TrackState,\n",
    "                                   action: Action, new_car_state: CarState, new_track_state: TrackState,\n",
    "                                   result: ActionResult):\n",
    "        super().update_with_action_results(previous_car_state, previous_track_state, \n",
    "                                           action, new_car_state, new_track_state, result)\n",
    "    \n",
    "    def _update_safety_car(self, new_car_state: CarState, result: ActionResult):\n",
    "        super()._update_safety_car(new_car_state, result)\n",
    "\n",
    "my_driver = MyYoungDriver(driver_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "race(driver=my_driver, level=Level.Young)\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_q_table(driver)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}