12.A2C.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advantage Actor Critic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "gym.logger.set_level(40)\n",
    "\n",
    "import numpy as np\n",
    "\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 IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from timeit import default_timer as timer\n",
    "from datetime import timedelta\n",
    "import os\n",
    "import glob\n",
    "\n",
    "\n",
    "from baselines.common.vec_env.dummy_vec_env import DummyVecEnv\n",
    "from baselines.common.vec_env.subproc_vec_env import SubprocVecEnv\n",
    "\n",
    "from utils.hyperparameters import Config\n",
    "from utils.plot import plot\n",
    "from utils.wrappers import make_env_a2c_atari\n",
    "from agents.BaseAgent import BaseAgent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "port=8097\n",
    "log_dir = \"/tmp/gym/\"\n",
    "\n",
    "try:\n",
    "    os.makedirs(log_dir)\n",
    "except OSError:\n",
    "    files = glob.glob(os.path.join(log_dir, '*.monitor.csv'))\n",
    "    for f in files:\n",
    "        os.remove(f)\n",
    "\n",
    "config = Config()\n",
    "\n",
    "#a2c control\n",
    "config.num_agents=16\n",
    "config.rollout=5\n",
    "\n",
    "#misc agent variables\n",
    "config.GAMMA=0.99\n",
    "config.LR=7e-4\n",
    "config.entropy_loss_weight=0.01\n",
    "config.value_loss_weight=0.5\n",
    "\n",
    "# Number of updates in 10000000 frames\n",
    "config.MAX_FRAMES=int(1e7 / config.num_agents / config.rollout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rollout Storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RolloutStorage(object):\n",
    "    def __init__(self, num_steps, num_processes, obs_shape, action_space, device):\n",
    "        self.observations = torch.zeros(num_steps + 1, num_processes, *obs_shape).to(device)\n",
    "        self.rewards = torch.zeros(num_steps, num_processes, 1).to(device)\n",
    "        self.value_preds = torch.zeros(num_steps + 1, num_processes, 1).to(device)\n",
    "        self.returns = torch.zeros(num_steps + 1, num_processes, 1).to(device)\n",
    "        self.action_log_probs = torch.zeros(num_steps, num_processes, 1).to(device)\n",
    "        self.actions = torch.zeros(num_steps, num_processes, 1).to(device, torch.long)\n",
    "        self.masks = torch.ones(num_steps + 1, num_processes, 1).to(device)\n",
    "\n",
    "        self.num_steps = num_steps\n",
    "        self.step = 0\n",
    "\n",
    "    def insert(self, current_obs, action, action_log_prob, value_pred, reward, mask):\n",
    "        self.observations[self.step + 1].copy_(current_obs)\n",
    "        self.actions[self.step].copy_(action)\n",
    "        self.action_log_probs[self.step].copy_(action_log_prob)\n",
    "        self.value_preds[self.step].copy_(value_pred)\n",
    "        self.rewards[self.step].copy_(reward)\n",
    "        self.masks[self.step + 1].copy_(mask)\n",
    "\n",
    "        self.step = (self.step + 1) % self.num_steps\n",
    "\n",
    "    def after_update(self):\n",
    "        self.observations[0].copy_(self.observations[-1])\n",
    "        self.masks[0].copy_(self.masks[-1])\n",
    "\n",
    "    def compute_returns(self, next_value, gamma):\n",
    "        self.returns[-1] = next_value\n",
    "        for step in reversed(range(self.rewards.size(0))):\n",
    "            self.returns[step] = self.returns[step + 1] * \\\n",
    "                gamma * self.masks[step + 1] + self.rewards[step]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActorCritic(nn.Module):\n",
    "    def __init__(self, input_shape, num_actions):\n",
    "        super(ActorCritic, self).__init__()\n",
    "\n",
    "        init_ = lambda m: self.layer_init(m, nn.init.orthogonal_,\n",
    "                    lambda x: nn.init.constant_(x, 0),\n",
    "                    nn.init.calculate_gain('relu'))\n",
    "\n",
    "        self.conv1 = init_(nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4))\n",
    "        self.conv2 = init_(nn.Conv2d(32, 64, kernel_size=4, stride=2))\n",
    "        self.conv3 = init_(nn.Conv2d(64, 32, kernel_size=3, stride=1))\n",
    "        self.fc1 = init_(nn.Linear(self.feature_size(input_shape), 512))\n",
    "\n",
    "        init_ = lambda m: self.layer_init(m, nn.init.orthogonal_,\n",
    "          lambda x: nn.init.constant_(x, 0))\n",
    "\n",
    "        self.critic_linear = init_(nn.Linear(512, 1))\n",
    "\n",
    "        init_ = lambda m: self.layer_init(m, nn.init.orthogonal_,\n",
    "              lambda x: nn.init.constant_(x, 0), gain=0.01)\n",
    "\n",
    "        self.actor_linear = init_(nn.Linear(512, num_actions))\n",
    "\n",
    "        self.train()\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        x = F.relu(self.conv1(inputs/255.0))\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = x.view(x.size(0), -1)\n",
    "\n",
    "        x = F.relu(self.fc1(x))\n",
    "\n",
    "        value = self.critic_linear(x)\n",
    "        logits = self.actor_linear(x)\n",
    "\n",
    "        return logits, value\n",
    "\n",
    "    def feature_size(self, input_shape):\n",
    "        return self.conv3(self.conv2(self.conv1(torch.zeros(1, *input_shape)))).view(1, -1).size(1)\n",
    "\n",
    "    def layer_init(self, module, weight_init, bias_init, gain=1):\n",
    "        weight_init(module.weight.data, gain=gain)\n",
    "        bias_init(module.bias.data)\n",
    "        return module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(BaseAgent):\n",
    "    def __init__(self, static_policy=False, env=None, config=None, log_dir='/tmp/gym'):\n",
    "        super(Model, self).__init__(config=config, env=env, log_dir=log_dir)\n",
    "        self.device = config.device\n",
    "\n",
    "        self.noisy=config.USE_NOISY_NETS\n",
    "        self.priority_replay=config.USE_PRIORITY_REPLAY\n",
    "\n",
    "        self.gamma = config.GAMMA\n",
    "        self.lr = config.LR\n",
    "        self.target_net_update_freq = config.TARGET_NET_UPDATE_FREQ\n",
    "        self.learn_start = config.LEARN_START\n",
    "        self.sigma_init= config.SIGMA_INIT\n",
    "        self.num_agents = config.num_agents\n",
    "        self.value_loss_weight = config.value_loss_weight\n",
    "        self.entropy_loss_weight = config.entropy_loss_weight\n",
    "        self.rollout = config.rollout\n",
    "        self.grad_norm_max = config.grad_norm_max\n",
    "\n",
    "        self.static_policy = static_policy\n",
    "        self.num_feats = env.observation_space.shape\n",
    "        self.num_feats = (self.num_feats[0] * 4, *self.num_feats[1:])\n",
    "        self.num_actions = env.action_space.n\n",
    "        self.env = env\n",
    "\n",
    "        self.declare_networks()\n",
    "            \n",
    "        self.optimizer = optim.RMSprop(self.model.parameters(), lr=self.lr, alpha=0.99, eps=1e-5)\n",
    "        \n",
    "        #move to correct device\n",
    "        self.model = self.model.to(self.device)\n",
    "\n",
    "        if self.static_policy:\n",
    "            self.model.eval()\n",
    "        else:\n",
    "            self.model.train()\n",
    "\n",
    "        self.rollouts = RolloutStorage(self.rollout, self.num_agents,\n",
    "            self.num_feats, self.env.action_space, self.device)\n",
    "\n",
    "        self.value_losses = []\n",
    "        self.entropy_losses = []\n",
    "        self.policy_losses = []\n",
    "\n",
    "\n",
    "    def declare_networks(self):\n",
    "        self.model = ActorCritic(self.num_feats, self.num_actions)\n",
    "\n",
    "    def get_action(self, s, deterministic=False):\n",
    "        logits, values = self.model(s)\n",
    "        dist = torch.distributions.Categorical(logits=logits)\n",
    "\n",
    "        if deterministic:\n",
    "            actions = dist.probs.argmax(dim=1, keepdim=True)\n",
    "        else:\n",
    "            actions = dist.sample().view(-1, 1)\n",
    "\n",
    "        log_probs = F.log_softmax(logits, dim=1)\n",
    "        action_log_probs = log_probs.gather(1, actions)\n",
    "\n",
    "        return values, actions, action_log_probs\n",
    "        \n",
    "\n",
    "    def evaluate_actions(self, s, actions):\n",
    "        logits, values = self.model(s)\n",
    "\n",
    "        dist = torch.distributions.Categorical(logits=logits)\n",
    "\n",
    "        log_probs = F.log_softmax(logits, dim=1)\n",
    "        action_log_probs = log_probs.gather(1, actions)\n",
    "\n",
    "        dist_entropy = dist.entropy().mean()\n",
    "\n",
    "        return values, action_log_probs, dist_entropy\n",
    "\n",
    "    def get_values(self, s):\n",
    "        _, values = self.model(s)\n",
    "\n",
    "        return values\n",
    "\n",
    "    def compute_loss(self, rollouts):\n",
    "        obs_shape = rollouts.observations.size()[2:]\n",
    "        action_shape = rollouts.actions.size()[-1]\n",
    "        num_steps, num_processes, _ = rollouts.rewards.size()\n",
    "\n",
    "        values, action_log_probs, dist_entropy = self.evaluate_actions(\n",
    "            rollouts.observations[:-1].view(-1, *obs_shape),\n",
    "            rollouts.actions.view(-1, 1))\n",
    "\n",
    "        values = values.view(num_steps, num_processes, 1)\n",
    "        action_log_probs = action_log_probs.view(num_steps, num_processes, 1)\n",
    "\n",
    "        advantages = rollouts.returns[:-1] - values\n",
    "        value_loss = advantages.pow(2).mean()\n",
    "\n",
    "        action_loss = -(advantages.detach() * action_log_probs).mean()\n",
    "\n",
    "        loss = action_loss + self.value_loss_weight * value_loss - self.entropy_loss_weight * dist_entropy\n",
    "\n",
    "        return loss, action_loss, value_loss, dist_entropy\n",
    "\n",
    "    def update(self, rollout):\n",
    "        loss, action_loss, value_loss, dist_entropy = self.compute_loss(rollout)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.grad_norm_max)\n",
    "        self.optimizer.step()\n",
    "\n",
    "        #self.save_loss(loss.item(), action_loss.item(), value_loss.item(), dist_entropy.item())\n",
    "        #self.save_sigma_param_magnitudes()\n",
    "\n",
    "        return value_loss.item(), action_loss.item(), dist_entropy.item()\n",
    "\n",
    "    '''def save_loss(self, loss, policy_loss, value_loss, entropy_loss):\n",
    "        super(Model, self).save_loss(loss)\n",
    "        self.policy_losses.append(policy_loss)\n",
    "        self.value_losses.append(value_loss)\n",
    "        self.entropy_losses.append(entropy_loss)'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updates 125000, Num Timesteps 10000080, FPS 2221,\n",
      "Mean/Median Reward 19.1/19.5, Min/Max Reward 16.0/21.0,\n",
      "Entropy 1.68394, Value Loss 0.00700, Policy Loss 0.04381\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__=='__main__':\n",
    "    seed = 1\n",
    "\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed)\n",
    "\n",
    "    torch.set_num_threads(1)\n",
    "\n",
    "    env_id = \"PongNoFrameskip-v4\"\n",
    "    envs = [make_env_a2c_atari(env_id, seed, i, log_dir) for i in range(config.num_agents)]\n",
    "    envs = SubprocVecEnv(envs) if config.num_agents > 1 else DummyVecEnv(envs)\n",
    "\n",
    "    obs_shape = envs.observation_space.shape\n",
    "    obs_shape = (obs_shape[0] * 4, *obs_shape[1:])\n",
    "\n",
    "    model = Model(env=envs, config=config)\n",
    "\n",
    "    current_obs = torch.zeros(config.num_agents, *obs_shape,\n",
    "                    device=config.device, dtype=torch.float)\n",
    "\n",
    "    def update_current_obs(obs):\n",
    "        shape_dim0 = envs.observation_space.shape[0]\n",
    "        obs = torch.from_numpy(obs.astype(np.float32)).to(config.device)\n",
    "        current_obs[:, :-shape_dim0] = current_obs[:, shape_dim0:]\n",
    "        current_obs[:, -shape_dim0:] = obs\n",
    "\n",
    "    obs = envs.reset()\n",
    "    update_current_obs(obs)\n",
    "\n",
    "    model.rollouts.observations[0].copy_(current_obs)\n",
    "    \n",
    "    episode_rewards = np.zeros(config.num_agents, dtype=np.float)\n",
    "    final_rewards = np.zeros(config.num_agents, dtype=np.float)\n",
    "\n",
    "    start=timer()\n",
    "\n",
    "    print_step = 1\n",
    "    print_threshold = 10\n",
    "    \n",
    "    for frame_idx in range(1, config.MAX_FRAMES+1):\n",
    "        for step in range(config.rollout):\n",
    "            with torch.no_grad():\n",
    "                values, actions, action_log_prob = model.get_action(model.rollouts.observations[step])\n",
    "            cpu_actions = actions.view(-1).cpu().numpy()\n",
    "    \n",
    "            obs, reward, done, _ = envs.step(cpu_actions)\n",
    "\n",
    "            episode_rewards += reward\n",
    "            masks = 1. - done.astype(np.float32)\n",
    "            final_rewards *= masks\n",
    "            final_rewards += (1. - masks) * episode_rewards\n",
    "            episode_rewards *= masks\n",
    "\n",
    "            rewards = torch.from_numpy(reward.astype(np.float32)).view(-1, 1).to(config.device)\n",
    "            masks = torch.from_numpy(masks).to(config.device).view(-1, 1)\n",
    "\n",
    "            current_obs *= masks.view(-1, 1, 1, 1)\n",
    "            update_current_obs(obs)\n",
    "\n",
    "            model.rollouts.insert(current_obs, actions.view(-1, 1), action_log_prob, values, rewards, masks)\n",
    "            \n",
    "        with torch.no_grad():\n",
    "            next_value = model.get_values(model.rollouts.observations[-1])\n",
    "\n",
    "        model.rollouts.compute_returns(next_value, config.GAMMA)\n",
    "            \n",
    "        value_loss, action_loss, dist_entropy = model.update(model.rollouts)\n",
    "        \n",
    "        model.rollouts.after_update()\n",
    "\n",
    "        if frame_idx % 100 == 0:\n",
    "            try:\n",
    "                clear_output()\n",
    "                end = timer()\n",
    "                total_num_steps = (frame_idx + 1) * config.num_agents * config.rollout\n",
    "                print(\"Updates {}, Num Timesteps {}, FPS {},\\nMean/Median Reward {:.1f}/{:.1f}, Min/Max Reward {:.1f}/{:.1f},\\nEntropy {:.5f}, Value Loss {:.5f}, Policy Loss {:.5f}\".\n",
    "                format(frame_idx, total_num_steps,\n",
    "                       int(total_num_steps / (end - start)),\n",
    "                       np.mean(final_rewards),\n",
    "                       np.median(final_rewards),\n",
    "                       np.min(final_rewards),\n",
    "                       np.max(final_rewards), dist_entropy,\n",
    "                       value_loss, action_loss))\n",
    "                plot(log_dir, \"PongNoFrameskip-v4\", 'a2c', \n",
    "                     config.MAX_FRAMES * config.num_agents * config.rollout)\n",
    "            except IOError:\n",
    "                pass\n",
    "\n",
    "    model.save_w()\n",
    "    envs.close()"
   ]
  },
  {
   "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
}