Continuous_Control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continuous Control\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": 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 2.0.9 which is incompatible.\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!pip -q install ./python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The environments corresponding to both versions of the environment are already saved in the Workspace and can be accessed at the file paths provided below.  \n",
    "\n",
    "Please select one of the two options below for loading the environment."
   ]
  },
  {
   "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_size -> 5.0\n",
      "\t\tgoal_speed -> 1.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": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\n",
    "\n",
    "# select this option to load version 1 (with a single agent) of the environment\n",
    "env = UnityEnvironment(file_name='/data/Reacher_One_Linux_NoVis/Reacher_One_Linux_NoVis.x86_64')\n",
    "\n",
    "# select this option to load version 2 (with 20 agents) of the environment\n",
    "# env = UnityEnvironment(file_name='/data/Reacher_Linux_NoVis/Reacher.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": 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",
    "Run the code cell below to print some information about the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of agents: 1\n",
      "Size of each action: 4\n",
      "There are 1 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.55726671e+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",
    "Note that **in this coding environment, you will not be able to watch the agents while they are training**, and you should set `train_mode=True` to restart 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=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",
    "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",
    "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": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. It's Your Turn!\n",
    "\n",
    "Now it's your turn to train your own agent to solve the environment!  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 agents while they are training.  However, **_after training the agents_**, you can download the saved model weights to watch the agents on your own machine! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import matplotlib.pyplot as plt\n",
    "from ddpg_agent import Agent\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = Agent(state_size=state_size, action_size=action_size, random_seed=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg(n_episodes=1000, max_t=10000, print_every=100):\n",
    "        \"\"\"\n",
    "        params:\n",
    "            n_episodes, int: max episodes\n",
    "            max_t, int: max steps per episode\n",
    "            print_every, int: frequency of printing\n",
    "        \"\"\"\n",
    "    \n",
    "    scores = []\n",
    "    scores_deque = deque(maxlen=print_every)\n",
    "    \n",
    "    for i_episode in range(1, n_episodes+1):\n",
    "        env_info = env.reset(train_mode=True)[brain_name]\n",
    "        agent.reset()\n",
    "        state = env_info.vector_observations[0]\n",
    "        score = 0\n",
    "        \n",
    "        for t in range(max_t):\n",
    "            action = agent.act(state)\n",
    "       \n",
    "            env_info = env.step(action)[brain_name]\n",
    "            next_state = env_info.vector_observations[0]\n",
    "            reward = env_info.rewards[0]\n",
    "            done = env_info.local_done[0]\n",
    "            agent.step(state, action, reward, next_state, done)\n",
    "            score += reward\n",
    "            state = next_state\n",
    "            if done:\n",
    "                break\n",
    "        \n",
    "        scores_deque.append(score)\n",
    "        scores.append(score)\n",
    "\n",
    "        print(f'\\rEpisode {i_episodes}\\tAverage Score: {np.mean(scores_deque)}')\n",
    "        \n",
    "        if i_episode % print_every == 0:\n",
    "            print(f'\\rEpisode {i_episode}\\tAverage Score: {np.mean(scores_deque)}')\n",
    "            torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\n",
    "            torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\n",
    "        \n",
    "        if np.mean(scores_deque)>=30.0:\n",
    "            print(f'\\nsolved in {i_episode} episodes!\\tAverage Score: {np.mean(scores_deque)}')\n",
    "            torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\n",
    "            torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\n",
    "            break\n",
    "            \n",
    "    return scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\tAverage Score: 3.55\n",
      "Episode 200\tAverage Score: 23.62\n",
      "Episode 244\tAverage Score: 30.01\n",
      "Environment solved in 244 episodes!\tAverage Score: 30.01\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fab932fa550>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "scores = ddpg(n_episodes=1500)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(1, len(scores)+1), scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  }
 ],
 "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
}