Submission.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run this code on the Udacity servers you will have to run the below line. If you are using a local environment you can ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mtensorflow 1.7.1 has requirement numpy>=1.13.3, but you'll have numpy 1.12.1 which is incompatible.\u001b[0m\r\n",
      "\u001b[31mipython 6.5.0 has requirement prompt-toolkit<2.0.0,>=1.0.15, but you'll have prompt-toolkit 3.0.5 which is incompatible.\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!pip -q install ./python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we will import our libraries and intialize the environment. We are using the pytorch library for our deep neural network, so we will import a few different packages from that. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we initialize our environment. Due to difficulties with the udacity VM, please only run this code once per kernel, or you will have to restart the whole thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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=\"/data/Banana_Linux_NoVis/Banana.x86_64\")\n",
    "# get the default brain\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're creating a fully connected network for our learning agent. You can see that it has the input layer the size of the state space, 2 hidden fully connected layers and an output layer the size of the action space. If we were to use the pixel version of the game, we would add at least one convolutional layer to the front of this. Future work on this network could including making more or bigger fully connected layers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QNetwork(nn.Module):\n",
    "    \"\"\"Actor (Policy) Model.\"\"\"\n",
    "\n",
    "    def __init__(self, state_size, action_size, seed, fc1_units=64, fc2_units=64):\n",
    "        \"\"\"Initialize parameters and build model.\n",
    "        Params\n",
    "        ======\n",
    "            state_size (int): Dimension of each state\n",
    "            action_size (int): Dimension of each action\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(QNetwork, 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",
    "\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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No we're creating our agent. The agent will have it's own Qnetwork to learn into, and have functions to be able to step, learn and act, so that it can interact and learn from it's environment. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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\n",
    "LR = 5e-4               # learning rate \n",
    "UPDATE_EVERY = 4        # how often to update the network\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "class Agent():\n",
    "    \"\"\"Interacts with and learns 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): dimension of each action\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.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)\n",
    "        self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)\n",
    "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n",
    "\n",
    "        # Replay memory\n",
    "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
    "        # Initialize time step (for updating every UPDATE_EVERY steps)\n",
    "        self.t_step = 0\n",
    "    \n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        # Save 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.sample()\n",
    "                self.learn(experiences, GAMMA)\n",
    "\n",
    "    def act(self, state, eps=0.):\n",
    "        \"\"\"Returns actions for given 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",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
    "        self.qnetwork_local.eval()\n",
    "        with torch.no_grad():\n",
    "            action_values = self.qnetwork_local(state)\n",
    "        self.qnetwork_local.train()\n",
    "\n",
    "        # Epsilon-greedy action selection\n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy())\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size))\n",
    "\n",
    "    def learn(self, experiences, gamma):\n",
    "        \"\"\"Update value parameters using given 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",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "\n",
    "        # Get max predicted Q values (for next states) from target model\n",
    "        Q_targets_next = self.qnetwork_target(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_expected = self.qnetwork_local(states).gather(1, actions)\n",
    "\n",
    "        # Compute loss\n",
    "        loss = F.mse_loss(Q_expected, Q_targets)\n",
    "        # Minimize the loss\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        # ------------------- update target network ------------------- #\n",
    "        self.soft_update(self.qnetwork_local, self.qnetwork_target, 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": [
    "Finally, we have our ReplayBuffer. This is an object created while learning, so that we can go back and \"replay\" our experiences in order to learn from previous experiences repeatedly. Ideally I would like to implement a prioritized experience replay in here to expand my skills. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"Fixed-size buffer to store experience tuples.\"\"\"\n",
    "\n",
    "    def __init__(self, action_size, buffer_size, batch_size, seed):\n",
    "        \"\"\"Initialize a ReplayBuffer object.\n",
    "\n",
    "        Params\n",
    "        ======\n",
    "            action_size (int): dimension of each action\n",
    "            buffer_size (int): maximum size of buffer\n",
    "            batch_size (int): size of each training batch\n",
    "            seed (int): random seed\n",
    "        \"\"\"\n",
    "        self.action_size = action_size\n",
    "        self.memory = deque(maxlen=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 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 priority_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",
    "        \"\"\"Return the current size of internal memory.\"\"\"\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\tAverage Score: 0.97\n",
      "Episode 200\tAverage Score: 3.03\n",
      "Episode 300\tAverage Score: 6.76\n",
      "Episode 400\tAverage Score: 12.51\n",
      "Episode 500\tAverage Score: 14.12\n",
      "Episode 600\tAverage Score: 16.29\n",
      "Episode 700\tAverage Score: 16.62\n",
      "Episode 800\tAverage Score: 16.16\n",
      "Episode 900\tAverage Score: 16.32\n",
      "Episode 1000\tAverage Score: 16.91\n",
      "Episode 1100\tAverage Score: 16.30\n",
      "Episode 1200\tAverage Score: 17.03\n",
      "Episode 1300\tAverage Score: 17.58\n",
      "Episode 1400\tAverage Score: 17.58\n",
      "Episode 1500\tAverage Score: 17.43\n",
      "Episode 1600\tAverage Score: 16.71\n",
      "Episode 1700\tAverage Score: 16.93\n",
      "Episode 1800\tAverage Score: 16.13\n",
      "Episode 1900\tAverage Score: 16.44\n",
      "Episode 2000\tAverage Score: 16.08\n"
     ]
    }
   ],
   "source": [
    "agent = Agent(state_size=37, action_size=4, seed=0)\n",
    "\n",
    "def dqn(n_episodes=700, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
    "    \"\"\"Deep Q-Learning.\n",
    "    \n",
    "    Params\n",
    "    ======\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",
    "    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",
    "        #state = env.reset()\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)        # 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",
    "            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",
    "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
    "        if i_episode % 100 == 0:\n",
    "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
    "        if np.mean(scores_window)>=200.0:\n",
    "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n",
    "            torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
    "            break\n",
    "    return scores\n",
    "\n",
    "scores = dqn()\n",
    "\n",
    "# plot the scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2d6689eef0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2d044c0588>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "window_size = 100\n",
    "i = 0\n",
    "moving_averages = []\n",
    "\n",
    "while i < len(scores) - window_size + 1:\n",
    "    this_window = scores[i : i + window_size]\n",
    "    window_average = sum(this_window) / window_size\n",
    "    moving_averages.append(window_average)\n",
    "    i += 1\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores, label = 'raw score')\n",
    "plt.plot(np.arange(len(moving_averages)), moving_averages, c= 'red', label = 'moving average of 100 episodes')\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}