1_research.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Autonomous Vehicles using Augmented Random Search (ARS) in Carla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outline\n",
    "[Project Abstract](#abstract)<br>\n",
    "The abstract of the project, summarizing the goals, research, methodology, and conclusion.\n",
    "\n",
    "[The Math Behind ARS](#ars_math)<br>\n",
    "This section explains the mechanics of the ARS learning process.\n",
    "\n",
    "[Testing Car Environment with ARS](#testing_environment)<br>\n",
    "This section involves testing a modified version of Sentdex's Carla 'CarEnv' environment in the [framework for ARS learning provided by Colin Skow](https://github.com/colinskow/move37/tree/master/ars), which has also been modified to make use of the environment.<br>\n",
    "\n",
    "[Parallel Training using Ray](notebook2_train_agent.ipynb)<br>\n",
    "This notebook makes use of a version of the [ARS framework made available by the authors of the 2018 ARS paper](https://github.com/modestyachts/ARS) that has been modified to make use of the modified Sentdex 'CarEnv' environment in a parallel fashion using a Ray cluster. This allows multiple workers to explore deltas simultaneously and pool the results of their rollouts at each update step, leading to faster training of the agent.\n",
    "\n",
    "[Analysis of Results and Conclusions](notebook3_results_analysis.ipynb)<br>\n",
    "This notebook reviews and analyzes the results obtained from the first round of training, and provides the conclusions of this study."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract\n",
    "[Carla](https://carla.org/) is an open source driving simulator with a Python API used for autonomous driving research. Built on Unreal Engine 4, it employs high-end graphics to provide a suitable representation of the real world conducive for reinforcement learning with camera data. This research sought to test the ability of the [Augmented Random Searching (ARS) algorithm](https://arxiv.org/pdf/1803.07055.pdf) to train a self-driving car policy on the data gathered from a single front-facing camera per car. ARS is an exciting new algorithm for reinforcement learning (RL) proposed in 2018 by Mania, Guy, and Recht, which has been shown to achieve competitive results on benchmark MuJoCo continuous control locomotion tasks compared to more complex model-free methods, while offering at least 15x more computational efficiency. This significant reduction in computational resource requirements makes it an attractive algorithm for small-scale autonomous vehicle research, and so it was chosen for this study. \n",
    "\n",
    "Code for usable car environment for this task was derived from a [Sentdex tutorial on using Carla for Deep Q-Learning](https://pythonprogramming.net/introduction-self-driving-autonomous-cars-carla-python/) and modified to fit the context of ARS learning. The modified environment was then tested by splicing it into [ARS code provided by Colin Skow](https://github.com/colinskow/move37/tree/master/ars) as a part of his course on RL. Once the environment was functional with ARS learning, the ability to train in parallel was achieved by modifying the [code provided by the authors of the ARS study](https://github.com/modestyachts/ARS) to make use of this car environment. This allowed testing of the efficacy of this efficient learning algorithm on training autonomous vehicles using camera data from Carla. To convert the raw RGB camera data into feature space, it was first passed through the pretrained VGG19 convolutional neural network using imagenet weights, without the top layer.\n",
    "\n",
    "A reward system was devised which penalized collisions, extreme steering control values, and sitting stationary, while rewarding traveling at speed especially when moving in straight lines. Much experimentation was done in creating this reward system, but it is likely that more adjustments need to be made in the future to facilitate the learning process.\n",
    "\n",
    "Even despite the simplicity of the ARS algorithm, the personal computer used for training was only able to handle training with 4 workers in parallel due to the high computational demands of the Carla simulator, and this led to the process of learning being slow. Testing a range of hyperparameter values for learning rate, number of deltas tested/used, and delta std would require multiple deployments of a multi-day training process, and it is understandable that optimal balance of these parameter values for this task has not been found by this study, which only represents the first attempt at training using this framework. Instructions for running the parallelized training process can be found in the '[notebook2_train_agent](notebook2_train_agent.ipynb)' notebook.\n",
    "\n",
    "An in-depth review and analysis of the results of the training can be found in the '[notebook3_results_analysis](notebook3_results_analysis.ipynb)' notebook in this repository, along with the conclusions of this study. In summary, the first 5-day round of training did not lead to a noticably improving policy for the agent by the end of the 1250 iteration training period. It is possible that the learning rate and delta std was set too high for this task, and further testing using different values is needed. It may also be necessary to control the variability of the circumstances that each delta is tested on by controlling the spawning position of a worker, so that more fair comparisons may be made between the rewards achieved by positive and negative addition of each delta to the current policy, reducing the element of luck that a worker might experience based on starting position. Further, the reward system likely needs adjustment, as it is possible that the penalty for collisions was too high, leading the agent to too highly prioritize avoiding the collisions which it needed to be experiencing in order to learn the edge cases they were associated with. Finally, it is possible that 1250 training episodes was simply not enough time for meaningful progress to be made with training the agent. As can be seen in the '[ars_practice](ars_practice.ipynb)' notebook, the BipedalWalker-v3  (a much simpler environment from the gym module which always starts workers with an identical initial state) required 600 training steps before the algorithm began to make noticeable improvements to the policy. In the context of Carla, with so many unique scenarios for workers to find themselves in, it is understandable that this number of training episodes could be expected to be far larger. Scaling this research up onto more powerful hardware would help to answer this question.\n",
    "\n",
    "Below is a graphic summarizing the results of the training period of this study, which was just over 5 days (121.43 hours). Learning rate and delta std decay was applied, so the changing values of these hyperparameters over time is shown.\n",
    "\n",
    "![Training Results](images/training_results.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='ars_math'></a>\n",
    "## The Math Behind ARS\n",
    "To understand what happens under the hood during the ARS learning process, let's take a look at the equation found in the 2018 paper, which I have annotated for clarity.<br>\n",
    "![ARS Formula](images/ars_formula_explained.png)<br>\n",
    "In words, a user-defined number of deltas (random noise arrays with the same shape as the weights) are generated for each update step, and each delta is applied on 2 separate episodes: one in which it is added to the weights (positive direction) and one in which it is subtracted from the weights (negative direction). The rewards produced from the positive and negative directions are stored with their corresponding delta. Then the deltas are organized in order of maximum rewards produced in either the positive or negative direction, and then a user-defined number of the top performing deltas (up to the total number of deltas) are used in the update step (# deltas used). Each of the used deltas is multiplied by the difference between the rewards of the positive direction and the rewards of the negative direction corresponding to that delta, standardized by dividing these rewards by the collective standard deviation of all positive and negative rewards recorded from the deltas used during this step, which allows us to disregard the actual numerical scale of the reward system at hand. This effectively scales each delta by the magnitude of impact it had on performance, and reverses the sign when the negative direction has higher rewards than the positive direction. The result of each of these multiplication steps is then averaged by summing them together and dividing by the number of deltas used. The result is multiplied by the learning rate, then added to the weights, completing the update step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='testing_environment'></a>\n",
    "## Testing Car Environment with ARS\n",
    "Now that we have an understanding of the ARS process, let's look at how we can fit [Sentdex's car environment for Carla](https://pythonprogramming.net/reinforcement-learning-self-driving-autonomous-cars-carla-python/) into the [basic ARS framework offered by Colin Skow](https://github.com/colinskow/move37/tree/master/ars)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import glob\n",
    "import os\n",
    "import sys\n",
    "import random\n",
    "import time\n",
    "import cv2\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.applications import VGG19\n",
    "\n",
    "# carla should be installed via conda, or use with a different version\n",
    "try:\n",
    "    import carla\n",
    "except ImportError:\n",
    "    sys.path.append(glob.glob(r'D:/CARLA_0.9.13/PythonAPI/carla/dist/carla-*%d.%d-%s.egg' % (\n",
    "        sys.version_info.major,\n",
    "        sys.version_info.minor,\n",
    "        'win-amd64' if os.name == 'nt' else 'linux-x86_64'))[0])\n",
    "    import carla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU'),\n",
       " PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.config.list_physical_devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun Aug 20 12:46:44 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 511.09       Driver Version: 511.09       CUDA Version: 11.6     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ... WDDM  | 00000000:01:00.0  On |                  N/A |\n",
      "| N/A   91C    P0    68W /  N/A |   5351MiB /  6144MiB |     58%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1292    C+G                                   N/A      |\n",
      "|    0   N/A  N/A      1360    C+G   ...icrosoft VS Code\\Code.exe    N/A      |\n",
      "|    0   N/A  N/A      4168    C+G   ...e\\PhoneExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A      5632    C+G   ...8wekyb3d8bbwe\\GameBar.exe    N/A      |\n",
      "|    0   N/A  N/A      9604    C+G   ...5n1h2txyewy\\SearchApp.exe    N/A      |\n",
      "|    0   N/A  N/A     13496    C+G   ...qxf38zg5c\\Skype\\Skype.exe    N/A      |\n",
      "|    0   N/A  N/A     13868    C+G   ...022.3.1\\bin\\pycharm64.exe    N/A      |\n",
      "|    0   N/A  N/A     13968    C+G   ...bbwe\\Microsoft.Photos.exe    N/A      |\n",
      "|    0   N/A  N/A     14708    C+G   ...Files\\NordVPN\\NordVPN.exe    N/A      |\n",
      "|    0   N/A  N/A     14752    C+G   ...oft\\OneDrive\\OneDrive.exe    N/A      |\n",
      "|    0   N/A  N/A     16044    C+G                                   N/A      |\n",
      "|    0   N/A  N/A     16272    C+G   ...ge\\Application\\msedge.exe    N/A      |\n",
      "|    0   N/A  N/A     17024    C+G   ...3d8bbwe\\CalculatorApp.exe    N/A      |\n",
      "|    0   N/A  N/A     18696    C+G   ...ack\\app-4.33.90\\slack.exe    N/A      |\n",
      "|    0   N/A  N/A     21152    C+G   C:\\Windows\\explorer.exe         N/A      |\n",
      "|    0   N/A  N/A     22284    C+G   ...icrosoft.Media.Player.exe    N/A      |\n",
      "|    0   N/A  N/A     25500    C+G   ...in7x64\\steamwebhelper.exe    N/A      |\n",
      "|    0   N/A  N/A     31304    C+G   ...5n1h2txyewy\\SearchApp.exe    N/A      |\n",
      "|    0   N/A  N/A     32220    C+G   ...y\\ShellExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     32488    C+G   ...2txyewy\\TextInputHost.exe    N/A      |\n",
      "|    0   N/A  N/A     34004    C+G                                   N/A      |\n",
      "|    0   N/A  N/A     34056    C+G   ...artMenuExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     34792    C+G   ...rlaUE4-Win64-Shipping.exe    N/A      |\n",
      "|    0   N/A  N/A     35432    C+G   ...wekyb3d8bbwe\\Video.UI.exe    N/A      |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you have GPU-capable tensorflow, the config must be adjusted for the code in this notebook\n",
    "# to work properly, because of some nebulous error with loading the VGG19 CNN when using the GPU\n",
    "# Either way, run this cell to make your setup compatible with this process.\n",
    "from tensorflow.compat.v1 import ConfigProto\n",
    "from tensorflow.compat.v1 import InteractiveSession\n",
    "\n",
    "config = ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "session = InteractiveSession(config=config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skow's Hyperparameter class\n",
    "class HP():\n",
    "    # Hyperparameters\n",
    "    def __init__(self,\n",
    "                 nb_steps=100,\n",
    "                 episode_length=2000,\n",
    "                 learning_rate=0.02,\n",
    "                 num_deltas=16,\n",
    "                 num_best_deltas=8,\n",
    "                 noise=0.03,\n",
    "                 seed=1,\n",
    "                 env_name='BipedalWalker-v3',\n",
    "                 record_every=50):\n",
    "\n",
    "        self.nb_steps = nb_steps\n",
    "        self.episode_length = episode_length\n",
    "        self.learning_rate = learning_rate\n",
    "        self.num_deltas = num_deltas\n",
    "        self.num_best_deltas = num_best_deltas\n",
    "        assert self.num_best_deltas <= self.num_deltas\n",
    "        self.noise = noise\n",
    "        self.seed = seed\n",
    "        self.env_name = env_name\n",
    "        self.record_every = record_every"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skow's Policy class\n",
    "class Policy():\n",
    "    def __init__(self, input_size, output_size, hp, theta=None):\n",
    "        self.input_size = input_size\n",
    "        self.output_size = output_size\n",
    "        if theta is not None:\n",
    "            self.theta = theta\n",
    "        else:\n",
    "            #self.theta = np.random.random((output_size, input_size))\n",
    "            self.theta = np.zeros((output_size, input_size))\n",
    "        self.hp = hp\n",
    "\n",
    "    def evaluate(self, input, delta = None, direction = None):\n",
    "        if direction is None:\n",
    "            return self.theta.dot(input)\n",
    "        elif direction == \"+\":\n",
    "            return (self.theta + self.hp.noise * delta).dot(input)\n",
    "        elif direction == \"-\":\n",
    "            return (self.theta - self.hp.noise * delta).dot(input)\n",
    "\n",
    "    def sample_deltas(self):\n",
    "        return [np.random.randn(*self.theta.shape) for _ in range(self.hp.num_deltas)]\n",
    "#This code below here is super important \n",
    "#This is how the weights are updated according to which configuration of weights led to the biggest reward\n",
    "    def update(self, rollouts, sigma_rewards):\n",
    "        # sigma_rewards is the standard deviation of the rewards\n",
    "        old_theta = self.theta.copy()\n",
    "        step = np.zeros(self.theta.shape)\n",
    "        for r_pos, r_neg, delta in rollouts:\n",
    "            step += (r_pos - r_neg) * delta\n",
    "        theta_update = self.hp.learning_rate / (self.hp.num_best_deltas * sigma_rewards) * step\n",
    "        self.theta += theta_update\n",
    "        if np.array_equal(old_theta, self.theta):\n",
    "            print(\"Theta did not change.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mkdir(base, name):\n",
    "    path = os.path.join(base, name)\n",
    "    if not os.path.exists(path):\n",
    "        os.makedirs(path)\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentdex's CarEnv class, modified to work in the context of ARS learning\n",
    "# This required giving it a continuous control scheme for use in a continuous\n",
    "# action space. The camera input resolution has been changed to 224x224 since\n",
    "# we will be running it through VGG19 to get features, and this is the image\n",
    "# resolution that VGG19 was originally trained on. I have set the number of\n",
    "# seconds per episode to 15.\n",
    "# The scoring system has been modified to try and facilitate the learning\n",
    "# process. Since cars will tend to learn to drive in circles in order to avoid\n",
    "# collisions, it was necessary to punish driving in circles, and reward driving\n",
    "# in straighter lines.\n",
    "class CarEnv:\n",
    "\n",
    "    def __init__(self, \n",
    "                 img_width=224, \n",
    "                 img_height=224, \n",
    "                 show_cam=False, \n",
    "                 control_type='continuous',\n",
    "                 car_model='mustang',\n",
    "                 seconds_per_episode=15\n",
    "                ):\n",
    "        self.img_width = img_width\n",
    "        self.img_height = img_height\n",
    "        self.client = carla.Client(\"localhost\", 2000)\n",
    "        self.client.set_timeout(5.0)\n",
    "        self.world = self.client.get_world()\n",
    "        self.blueprint_library = self.world.get_blueprint_library()\n",
    "        self.car = self.blueprint_library.filter(car_model)[0]\n",
    "        self.show_cam = show_cam\n",
    "        self.control_type = control_type\n",
    "        self.front_camera = None\n",
    "        self.actor_list = []\n",
    "        self.seconds_per_episode = seconds_per_episode\n",
    "        \n",
    "        if self.control_type == 'continuous':\n",
    "            self.action_space = np.array(['throttle', 'steer', 'brake'])\n",
    "\n",
    "    def reset(self):\n",
    "        self.collision_hist = []\n",
    "        self.steering_cache = []\n",
    "        \n",
    "        if len(self.actor_list) > 0:\n",
    "            for actor in self.actor_list:\n",
    "                actor.destroy()\n",
    "        self.actor_list = []\n",
    "        \n",
    "        try:\n",
    "            self.transform = random.choice(self.world.get_map().get_spawn_points())\n",
    "            self.vehicle = self.world.spawn_actor(self.car, self.transform)\n",
    "            self.actor_list.append(self.vehicle)\n",
    "        except:\n",
    "            self.reset()\n",
    "\n",
    "        # Attach RGB Camera\n",
    "        self.rgb_cam = self.blueprint_library.find('sensor.camera.rgb')\n",
    "        self.rgb_cam.set_attribute(\"image_size_x\", f\"{self.img_width}\")\n",
    "        self.rgb_cam.set_attribute(\"image_size_y\", f\"{self.img_height}\")\n",
    "        self.rgb_cam.set_attribute(\"fov\", f\"110\")\n",
    "        \n",
    "        # This establishes location on the vehicle that the sensor attaches to, we are\n",
    "        # aiming for the hood in this case.\n",
    "        transform = carla.Transform(carla.Location(x=2.5, z=0.7))\n",
    "        self.sensor = self.world.spawn_actor(self.rgb_cam, transform, attach_to=self.vehicle)\n",
    "        self.actor_list.append(self.sensor)\n",
    "        self.sensor.listen(lambda data: self.process_img(data))\n",
    "\n",
    "        self.vehicle.apply_control(carla.VehicleControl(throttle=0.0, brake=0.0))\n",
    "        time.sleep(4)\n",
    "\n",
    "        # Spawn and attach a collision sensor to the vehicle\n",
    "        colsensor = self.blueprint_library.find(\"sensor.other.collision\")\n",
    "        self.colsensor = self.world.spawn_actor(colsensor, transform, attach_to=self.vehicle)\n",
    "        self.actor_list.append(self.colsensor)\n",
    "        self.colsensor.listen(lambda event: self.collision_data(event))\n",
    "\n",
    "        # This loop will wait until the camera is functioning before continuing\n",
    "        while self.front_camera is None:\n",
    "            time.sleep(0.01)\n",
    "\n",
    "        self.episode_start = time.time()\n",
    "        self.vehicle.apply_control(carla.VehicleControl(throttle=0.0, brake=0.0))\n",
    "\n",
    "        return self.front_camera\n",
    "\n",
    "    def collision_data(self, event):\n",
    "        self.collision_hist.append(event)\n",
    "\n",
    "    def process_img(self, image):\n",
    "        i = np.array(image.raw_data)\n",
    "        i2 = i.reshape((self.img_height, self.img_width, 4))\n",
    "        i3 = i2[:, :, :3]\n",
    "        if self.show_cam:\n",
    "            cv2.imshow(\"\", i3)\n",
    "            cv2.waitKey(1)\n",
    "        self.front_camera = i3\n",
    "\n",
    "    def step(self, action, step_num):\n",
    "        # Continuous action space for use with ARS\n",
    "        if self.control_type == 'continuous':\n",
    "            self.vehicle.apply_control(carla.VehicleControl(throttle=np.clip(action[0], 0.0, 1.0), \n",
    "                                                            steer=np.clip(action[1], -1.0, 1.0), \n",
    "                                                            brake=np.clip(action[2], 0.0, 1.0)))\n",
    "        # Preserved Sentdex's discrete action space for DQN learning. Not used for ARS\n",
    "        elif self.control_type == 'action':\n",
    "            if action == 0:\n",
    "                self.vehicle.apply_control(carla.VehicleControl(throttle=1.0, \n",
    "                                                                steer=-1*self.STEER_AMT))\n",
    "            elif action == 1:\n",
    "                self.vehicle.apply_control(carla.VehicleControl(throttle=1.0, steer= 0))\n",
    "            elif action == 2:\n",
    "                self.vehicle.apply_control(carla.VehicleControl(throttle=1.0, \n",
    "                                                                steer=1*self.STEER_AMT))\n",
    "        \n",
    "        # Append current steering control to cache to punish high values. Cleared with reset\n",
    "        # at start of episode.\n",
    "        self.steering_cache.append(action[1])\n",
    "        v = self.vehicle.get_velocity()\n",
    "        kmh = int(3.6 * math.sqrt(v.x**2 + v.y**2 + v.z**2))\n",
    "\n",
    "        # Reward System:\n",
    "        if len(self.collision_hist) != 0:\n",
    "            # Check to see if on first step (for rough spawns by Carla)\n",
    "            # Disregards collisions registered on first step of episode\n",
    "            if step_num == 1:\n",
    "                self.collision_hist = []\n",
    "                done = False\n",
    "                reward = 0\n",
    "            else:\n",
    "                done = True\n",
    "                print('Collision!')\n",
    "                reward = -200\n",
    "        elif kmh < 60 & kmh > 0.2:\n",
    "            done = False\n",
    "            reward = 1 #-1\n",
    "            # Reward lighter steering when moving\n",
    "            if np.abs(action[1]) < 0.3:\n",
    "                reward += 9\n",
    "            elif np.abs(action[1]) > 0.5 and np.abs(action[1]) < 0.9:\n",
    "                reward -= 1\n",
    "            elif np.abs(action[1]) >= 0.9:\n",
    "                reward -= 6\n",
    "        elif kmh <=0.2:\n",
    "            done = False\n",
    "            reward = -10\n",
    "        else:\n",
    "            done = False\n",
    "            reward = 20 #2\n",
    "            # Reward lighter steering when moving\n",
    "            if np.abs(action[1]) < 0.3:\n",
    "                reward += 20\n",
    "            # Reduce score for heavy steering\n",
    "            if np.abs(action[1]) > 0.5 and np.abs(action[1]) < 0.9:\n",
    "                reward -= 10\n",
    "            elif np.abs(action[1]) >= 0.9:\n",
    "                reward -= 20\n",
    "\n",
    "        # Penalize consistent and heavily directional steering\n",
    "        reward -= (np.abs(np.mean(self.steering_cache)) + np.abs(action[1])) * 10 / 2\n",
    "\n",
    "        # Terminate episode after set number of seconds\n",
    "        if self.episode_start + self.seconds_per_episode < time.time():\n",
    "            done = True\n",
    "\n",
    "        return self.front_camera, reward, done, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a test car\n",
    "test_car = CarEnv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate images for testing VGG19 predictions (kept small for example)\n",
    "train_images = np.array([test_car.reset().reshape(224, 224, 3) for i in range(1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 224, 224, 3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 150528)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An experiment with flattening shapes\n",
    "train_imgs2 = train_images[..., ::-1].reshape(train_images.shape[0], -1)\n",
    "train_imgs2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's have a look at what our car sees\n",
    "plt.imshow(train_imgs2[0].reshape(224, 224, 3)/255.)\n",
    "plt.xticks(())\n",
    "plt.yticks(());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clean up actors in test_car and clear object from memory\n",
    "for actor in test_car.actor_list:\n",
    "    actor.destroy()\n",
    "del(test_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, 224, 224, 3)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can now pass this image through the VGG19 CNN and observe what the output looks like\n",
    "# Let's first get an idea of what the model input looks like\n",
    "base_model = VGG19(weights='imagenet',\n",
    "                   include_top=False,\n",
    "                   input_shape=(224,\n",
    "                                224,\n",
    "                                3\n",
    "                               )\n",
    "                   )\n",
    "base_model.input_shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 7, 7, 512)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Testing to determine output shape of VGG19\n",
    "prediction = base_model.predict(train_images[0].reshape(1, 224, 224, 3) / 255.)\n",
    "prediction.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can see that the CNN has produced 512 7x7 convolutions. Let's look at some\n",
    "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n",
    "for i in range(4):\n",
    "    col = i % 2\n",
    "    row = i // 2\n",
    "    axes[row, col].imshow(prediction[0][:, :, i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While not very meaningful to us humans, these 7x7 images represent image features like edges to the computer, and may help to generalize the input we give to the ARS perceptron by relaying its content, rather than just the RGB input which can vary a lot in lighting and color for similar driving situations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25088,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We will need to flatten this output to make use of the ARS perceptron, let's see what this looks like.\n",
    "prediction.flatten().shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For ARS, inputs to the perceptron must be normalized. Usually, this is done by taking rolling statistics of the inputs, and using them to perform mean/std filtering to normalize future inputs. This allows the algorithm to build these distributions from scratch without needing prior information about them. For this context, the outputs of the CNN are going to be on the same scale, and just as RGB camera data can be normalized by dividing the pixel values by 255, we can similarly normalize the outputs of this CNN by finding out what scale they are on. We can do this by creating a histogram of the values within the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum output value: 9.939948\n",
      "Minimum output value: 0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Maximum output value:', np.max(prediction))\n",
    "print('Minimum output value:', np.min(prediction))\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "plt.figure(figsize=(11,7))\n",
    "plt.title('Distribution of CNN output values')\n",
    "plt.xlabel('Output Value')\n",
    "plt.ylabel('Density')\n",
    "plt.hist(prediction.flatten());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that these values are occurring on a scale between 0 and 10. This makes normalization easy, since all we need to do is divide all of these values by 10, just as we would divide RGB camera data by 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skow's ARSAgent class, modified to make use of the CarEnv\n",
    "# initial_train option is experimental, uses train_imgs to train\n",
    "# some initial weights for the ARS process to start with.\n",
    "class ARSAgent():\n",
    "    def __init__(self,\n",
    "                 hp=None,\n",
    "                 env=None,\n",
    "                 base_model=True,\n",
    "                 policy=None,\n",
    "                 weights_dir='ars_weights',\n",
    "                 initial_train=False\n",
    "                ):\n",
    "\n",
    "        self.hp = hp or HP()\n",
    "        np.random.seed(self.hp.seed)\n",
    "        self.env = env or CarEnv(control_type='continuous')\n",
    "        self.output_size = self.env.action_space.shape[0]\n",
    "        self.record_video = False\n",
    "        self.history = {'step': [],\n",
    "                        'score': [],\n",
    "                        'theta': []}\n",
    "        self.generate_theta = False\n",
    "        self.historical_steps = 0\n",
    "        \n",
    "        if base_model is None:\n",
    "            self.input_size = self.env.front_camera.shape\n",
    "        else:\n",
    "            base_model = VGG19(weights='imagenet', \n",
    "                               include_top=False, \n",
    "                               input_shape=(self.env.img_height, self.env.img_width,3))\n",
    "            input_size = 1\n",
    "            for dim in base_model.output_shape:\n",
    "                if dim is not None:\n",
    "                    input_size *= dim\n",
    "            self.input_size = input_size\n",
    "            \n",
    "        if policy is None and initial_train == True:\n",
    "            self.generate_theta = True\n",
    "        self.base_model = base_model\n",
    "        self.policy = policy or Policy(self.input_size, self.output_size, self.hp)\n",
    "        self.weights_dir = mkdir('', weights_dir)\n",
    "\n",
    "    # Explore the policy on one specific direction and over one episode\n",
    "    def explore(self, direction=None, delta=None):\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        sum_rewards = 0.0\n",
    "        steps = 0\n",
    "        while not done:\n",
    "            # Get data from front camera and divide by 255 to normalize\n",
    "            state = self.env.front_camera.reshape(1, 224, 224, 3) / 255.\n",
    "            steps += 1\n",
    "            if self.base_model:\n",
    "                # Use base model to make prediction, flatten and divide by 10 to normalize\n",
    "                state = self.base_model.predict(state).flatten() / 10.\n",
    "            else:\n",
    "                state = state.flatten()\n",
    "            action = self.policy.evaluate(state, delta, direction)\n",
    "            state, reward, done, _ = self.env.step(action, steps)\n",
    "            #reward = max(min(reward, 1), -1)\n",
    "            sum_rewards += reward\n",
    "        print('Worker saw {} steps'.format(steps))\n",
    "        # Average the rewards per step to account for variable FPS seen by workers\n",
    "        print('Sum of episode rewards:', sum_rewards)\n",
    "        adjusted_reward = sum_rewards / steps\n",
    "        print('Adjusted Reward for episode:', adjusted_reward)\n",
    "        return adjusted_reward\n",
    "\n",
    "    def train(self):\n",
    "        # Experimental. Used to train an initial set of weights for ARS to modify.\n",
    "        if self.generate_theta:\n",
    "            print('Training initial weights...')\n",
    "            pred_model = keras.models.Sequential()\n",
    "            base_model = VGG19(weights='imagenet', \n",
    "                               include_top=False, \n",
    "                               input_shape=(224, 224,3))\n",
    "            for layer in base_model.layers:\n",
    "                layer.trainable = False\n",
    "            pred_model.add(base_model)\n",
    "            pred_model.add(keras.layers.Flatten())\n",
    "            pred_model.add(Dense(3, input_dim=base_model.output_shape, activation='linear'))\n",
    "            pred_model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "            X = train_imgs.reshape(50, 224, 224, 3)/255.\n",
    "            y = np.array([1., 0., 0.])\n",
    "            y = np.tile(y, (50, 1))\n",
    "            pred_model.fit(X, y, epochs=5, workers=2)\n",
    "            self.policy.theta = pred_model.get_weights()[-2].T\n",
    "        \n",
    "        for step in range(self.hp.nb_steps):\n",
    "            self.historical_steps += 1\n",
    "            print('Performing step {}. ({}/{})'.format(self.historical_steps,\n",
    "                                                       step + 1,\n",
    "                                                       self.hp.nb_steps\n",
    "                                                      ))\n",
    "            start = time.time()\n",
    "            # Only record video during evaluation, every n steps\n",
    "            if step % self.hp.record_every == 0:\n",
    "                self.env.show_cam = True\n",
    "            # initialize the random noise deltas and the positive/negative rewards\n",
    "            deltas = self.policy.sample_deltas()\n",
    "            positive_rewards = [0] * self.hp.num_deltas\n",
    "            negative_rewards = [0] * self.hp.num_deltas\n",
    "\n",
    "            # play an episode each with positive deltas and negative deltas, collect rewards\n",
    "            for k in range(self.hp.num_deltas):\n",
    "                positive_rewards[k] = self.explore(direction=\"+\", delta=deltas[k])\n",
    "                negative_rewards[k] = self.explore(direction=\"-\", delta=deltas[k])\n",
    "                \n",
    "            # Compute the standard deviation of all rewards\n",
    "            sigma_rewards = np.array(positive_rewards + negative_rewards).std()\n",
    "\n",
    "            # Sort the rollouts by the max(r_pos, r_neg) and select the deltas with best rewards\n",
    "            scores = {k:max(r_pos, r_neg) for k,(r_pos,r_neg) in enumerate(zip(positive_rewards, negative_rewards))}\n",
    "            order = sorted(scores.keys(), key = lambda x:scores[x], reverse = True)[:self.hp.num_best_deltas]\n",
    "            rollouts = [(positive_rewards[k], negative_rewards[k], deltas[k]) for k in order]\n",
    "\n",
    "            # Update the policy\n",
    "            self.policy.update(rollouts, sigma_rewards)\n",
    "\n",
    "            if step % self.hp.record_every == 0:\n",
    "                # Play an episode with the new weights and print the score\n",
    "                reward_evaluation = self.run_episode()\n",
    "                print('Step:', step + 1, 'Reward:', reward_evaluation)\n",
    "                self.history['step'].append(self.historical_steps)\n",
    "                self.history['score'].append(reward_evaluation)\n",
    "                self.history['theta'].append(self.policy.theta.copy())\n",
    "                #self.save()\n",
    "                \n",
    "            end = time.time()\n",
    "            print('Time to complete update step:', end - start)\n",
    "            self.env.show_cam = False\n",
    "        \n",
    "        self.save()\n",
    "\n",
    "    def save(self):\n",
    "        save_file = mkdir(self.weights_dir, str(datetime.date.today()))\n",
    "        np.savetxt(save_file+'/recent_weights.csv'.format(self.historical_steps), \n",
    "                   self.policy.theta,\n",
    "                   delimiter=','\n",
    "                  )  \n",
    "            \n",
    "    def run_episode(self):\n",
    "        return self.explore()\n",
    "            \n",
    "    def clean_up(self):\n",
    "        for actor in self.env.actor_list:\n",
    "            actor.destroy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Establish hyperparameters to pass to agent\n",
    "hp_test = HP(nb_steps=10, \n",
    "             noise=0.05, \n",
    "             learning_rate=0.02, \n",
    "             num_deltas=16, \n",
    "             num_best_deltas=8,\n",
    "             record_every=1\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the agent using these hyperparameters\n",
    "ars_agent = ARSAgent(hp=hp_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load in previously trained weights if you have some\n",
    "#weights = np.genfromtxt('ars_weights/2020-12-21/recent_weights.csv', delimiter=',')\n",
    "#ars_agent.policy.theta = weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing step 1. (1/10)\n",
      "Worker saw 68 steps\n",
      "Sum of episode rewards: 549.0793845087973\n",
      "Adjusted Reward for episode: 8.074696831011725\n",
      "Worker saw 79 steps\n",
      "Sum of episode rewards: -1293.528435470346\n",
      "Adjusted Reward for episode: -16.373777664181596\n",
      "Worker saw 79 steps\n",
      "Sum of episode rewards: -909.5370135250719\n",
      "Adjusted Reward for episode: -11.513126753481922\n",
      "Collision!\n",
      "Worker saw 17 steps\n",
      "Sum of episode rewards: 108.46789020892018\n",
      "Adjusted Reward for episode: 6.380464129936481\n",
      "Worker saw 78 steps\n",
      "Sum of episode rewards: -787.0925363328447\n",
      "Adjusted Reward for episode: -10.090929952985189\n"
     ]
    }
   ],
   "source": [
    "# Train the agent\n",
    "ars_agent.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from the worker's reports of how many frames they saw that the FPS experienced by a worker is variable, which is why we computed the average reward per frame rather than the sum of rewards for each episode. We can also see that the amount of time it takes to complete each update step is rather large,at ~10.5 minutes. This would make a 1000 iteration training session take 175 hours, which is not feasible, and this is only with 16 deltas. This means we will need to have training done in parallel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 792x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the results of our brief training session.\n",
    "plt.figure(figsize=(11, 7))\n",
    "plt.plot(ars_agent.history['step'], ars_agent.history['score'])\n",
    "plt.title('Agent Score over Training Steps')\n",
    "plt.xlabel('Training Step')\n",
    "plt.ylabel('Score');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "different\n",
      "different\n",
      "different\n",
      "different\n",
      "different\n",
      "different\n",
      "different\n",
      "different\n",
      "different\n"
     ]
    }
   ],
   "source": [
    "# A quick sanity check to make sure that our theta was changing each time\n",
    "for i, theta in enumerate(ars_agent.history['theta']):\n",
    "    if i + 1 == len(ars_agent.history['theta']):\n",
    "        break\n",
    "    if np.array_equal(theta, ars_agent.history['theta'][i+1]):\n",
    "        print('same')\n",
    "    else:\n",
    "        print('different')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save weights for later use\n",
    "ars_agent.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clean up actors and clear agent from memory\n",
    "ars_agent.clean_up()\n",
    "del(ars_agent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that we have a functioning ARS Agent using our CarEnv environment, but training with a single car like this would take forever. We need to look into training cars in parallel. Fortunately, the authors of the 2018 paper have provided source code to run ARS training in parallel using Ray.io. As was necessary with the Skow code, this code needed to be heavily modified in order to work with the CarEnv. I have made extensive adjustments to their code for this study. My version of the code can be found in the ARS_Carla folder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continue to next notebook\n",
    "Click [here](notebook2_train_agent.ipynb) to proceed to the next notebook, where we train our agent using workers operating in parallel with the help of the Ray module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix\n",
    "This section contains dead code no longer used in this notebook, but stored down here for reference if needed. An attempt was made at using ipyparallel, which was not successful because it was unable to pickle the context objects, but luckily the Ray solution worked better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skow's class to normalize inputs with rolling statistics\n",
    "# Not used with the CarEnv since the outputs of the VGG19\n",
    "# were all on the same scale, but it might be worth comparing\n",
    "# using it later on.\n",
    "class Normalizer():\n",
    "    # Normalizes the inputs\n",
    "    def __init__(self, nb_inputs):\n",
    "        self.n = np.zeros(nb_inputs)\n",
    "        self.mean = np.zeros(nb_inputs)\n",
    "        self.mean_diff = np.zeros(nb_inputs)\n",
    "        self.var = np.zeros(nb_inputs)\n",
    "\n",
    "    def observe(self, x):\n",
    "        self.n += 1.0\n",
    "        last_mean = self.mean.copy()\n",
    "        self.mean += (x - self.mean) / self.n\n",
    "        self.mean_diff += (x - last_mean) * (x - self.mean)\n",
    "        self.var = (self.mean_diff / self.n).clip(min = 1e-2)\n",
    "\n",
    "    def normalize(self, inputs):\n",
    "        obs_mean = self.mean\n",
    "        obs_std = np.sqrt(self.var)\n",
    "        return (inputs - obs_mean) / obs_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Original unmodified Skow Trainer class for reference\n",
    "class ARSTrainer():\n",
    "    def __init__(self,\n",
    "                 hp=None,\n",
    "                 input_size=None,\n",
    "                 output_size=None,\n",
    "                 normalizer=None,\n",
    "                 policy=None,\n",
    "                 monitor_dir=None):\n",
    "\n",
    "        self.hp = hp or HP()\n",
    "        np.random.seed(self.hp.seed)\n",
    "        self.env = gym.make(self.hp.env_name)\n",
    "        if monitor_dir is not None:\n",
    "            should_record = lambda i: self.record_video\n",
    "            self.env = wrappers.Monitor(self.env, monitor_dir, video_callable=should_record, force=True)\n",
    "        self.hp.episode_length = self.hp.episode_length\n",
    "        self.input_size = input_size or self.env.observation_space.shape[0]\n",
    "        self.output_size = output_size or self.env.action_space.shape[0]\n",
    "        self.normalizer = normalizer or Normalizer(self.input_size)\n",
    "        self.policy = policy or Policy(self.input_size, self.output_size, self.hp)\n",
    "        self.record_video = False\n",
    "\n",
    "    # Explore the policy on one specific direction and over one episode\n",
    "    def explore(self, direction=None, delta=None):\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        num_plays = 0.0\n",
    "        sum_rewards = 0.0\n",
    "        while not done and num_plays < self.hp.episode_length:\n",
    "            self.normalizer.observe(state)\n",
    "            state = self.normalizer.normalize(state)\n",
    "            action = self.policy.evaluate(state, delta, direction)\n",
    "            state, reward, done, _ = self.env.step(action)\n",
    "            reward = max(min(reward, 1), -1)\n",
    "            sum_rewards += reward\n",
    "            num_plays += 1\n",
    "        return sum_rewards\n",
    "\n",
    "    def train(self):\n",
    "        for step in range(self.hp.nb_steps):\n",
    "            # initialize the random noise deltas and the positive/negative rewards\n",
    "            deltas = self.policy.sample_deltas()\n",
    "            positive_rewards = [0] * self.hp.num_deltas\n",
    "            negative_rewards = [0] * self.hp.num_deltas\n",
    "\n",
    "            # play an episode each with positive deltas and negative deltas, collect rewards\n",
    "            for k in range(self.hp.num_deltas):\n",
    "                positive_rewards[k] = self.explore(direction=\"+\", delta=deltas[k])\n",
    "                negative_rewards[k] = self.explore(direction=\"-\", delta=deltas[k])\n",
    "                \n",
    "            # Compute the standard deviation of all rewards\n",
    "            sigma_rewards = np.array(positive_rewards + negative_rewards).std()\n",
    "\n",
    "            # Sort the rollouts by the max(r_pos, r_neg) and select the deltas with best rewards\n",
    "            scores = {k:max(r_pos, r_neg) for k,(r_pos,r_neg) in enumerate(zip(positive_rewards, negative_rewards))}\n",
    "            order = sorted(scores.keys(), key = lambda x:scores[x], reverse = True)[:self.hp.num_best_deltas]\n",
    "            rollouts = [(positive_rewards[k], negative_rewards[k], deltas[k]) for k in order]\n",
    "\n",
    "            # Update the policy\n",
    "            self.policy.update(rollouts, sigma_rewards)\n",
    "\n",
    "            # Only record video during evaluation, every n steps\n",
    "            if step % self.hp.record_every == 0:\n",
    "                self.record_video = True\n",
    "            # Play an episode with the new weights and print the score\n",
    "            reward_evaluation = self.explore()\n",
    "            print('Step: ', step, 'Reward: ', reward_evaluation)\n",
    "            self.record_video = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AsyncResult: use_cloudpickle>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is an attempt to get the trainer to work with ipyparallel\n",
    "# It did not work because ipyparallel will not pickle context objects\n",
    "import ipyparallel as ipp\n",
    "c = ipp.Client()\n",
    "c[:].use_cloudpickle()\n",
    "\n",
    "class ARSAgent_Parallel():\n",
    "    def __init__(self,\n",
    "                 hp=None,\n",
    "                 num_envs=4,\n",
    "                 base_model=True,\n",
    "                 policy=None,\n",
    "                 weights_dir='ars_weights',\n",
    "                 initial_train=False\n",
    "                ):\n",
    "\n",
    "        self.hp = hp or HP()\n",
    "        np.random.seed(self.hp.seed)\n",
    "        self.envs = [CarEnv(control_type='continuous') for i in range(num_envs)]\n",
    "        self.env = self.envs[0]\n",
    "        self.output_size = self.env.action_space.shape[0]\n",
    "        self.record_video = False\n",
    "        self.history = {'step': [],\n",
    "                        'score': [],\n",
    "                        'theta': []}\n",
    "        self.generate_theta = False\n",
    "        self.historical_steps = 0\n",
    "        \n",
    "        if base_model is None:\n",
    "            self.input_size = self.env.front_camera.shape\n",
    "        else:\n",
    "            base_model = VGG19(weights='imagenet', \n",
    "                               include_top=False, \n",
    "                               input_shape=(self.env.img_height, self.env.img_width,3))\n",
    "            input_size = 1\n",
    "            for dim in base_model.output_shape:\n",
    "                if dim is not None:\n",
    "                    input_size *= dim\n",
    "            self.input_size = input_size\n",
    "            \n",
    "        if policy is None and initial_train == True:\n",
    "            self.generate_theta = True\n",
    "        self.base_model = base_model\n",
    "        self.policy = policy or Policy(self.input_size, self.output_size, self.hp)\n",
    "        self.weights_dir = mkdir('', weights_dir)\n",
    "        \n",
    "    # Explore the policy on one specific direction and over one episode\n",
    "    def explore(self, direction=None, delta=None):\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        sum_rewards = 0.0\n",
    "        while not done:\n",
    "            state = self.env.front_camera.reshape(1, 224, 224, 3)/255.\n",
    "            if self.base_model:\n",
    "                state = self.base_model.predict(state).flatten()\n",
    "            else:\n",
    "                state = state.flatten()\n",
    "            action = self.policy.evaluate(state, delta, direction)\n",
    "            state, reward, done, _ = self.env.step(action)\n",
    "            reward = max(min(reward, 1), -1)\n",
    "            sum_rewards += reward\n",
    "        return sum_rewards\n",
    "\n",
    "    # Explore the policy on one specific direction and over one episode\n",
    "    def explore_directions(self, env):\n",
    "        delta = np.random.randn(*self.policy.theta.shape)\n",
    "        sum_positive_rewards = 0.0\n",
    "        sum_negative_rewards = 0.0\n",
    "        \n",
    "        # Get positive direction for delta\n",
    "        state = env.reset()\n",
    "        done = False\n",
    "        while not done:\n",
    "            state = self.env.front_camera.reshape(1, 224, 224, 3)/255.\n",
    "            if self.base_model:\n",
    "                state = self.base_model.predict(state).flatten()\n",
    "            else:\n",
    "                state = state.flatten()\n",
    "            action = self.policy.evaluate(state, delta, '+')\n",
    "            state, reward, done, _ = self.env.step(action)\n",
    "            #reward = max(min(reward, 1), -1)\n",
    "            sum_positive_rewards += reward\n",
    "            \n",
    "        # Get negative direction for delta\n",
    "        state = env.reset()\n",
    "        done = False\n",
    "        while not done:\n",
    "            state = self.env.front_camera.reshape(1, 224, 224, 3)/255.\n",
    "            if self.base_model:\n",
    "                state = self.base_model.predict(state).flatten()\n",
    "            else:\n",
    "                state = state.flatten()\n",
    "            action = self.policy.evaluate(state, delta, '-')\n",
    "            state, reward, done, _ = self.env.step(action)\n",
    "            reward = max(min(reward, 1), -1)\n",
    "            sum_negative_rewards += reward\n",
    "            \n",
    "        return delta, sum_positive_rewards, sum_negative_rewards\n",
    "\n",
    "    def train(self):\n",
    "        if self.generate_theta:\n",
    "            print('Training initial weights...')\n",
    "            pred_model = keras.models.Sequential()\n",
    "            base_model = VGG19(weights='imagenet', \n",
    "                               include_top=False, \n",
    "                               input_shape=(224, 224,3))\n",
    "            for layer in base_model.layers:\n",
    "                layer.trainable = False\n",
    "            pred_model.add(base_model)\n",
    "            pred_model.add(keras.layers.Flatten())\n",
    "            pred_model.add(Dense(3, input_dim=base_model.output_shape, activation='linear'))\n",
    "            pred_model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "            X = train_imgs.reshape(50, 224, 224, 3)/255.\n",
    "            y = np.array([1., 0., 0.])\n",
    "            y = np.tile(y, (50, 1))\n",
    "            pred_model.fit(X, y, epochs=5, workers=2)\n",
    "            self.policy.theta = pred_model.get_weights()[-2].T\n",
    "        \n",
    "        for step in range(self.hp.nb_steps):\n",
    "            print('Performing step {}. ({}/{})'.format(self.historical_steps,\n",
    "                                                       step + 1,\n",
    "                                                       self.hp.nb_steps\n",
    "                                                      ))\n",
    "            self.historical_steps += 1\n",
    "            # Only record video during evaluation, every n steps\n",
    "            if step % self.hp.record_every == 0:\n",
    "                for env in self.envs:\n",
    "                    env.show_cam = True\n",
    "            # initialize the random noise deltas and the positive/negative rewards\n",
    "            deltas = [] #self.policy.sample_deltas()\n",
    "            positive_rewards = [] #[0] * self.hp.num_deltas\n",
    "            negative_rewards = [] #[0] * self.hp.num_deltas\n",
    "\n",
    "            # play an episode each with positive deltas and negative deltas, collect rewards\n",
    "            for i in range(self.hp.num_deltas // 4):\n",
    "                responses = c[:].map_sync(self.explore_directions, self.envs)\n",
    "                for res in positive_responses:\n",
    "                    deltas.append(res[0])\n",
    "                    positive_rewards.append(res[1])\n",
    "                    negative_rewards.append(res[3])\n",
    "                \n",
    "            # Compute the standard deviation of all rewards\n",
    "            sigma_rewards = np.array(positive_rewards + negative_rewards).std()\n",
    "\n",
    "            # Sort the rollouts by the max(r_pos, r_neg) and select the deltas with best rewards\n",
    "            scores = {k:max(r_pos, r_neg) for k,(r_pos,r_neg) in enumerate(zip(positive_rewards, negative_rewards))}\n",
    "            order = sorted(scores.keys(), key = lambda x:scores[x], reverse = True)[:self.hp.num_best_deltas]\n",
    "            rollouts = [(positive_rewards[k], negative_rewards[k], deltas[k]) for k in order]\n",
    "\n",
    "            # Update the policy\n",
    "            self.policy.update(rollouts, sigma_rewards)\n",
    "\n",
    "            if step % self.hp.record_every == 0:\n",
    "                # Play an episode with the new weights and print the score\n",
    "                reward_evaluation = self.run_episode()\n",
    "                print('Step:', step + 1, 'Reward:', reward_evaluation)\n",
    "                self.history['step'].append(self.historical_steps)\n",
    "                self.history['score'].append(reward_evaluation)\n",
    "                self.history['theta'].append(self.policy.theta.copy())\n",
    "                \n",
    "            self.env.show_cam = False\n",
    "        \n",
    "        save_file = mkdir(self.weights_dir, str(datetime.date.today()))\n",
    "        np.savetxt(save_file+'/{}_episodes.csv'.format(self.historical_steps), \n",
    "                   self.policy.theta,\n",
    "                   delimiter=','\n",
    "                  )            \n",
    "            \n",
    "    def run_episode(self):\n",
    "        return self.explore()\n",
    "            \n",
    "    def clean_up(self):\n",
    "        for actor in self.env.actor_list:\n",
    "            actor.destroy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "hp_test = HP(nb_steps=50, \n",
    "             noise=0.05, \n",
    "             learning_rate=0.02, \n",
    "             num_deltas=32, \n",
    "             num_best_deltas=16,\n",
    "             record_every=1\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ars_agent.history['theta'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "ars_agent_parallel = ARSAgent_Parallel(hp=hp_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights = ars_agent.history['theta'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "ars_agent_parallel.policy.theta = weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ars_agent_parallel.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "ars_agent_parallel.clean_up()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'd like to try training in a variety of circumstances and with various combinations of inputs. The semantic segmentation cam may give great performance with camera-based training. There are also radar, lidar, and other sensors that can be added into the inputs. First, let's just set up a basic RGB cam and try to see what that can do. I am thinking that putting the VGG19 with imagenet weights in front of the ARS agent may help it find edges, so we need to compare both of these methods over a given number of episodes. Sentdex's scoring system is not badly designed, and it may be enlightening to know how my scores compare."
   ]
  }
 ],
 "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.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}