Continuous_Control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continuous Control\n",
    "\n",
    "---\n",
    "\n",
    "In this notebook, you will learn how to use the Unity ML-Agents environment for the second project of the [Deep Reinforcement Learning Nanodegree](https://www.udacity.com/course/deep-reinforcement-learning-nanodegree--nd893) program.\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "We begin by importing the 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": [
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "\n",
    "from unityagents import UnityEnvironment\n",
    "from collections import deque\n",
    "from itertools import count\n",
    "import datetime\n",
    "\n",
    "from ddpg import DDPG, ReplayBuffer\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "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/Reacher.app\"`\n",
    "- **Windows** (x86): `\"path/to/Reacher_Windows_x86/Reacher.exe\"`\n",
    "- **Windows** (x86_64): `\"path/to/Reacher_Windows_x86_64/Reacher.exe\"`\n",
    "- **Linux** (x86): `\"path/to/Reacher_Linux/Reacher.x86\"`\n",
    "- **Linux** (x86_64): `\"path/to/Reacher_Linux/Reacher.x86_64\"`\n",
    "- **Linux** (x86, headless): `\"path/to/Reacher_Linux_NoVis/Reacher.x86\"`\n",
    "- **Linux** (x86_64, headless): `\"path/to/Reacher_Linux_NoVis/Reacher.x86_64\"`\n",
    "\n",
    "For instance, if you are using a Mac, then you downloaded `Reacher.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=\"Reacher.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\tgoal_speed -> 1.0\n",
      "\t\tgoal_size -> 5.0\n",
      "Unity brain name: ReacherBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 33\n",
      "        Number of stacked Vector Observation: 1\n",
      "        Vector Action space type: continuous\n",
      "        Vector Action space size (per agent): 4\n",
      "        Vector Action descriptions: , , , \n"
     ]
    }
   ],
   "source": [
    "#env = UnityEnvironment(file_name='envs/Reacher_Linux_NoVis_20/Reacher.x86_64') # Headless\n",
    "env = UnityEnvironment(file_name='envs/Reacher_Linux_20/Reacher.x86_64') # Visual"
   ]
  },
  {
   "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",
    "In this environment, a double-jointed arm can move to target locations. A reward of `+0.1` is provided for each step that the agent's hand is in the goal location. Thus, the goal of your agent is to maintain its position at the target location for as many time steps as possible.\n",
    "\n",
    "The observation space consists of `33` variables corresponding to position, rotation, velocity, and angular velocities of the arm.  Each action is a vector with four numbers, corresponding to torque applicable to two joints.  Every entry in the action vector must be a number between `-1` and `1`.\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: 20\n",
      "Size of each action: 4\n",
      "There are 20 agents. Each observes a state with length: 33\n",
      "The state for the first agent looks like: [ 0.00000000e+00 -4.00000000e+00  0.00000000e+00  1.00000000e+00\n",
      " -0.00000000e+00 -0.00000000e+00 -4.37113883e-08  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00 -1.00000000e+01  0.00000000e+00\n",
      "  1.00000000e+00 -0.00000000e+00 -0.00000000e+00 -4.37113883e-08\n",
      "  0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00  5.75471878e+00 -1.00000000e+00\n",
      "  5.55726624e+00  0.00000000e+00  1.00000000e+00  0.00000000e+00\n",
      " -1.68164849e-01]\n"
     ]
    }
   ],
   "source": [
    "# reset the environment\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "\n",
    "# number of agents\n",
    "num_agents = len(env_info.agents)\n",
    "print('Number of agents:', num_agents)\n",
    "\n",
    "# size of each action\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Size of each action:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "states = env_info.vector_observations\n",
    "state_size = states.shape[1]\n",
    "print('There are {} agents. Each observes a state with length: {}'.format(states.shape[0], state_size))\n",
    "print('The state for the first agent looks like:', states[0])"
   ]
  },
  {
   "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 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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total score (averaged over agents) this episode: 0.0\n"
     ]
    }
   ],
   "source": [
    "env_info = env.reset(train_mode=False)[brain_name]     # reset the environment    \n",
    "states = env_info.vector_observations                  # get the current state (for each agent)\n",
    "scores = np.zeros(num_agents)                          # initialize the score (for each agent)\n",
    "while True:\n",
    "    actions = np.random.randn(num_agents, action_size) # select an action (for each agent)\n",
    "    actions = np.clip(actions, -1, 1)                  # all actions between -1 and 1\n",
    "    env_info = env.step(actions)[brain_name]           # send all actions to tne environment\n",
    "    next_states = env_info.vector_observations         # get next state (for each agent)\n",
    "    rewards = env_info.rewards                         # get reward (for each agent)\n",
    "    dones = env_info.local_done                        # see if episode finished\n",
    "    scores += env_info.rewards                         # update the score (for each agent)\n",
    "    states = next_states                               # roll over states to next time step\n",
    "    if np.any(dones):                                  # exit loop if episode finished\n",
    "        break\n",
    "    break\n",
    "print('Total score (averaged over agents) this episode: {}'.format(np.mean(scores)))"
   ]
  },
  {
   "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!  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": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = int(5e5)  # replay buffer size\n",
    "CACHE_SIZE = int(6e4)\n",
    "BATCH_SIZE = 256        # minibatch size\n",
    "GAMMA = 0.99            # discount factor\n",
    "TAU = 1e-3              # for soft update of target parameters\n",
    "LR_ACTOR = 1e-3         # learning rate of the actor\n",
    "LR_CRITIC = 1e-3        # learning rate of the critic\n",
    "WEIGHT_DECAY = 0        # L2 weight decay\n",
    "UPDATE_EVERY = 20       # timesteps between updates\n",
    "NUM_UPDATES = 15        # num of update passes when updating\n",
    "EPSILON = 1.0           # epsilon for the noise process added to the actions\n",
    "EPSILON_DECAY = 1e-6    # decay for epsilon above\n",
    "NOISE_SIGMA = 0.05\n",
    "# 96 Neurons solves the environment consistently and usually fastest\n",
    "fc1_units=96\n",
    "fc2_units=96\n",
    "\n",
    "random_seed=23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.store(buffers, states, actions, rewards, next_states, dones, timestep)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def store(buffers, states, actions, rewards, next_states, dones, timestep):\n",
    "    memory, cache = buffers\n",
    "    for state, action, reward, next_state, done in zip(states, actions, rewards, next_states, dones):\n",
    "        memory.add(state, action, reward, next_state, done)\n",
    "        cache.add(state, action, reward, next_state, done)\n",
    "store        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.learn(agent, buffers, timestep)>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def learn(agent, buffers, timestep):\n",
    "    memory, cache = buffers\n",
    "    if len(memory) > BATCH_SIZE and timestep % UPDATE_EVERY == 0:            \n",
    "        for _ in range(NUM_UPDATES):\n",
    "            experiences = memory.sample()\n",
    "            agent.learn(experiences, GAMMA)\n",
    "        for _ in range(3):\n",
    "            experiences = cache.sample()\n",
    "            agent.learn(experiences, GAMMA)\n",
    "learn            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.ddpg(agent, buffers, n_episodes=200, stopOnSolved=True)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_over = 100\n",
    "print_every = 10\n",
    "\n",
    "def ddpg(agent, buffers, n_episodes=200, stopOnSolved=True):\n",
    "    print('Start: ',datetime.datetime.now())\n",
    "    scores_deque = deque(maxlen=avg_over)\n",
    "    scores_global = []\n",
    "    average_global = []\n",
    "    min_global = []\n",
    "    max_global = []\n",
    "    best_avg = -np.inf\n",
    "\n",
    "    tic = time.time()\n",
    "    print('\\rEpis,EpAvg,GlAvg,  Max,  Min, Time')\n",
    "    for i_episode in range(1, n_episodes+1):\n",
    "        env_info = env.reset(train_mode=True)[brain_name]      # reset the environment    \n",
    "        states = env_info.vector_observations                  # get the current state (for each agent)\n",
    "        scores = np.zeros(num_agents)                          # initialize the score (for each agent)\n",
    "        agent.reset()\n",
    "        \n",
    "        score_average = 0\n",
    "        timestep = time.time()\n",
    "        for t in count():\n",
    "            actions = agent.act(states, add_noise=True)\n",
    "            env_info = env.step(actions)[brain_name]           # send all actions to tne environment\n",
    "            next_states = env_info.vector_observations         # get next state (for each agent)\n",
    "            rewards = env_info.rewards                         # get reward (for each agent)\n",
    "            dones = env_info.local_done                        # see if episode finished            \n",
    "            store(buffers, states, actions, rewards, next_states, dones, t)\n",
    "            learn(agent, buffers, t)\n",
    "            states = next_states                               # roll over states to next time step\n",
    "            scores += rewards                                  # update the score (for each agent)            \n",
    "            if np.any(dones):                                  # exit loop if episode finished\n",
    "                break\n",
    "        \n",
    "        score = np.mean(scores)        \n",
    "        scores_deque.append(score)\n",
    "        score_average = np.mean(scores_deque)\n",
    "        scores_global.append(score)\n",
    "        average_global.append(score_average)  \n",
    "        min_global.append(np.min(scores))  \n",
    "        max_global.append(np.max(scores))  \n",
    "        print('\\r {}, {:.2f}, {:.2f}, {:.2f}, {:.2f}, {:.2f}'\\\n",
    "              .format(str(i_episode).zfill(3), score, score_average, np.max(scores), \n",
    "                      np.min(scores), time.time() - timestep), end=\"\\n\")        \n",
    "        if i_episode % print_every == 0:\n",
    "            agent.save('./')            \n",
    "        if  stopOnSolved and score_average >= 30.0:            \n",
    "            toc = time.time()\n",
    "            print('\\nSolved in {:d} episodes!\\tAvg Score: {:.2f}, time: {}'.format(i_episode, score_average, toc-tic))\n",
    "            agent.save('./'+str(i_episode)+'_')\n",
    "            break\n",
    "     \n",
    "    print('End: ',datetime.datetime.now())\n",
    "    return scores_global, average_global, max_global, min_global\n",
    "\n",
    "ddpg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start:  2018-10-22 18:07:36.058249\n",
      "Epis,EpAvg,GlAvg,  Max,  Min, Time\n",
      " 001, 0.51, 0.51, 1.09, 0.11, 12.53\n",
      " 002, 0.73, 0.62, 1.97, 0.00, 12.28\n",
      " 003, 0.78, 0.67, 1.83, 0.17, 12.09\n",
      " 004, 0.88, 0.73, 2.59, 0.14, 12.22\n",
      " 005, 1.05, 0.79, 2.22, 0.45, 12.23\n",
      " 006, 1.05, 0.83, 1.73, 0.44, 12.40\n",
      " 007, 1.12, 0.87, 2.61, 0.33, 12.71\n",
      " 008, 1.33, 0.93, 2.32, 0.04, 12.76\n",
      " 009, 1.92, 1.04, 3.50, 0.10, 12.94\n",
      " 010, 2.39, 1.18, 3.79, 0.73, 12.87\n",
      " 011, 2.10, 1.26, 4.37, 0.60, 13.00\n",
      " 012, 2.18, 1.34, 3.77, 0.73, 13.22\n",
      " 013, 3.41, 1.50, 5.76, 1.64, 13.54\n",
      " 014, 4.08, 1.68, 7.74, 2.53, 13.51\n",
      " 015, 4.05, 1.84, 6.53, 1.22, 14.05\n",
      " 016, 5.10, 2.04, 9.38, 2.01, 14.14\n",
      " 017, 4.28, 2.17, 8.01, 1.57, 14.20\n",
      " 018, 4.95, 2.33, 8.30, 1.62, 14.78\n",
      " 019, 6.12, 2.53, 13.01, 2.59, 14.61\n",
      " 020, 6.99, 2.75, 11.67, 3.59, 14.49\n",
      " 021, 5.71, 2.89, 12.32, 2.96, 14.71\n",
      " 022, 6.78, 3.07, 13.16, 3.37, 15.27\n",
      " 023, 8.15, 3.29, 13.13, 4.53, 15.15\n",
      " 024, 9.46, 3.55, 14.86, 4.44, 15.94\n",
      " 025, 9.51, 3.79, 14.28, 4.59, 16.04\n",
      " 026, 10.83, 4.06, 15.42, 6.10, 17.47\n",
      " 027, 10.95, 4.31, 17.01, 4.85, 17.01\n",
      " 028, 11.31, 4.56, 18.33, 5.65, 16.17\n",
      " 029, 12.17, 4.82, 18.43, 2.67, 16.53\n",
      " 030, 12.57, 5.08, 17.44, 6.91, 16.99\n",
      " 031, 12.54, 5.32, 19.20, 7.18, 17.67\n",
      " 032, 15.06, 5.63, 21.38, 8.77, 18.03\n",
      " 033, 13.89, 5.88, 21.54, 9.18, 18.16\n",
      " 034, 14.67, 6.14, 20.91, 5.97, 18.54\n",
      " 035, 17.80, 6.47, 23.40, 11.44, 18.54\n",
      " 036, 20.49, 6.86, 38.39, 6.55, 18.43\n",
      " 037, 23.27, 7.30, 28.21, 16.53, 19.03\n",
      " 038, 24.36, 7.75, 35.24, 15.74, 18.99\n",
      " 039, 24.60, 8.18, 35.81, 8.72, 20.19\n",
      " 040, 25.19, 8.61, 30.01, 19.37, 19.06\n",
      " 041, 26.88, 9.05, 32.64, 21.47, 20.03\n",
      " 042, 26.37, 9.47, 35.07, 18.69, 20.36\n",
      " 043, 28.64, 9.91, 35.34, 22.21, 21.35\n",
      " 044, 29.17, 10.35, 33.88, 24.41, 20.51\n",
      " 045, 28.24, 10.75, 34.76, 21.07, 20.16\n",
      " 046, 30.40, 11.18, 37.57, 22.16, 20.50\n",
      " 047, 30.05, 11.58, 36.40, 24.65, 20.19\n",
      " 048, 31.68, 12.00, 38.45, 24.59, 20.73\n",
      " 049, 31.15, 12.39, 35.83, 24.57, 21.11\n",
      " 050, 32.46, 12.79, 39.34, 18.16, 22.00\n",
      " 051, 32.44, 13.17, 39.34, 18.74, 22.07\n",
      " 052, 35.50, 13.60, 39.60, 30.02, 21.62\n",
      " 053, 35.22, 14.01, 39.54, 29.48, 22.12\n",
      " 054, 35.34, 14.41, 39.32, 26.27, 21.98\n",
      " 055, 37.20, 14.82, 39.55, 30.60, 21.44\n",
      " 056, 36.98, 15.22, 39.42, 33.16, 20.86\n",
      " 057, 36.70, 15.59, 39.25, 32.87, 21.15\n",
      " 058, 36.82, 15.96, 39.52, 31.55, 21.54\n",
      " 059, 36.33, 16.30, 39.51, 27.50, 23.25\n",
      " 060, 36.19, 16.64, 39.56, 32.40, 23.51\n",
      " 061, 37.29, 16.97, 39.49, 32.23, 23.20\n",
      " 062, 36.02, 17.28, 39.52, 29.72, 27.99\n",
      " 063, 36.36, 17.58, 39.20, 29.44, 23.26\n",
      " 064, 35.23, 17.86, 39.50, 28.77, 21.87\n",
      " 065, 37.89, 18.17, 39.54, 27.34, 21.11\n",
      " 066, 35.91, 18.44, 39.57, 26.63, 21.33\n",
      " 067, 37.73, 18.72, 39.51, 32.23, 23.02\n",
      " 068, 38.51, 19.02, 39.63, 36.12, 20.81\n",
      " 069, 37.93, 19.29, 39.54, 35.12, 20.68\n",
      " 070, 38.49, 19.56, 39.51, 34.50, 20.54\n",
      " 071, 37.70, 19.82, 39.60, 29.43, 20.62\n",
      " 072, 38.44, 20.08, 39.60, 36.08, 20.53\n",
      " 073, 38.09, 20.33, 39.57, 35.33, 20.74\n",
      " 074, 38.64, 20.57, 39.56, 36.23, 21.02\n",
      " 075, 38.62, 20.81, 39.66, 36.25, 21.00\n",
      " 076, 38.64, 21.05, 39.56, 35.62, 20.71\n",
      " 077, 39.17, 21.28, 39.51, 38.15, 21.09\n",
      " 078, 38.90, 21.51, 39.49, 38.20, 20.88\n",
      " 079, 39.05, 21.73, 39.60, 35.87, 20.60\n",
      " 080, 39.18, 21.95, 39.57, 37.41, 20.67\n",
      " 081, 37.93, 22.15, 39.54, 33.52, 20.70\n",
      " 082, 37.66, 22.34, 39.30, 34.44, 20.80\n",
      " 083, 38.45, 22.53, 39.54, 33.71, 20.71\n",
      " 084, 38.81, 22.72, 39.59, 36.97, 20.77\n",
      " 085, 38.75, 22.91, 39.58, 36.35, 20.79\n",
      " 086, 38.67, 23.10, 39.62, 33.24, 21.00\n",
      " 087, 38.05, 23.27, 39.61, 35.26, 20.99\n",
      " 088, 38.85, 23.44, 39.59, 37.19, 20.72\n",
      " 089, 39.26, 23.62, 39.55, 38.54, 20.78\n",
      " 090, 38.85, 23.79, 39.66, 34.69, 20.56\n",
      " 091, 38.69, 23.96, 39.58, 36.42, 20.47\n",
      " 092, 39.00, 24.12, 39.57, 37.05, 20.75\n",
      " 093, 38.60, 24.27, 39.55, 36.43, 20.57\n",
      " 094, 38.76, 24.43, 39.59, 36.81, 20.85\n",
      " 095, 38.67, 24.58, 39.61, 32.09, 20.86\n",
      " 096, 38.30, 24.72, 39.51, 33.45, 20.66\n",
      " 097, 36.94, 24.85, 39.04, 32.80, 20.70\n",
      " 098, 36.45, 24.97, 39.59, 32.08, 20.38\n",
      " 099, 36.91, 25.09, 39.35, 30.84, 20.36\n",
      " 100, 38.79, 25.22, 39.66, 36.67, 20.88\n",
      " 101, 35.07, 25.57, 39.53, 26.10, 20.87\n",
      " 102, 36.42, 25.93, 38.18, 33.47, 21.15\n",
      " 103, 35.36, 26.27, 39.52, 26.30, 20.68\n",
      " 104, 34.30, 26.61, 38.48, 27.45, 20.76\n",
      " 105, 37.15, 26.97, 39.67, 19.72, 21.08\n",
      " 106, 35.29, 27.31, 39.62, 29.61, 20.73\n",
      " 107, 36.21, 27.66, 39.51, 23.82, 20.85\n",
      " 108, 34.45, 27.99, 39.68, 25.07, 20.60\n",
      " 109, 33.81, 28.31, 38.84, 26.93, 20.65\n",
      " 110, 33.49, 28.62, 39.51, 24.37, 20.99\n",
      " 111, 32.92, 28.93, 39.05, 27.07, 21.00\n",
      " 112, 36.27, 29.27, 39.20, 20.57, 20.89\n",
      " 113, 31.63, 29.55, 35.82, 20.15, 20.91\n",
      " 114, 34.66, 29.86, 39.31, 22.26, 20.95\n",
      " 115, 32.98, 30.15, 39.66, 22.31, 21.01\n",
      "\n",
      "Solved in 115 episodes!\tAvg Score: 30.15, time: 2198.465326309204\n",
      "End:  2018-10-22 18:44:14.525753\n"
     ]
    }
   ],
   "source": [
    "# Create new empty buffers to start training from scratch\n",
    "buffers = [ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, random_seed),\n",
    "           ReplayBuffer(action_size, CACHE_SIZE, BATCH_SIZE, random_seed)]\n",
    "agent = DDPG(state_size=state_size, action_size=action_size, random_seed=23, \n",
    "              fc1_units=96, fc2_units=96)\n",
    "scores, averages, maxima, minima = ddpg(agent, buffers, n_episodes=130)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": [
    "plt.plot(np.arange(1, len(scores)+1), scores)\n",
    "plt.plot(np.arange(1, len(averages)+1), averages)\n",
    "plt.plot(np.arange(1, len(maxima)+1), maxima)\n",
    "plt.plot(np.arange(1, len(minima)+1), minima)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.legend(['EpAvg', 'GlAvg', 'Max', 'Min'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start:  2018-10-22 20:29:34.054026\n",
      "Epis,EpAvg,GlAvg,  Max,  Min, Time\n",
      " 001, 0.63, 0.63, 1.79, 0.00, 21.90\n",
      " 002, 0.90, 0.76, 2.23, 0.07, 22.22\n",
      " 003, 0.89, 0.81, 1.99, 0.00, 24.03\n",
      " 004, 1.17, 0.90, 2.59, 0.14, 22.20\n",
      " 005, 1.51, 1.02, 2.57, 0.50, 24.96\n",
      " 006, 1.19, 1.05, 1.99, 0.23, 23.43\n",
      " 007, 1.09, 1.05, 1.90, 0.17, 24.12\n",
      " 008, 1.11, 1.06, 2.73, 0.18, 23.34\n",
      " 009, 2.98, 1.27, 5.04, 1.60, 23.90\n",
      " 010, 3.74, 1.52, 7.35, 0.96, 23.29\n",
      " 011, 4.95, 1.83, 10.34, 1.99, 23.06\n",
      " 012, 11.34, 2.63, 18.17, 4.67, 22.91\n",
      " 013, 21.51, 4.08, 28.17, 14.17, 23.59\n",
      " 014, 31.32, 6.02, 36.47, 22.24, 23.39\n",
      " 015, 34.92, 7.95, 39.59, 25.19, 22.69\n",
      " 016, 37.14, 9.78, 38.96, 34.27, 26.16\n",
      " 017, 35.03, 11.26, 39.42, 21.28, 23.17\n",
      " 018, 34.21, 12.54, 39.49, 15.96, 23.29\n",
      " 019, 37.11, 13.83, 39.28, 33.14, 22.98\n",
      " 020, 36.58, 14.97, 39.41, 30.97, 23.08\n",
      " 021, 36.56, 16.00, 39.59, 17.56, 24.16\n",
      " 022, 37.45, 16.97, 39.54, 34.50, 23.07\n",
      " 023, 37.94, 17.88, 39.38, 36.54, 22.74\n",
      " 024, 35.29, 18.61, 39.27, 7.56, 23.34\n",
      " 025, 37.80, 19.38, 39.65, 35.15, 23.15\n",
      " 026, 37.67, 20.08, 39.49, 32.14, 22.25\n",
      " 027, 37.85, 20.74, 39.66, 31.38, 22.22\n",
      " 028, 34.27, 21.22, 37.76, 30.16, 22.70\n",
      " 029, 34.96, 21.69, 39.16, 21.20, 23.54\n",
      " 030, 38.76, 22.26, 39.66, 36.52, 22.84\n",
      " 031, 38.03, 22.77, 39.56, 34.17, 23.26\n",
      " 032, 37.96, 23.25, 39.62, 33.99, 23.13\n",
      " 033, 33.52, 23.56, 39.20, 19.16, 23.15\n",
      " 034, 37.37, 23.96, 39.55, 33.80, 22.96\n",
      " 035, 37.87, 24.36, 39.59, 33.72, 22.81\n",
      " 036, 37.59, 24.73, 39.42, 31.33, 22.25\n",
      " 037, 36.08, 25.04, 39.63, 20.37, 22.68\n",
      " 038, 34.42, 25.28, 38.69, 24.79, 22.27\n",
      " 039, 35.84, 25.55, 39.01, 27.73, 22.83\n",
      " 040, 36.20, 25.82, 39.01, 31.21, 22.09\n",
      " 041, 34.97, 26.04, 38.93, 25.67, 22.46\n",
      " 042, 37.29, 26.31, 39.51, 25.98, 21.99\n",
      " 043, 33.40, 26.47, 39.36, 19.35, 22.72\n",
      " 044, 35.01, 26.67, 39.46, 20.89, 22.18\n",
      " 045, 37.66, 26.91, 39.02, 35.71, 22.95\n",
      " 046, 36.21, 27.12, 39.19, 34.00, 23.37\n",
      " 047, 35.21, 27.29, 39.01, 27.84, 23.27\n",
      " 048, 37.36, 27.50, 39.56, 33.30, 23.14\n",
      " 049, 38.45, 27.72, 39.57, 36.27, 23.04\n",
      " 050, 37.02, 27.91, 39.36, 33.33, 23.05\n",
      " 051, 35.69, 28.06, 38.29, 26.76, 23.06\n",
      " 052, 35.78, 28.21, 39.16, 23.28, 22.73\n",
      " 053, 36.31, 28.36, 38.86, 31.58, 22.83\n",
      " 054, 30.98, 28.41, 38.84, 22.66, 23.31\n",
      " 055, 34.44, 28.52, 39.07, 13.21, 22.64\n",
      " 056, 34.64, 28.63, 39.42, 21.66, 23.05\n",
      " 057, 34.14, 28.72, 38.72, 23.39, 22.84\n",
      " 058, 34.42, 28.82, 39.31, 23.66, 22.45\n",
      " 059, 34.60, 28.92, 37.94, 31.20, 22.94\n",
      " 060, 36.07, 29.04, 39.35, 32.60, 23.65\n",
      " 061, 35.45, 29.15, 38.02, 30.65, 23.33\n",
      " 062, 36.85, 29.27, 39.45, 32.68, 26.06\n",
      " 063, 37.64, 29.40, 39.49, 27.42, 25.28\n",
      " 064, 34.84, 29.49, 39.53, 6.43, 25.96\n",
      " 065, 36.42, 29.59, 39.51, 32.75, 25.03\n",
      " 066, 34.80, 29.67, 39.66, 17.90, 24.94\n",
      " 067, 36.07, 29.77, 39.27, 31.23, 25.69\n",
      " 068, 33.33, 29.82, 37.99, 9.40, 24.59\n",
      " 069, 34.48, 29.89, 39.38, 28.72, 24.86\n",
      " 070, 34.62, 29.96, 38.92, 29.30, 24.17\n",
      " 071, 36.70, 30.05, 39.55, 29.94, 24.15\n",
      "\n",
      "Solved in 71 episodes!\tAvg Score: 30.05, time: 1657.2164599895477\n",
      "End:  2018-10-22 20:57:11.275171\n"
     ]
    }
   ],
   "source": [
    "# Smaller agent learning this task from larger agent experiences\n",
    "agent = DDPG(state_size=state_size, action_size=action_size, random_seed=23, \n",
    "              fc1_units=48, fc2_units=48)\n",
    "scores, averages, maxima, minima = ddpg(agent, buffers, n_episodes=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": [
    "plt.plot(np.arange(1, len(scores)+1), scores)\n",
    "plt.plot(np.arange(1, len(averages)+1), averages)\n",
    "plt.plot(np.arange(1, len(maxima)+1), maxima)\n",
    "plt.plot(np.arange(1, len(minima)+1), minima)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.legend(['EpAvg', 'GlAvg', 'Max', 'Min'], loc='lower center')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saves experiences for training future agents. Warning file is quite large."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "memory, cache = buffers\n",
    "memory.save('experiences.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#env.close() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. See the pre-trained agent in action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DDPG(state_size=state_size, action_size=action_size, random_seed=23, \n",
    "              fc1_units=96, fc2_units=96)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.load('./saves/96_96_108_actor.pth', './saves/96_96_108_critic.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play(agent, episodes=3):\n",
    "    for i_episode in range(episodes):\n",
    "        env_info = env.reset(train_mode=False)[brain_name]     # reset the environment    \n",
    "        states = env_info.vector_observations                  # get the current state (for each agent)\n",
    "        scores = np.zeros(num_agents)                          # initialize the score (for each agent)\n",
    "        while True:\n",
    "            actions = np.random.randn(num_agents, action_size) # select an action (for each agent)\n",
    "            actions = agent.act(states, add_noise=False)       # all actions between -1 and 1\n",
    "            env_info = env.step(actions)[brain_name]           # send all actions to tne environment\n",
    "            next_states = env_info.vector_observations         # get next state (for each agent)\n",
    "            rewards = env_info.rewards                         # get reward (for each agent)\n",
    "            dones = env_info.local_done                        # see if episode finished\n",
    "            scores += env_info.rewards                         # update the score (for each agent)\n",
    "            states = next_states                               # roll over states to next time step\n",
    "            if np.any(dones):                                  # exit loop if episode finished\n",
    "                break\n",
    "            #break\n",
    "        print('Ep No: {} Total score (averaged over agents): {}'.format(i_episode, np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ep No: 0 Total score (averaged over agents): 37.69499915745109\n",
      "Ep No: 1 Total score (averaged over agents): 36.70099917966873\n",
      "Ep No: 2 Total score (averaged over agents): 36.49249918432906\n",
      "Ep No: 3 Total score (averaged over agents): 37.94049915196374\n",
      "Ep No: 4 Total score (averaged over agents): 37.35449916506186\n",
      "Ep No: 5 Total score (averaged over agents): 37.17449916908517\n",
      "Ep No: 6 Total score (averaged over agents): 36.74749917862937\n",
      "Ep No: 7 Total score (averaged over agents): 37.175499169062824\n",
      "Ep No: 8 Total score (averaged over agents): 37.99799915067852\n",
      "Ep No: 9 Total score (averaged over agents): 36.05999919399619\n"
     ]
    }
   ],
   "source": [
    "play(agent, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Experiences\n",
    "\n",
    "Experiences from the Replay Buffer could be saved and loaded for training different agents.\n",
    "As an example I've provided `experiences.pkl.7z` which you should unpack with your favorite archiver."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create new ReplayBuffer and load saved experiences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "savedBuffer = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, random_seed)\n",
    "savedBuffer.load('experiences.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afterward you can use it to train your agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[  0.1843,  -2.1884,  -3.3540,  ...,   1.0000,   0.0000,\n",
       "            0.2906],\n",
       "         [ -0.3340,  -2.9106,   2.7314,  ...,   1.0000,   0.0000,\n",
       "            0.2096],\n",
       "         [  2.7665,  -2.8140,  -0.6899,  ...,   1.0000,   0.0000,\n",
       "           -0.5139],\n",
       "         ...,\n",
       "         [  2.4666,  -3.1540,  -0.0464,  ...,   1.0000,   0.0000,\n",
       "           -0.6285],\n",
       "         [  0.5272,  -2.4832,   3.1011,  ...,   1.0000,   0.0000,\n",
       "            0.7270],\n",
       "         [  0.3468,  -3.1214,  -2.4845,  ...,   1.0000,   0.0000,\n",
       "           -0.1191]], device='cuda:0'),\n",
       " tensor([[ 0.7887,  0.4954,  0.0996, -0.2518],\n",
       "         [-0.8927,  1.0790,  1.0477,  0.2699],\n",
       "         [ 0.4094,  1.1508,  0.4509,  0.2106],\n",
       "         ...,\n",
       "         [-0.6975,  1.0367, -0.2684,  0.0584],\n",
       "         [-0.0126,  1.1495,  0.0086,  0.3860],\n",
       "         [ 1.1436, -0.0179, -0.4752, -0.6036]], device='cuda:0'),\n",
       " tensor(1.00000e-02 *\n",
       "        [[ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 3.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 2.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 0.0000],\n",
       "         [ 0.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 0.0000],\n",
       "         [ 1.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 2.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000],\n",
       "         [ 4.0000]], device='cuda:0'),\n",
       " tensor([[  0.1256,  -2.1803,  -3.3621,  ...,   1.0000,   0.0000,\n",
       "            0.2906],\n",
       "         [ -0.3615,  -2.9228,   2.7148,  ...,   1.0000,   0.0000,\n",
       "            0.2096],\n",
       "         [  2.7866,  -2.8036,  -0.6504,  ...,   1.0000,   0.0000,\n",
       "           -0.5139],\n",
       "         ...,\n",
       "         [  2.4529,  -3.1636,   0.1022,  ...,   1.0000,   0.0000,\n",
       "           -0.6285],\n",
       "         [  0.6258,  -2.5206,   3.0521,  ...,   1.0000,   0.0000,\n",
       "            0.7270],\n",
       "         [  0.4101,  -3.1097,  -2.4894,  ...,   1.0000,   0.0000,\n",
       "           -0.1191]], device='cuda:0'),\n",
       " tensor([[ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.],\n",
       "         [ 0.]], device='cuda:0'))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "savedBuffer.sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}