Navigation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigation\n",
    "\n",
    "---\n",
    "\n",
    "You are welcome to use this coding environment to train your agent for the project.  Follow the instructions below to get started!\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "Run the next code cell to install a few packages.  This line will take a few minutes to run!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Invalid requirement: './python'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!pip -q install ./python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The environment is already saved in the Workspace and can be accessed at the file path provided below.  Please run the next code cell without making any changes."
   ]
  },
  {
   "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": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\n",
    "\n",
    "# please do not modify the line below\n",
    "env = UnityEnvironment(file_name=\"/data/Banana_Linux_NoVis/Banana.x86_64\")"
   ]
  },
  {
   "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": 4,
   "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",
    "Run the code cell below to print some information about the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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.          0.\n",
      "  1.          0.          0.0748472   0.          1.          0.          0.\n",
      "  0.25755     1.          0.          0.          0.          0.74177343\n",
      "  0.          1.          0.          0.          0.25854847  0.          0.\n",
      "  1.          0.          0.09355672  0.          1.          0.          0.\n",
      "  0.31969345  0.          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",
    "Note that **in this coding environment, you will not be able to watch the agent while it is training**, and you should set `train_mode=True` to restart the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 1.0\n"
     ]
    }
   ],
   "source": [
    "env_info = env.reset(train_mode=True)[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(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": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When finished, you can close the environment."
   ]
  },
  {
   "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!  A few **important notes**:\n",
    "- 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",
    "```\n",
    "- To structure your work, you're welcome to work directly in this Jupyter notebook, or you might like to start over with a new file!  You can see the list of files in the workspace by clicking on **_Jupyter_** in the top left corner of the notebook.\n",
    "- In this coding environment, you will not be able to watch the agent while it is training.  However, **_after training the agent_**, you can download the saved model weights to watch the agent on your own machine!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Creating a Neural Network Architecture\n",
    "\n",
    "Building a simple Feed forward two hidden layer neural network. This architecture would be used for trainnig the agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleQNetwork(nn.Module):\n",
    "    \"\"\"Architecture used to train model\"\"\"\n",
    "    \n",
    "    def __init__(self, state_size, action_size, seed, fc1_units=32, fc2_units=32):\n",
    "        \"\"\"Initialize parameters and build model\n",
    "        Param\n",
    "        ======\n",
    "            state_size (int): Dimension of each state\n",
    "            action_size (int): Total number of actions available\n",
    "            seed (int): Random seed\n",
    "            fc1_units (int) : Number of nodes in first hidden layer\n",
    "            fc2_units (int) : Number of nodes in second hidden layer\n",
    "        \"\"\"\n",
    "        super(SimpleQNetwork, self).__init__()\n",
    "        self.seed = torch.manual_seed(seed)\n",
    "        self.fc1 = nn.Linear(state_size, fc1_units)\n",
    "        self.fc2 = nn.Linear(fc1_units, fc2_units)\n",
    "        self.fc3 = nn.Linear(fc2_units, action_size)\n",
    "    def forward(self, state):\n",
    "        \"\"\"Build a network that maps state -> action values\"\"\"\n",
    "        x = F.relu(self.fc1(state))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building the Agent\n",
    "\n",
    "Contains parameters and methods that the agent would contain so that it could work in our environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "from collections import namedtuple, deque\n",
    "\n",
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = int(1e5) # replay buffer size\n",
    "BATCH_SIZE = 64        # minibatch size\n",
    "GAMMA = 0.99           # discount factor\n",
    "TAU = 1e-3             # for soft update of target parameters. Used in place of fixed target technique.\n",
    "LR = 5e-4              # learning rate\n",
    "UPDATE_EVERY = 4       # how often to update the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"Fixed size buffer to store experience tuples\"\"\"\n",
    "    \n",
    "    def __init__(self, max_buffer_size, batch_size, seed):\n",
    "        \"\"\"Initialize a Replay Buffer Object\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            max_buffer_size (int): maximum size of buffer\n",
    "            batch_size (int) : size of each training batch\n",
    "            seed (int) : random seed\n",
    "        \"\"\"\n",
    "        self.memory = deque(maxlen=max_buffer_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
    "        self.seed = random.seed(seed)\n",
    "        \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        \"\"\"Add a new experience to memory\"\"\"\n",
    "        e = self.experience(state, action, reward, next_state, done)\n",
    "        self.memory.append(e)\n",
    "    \n",
    "    def random_sample(self):\n",
    "        \"\"\"Randomly sample a batch of experiences from memory\"\"\"\n",
    "        experiences = random.sample(self.memory, k=self.batch_size)\n",
    "        \n",
    "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
    "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
    "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
    "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)\n",
    "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)\n",
    "        \n",
    "        return (states, actions, rewards, next_states, dones)\n",
    "    \n",
    "    def __len__(self):\n",
    "        \"\"\"Returns the current size filled in the memory\"\"\"\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent():\n",
    "    \"\"\"Interacts with and learn from the environment\"\"\"\n",
    "    \n",
    "    def __init__(self, state_size, action_size, seed):\n",
    "        \"\"\"Initialize an Agent Object.\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            state_size (int): dimension of each state\n",
    "            action_size (int): Total number of actions\n",
    "            seed (int): random seed\n",
    "        \"\"\"\n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.seed = random.seed(seed)\n",
    "        \n",
    "        # Q Network\n",
    "        self.local_q_network = SimpleQNetwork(state_size, action_size, seed).to(device)\n",
    "        self.target_q_network = SimpleQNetwork(state_size, action_size, seed).to(device)\n",
    "        self.optimizer = optim.Adam(self.local_q_network.parameters(), lr=LR)\n",
    "        \n",
    "        # Replay Memory\n",
    "        self.memory = ReplayBuffer(BUFFER_SIZE, BATCH_SIZE, seed)\n",
    "        # initialize time step\n",
    "        self.t_step = 0\n",
    "        \n",
    "    def choose_action(self, state, eps=0.):\n",
    "        \"\"\"Returns action which should be taken for a current state as per current policy\n",
    "        \n",
    "            Params:\n",
    "            ======\n",
    "                state (array_like): current state\n",
    "                eps (float): epsilon for epsilon greedy action selection\n",
    "        \"\"\"\n",
    "        \n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
    "        self.local_q_network.eval() # first set in eval stage for evaluation of regression values\n",
    "        with torch.no_grad():\n",
    "            action_values = self.local_q_network(state)\n",
    "        self.local_q_network.train() # now that evaluation is finished above revert to train mode\n",
    "        \n",
    "        # Epsilon-greedy action selection\n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy()) # return the action having max q value\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size)) # return any one of the action randomly\n",
    "        \n",
    "    def agent_next_step(self, state, action, reward, next_state, done, is_double_q=True):\n",
    "        \"\"\"After getting reward, next_state and done status from the environment update agent experience using them\"\"\"\n",
    "        \n",
    "        # save this new experience in replay memory\n",
    "        self.memory.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        # Learn every UPDATE_EVERY time steps.\n",
    "        self.t_step = (self.t_step + 1) % UPDATE_EVERY\n",
    "        if self.t_step == 0:\n",
    "            # If enough samples are available in memory, get random subset and learn\n",
    "            if len(self.memory) > BATCH_SIZE:\n",
    "                experiences = self.memory.random_sample()\n",
    "                self.learn(experiences, GAMMA, is_double_q)\n",
    "    \n",
    "    def learn(self, experiences, gamma, is_double_q=True):\n",
    "        \"\"\"Update value parameters using selected batch of experience tuples.\n",
    "            \n",
    "            Params\n",
    "            ======\n",
    "            experiences (Tuple[torch.Variable]): tuple of (s, a, r, s', done) tuples\n",
    "            gamma (float) : discount factor\n",
    "        \"\"\"\n",
    "        \n",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "        \n",
    "        if is_double_q:\n",
    "            next_actions = self.local_q_network(next_states).detach().argmax(1).unsqueeze(1)\n",
    "            q_targets_next = self.target_q_network(next_states).gather(1, next_actions)\n",
    "        else:\n",
    "            # Get max predicted Q values (for next state) from target model\n",
    "            q_targets_next = self.target_q_network(next_states).detach().max(1)[0].unsqueeze(1)\n",
    "        # Compute Q targets for current states\n",
    "        q_targets = rewards + (gamma * q_targets_next * (1 - dones))\n",
    "        \n",
    "        # Get expected Q values from local model\n",
    "        q_expecteds = self.local_q_network(states).gather(1, actions)\n",
    "        \n",
    "        # Compute loss\n",
    "        loss = F.mse_loss(q_expecteds, q_targets)\n",
    "        # Minimize the loss\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        ## Update target network softly ##\n",
    "        self.soft_update(self.local_q_network, self.target_q_network, TAU)\n",
    "        \n",
    "    def soft_update(self, local_model, target_model, tau):\n",
    "        \"\"\"Soft update model parameters.\n",
    "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "\n",
    "        Params\n",
    "        ======\n",
    "            local_model (PyTorch model): weights will be copied from\n",
    "            target_model (PyTorch model): weights will be copied to\n",
    "            tau (float): interpolation parameter \n",
    "        \"\"\"\n",
    "        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
    "            target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = Agent(state_size, action_size, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(is_double_dqn=True, n_episodes=720, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
    "    \"\"\"Train an agent by iterating episodes\n",
    "        Params\n",
    "        ======\n",
    "            n_episodes (int): maximum number of training episodes\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",
    "    checkpoint_name = 'simple_dqn.pth'\n",
    "    if is_double_dqn:\n",
    "        checkpoint_name = 'with_double_dqn.pth'\n",
    "    scores = []\n",
    "    scores_window = deque(maxlen=120)\n",
    "    eps = eps_start\n",
    "    printed = False\n",
    "    for i in range(1, n_episodes+1):\n",
    "        env_info = env.reset(train_mode=True)[brain_name]\n",
    "        current_state = env_info.vector_observations[0]\n",
    "        score = 0\n",
    "        while True:\n",
    "            action = agent.choose_action(current_state, eps)      # Select an action\n",
    "            env_info = env.step(action)[brain_name]               # Send the action to the environment\n",
    "            next_state = env_info.vector_observations[0]           # Get the next state from env after action taken\n",
    "            reward = env_info.rewards[0]                          # Get the reward received\n",
    "            done = env_info.local_done[0]                         # See if the episode has finished\n",
    "            agent.agent_next_step(current_state, action, reward, next_state, done, is_double_dqn) # make the agent learn\n",
    "            score += reward\n",
    "            current_state = next_state\n",
    "            if done:\n",
    "                break\n",
    "        scores_window.append(score)                               # Save most recent score\n",
    "        scores.append(score)\n",
    "        eps = max(eps_end, eps_decay * eps)                       # Decrease epsilon\n",
    "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i, np.mean(scores_window)), end=\"\")\n",
    "        if i % 120 == 0:\n",
    "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i, np.mean(scores_window)))\n",
    "        if np.mean(scores_window) >= 13.0 and printed == False:\n",
    "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i-120, np.mean(scores_window)))\n",
    "            torch.save(agent.local_q_network.state_dict(), checkpoint_name)\n",
    "            printed = True\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 120\tAverage Score: 0.83\n",
      "Episode 240\tAverage Score: 3.48\n",
      "Episode 360\tAverage Score: 7.67\n",
      "Episode 480\tAverage Score: 12.11\n",
      "Episode 500\tAverage Score: 13.02\n",
      "Environment solved in 380 episodes!\tAverage Score: 13.02\n",
      "Episode 600\tAverage Score: 14.40\n",
      "Episode 720\tAverage Score: 15.07\n"
     ]
    }
   ],
   "source": [
    "scores = train_agent(is_double_dqn=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 120\tAverage Score: 2.31\n",
      "Episode 240\tAverage Score: 7.61\n",
      "Episode 360\tAverage Score: 10.90\n",
      "Episode 460\tAverage Score: 13.01\n",
      "Environment solved in 340 episodes!\tAverage Score: 13.01\n",
      "Episode 480\tAverage Score: 13.17\n",
      "Episode 600\tAverage Score: 13.31\n",
      "Episode 720\tAverage Score: 15.49\n"
     ]
    }
   ],
   "source": [
    "# using double dqn\n",
    "scores = train_agent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1adf692fd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# scores for simple dqn\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores)\n",
    "plt.title('Simple DQN')\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1add544e48>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# scores for double dqn\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores)\n",
    "plt.title('Double DQN')\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}