model_compile.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "from collections import deque,namedtuple\n",
    "import random\n",
    "import gym\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import models, layers, optimizers\n",
    "from tqdm import tqdm_notebook\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "Transition = namedtuple('Transition', ('state', 'action', 'reward', 'next_state','done'))\n",
    "class VanillaMemory:\n",
    "    def __init__(self, memory_size):\n",
    "        self.memory_size = memory_size\n",
    "        self.memory = deque(maxlen=memory_size) \n",
    "    def add(self, *args):\n",
    "        t = Transition(*args)\n",
    "        self.memory.append(t)\n",
    "    def sample(self, batch_size):\n",
    "        ts = random.sample(self.memory, batch_size)\n",
    "        states = np.vstack([t.state for t in ts])\n",
    "        actions = np.vstack([t.action for t in ts])\n",
    "        rewards = np.vstack([t.reward for t in ts])\n",
    "        next_states = np.vstack([t.next_state for t in ts])\n",
    "        dones = np.vstack([t.done for t in ts]).astype(np.uint8)\n",
    "        return(states,actions,rewards,next_states,dones)\n",
    "        return random.sample(self.memory, batch_size)\n",
    "    def __len__(self):\n",
    "        return(len(self.memory))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mem = VanillaMemory(1000)\n",
    "len(mem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n",
      "Done in 200 timsteps with score -200.0.\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('MountainCar-v0')\n",
    "state = env.reset()\n",
    "score = 0\n",
    "t=0\n",
    "frames = []\n",
    "while True:\n",
    "    action = np.random.choice([0,1,2])\n",
    "    next_state, reward, done, info = env.step(action)\n",
    "    mem.add(state,action,reward,next_state,done)\n",
    "    \n",
    "    state = next_state\n",
    "    t+=1\n",
    "    score+=reward\n",
    "    if done: break\n",
    "print(f'Done in {t} timsteps with score {score}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0],\n",
       "       [0]], dtype=uint8)"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mem.sample(10)[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    def __init__(self, state_size, action_size, replay_memory,\n",
    "        lr=5e-3, bs = 64, clip=1., nb_hidden = [256],\n",
    "        gamma=0.99, tau= 1e-3, update_interval = 5, update_times = 1, tpe = 200):\n",
    "        \n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.nb_hidden = nb_hidden\n",
    "        self.lr = lr\n",
    "        self.bs = bs\n",
    "        self.gamma = gamma\n",
    "        self.update_interval = update_interval\n",
    "        self.update_times = update_times\n",
    "        self.tau = tau\n",
    "        self.losses = []\n",
    "        self.tpe = tpe\n",
    "        self.clip = clip\n",
    "\n",
    "        #vanilla\n",
    "        self.network_local = self.create_critic_network()\n",
    "        self.network_target = tf.keras.models.clone_model(self.network_local)\n",
    "        self.network_target.set_weights(self.network_local.get_weights())\n",
    "\n",
    "        # replay memory\n",
    "        self.memory = replay_memory\n",
    "        # count time steps\n",
    "        self.t_step = 0\n",
    "\n",
    "    def vanilla_loss(self, targets, preds):\n",
    "        actions, q_targets = targets[:, 0], targets[:, 1]\n",
    "        seq = tf.cast(tf.range(0, tf.shape(actions)[0]), tf.int32)\n",
    "        actions = tf.cast(actions, tf.int32)\n",
    "        action_idxs = tf.transpose(tf.stack([seq, actions]))\n",
    "        q_expected = tf.gather_nd(preds, action_idxs)\n",
    "        return tf.keras.losses.mse(q_targets, q_expected)\n",
    "        \n",
    "    def create_critic_network(self):\n",
    "        l = [layers.Dense(self.nb_hidden[0], input_dim=self.state_size, activation='relu')]\n",
    "        for h in self.nb_hidden[1:]: l.append(layers.Dense(h, activation='relu'))\n",
    "        l.append(layers.Dense(self.action_size, activation=\"linear\"))\n",
    "        network = models.Sequential(l)\n",
    "        network.compile(loss=self.vanilla_loss,\n",
    "                        optimizer=tf.keras.optimizers.Adam(learning_rate = self.lr, \n",
    "                                                           clipvalue=self.clip))\n",
    "        return network\n",
    "    \n",
    "    def get_eps(self, i, eps_start = 1., eps_end = 0.001, eps_decay = 0.9):\n",
    "        eps = max(eps_start * (eps_decay ** i), eps_end)\n",
    "        return(eps)\n",
    "    \n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        #add transition to replay memory\n",
    "        self.memory.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        #update target network\n",
    "        self.soft_update()\n",
    "        \n",
    "        # learn every self.t_step\n",
    "        self.t_step += 1\n",
    "        if self.t_step % self.update_interval == 0:\n",
    "            if len(self.memory) > self.bs:\n",
    "                #vanilla\n",
    "                for _ in range(self.update_times):\n",
    "                    transitions = self.memory.sample(self.bs)\n",
    "                    loss = self.learn(transitions)\n",
    "                    self.losses.append(loss)\n",
    "                    \n",
    "    def act(self, state):\n",
    "        eps = self.get_eps(int(self.t_step / self.tpe))\n",
    "        action_values = self.network_local(state[None,:])\n",
    "        #epsilon greedy\n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.numpy())\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size))\n",
    "\n",
    "    def learn(self, transitions):\n",
    "        states, actions, rewards, next_states, dones = transitions\n",
    "        q_targets_next = self.network_target(next_states).numpy().max(1)[:,None]\n",
    "        q_targets = rewards + (self.gamma * q_targets_next) * (1 - dones)\n",
    "        loss = self.network_local.train_on_batch(states, np.hstack([actions,q_targets]))\n",
    "        return loss\n",
    "\n",
    "    def hard_update(self):\n",
    "        if self.t_step % 1/self.tau==0:\n",
    "            self.network_target.set_weights(self.network_local.get_weights())\n",
    "     \n",
    "    def soft_update(self):\n",
    "        weights_local = np.array(self.network_local.get_weights())\n",
    "        weights_target = np.array(self.network_target.get_weights())\n",
    "        self.network_target.set_weights(self.tau * weights_local + (1 - self.tau) * weights_target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# env = gym.make('MountainCar-v0')\n",
    "env = gym.make('CartPole-v1')\n",
    "mem = VanillaMemory(int(1e5)) \n",
    "a = DQNAgent(state_size = env.reset().shape[0], \n",
    "             action_size = env.action_space.n, replay_memory = mem) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b00d94fefb4b40a7b51bd95434c5355f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episdoe 99 Moving Average: 17.414141414141415\n",
      "Episdoe 199 Moving Average: 14.78\n",
      "Episdoe 299 Moving Average: 176.83\n",
      "Solved at Play 304: 0:02:08.589982 Moving average: 191.03\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "scores = []\n",
    "scores_deque = deque(maxlen=100) \n",
    "moving_scores = []\n",
    "start_time = datetime.now()\n",
    "solved_score=190\n",
    "\n",
    "for i in tqdm_notebook(range(1000)):\n",
    "    if (i+1) % 100==0: print(f'Episdoe {i} Moving Average: {np.mean(scores_deque)}')\n",
    "    state = env.reset()\n",
    "    score = 0\n",
    "    t=0\n",
    "    while True:\n",
    "        t+=1\n",
    "        #select action\n",
    "        action = a.act(state)  \n",
    "\n",
    "        #env step\n",
    "        next_state, reward, done, info = env.step(action)   \n",
    "        \n",
    "        #engineer the reward to motive your agent even more\n",
    "        if done: \n",
    "            fake_reward = reward #+ (200-t)/10\n",
    "        else:\n",
    "            fake_reward = reward\n",
    "\n",
    "        #agent step\n",
    "        a.step(state,action,fake_reward,next_state,done)\n",
    "        \n",
    "        #collect score\n",
    "        score += reward\n",
    "        \n",
    "        #go to next state\n",
    "        state = next_state   \n",
    "        \n",
    "        #break if done\n",
    "        if done: break\n",
    "            \n",
    "    #book keeping\n",
    "    scores.append(score)\n",
    "    scores_deque.append(score)\n",
    "    moving_scores.append(np.mean(scores_deque))\n",
    "        \n",
    "    if moving_scores[-1] > solved_score: \n",
    "        print(f'Solved at Play {i}: {datetime.now() - start_time} Moving average: {moving_scores[-1]}')\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f5196e7d9b0>]"
      ]
     },
     "execution_count": 218,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(scores)\n",
    "plt.plot(moving_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f51971aef28>]"
      ]
     },
     "execution_count": 219,
     "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.plot(a.losses)"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}