Train_Vector_DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML-Agents: Banana Collector \n",
    "Double DQN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git clone https://github.com/Unity-Technologies/ml-agents.git\n",
    "!git -C ml-agents checkout 0.4.0b\n",
    "\n",
    "!sudo pip3 install ml-agents/python/.\n",
    "\n",
    "!pip install grpcio\n",
    "!pip install seaborn\n",
    "!pip install tqdm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Linux_NoVis.zip\n",
    "!unzip Banana_Linux_NoVis.zip\n",
    "!mv Banana_Linux_NoVis/ data/\n",
    "!rm Banana_Linux_NoVis.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys \n",
    "sys.path.append(\"ml-agents/python\")\n",
    "import numpy as np\n",
    "from unityagents import UnityEnvironment\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tnrange, tqdm_notebook\n",
    "from IPython.display import FileLink, FileLinks\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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\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.x86_64\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]\n",
    "\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "action_size = brain.vector_action_space_size\n",
    "state = env_info.vector_observations[0]\n",
    "state_size = len(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reset_env(env, brain_name):\n",
    "    env_info = env.reset(train_mode=True)[brain_name]\n",
    "    return env_info.vector_observations[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step_env(env, action, brain_name):\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",
    "    return (next_state, reward, done)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_replay_memory(agent, env, action_size, brain_name, size=50000):\n",
    "    state = reset_env(env, brain_name)\n",
    "    it = 0\n",
    "    while it < size:\n",
    "        action = np.random.randint(action_size)\n",
    "        next_state, reward, done = step_env(env,action,brain_name)\n",
    "        agent.step(state, action, reward, next_state, done, train=False)\n",
    "        \n",
    "        it+=1 \n",
    "        if done:\n",
    "            state = reset_env(env, brain_name)\n",
    "        else:\n",
    "            state = next_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(agent, scores, env, brain_name, episodes, steps, replay_start_size, \n",
    "          inital_eps, final_eps, final_exp_ep,\n",
    "          print_every=10, out_file='model_v1.ckpt'):\n",
    "    #init_replay_memory(agent, env, replay_start_size)\n",
    "    \n",
    "    eps = initial_eps\n",
    "    last_saved = 0 \n",
    "    it = 0\n",
    "\n",
    "    with tnrange(episodes) as t: \n",
    "        for ep_i in t: \n",
    "            state = reset_env(env, brain_name)\n",
    "            score = 0\n",
    "            for step_i in range(steps):\n",
    "                action = agent.act(state, epsilon=eps)\n",
    "                next_state, reward, done = step_env(env,action,brain_name)\n",
    "                score += reward\n",
    "                agent.step(state, action, reward, next_state, done)\n",
    "                it += 1 \n",
    "                state = next_state\n",
    "                if done:\n",
    "                    break\n",
    "                \n",
    "            eps = max(final_eps,initial_eps-(initial_eps-final_eps)/final_exp_ep*ep_i) \n",
    "            scores.add(score)\n",
    "        \n",
    "            if (ep_i+1) % print_every == 0:\n",
    "                t.set_postfix(epsilon=eps, score=scores.last)\n",
    "        \n",
    "            if scores.last >= 13.0 and scores.last > last_saved:\n",
    "                last_saved = scores.last\n",
    "                print('Saving...')\n",
    "                agent.save(out_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hyper_search(scores, env, brain_name, \n",
    "                 lrates, \n",
    "                 final_exp_eps, \n",
    "                 taus, \n",
    "                 final_epsilons, \n",
    "                 gammas,\n",
    "                 episodes=500, \n",
    "                 iterations=10):\n",
    "    env_info = env.reset(train_mode=True)[brain_name]\n",
    "    action_size = brain.vector_action_space_size\n",
    "    state = env_info.vector_observations[0]\n",
    "    state_size = len(state)\n",
    "    \n",
    "    for it in range(iterations):\n",
    "        lrate = lrates[np.random.randint(len(lrates))]\n",
    "        final_exp_ep = final_exp_eps[np.random.randint(len(final_exp_eps))]\n",
    "        tau = taus[np.random.randint(len(taus))] \n",
    "        final_eps = final_epsilons[np.random.randint(len(final_epsilons))] \n",
    "        gamma = gammas[np.random.randint(len(gammas))] \n",
    "        \n",
    "        agent = Agent(\n",
    "            state_size, \n",
    "            action_size, \n",
    "            seed=0, \n",
    "            replay_size=replay_size,\n",
    "            tau = tau,\n",
    "            lrate = lrate, \n",
    "            gamma = gamma\n",
    "        )\n",
    "        \n",
    "        score = helpers.MovingResult(100, params = agent.params, name='score')\n",
    "        score.params.add('final_exp_ep', final_exp_ep) \n",
    "        score.params.add('final_eps', final_eps)\n",
    "        scores.append(score)\n",
    "        \n",
    "        print(f'-- Iteration {it+1}/{iterations} --')\n",
    "        print(f'{score.params}')\n",
    "        \n",
    "        train(\n",
    "            agent, \n",
    "            score, \n",
    "            env, \n",
    "            brain_name,\n",
    "            episodes, \n",
    "            steps, \n",
    "            replay_start_size, \n",
    "            initial_eps, final_eps, \n",
    "            final_exp_ep\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_scores(scores):\n",
    "    plt.figure(figsize=(10,5), dpi=80)\n",
    "    \n",
    "    for i in range(len(scores)):\n",
    "        print(f'Test #{i+1}: {scores[i].params}')\n",
    "        x_moving, y_moving = zip(*scores[i].buffer_moving)\n",
    "        plt.plot(list(x_moving), list(y_moving), label=f'Test #{i+1}')\n",
    "        \n",
    "    plt.legend()\n",
    "    plt.xlabel('Episode #')\n",
    "    plt.ylabel(f'Moving Score (100)')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_score(env, brain_name, agent):\n",
    "    scores = np.zeros(100)\n",
    "    for ep_i in range(scores.shape[0]):\n",
    "        state = reset_env(env, brain_name)\n",
    "        score = 0\n",
    "        while True:\n",
    "            action = agent.act(state)\n",
    "            next_state, reward, done = step_env(env,action,brain_name)\n",
    "            score += reward\n",
    "            state = next_state\n",
    "            if done: \n",
    "                scores[ep_i] = score\n",
    "                break    \n",
    "    return scores.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "\n",
    "from replay_buffer import ReplayBuffer\n",
    "from moving_result import MovingResult\n",
    "\n",
    "class QNetwork(nn.Module):\n",
    "    def __init__(self, state_size, action_size, layers, seed=None):\n",
    "        super(QNetwork, self).__init__()\n",
    "        torch.manual_seed(seed)\n",
    "        ls = [nn.Linear(state_size, layers[0])]\n",
    "        ls.extend([nn.Linear(layers[i], layers[i+1]) for i in range(len(layers)-1)])\n",
    "        ls.append(nn.Linear(layers[-1], action_size))\n",
    "        \n",
    "        self.layers = nn.ModuleList(ls)\n",
    "        self.bns = nn.ModuleList([nn.BatchNorm1d(l) for l in layers])\n",
    "        \n",
    "    def forward(self, x):\n",
    "        for i, l in enumerate(self.layers[:-1]):\n",
    "            x = self.bns[i](F.relu(l(x)))\n",
    "        x = self.layers[-1](x)\n",
    "        return x\n",
    "\n",
    "class Agent():\n",
    "    \"\"\"Double DQN Agent with epsilon-greedy policy \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    state_size: int \n",
    "        Size of the observation space\n",
    "    action_size: int\n",
    "        Number of discrete actions\n",
    "    seed: int \n",
    "        Number for random seeding\n",
    "    replay_size: int\n",
    "        Size of the experience replay buffer\n",
    "    batch_size: int\n",
    "        Size of the batch used when learning\n",
    "    gamma: float\n",
    "        Discount rate\n",
    "    lrate: int or float\n",
    "        Learning rate \n",
    "    tau: float\n",
    "        Soft target update rate\n",
    "    \"\"\"\n",
    "    def __init__(self, state_size=None, action_size=None, seed=None,\n",
    "                 replay_size = 100000, batch_size=64, \n",
    "                 gamma=0.99, lrate=5e-4, tau=0.001, update_every = 4, \n",
    "                 hidden_layers = [250, 500, 250],\n",
    "                 restore=None):\n",
    "\n",
    "        if restore is not None:\n",
    "            checkpoint = torch.load(restore, map_location={'cuda:0': 'cpu'})\n",
    "\n",
    "        self.seed = seed if not restore else checkpoint['seed']\n",
    "        self.action_size = action_size if not restore else checkpoint['action_size']\n",
    "        self.state_size = state_size if not restore else checkpoint['state_size']\n",
    "        self.replay_size = replay_size if not restore else checkpoint['replay_size']\n",
    "        self.batch_size = batch_size if not restore else checkpoint['batch_size']\n",
    "        self.gamma = gamma if not restore else checkpoint['gamma']\n",
    "        self.lrate = lrate if not restore else checkpoint['lrate']\n",
    "        self.tau = tau if not restore else checkpoint['tau']\n",
    "        self.update_every = update_every if not restore else checkpoint['update_every']\n",
    "        self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "        self.hidden_layers = hidden_layers if not restore else checkpoint['hidden_layers']\n",
    "        \n",
    "        self.q_network = QNetwork(\n",
    "            self.state_size, \n",
    "            self.action_size, \n",
    "            self.hidden_layers, \n",
    "            self.seed\n",
    "        ).to(self.device)\n",
    "\n",
    "        self.q_network_target = QNetwork(\n",
    "            self.state_size, \n",
    "            self.action_size, \n",
    "            self.hidden_layers, \n",
    "            self.seed\n",
    "        ).to(self.device)\n",
    "        \n",
    "        if restore is not None:\n",
    "            self.q_network.load_state_dict(checkpoint['state_dict'])\n",
    "            self.q_network_target.load_state_dict(checkpoint['state_dict'])\n",
    "\n",
    "        self.optimizer = optim.Adam(self.q_network.parameters(), lr=self.lrate)\n",
    "        \n",
    "        self.reset()\n",
    "        \n",
    "    def save(self, filename):\n",
    "        checkpoint = self.params\n",
    "        checkpoint['state_dict'] = self.q_network.state_dict()\n",
    "        torch.save(checkpoint, filename)\n",
    "        \n",
    "    def reset(self):\n",
    "        self.it = 0\n",
    "        self.memory = ReplayBuffer(\n",
    "            self.action_size, self.replay_size, \n",
    "            self.update_every * self.batch_size, \n",
    "            self.seed, self.device\n",
    "        )\n",
    "        self.losses = MovingResult(100, name='loss', save_raw=False)\n",
    "    \n",
    "    def step(self, state, action, reward, next_state, done, train=True):\n",
    "        self.memory.add(state, action, reward, next_state, done)\n",
    "        self.it += 1 \n",
    "        if train and self.it % self.update_every and len(self.memory) > self.memory.batch_size:\n",
    "            experiences = self.memory.sample()\n",
    "            self.learn(experiences)\n",
    "    \n",
    "    def act(self, state, epsilon=0.):\n",
    "        \"\"\" Epsilon-Greedy policy\n",
    "        \n",
    "        \"\"\"\n",
    "        probs = epsilon * np.ones(self.action_size) / self.action_size\n",
    "        state = torch.from_numpy(state).float().to(self.device)\n",
    "        \n",
    "        self.q_network.eval()\n",
    "        with torch.no_grad():\n",
    "            probs[np.argmax(self.q_network(state.reshape(1,-1)).cpu().numpy())] += 1-epsilon\n",
    "        self.q_network.train()\n",
    "        \n",
    "        return np.random.choice(np.arange(self.action_size), p=probs)\n",
    "    \n",
    "    def learn(self, experiences):\n",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "        # argmax_a Q^(next_state,a, w)\n",
    "        with torch.no_grad():\n",
    "            _ , best_actions = self.q_network(next_states).max(dim=1)\n",
    "            # y^ = td_target\n",
    "            # y^ = reward + gamma * Q^(next_state,argmax_a(next_state,a, w), w-), episode not terminal\n",
    "            # y^ = reward, episode terminal\n",
    "            td_targets = rewards + self.gamma * torch.gather(self.q_network_target(next_states),1,best_actions.view(-1,1))\n",
    "            for i in range(self.memory.batch_size):\n",
    "                if dones[i].item() == 1.0:\n",
    "                    td_targets[i] = rewards[i]   \n",
    "        \n",
    "        # delta = y^-Q\n",
    "        # clamp btwn -1..1\n",
    "        delta = torch.clamp(td_targets-torch.gather(self.q_network(states),1,actions), -1., 1.)\n",
    "        # loss = sum (y^-Q)^2\n",
    "        loss = torch.sum(torch.pow(delta,2))\n",
    "        self.losses.add(loss.item()/self.memory.batch_size)\n",
    "        \n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        self.soft_update()\n",
    "            \n",
    "    def soft_update(self):\n",
    "        \"\"\"Soft update of target network\n",
    "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "        \"\"\"\n",
    "        for target_param, param in zip(self.q_network_target.parameters(), self.q_network.parameters()):\n",
    "            target_param.data.copy_(self.tau*param.data+(1-self.tau)*target_param.data)\n",
    "            \n",
    "    @property\n",
    "    def params(self):\n",
    "        params = {\n",
    "            'state_size': self.state_size,\n",
    "            'action_size': self.action_size,\n",
    "            'seed': self.seed,\n",
    "            'replay_size': self.replay_size,\n",
    "            'batch_size': self.batch_size,\n",
    "            'gamma': self.gamma, \n",
    "            'lrate': self.lrate,\n",
    "            'tau': self.tau,\n",
    "            'update_every': self.update_every,\n",
    "            'hidden_layers': self.hidden_layers\n",
    "        }\n",
    "        return params\n",
    "    \n",
    "    @property \n",
    "    def trainable_params(self):\n",
    "        return sum([np.prod(p.size()) for p in self.q_network.parameters()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_exp_ep = 500\n",
    "\n",
    "# 1.0 -> 0.1\n",
    "initial_eps = 1.0\n",
    "final_eps = 0.01 \n",
    "\n",
    "episodes = 1000\n",
    "steps = 2000\n",
    "replay_start_size = 5000\n",
    "replay_size = 100000\n",
    "tau = 0.05 \n",
    "lrate = 5.0e-5\n",
    "update_every = 4\n",
    "batch_size = 32\n",
    "hidden_layers = [100, 200, 100]\n",
    "\n",
    "print_every = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "agent = Agent(\n",
    "    state_size, \n",
    "    action_size, \n",
    "    seed=0, \n",
    "    replay_size=replay_size,\n",
    "    tau = tau,\n",
    "    lrate = lrate,\n",
    "    batch_size = batch_size,\n",
    "    update_every = update_every,\n",
    "    hidden_layers = hidden_layers\n",
    ")\n",
    "\n",
    "scores = helpers.MovingResult(100, name='score', save_raw=False)\n",
    "\n",
    "scores_agent = train(\n",
    "    agent, \n",
    "    scores, \n",
    "    env, \n",
    "    brain_name,\n",
    "    episodes, \n",
    "    steps, \n",
    "    replay_start_size, \n",
    "    initial_eps, final_eps, \n",
    "    final_exp_ep,\n",
    "    out_file='model_v1.ckpt',\n",
    "    print_every = print_every\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<a href='model_v1.ckpt' target='_blank'>model_v1.ckpt</a><br>"
      ],
      "text/plain": [
       "/home/ubuntu/banana-collector/model_v1.ckpt"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FileLink('model_v1.ckpt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "scores.plot()\n",
    "agent.losses.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = []\n",
    "\n",
    "hyper_search(\n",
    "    scores,\n",
    "    env, brain_name, \n",
    "    final_exp_eps = [250],\n",
    "    taus=[0.05],\n",
    "    lrates = [0.1e-4, 0.5e-4, 1.0e-4],\n",
    "    final_epsilons = [0.1, 0.01],\n",
    "    gammas = [0.9, 0.95, 0.99],\n",
    "    iterations = 25\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "deep-learning",
   "language": "python",
   "name": "deep-learning"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}