DDPG.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Deterministic Policy Gradients (DDPG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 548
    },
    "id": "lIYdn1woOS1n",
    "outputId": "4ac3019d-8647-4407-c64a-9c255256c16b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/ale_py/roms/utils.py:90: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n",
      "  for external in metadata.entry_points().get(self.group, []):\n"
     ]
    }
   ],
   "source": [
    "# Reference: https://github.com/dongminlee94/deep_rl/blob/main/agents/ddpg.py\n",
    "# This code is heavily derived from the above repo, with modifications to adjust to our problem\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "import argparse\n",
    "from distutils.util import strtobool\n",
    "import collections\n",
    "import numpy as np\n",
    "import gym\n",
    "from gym.wrappers import TimeLimit, Monitor\n",
    "from gym.spaces import Discrete, Box, MultiBinary, MultiDiscrete, Space\n",
    "import time\n",
    "import random\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import argparse\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The code for this Buffer implementation comes from the deep_rl repo at:\n",
    "# https://github.com/dongminlee94/deep_rl/blob/main/agents/common/buffers.py\n",
    "class ReplayBuffer(object):\n",
    "    \"\"\"\n",
    "    A simple FIFO experience replay buffer for the agent\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim, act_dim, size, device):\n",
    "        self.obs1_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.obs2_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.ptr, self.size, self.max_size = 0, 0, size\n",
    "        self.device = device\n",
    "\n",
    "    def add(self, obs, act, rew, next_obs, done):\n",
    "        self.obs1_buf[self.ptr] = obs\n",
    "        self.obs2_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr+1) % self.max_size\n",
    "        self.size = min(self.size+1, self.max_size)\n",
    "\n",
    "    def sample(self, batch_size=64):\n",
    "        idxs = np.random.randint(0, self.size, size=batch_size)\n",
    "        return dict(obs1=torch.Tensor(self.obs1_buf[idxs]).to(self.device),\n",
    "                    obs2=torch.Tensor(self.obs2_buf[idxs]).to(self.device),\n",
    "                    acts=torch.Tensor(self.acts_buf[idxs]).to(self.device),\n",
    "                    rews=torch.Tensor(self.rews_buf[idxs]).to(self.device),\n",
    "                    done=torch.Tensor(self.done_buf[idxs]).to(self.device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "MLLwE9TQ5NUU"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gswatiseas/gym/gym/envs/registration.py:579: UserWarning: \u001b[33mWARN: The environment Humanoid-v2 is out of date. You should consider upgrading to version v3 with the environment ID `Humanoid-v3`.\u001b[0m\n",
      "  f\"The environment {spec.id} is out of date. You should consider \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "376 17 0.4\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "env = gym.make('Humanoid-v2')\n",
    "seed = 1234\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "env.seed(seed)\n",
    "\n",
    "obs_dim = env.observation_space.shape[0]\n",
    "act_dim = env.action_space.shape[0]\n",
    "act_limit = env.action_space.high[0]\n",
    "\n",
    "print (obs_dim, act_dim, act_limit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyper params\n",
    "n_iters = 30\n",
    "steps_per_iter = 4000\n",
    "phase = 'train'\n",
    "max_step = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "k6w-tmg2421Q"
   },
   "outputs": [],
   "source": [
    "def identity(x):\n",
    "    \"\"\"Return input without any change.\"\"\"\n",
    "    return x\n",
    "\"\"\"\n",
    "Multi Layer Percpetron architecture, to be used for policy function approximation\n",
    "\"\"\"\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, \n",
    "                 input_size, \n",
    "                 output_size, \n",
    "                 output_limit=1.0,\n",
    "                 hidden_sizes=(64,64), \n",
    "                 activation=F.relu, \n",
    "                 output_activation=identity,\n",
    "                 use_output_layer=True,\n",
    "                 use_actor=False,\n",
    "    ):\n",
    "        super(MLP, self).__init__()\n",
    "\n",
    "        self.input_size = input_size\n",
    "        self.output_size = output_size\n",
    "        self.output_limit = output_limit\n",
    "        self.hidden_sizes = hidden_sizes\n",
    "        self.activation = activation\n",
    "        self.output_activation = output_activation\n",
    "        self.use_output_layer = use_output_layer\n",
    "        self.use_actor = use_actor\n",
    "\n",
    "        # Set hidden layers\n",
    "        self.hidden_layers = nn.ModuleList()\n",
    "        in_size = self.input_size\n",
    "        for next_size in self.hidden_sizes:\n",
    "            fc = nn.Linear(in_size, next_size)\n",
    "            in_size = next_size\n",
    "            self.hidden_layers.append(fc)\n",
    "\n",
    "        # Set output layers\n",
    "        if self.use_output_layer:\n",
    "            self.output_layer = nn.Linear(in_size, self.output_size)\n",
    "        else:\n",
    "            self.output_layer = identity\n",
    "\n",
    "    def forward(self, x):\n",
    "        for hidden_layer in self.hidden_layers:\n",
    "            x = self.activation(hidden_layer(x))\n",
    "        x = self.output_activation(self.output_layer(x))\n",
    "        # If the network is used as actor network, make sure output is in correct range\n",
    "        x = x * self.output_limit if self.use_actor else x   \n",
    "        return x\n",
    "    \n",
    "\"\"\"\n",
    "DDPG critic definition\n",
    "\"\"\"\n",
    "class FlattenMLP(MLP):\n",
    "    def forward(self, x, a):\n",
    "        q = torch.cat([x,a], dim=-1)\n",
    "        return super(FlattenMLP, self).forward(q)\n",
    "    \n",
    "def hard_target_update(main, target):\n",
    "    target.load_state_dict(main.state_dict())\n",
    "\n",
    "def soft_target_update(main, target, tau=0.005):\n",
    "    for main_param, target_param in zip(main.parameters(), target.parameters()):\n",
    "        target_param.data.copy_(tau*main_param.data + (1.0-tau)*target_param.data)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2756050376.py, line 66)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_6165/2756050376.py\"\u001b[0;36m, line \u001b[0;32m66\u001b[0m\n\u001b[0;31m    hard_target_update(self.policy, self.policy_target)\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "class Agent(object):\n",
    "   \"\"\"DDPG Agent implementation\"\"\"\n",
    "\n",
    "   def __init__(self,\n",
    "                env,\n",
    "                device,\n",
    "                obs_dim,\n",
    "                act_dim,\n",
    "                act_limit,\n",
    "                steps=0,\n",
    "                expl_before=2000,\n",
    "                train_after=1000,\n",
    "                gamma=0.99,\n",
    "                act_noise=0.1,\n",
    "                hidden_sizes=(128,128),\n",
    "                buffer_size=int(1e4),\n",
    "                batch_size=64,\n",
    "                policy_lr=3e-4,\n",
    "                qf_lr=3e-4,\n",
    "                gradient_clip_policy=0.5,\n",
    "                gradient_clip_qf=1.0,\n",
    "                eval_mode=False,\n",
    "                policy_losses=list(),\n",
    "                qf_losses=list(),\n",
    "                logger=dict(),\n",
    "   ):\n",
    "\n",
    "      self.env = env\n",
    "      self.device = device\n",
    "      self.obs_dim = obs_dim\n",
    "      self.act_dim = act_dim\n",
    "      self.act_limit = act_limit\n",
    "      self.steps = steps \n",
    "      self.expl_before = expl_before\n",
    "      self.train_after = train_after\n",
    "      self.gamma = gamma\n",
    "      self.act_noise = act_noise\n",
    "      self.hidden_sizes = hidden_sizes\n",
    "      self.buffer_size = buffer_size\n",
    "      self.batch_size = batch_size\n",
    "      self.policy_lr = policy_lr\n",
    "      self.qf_lr = qf_lr\n",
    "      self.gradient_clip_policy = gradient_clip_policy\n",
    "      self.gradient_clip_qf = gradient_clip_qf\n",
    "      self.eval_mode = eval_mode\n",
    "      self.policy_losses = policy_losses\n",
    "      self.qf_losses = qf_losses\n",
    "      self.logger = logger\n",
    "\n",
    "      # Main network - policy\n",
    "      self.policy = MLP(self.obs_dim, self.act_dim, self.act_limit, \n",
    "                                    hidden_sizes=self.hidden_sizes, \n",
    "                                    output_activation=torch.tanh,\n",
    "                                    use_actor=True).to(self.device)\n",
    "      # Main network - critic\n",
    "      self.qf = FlattenMLP(self.obs_dim+self.act_dim, 1, hidden_sizes=self.hidden_sizes).to(self.device)\n",
    "      \n",
    "      # Target network - policy\n",
    "      self.policy_target = MLP(self.obs_dim, self.act_dim, self.act_limit,\n",
    "                                           hidden_sizes=self.hidden_sizes, \n",
    "                                           output_activation=torch.tanh,\n",
    "      # Target network - critic                                    use_actor=True).to(self.device)\n",
    "      self.qf_target = FlattenMLP(self.obs_dim+self.act_dim, 1, hidden_sizes=self.hidden_sizes).to(self.device)\n",
    "      \n",
    "      # Initialize target parameters to match main parameters\n",
    "      hard_target_update(self.policy, self.policy_target)\n",
    "      hard_target_update(self.qf, self.qf_target)\n",
    "\n",
    "      # Create optimizers\n",
    "      self.policy_optimizer = optim.Adam(self.policy.parameters(), lr=self.policy_lr)\n",
    "      self.qf_optimizer = optim.Adam(self.qf.parameters(), lr=self.qf_lr)\n",
    "      \n",
    "      # Experience Replay buffer\n",
    "      self.replay_buffer = ReplayBuffer(self.obs_dim, self.act_dim, self.buffer_size, self.device)\n",
    "\n",
    "   def select_action(self, obs):\n",
    "      action = self.policy(obs).detach().cpu().numpy()\n",
    "      action += self.act_noise * np.random.randn(self.act_dim)\n",
    "      return np.clip(action, -self.act_limit, self.act_limit)\n",
    "\n",
    "   def train_model(self):\n",
    "      batch = self.replay_buffer.sample(self.batch_size)\n",
    "      obs1 = batch['obs1']\n",
    "      obs2 = batch['obs2']\n",
    "      acts = batch['acts']\n",
    "      rews = batch['rews']\n",
    "      done = batch['done']\n",
    "\n",
    "      if 0: # Check shape of experiences\n",
    "         print(\"obs1\", obs1.shape)\n",
    "         print(\"obs2\", obs2.shape)\n",
    "         print(\"acts\", acts.shape)\n",
    "         print(\"rews\", rews.shape)\n",
    "         print(\"done\", done.shape)\n",
    "\n",
    "      # Prediction Q(s,𝜇(s)), Q(s,a), Q‾(s',𝜇‾(s'))\n",
    "      q_pi = self.qf(obs1, self.policy(obs1))\n",
    "      q = self.qf(obs1, acts).squeeze(1)\n",
    "      q_pi_target = self.qf_target(obs2, self.policy_target(obs2)).squeeze(1)\n",
    "      \n",
    "      # Target for Q regression\n",
    "      q_backup = rews + self.gamma*(1-done)*q_pi_target\n",
    "      q_backup.to(self.device)\n",
    "\n",
    "      if 0: # Check shape of prediction and target\n",
    "         print(\"q\", q.shape)\n",
    "         print(\"q_backup\", q_backup.shape)\n",
    "\n",
    "      # DDPG losses\n",
    "      policy_loss = -q_pi.mean()\n",
    "      qf_loss = F.mse_loss(q, q_backup.detach())\n",
    "\n",
    "      # Update policy network parameter\n",
    "      self.policy_optimizer.zero_grad()\n",
    "      policy_loss.backward()\n",
    "      nn.utils.clip_grad_norm_(self.policy.parameters(), self.gradient_clip_policy)\n",
    "      self.policy_optimizer.step()\n",
    "      \n",
    "      # Update Q-function network parameter\n",
    "      self.qf_optimizer.zero_grad()\n",
    "      qf_loss.backward()\n",
    "      nn.utils.clip_grad_norm_(self.qf.parameters(), self.gradient_clip_qf)\n",
    "      self.qf_optimizer.step()\n",
    "\n",
    "      # Polyak averaging for target parameter\n",
    "      soft_target_update(self.policy, self.policy_target)\n",
    "      soft_target_update(self.qf, self.qf_target)\n",
    "      \n",
    "      # Save losses\n",
    "      self.policy_losses.append(policy_loss.item())\n",
    "      self.qf_losses.append(qf_loss.item())\n",
    "\n",
    "   # To save trained models\n",
    "   def save_models(self, path):\n",
    "       print (path)\n",
    "       torch.save(self.policy, path+\"model\")\n",
    "       torch.save(self.qf, path+\"model\")\n",
    "  \n",
    "   # For each episode run\n",
    "   def run(self, max_step):\n",
    "      step_number = 0\n",
    "      total_reward = 0.\n",
    "\n",
    "      obs = self.env.reset()\n",
    "      done = False\n",
    "\n",
    "      # Keep interacting until agent reaches a terminal state or agent reaches max_steps\n",
    "      while not (done or step_number == max_step): \n",
    "\n",
    "         # If in eval mode, exploit the learned policy\n",
    "         if self.eval_mode:\n",
    "            action = self.policy(torch.Tensor(obs).to(self.device))\n",
    "            action = action.detach().cpu().numpy()\n",
    "            next_obs, reward, done, _ = self.env.step(action)\n",
    "         else:\n",
    "            self.steps += 1\n",
    "            # Until expl_before have elapsed, randomly sample actions \n",
    "            # from a uniform distribution for exploration. \n",
    "            # Afterwards, use the learned policy.\n",
    "            if self.steps > self.expl_before:\n",
    "               action = self.select_action(torch.Tensor(obs).to(self.device))\n",
    "            else:\n",
    "               action = self.env.action_space.sample()\n",
    "\n",
    "            # Collect (s, a, s' r, done) tuple for the chosen action\n",
    "            next_obs, reward, done, _ = self.env.step(action)\n",
    "\n",
    "            # Add the experience sample to replay buffer\n",
    "            self.replay_buffer.add(obs, action, reward, next_obs, done)\n",
    "            \n",
    "            # Start training when the number of experience is greater than train_after\n",
    "            if self.steps > self.train_after:\n",
    "               self.train_model()\n",
    "\n",
    "         total_reward += reward\n",
    "         step_number += 1\n",
    "         obs = next_obs\n",
    "      \n",
    "      return step_number, total_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "x4KRqZ5I46Ti"
   },
   "outputs": [],
   "source": [
    "# Initialise agent\n",
    "agent = Agent(env, device, obs_dim, act_dim, act_limit, \n",
    "                      expl_before=10000, \n",
    "                      act_noise=0.1, \n",
    "                      hidden_sizes=(256,256), \n",
    "                      buffer_size=int(1e6), \n",
    "                      batch_size=256,\n",
    "                      policy_lr=3e-4, \n",
    "                      qf_lr=3e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "Lod0C2yG4dYa",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------\n",
      "Iterations: 1\n",
      "Steps: 4004\n",
      "Episodes: 161\n",
      "EpisodeReturn: 96.54\n",
      "AverageReturn: 124.42\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 117.88\n",
      "EvalAverageReturn: 126.23\n",
      "OtherLogs: {'LossPi': -280.05249, 'LossQ': 231.24587}\n",
      "Time: 19\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 2\n",
      "Steps: 8018\n",
      "Episodes: 327\n",
      "EpisodeReturn: 273.7\n",
      "AverageReturn: 123.01\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 204.0\n",
      "EvalAverageReturn: 135.55\n",
      "OtherLogs: {'LossPi': -277.74837, 'LossQ': 225.34678}\n",
      "Time: 45\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 3\n",
      "Steps: 12031\n",
      "Episodes: 442\n",
      "EpisodeReturn: 207.66\n",
      "AverageReturn: 137.37\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 211.21\n",
      "EvalAverageReturn: 215.53\n",
      "OtherLogs: {'LossPi': -280.8185, 'LossQ': 222.75324}\n",
      "Time: 72\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 4\n",
      "Steps: 16035\n",
      "Episodes: 621\n",
      "EpisodeReturn: 76.38\n",
      "AverageReturn: 129.36\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 159.87\n",
      "EvalAverageReturn: 118.26\n",
      "OtherLogs: {'LossPi': -284.28174, 'LossQ': 227.50345}\n",
      "Time: 99\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 5\n",
      "Steps: 20037\n",
      "Episodes: 828\n",
      "EpisodeReturn: 76.25\n",
      "AverageReturn: 120.8\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 76.18\n",
      "EvalAverageReturn: 77.96\n",
      "OtherLogs: {'LossPi': -289.54444, 'LossQ': 245.57319}\n",
      "Time: 125\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 6\n",
      "Steps: 24070\n",
      "Episodes: 988\n",
      "EpisodeReturn: 184.8\n",
      "AverageReturn: 122.18\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 203.83\n",
      "EvalAverageReturn: 198.61\n",
      "OtherLogs: {'LossPi': -288.7327, 'LossQ': 255.98308}\n",
      "Time: 153\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 7\n",
      "Steps: 28081\n",
      "Episodes: 1129\n",
      "EpisodeReturn: 185.91\n",
      "AverageReturn: 125.18\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 129.64\n",
      "EvalAverageReturn: 155.38\n",
      "OtherLogs: {'LossPi': -284.78917, 'LossQ': 252.19802}\n",
      "Time: 181\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 8\n",
      "Steps: 32126\n",
      "Episodes: 1231\n",
      "EpisodeReturn: 247.24\n",
      "AverageReturn: 130.96\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 207.78\n",
      "EvalAverageReturn: 207.34\n",
      "OtherLogs: {'LossPi': -280.34492, 'LossQ': 246.58956}\n",
      "Time: 208\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 9\n",
      "Steps: 36128\n",
      "Episodes: 1318\n",
      "EpisodeReturn: 155.14\n",
      "AverageReturn: 137.32\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 210.92\n",
      "EvalAverageReturn: 188.97\n",
      "OtherLogs: {'LossPi': -276.50566, 'LossQ': 241.13215}\n",
      "Time: 236\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 10\n",
      "Steps: 40166\n",
      "Episodes: 1420\n",
      "EpisodeReturn: 213.01\n",
      "AverageReturn: 140.04\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 241.2\n",
      "EvalAverageReturn: 285.55\n",
      "OtherLogs: {'LossPi': -273.88981, 'LossQ': 236.51204}\n",
      "Time: 264\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 11\n",
      "Steps: 44204\n",
      "Episodes: 1496\n",
      "EpisodeReturn: 373.41\n",
      "AverageReturn: 147.1\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 317.63\n",
      "EvalAverageReturn: 384.98\n",
      "OtherLogs: {'LossPi': -271.94819, 'LossQ': 232.47657}\n",
      "Time: 294\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 12\n",
      "Steps: 48246\n",
      "Episodes: 1556\n",
      "EpisodeReturn: 337.48\n",
      "AverageReturn: 155.33\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 272.51\n",
      "EvalAverageReturn: 316.74\n",
      "OtherLogs: {'LossPi': -271.27807, 'LossQ': 229.5387}\n",
      "Time: 323\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 13\n",
      "Steps: 52295\n",
      "Episodes: 1623\n",
      "EpisodeReturn: 551.72\n",
      "AverageReturn: 162.07\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 327.97\n",
      "EvalAverageReturn: 384.35\n",
      "OtherLogs: {'LossPi': -270.84886, 'LossQ': 226.74111}\n",
      "Time: 353\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 14\n",
      "Steps: 56324\n",
      "Episodes: 1679\n",
      "EpisodeReturn: 298.38\n",
      "AverageReturn: 168.32\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 432.67\n",
      "EvalAverageReturn: 429.18\n",
      "OtherLogs: {'LossPi': -271.74554, 'LossQ': 224.96065}\n",
      "Time: 383\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 15\n",
      "Steps: 60340\n",
      "Episodes: 1737\n",
      "EpisodeReturn: 383.24\n",
      "AverageReturn: 174.21\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 300.8\n",
      "EvalAverageReturn: 375.36\n",
      "OtherLogs: {'LossPi': -272.97279, 'LossQ': 224.0936}\n",
      "Time: 412\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 16\n",
      "Steps: 64370\n",
      "Episodes: 1810\n",
      "EpisodeReturn: 270.29\n",
      "AverageReturn: 178.46\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 277.0\n",
      "EvalAverageReturn: 296.13\n",
      "OtherLogs: {'LossPi': -274.34428, 'LossQ': 223.43709}\n",
      "Time: 441\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 17\n",
      "Steps: 68388\n",
      "Episodes: 1871\n",
      "EpisodeReturn: 298.77\n",
      "AverageReturn: 183.42\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 296.42\n",
      "EvalAverageReturn: 272.66\n",
      "OtherLogs: {'LossPi': -275.67578, 'LossQ': 223.30101}\n",
      "Time: 469\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 18\n",
      "Steps: 72438\n",
      "Episodes: 1924\n",
      "EpisodeReturn: 368.02\n",
      "AverageReturn: 188.79\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 280.07\n",
      "EvalAverageReturn: 346.51\n",
      "OtherLogs: {'LossPi': -276.59006, 'LossQ': 222.83742}\n",
      "Time: 499\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 19\n",
      "Steps: 76440\n",
      "Episodes: 1977\n",
      "EpisodeReturn: 499.15\n",
      "AverageReturn: 193.32\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 472.98\n",
      "EvalAverageReturn: 340.96\n",
      "OtherLogs: {'LossPi': -277.79083, 'LossQ': 222.86269}\n",
      "Time: 528\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 20\n",
      "Steps: 80472\n",
      "Episodes: 2028\n",
      "EpisodeReturn: 429.18\n",
      "AverageReturn: 197.57\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 286.13\n",
      "EvalAverageReturn: 413.8\n",
      "OtherLogs: {'LossPi': -280.23893, 'LossQ': 224.37355}\n",
      "Time: 558\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 21\n",
      "Steps: 84551\n",
      "Episodes: 2078\n",
      "EpisodeReturn: 538.39\n",
      "AverageReturn: 202.15\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 835.31\n",
      "EvalAverageReturn: 434.54\n",
      "OtherLogs: {'LossPi': -283.19685, 'LossQ': 226.44942}\n",
      "Time: 589\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 22\n",
      "Steps: 88616\n",
      "Episodes: 2134\n",
      "EpisodeReturn: 386.88\n",
      "AverageReturn: 206.57\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 320.73\n",
      "EvalAverageReturn: 390.79\n",
      "OtherLogs: {'LossPi': -286.34846, 'LossQ': 228.86717}\n",
      "Time: 619\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 23\n",
      "Steps: 92687\n",
      "Episodes: 2187\n",
      "EpisodeReturn: 434.13\n",
      "AverageReturn: 210.63\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 379.05\n",
      "EvalAverageReturn: 411.96\n",
      "OtherLogs: {'LossPi': -289.36116, 'LossQ': 231.20086}\n",
      "Time: 649\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 24\n",
      "Steps: 96747\n",
      "Episodes: 2235\n",
      "EpisodeReturn: 400.12\n",
      "AverageReturn: 214.67\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 606.36\n",
      "EvalAverageReturn: 460.24\n",
      "OtherLogs: {'LossPi': -292.20459, 'LossQ': 233.08384}\n",
      "Time: 680\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 25\n",
      "Steps: 100765\n",
      "Episodes: 2281\n",
      "EpisodeReturn: 532.69\n",
      "AverageReturn: 218.78\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 377.05\n",
      "EvalAverageReturn: 458.48\n",
      "OtherLogs: {'LossPi': -295.02156, 'LossQ': 234.74745}\n",
      "Time: 710\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 26\n",
      "Steps: 104810\n",
      "Episodes: 2323\n",
      "EpisodeReturn: 836.34\n",
      "AverageReturn: 223.33\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 456.76\n",
      "EvalAverageReturn: 405.13\n",
      "OtherLogs: {'LossPi': -298.09831, 'LossQ': 236.69789}\n",
      "Time: 740\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 27\n",
      "Steps: 108857\n",
      "Episodes: 2369\n",
      "EpisodeReturn: 587.02\n",
      "AverageReturn: 227.57\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 535.76\n",
      "EvalAverageReturn: 455.4\n",
      "OtherLogs: {'LossPi': -301.05188, 'LossQ': 238.78595}\n",
      "Time: 770\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 28\n",
      "Steps: 112924\n",
      "Episodes: 2415\n",
      "EpisodeReturn: 364.19\n",
      "AverageReturn: 231.45\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 341.26\n",
      "EvalAverageReturn: 429.24\n",
      "OtherLogs: {'LossPi': -303.64618, 'LossQ': 240.70303}\n",
      "Time: 800\n",
      "---------------------------------------\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------\n",
      "Iterations: 29\n",
      "Steps: 116983\n",
      "Episodes: 2462\n",
      "EpisodeReturn: 366.89\n",
      "AverageReturn: 235.16\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 301.11\n",
      "EvalAverageReturn: 437.34\n",
      "OtherLogs: {'LossPi': -305.87287, 'LossQ': 242.14591}\n",
      "Time: 830\n",
      "---------------------------------------\n",
      "---------------------------------------\n",
      "Iterations: 30\n",
      "Steps: 120999\n",
      "Episodes: 2505\n",
      "EpisodeReturn: 471.07\n",
      "AverageReturn: 238.72\n",
      "EvalEpisodes: 10\n",
      "EvalEpisodeReturn: 375.37\n",
      "EvalAverageReturn: 418.16\n",
      "OtherLogs: {'LossPi': -307.67462, 'LossQ': 242.94128}\n",
      "Time: 860\n",
      "---------------------------------------\n"
     ]
    }
   ],
   "source": [
    "### This is the actual train/eval loop.\n",
    "# We run 10 episodes of evaluation for every 4000 steps (steps_per_iter) taken by the agent in the environment during training\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "total_num_steps = 0\n",
    "train_sum_returns = 0.\n",
    "train_num_episodes = 0\n",
    "eval_mode = 0\n",
    "\n",
    "train_avg_ret = []\n",
    "train_ep_ret = []\n",
    "eval_avg_ret = []\n",
    "eval_ep_ret = []\n",
    "\n",
    "for i in range(n_iters):\n",
    "        # Perform the training phase, during which the agent learns\n",
    "        if phase == 'train':\n",
    "            train_step_count = 0\n",
    "\n",
    "            while train_step_count <= steps_per_iter:\n",
    "                eval_mode = False\n",
    "                \n",
    "                # Run one episode\n",
    "                train_step_length, train_episode_return = agent.run(max_step)\n",
    "                \n",
    "                total_num_steps += train_step_length\n",
    "                train_step_count += train_step_length\n",
    "                train_sum_returns += train_episode_return\n",
    "                train_num_episodes += 1\n",
    "\n",
    "                train_average_return = train_sum_returns / train_num_episodes if train_num_episodes > 0 else 0.0\n",
    "                \n",
    "                train_avg_ret.append(train_average_return)\n",
    "                train_ep_ret.append(train_episode_return)\n",
    "\n",
    "\n",
    "        # Perform the evaluation phase -- no learning\n",
    "        eval_sum_returns = 0.\n",
    "        eval_num_episodes = 0\n",
    "        eval_mode = True\n",
    "\n",
    "        for _ in range(10):\n",
    "            # Run one episode\n",
    "            eval_step_length, eval_episode_return = agent.run(max_step)\n",
    "\n",
    "            eval_sum_returns += eval_episode_return\n",
    "            eval_num_episodes += 1\n",
    "\n",
    "        eval_average_return = eval_sum_returns / eval_num_episodes if eval_num_episodes > 0 else 0.0\n",
    "        eval_avg_ret.append(eval_average_return)\n",
    "        eval_ep_ret.append(eval_episode_return)\n",
    "\n",
    "\n",
    "        if phase == 'train':\n",
    "            print('---------------------------------------')\n",
    "            print('Iterations:', i + 1)\n",
    "            print('Steps:', total_num_steps)\n",
    "            print('Episodes:', train_num_episodes)\n",
    "            print('EpisodeReturn:', round(train_episode_return, 2))\n",
    "            print('AverageReturn:', round(train_average_return, 2))\n",
    "            print('EvalEpisodes:', eval_num_episodes)\n",
    "            print('EvalEpisodeReturn:', round(eval_episode_return, 2))\n",
    "            print('EvalAverageReturn:', round(eval_average_return, 2))\n",
    "            print('OtherLogs:', agent.logger)\n",
    "            print('Time:', int(time.time() - start_time))\n",
    "            print('---------------------------------------')\n",
    "        else:\n",
    "            print('---------------------------------------')\n",
    "            print('EvalEpisodes:', eval_num_episodes)\n",
    "            print('EvalEpisodeReturn:', round(eval_episode_return, 2))\n",
    "            print('EvalAverageReturn:', round(eval_average_return, 2))\n",
    "            print('Time:', int(time.time() - start_time))\n",
    "            print('---------------------------------------')\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'train episode rewards')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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.show()\n",
    "plt.plot(train_avg_ret)\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Rewards\")\n",
    "plt.title(\"train average rewards\")\n",
    "\n",
    "plt.show()\n",
    "plt.plot(train_ep_ret)\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Rewards\")\n",
    "plt.title(\"train episode rewards\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "VEMSnKf9lsuB"
   },
   "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"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'test episode rewards')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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.show()\n",
    "plt.plot(eval_avg_ret)\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Rewards\")\n",
    "plt.title(\"test average rewards\")\n",
    "\n",
    "plt.show()\n",
    "plt.plot(eval_ep_ret)\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Rewards\")\n",
    "plt.title(\"test episode rewards\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "W6vLJACbE6Fu"
   },
   "outputs": [],
   "source": [
    "flag = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:11:2021_16:58:07\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "now = datetime.now() # current date and time\n",
    "date_time = str(now.strftime(\"%m:%d:%Y_%H:%M:%S\"))\n",
    "print (date_time)\n",
    "\n",
    "\n",
    "algo = \"DDPG\"\n",
    "path = \"Results/\" + algo + date_time + flag\n",
    "np.save(path +\"_train_avg\", train_avg_ret)\n",
    "np.save(path + \"_test_avg\", eval_avg_ret)\n",
    "np.save(path +\"_train_ep\", train_ep_ret)\n",
    "np.save(path + \"_test_ep\", eval_ep_ret)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent.save_models(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "Copy of dqn_working.ipynb",
   "provenance": []
  },
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}