Navigation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigation\n",
    "\n",
    "---\n",
    "\n",
    "In this notebook, you will learn how to use the Unity ML-Agents environment for the first project of the [Deep Reinforcement Learning Nanodegree](https://www.udacity.com/course/deep-reinforcement-learning-nanodegree--nd893).\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "We begin by importing some necessary packages.  If the code cell below returns an error, please revisit the project instructions to double-check that you have installed [Unity ML-Agents](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/Installation.md) and [NumPy](http://www.numpy.org/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will start the environment!  **_Before running the code cell below_**, change the `file_name` parameter to match the location of the Unity environment that you downloaded.\n",
    "\n",
    "- **Mac**: `\"path/to/Banana.app\"`\n",
    "- **Windows** (x86): `\"path/to/Banana_Windows_x86/Banana.exe\"`\n",
    "- **Windows** (x86_64): `\"path/to/Banana_Windows_x86_64/Banana.exe\"`\n",
    "- **Linux** (x86): `\"path/to/Banana_Linux/Banana.x86\"`\n",
    "- **Linux** (x86_64): `\"path/to/Banana_Linux/Banana.x86_64\"`\n",
    "- **Linux** (x86, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86\"`\n",
    "- **Linux** (x86_64, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86_64\"`\n",
    "\n",
    "For instance, if you are using a Mac, then you downloaded `Banana.app`.  If this file is in the same folder as the notebook, then the line below should appear as follows:\n",
    "```\n",
    "env = UnityEnvironment(file_name=\"Banana.app\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:unityagents:\n",
      "'Academy' started successfully!\n",
      "Unity Academy name: Academy\n",
      "        Number of Brains: 1\n",
      "        Number of External Brains : 1\n",
      "        Lesson number : 0\n",
      "        Reset Parameters :\n",
      "\t\t\n",
      "Unity brain name: BananaBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 37\n",
      "        Number of stacked Vector Observation: 1\n",
      "        Vector Action space type: discrete\n",
      "        Vector Action space size (per agent): 4\n",
      "        Vector Action descriptions: , , , \n"
     ]
    }
   ],
   "source": [
    "env = UnityEnvironment(file_name=\"C:/Users/RicardoRubio/Documents/Udacity/deep-reinforcement-learning/p1_navigation/Banana_Windows_x86_64/Banana_Windows_x86_64/Banana.exe\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Environments contain **_brains_** which are responsible for deciding the actions of their associated agents. Here we check for the first brain available, and set it as the default brain we will be controlling from Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the default brain\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Examine the State and Action Spaces\n",
    "\n",
    "The simulation contains a single agent that navigates a large environment.  At each time step, it has four actions at its disposal:\n",
    "- `0` - walk forward \n",
    "- `1` - walk backward\n",
    "- `2` - turn left\n",
    "- `3` - turn right\n",
    "\n",
    "The state space has `37` dimensions and contains the agent's velocity, along with ray-based perception of objects around agent's forward direction.  A reward of `+1` is provided for collecting a yellow banana, and a reward of `-1` is provided for collecting a blue banana. \n",
    "\n",
    "Run the code cell below to print some information about the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of agents: 1\n",
      "Number of actions: 4\n",
      "States look like: [1.         0.         0.         0.         0.84408134 0.\n",
      " 0.         1.         0.         0.0748472  0.         1.\n",
      " 0.         0.         0.25755    1.         0.         0.\n",
      " 0.         0.74177343 0.         1.         0.         0.\n",
      " 0.25854847 0.         0.         1.         0.         0.09355672\n",
      " 0.         1.         0.         0.         0.31969345 0.\n",
      " 0.        ]\n",
      "States have length: 37\n"
     ]
    }
   ],
   "source": [
    "# reset the environment\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "\n",
    "# number of agents in the environment\n",
    "print('Number of agents:', len(env_info.agents))\n",
    "\n",
    "# number of actions\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Number of actions:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "state = env_info.vector_observations[0]\n",
    "print('States look like:', state)\n",
    "state_size = len(state)\n",
    "print('States have length:', state_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Take Random Actions in the Environment\n",
    "\n",
    "In the next code cell, you will learn how to use the Python API to control the agent and receive feedback from the environment.\n",
    "\n",
    "Once this cell is executed, you will watch the agent's performance, if it selects an action (uniformly) at random with each time step.  A window should pop up that allows you to observe the agent, as it moves through the environment.  \n",
    "\n",
    "Of course, as part of the project, you'll have to change the code so that the agent is able to use its experience to gradually choose better actions when interacting with the environment!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env_info = env.reset(train_mode=False)[brain_name] # reset the environment\n",
    "state = env_info.vector_observations[0]            # get the current state\n",
    "score = 0                                          # initialize the score\n",
    "while True:\n",
    "    action = np.random.randint(action_size)        # select an action\n",
    "    env_info = env.step(int(action))[brain_name]        # send the action to the environment\n",
    "    next_state = env_info.vector_observations[0]   # get the next state\n",
    "    reward = env_info.rewards[0]                   # get the reward\n",
    "    done = env_info.local_done[0]                  # see if episode has finished\n",
    "    score += reward                                # update the score\n",
    "    state = next_state                             # roll over the state to next time step\n",
    "    if done:                                       # exit loop if episode finished\n",
    "        break\n",
    "    \n",
    "print(\"Score: {}\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When finished, you can close the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. It's Your Turn!\n",
    "\n",
    "Now it's your turn to train your own agent to solve the environment!  When training the environment, set `train_mode=True`, so that the line for resetting the environment looks like the following:\n",
    "```python\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import packages and Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dqn_agent import Agent\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import random\n",
    "from collections import namedtuple, deque\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dqn(env, agent, n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
    "    \"\"\"Deep Q-Learning.\n",
    "    \n",
    "    Params\n",
    "    ======\n",
    "        env: enviroment\n",
    "        agent: agent\n",
    "        n_episodes (int): maximum number of training episodes\n",
    "        max_t (int): maximum number of timesteps per episode\n",
    "        eps_start (float): starting value of epsilon, for epsilon-greedy action selection\n",
    "        eps_end (float): minimum value of epsilon\n",
    "        eps_decay (float): multiplicative factor (per episode) for decreasing epsilon\n",
    "    \"\"\"\n",
    "    \n",
    "    scores = []                        # list containing scores from each episode\n",
    "    scores_window = deque(maxlen=100)  # last 100 scores\n",
    "    eps = eps_start                    # initialize epsilon\n",
    "    for i_episode in range(1, n_episodes+1):\n",
    "        env_info = env.reset(train_mode=True)[brain_name]\n",
    "        state = env_info.vector_observations[0]\n",
    "        score = 0\n",
    "        for t in range(max_t):\n",
    "            action = agent.act(state, eps)\n",
    "            env_info = env.step(int(action))[brain_name]    \n",
    "            next_state = env_info.vector_observations[0]\n",
    "            reward = env_info.rewards[0]\n",
    "            done = env_info.local_done[0]\n",
    "            agent.step(state, action, reward, next_state, done)\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            if done:\n",
    "                break \n",
    "        scores_window.append(score)       # save most recent score\n",
    "        scores.append(score)              # save most recent score\n",
    "        eps = max(eps_end, eps_decay*eps) # decrease epsilon\n",
    "        if i_episode % 100 == 0:\n",
    "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
    "        torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
    "    return scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = Agent(state_size=37, action_size=4, seed=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\tAverage Score: 1.06\n",
      "Episode 200\tAverage Score: 4.79\n",
      "Episode 300\tAverage Score: 7.85\n",
      "Episode 400\tAverage Score: 9.95\n",
      "Episode 500\tAverage Score: 13.80\n",
      "Episode 600\tAverage Score: 13.96\n",
      "Episode 700\tAverage Score: 15.07\n",
      "Episode 800\tAverage Score: 15.38\n",
      "Episode 900\tAverage Score: 15.46\n",
      "Episode 1000\tAverage Score: 14.81\n",
      "Episode 1100\tAverage Score: 15.68\n",
      "Episode 1200\tAverage Score: 15.57\n",
      "Episode 1300\tAverage Score: 15.19\n",
      "Episode 1400\tAverage Score: 15.10\n",
      "Episode 1500\tAverage Score: 15.14\n",
      "Episode 1600\tAverage Score: 14.93\n",
      "Episode 1700\tAverage Score: 16.14\n",
      "Episode 1800\tAverage Score: 15.57\n",
      "Episode 1900\tAverage Score: 14.91\n",
      "Episode 2000\tAverage Score: 15.03\n"
     ]
    }
   ],
   "source": [
    "scores = dqn(env, agent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the scores\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 games  - average score 15.55\n"
     ]
    }
   ],
   "source": [
    "games = 100\n",
    "max_t=1000\n",
    "\n",
    "# Load trained agent \n",
    "agent.qnetwork_local.load_state_dict(torch.load('checkpoint.pth'))\n",
    "\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]\n",
    "    \n",
    "scores = []\n",
    "for i_game in range(1, games+1):\n",
    "    env_info = env.reset(train_mode=False)[brain_name]\n",
    "    state = env_info.vector_observations[0]\n",
    "    score = 0\n",
    "        \n",
    "    for t in range(max_t):                    \n",
    "        # select action \n",
    "        action = agent.act(state) \n",
    "        # send the action to the environment\n",
    "        env_info = env.step(int(action))[brain_name]        \n",
    "        # get next state \n",
    "        next_state = env_info.vector_observations[0]\n",
    "        # get reward \n",
    "        reward = env_info.rewards[0]\n",
    "        # see if episode has finished \n",
    "        done = env_info.local_done[0]                    \n",
    "            \n",
    "        # Increment score \n",
    "        score += reward\n",
    "        # update current state with next state \n",
    "        state = next_state \n",
    "            \n",
    "        # Exit if done \n",
    "        if done:\n",
    "            break \n",
    "\n",
    "    scores.append(score) # save score                 \n",
    "        \n",
    "print(\"{} games  - average score {:.2f}\".format(\n",
    "    i_game, \n",
    "    np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the scores\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "drlnd",
   "language": "python",
   "name": "drlnd"
  },
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}