Cartpole_Classical_RL_Experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:42.876409200Z",
     "start_time": "2023-07-27T00:10:39.516075700Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-27 01:10:39.969569: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:39.969617: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7.0\n",
      "0.18.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "# import gymnasium as gym\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "from collections import deque, defaultdict\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "import gym\n",
    "\n",
    "print(tf.__version__)\n",
    "print(gym.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# REINFORCE Agent:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "#defining a standard dense NN\n",
    "\n",
    "def build_model(state_size, action_size, learning_rate = 0.001):\n",
    "    model = tf.keras.models.Sequential()\n",
    "    model.add(tf.keras.layers.Dense(16, input_dim = state_size, activation = 'relu'))\n",
    "    model.add(tf.keras.layers.Dense(16))\n",
    "    model.add(tf.keras.layers.Dense(2, activation = 'relu', kernel_initializer='RandomNormal'))\n",
    "    model.add(tf.keras.layers.Dense(action_size, activation = 'softmax'))\n",
    "    return model"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:49.914613100Z",
     "start_time": "2023-07-27T00:10:49.899480100Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "#function that gathers episodes of interaction with the environment\n",
    "def gather_episodes(state_bounds, n_actions, model, n_episodes, env_name):\n",
    "    \"\"\"Interact with environment in batched fashion.\"\"\"\n",
    "\n",
    "    trajectories = [defaultdict(list) for _ in range(n_episodes)]\n",
    "    envs = [gym.make(env_name) for _ in range(n_episodes)]\n",
    "\n",
    "\n",
    "    done = [False for _ in range(n_episodes)]\n",
    "    states = [e.reset()[0] for e in envs]\n",
    "\n",
    "    while not all(done):\n",
    "        unfinished_ids = [i for i in range(n_episodes) if not done[i]]\n",
    "        normalized_states = [s/state_bounds for i, s in enumerate(states) if not done[i]]\n",
    "\n",
    "        for i, state in zip(unfinished_ids, normalized_states):\n",
    "            trajectories[i]['states'].append(state)\n",
    "\n",
    "        # Compute policy for all unfinished envs in parallel\n",
    "        states = tf.convert_to_tensor(normalized_states)\n",
    "        action_probs = model([states])\n",
    "\n",
    "        # Store action and transition all environments to the next state\n",
    "        states = [None for i in range(n_episodes)]\n",
    "        for i, policy in zip(unfinished_ids, action_probs.numpy()):\n",
    "            #print(policy)\n",
    "            action = np.random.choice(n_actions, p=policy)\n",
    "            states[i], reward, done[i], _= envs[i].step(action)\n",
    "            trajectories[i]['actions'].append(action)\n",
    "            trajectories[i]['rewards'].append(reward)\n",
    "\n",
    "    return trajectories"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:50.191521100Z",
     "start_time": "2023-07-27T00:10:50.185017100Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def compute_returns(rewards_history, gamma):\n",
    "    \"\"\"Compute discounted returns with discount factor `gamma`.\"\"\"\n",
    "    returns = []\n",
    "    discounted_sum = 0\n",
    "    for r in rewards_history[::-1]:\n",
    "        discounted_sum = r + gamma * discounted_sum\n",
    "        returns.insert(0, discounted_sum)\n",
    "\n",
    "    # Normalize them for faster and more stable learning\n",
    "    returns = np.array(returns)\n",
    "    returns = (returns - np.mean(returns)) / (np.std(returns) + 1e-8)\n",
    "    returns = returns.tolist()\n",
    "\n",
    "    return returns"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:50.466877500Z",
     "start_time": "2023-07-27T00:10:50.454843200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "#function that updates the policy using states, actions and returns\n",
    "@tf.function\n",
    "def reinforce_update(states, actions, returns, model):\n",
    "    states = tf.convert_to_tensor(states)\n",
    "    actions = tf.convert_to_tensor(actions)\n",
    "    returns = tf.convert_to_tensor(returns)\n",
    "\n",
    "    with tf.GradientTape() as tape:\n",
    "        tape.watch(model.trainable_variables)\n",
    "        logits = model(states)\n",
    "        p_actions = tf.gather_nd(logits, actions)\n",
    "        log_probs = tf.math.log(p_actions)\n",
    "        loss = tf.math.reduce_sum(-log_probs * returns) / batch_size\n",
    "    grads = tape.gradient(loss, model.trainable_variables)\n",
    "    #for optimizer, w in zip([optimizer_in, optimizer_var, optimizer_out], [w_in, w_var, w_out]):\n",
    "    #    optimizer.apply_gradients([(grads[w], model.trainable_variables[w])])\n",
    "    optimizer.apply_gradients(zip(grads, model.trainable_variables))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:50.741743300Z",
     "start_time": "2023-07-27T00:10:50.721802600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 16)                80        \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 16)                272       \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2)                 34        \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 2)                 6         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 392\n",
      "Trainable params: 392\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-27 01:10:52.698868: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:925] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-07-27 01:10:52.699109: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.699938: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.700177: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.700773: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.701167: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.701257: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.701312: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.701361: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n",
      "2023-07-27 01:10:52.701373: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2023-07-27 01:10:52.702122: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('CartPole-v1')\n",
    "state_size = env.observation_space.shape[0]\n",
    "action_size = env.action_space.n\n",
    "\n",
    "model = build_model(state_size, action_size, 0.1)\n",
    "#print(len(model.layers))\n",
    "model.summary()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:52.775031100Z",
     "start_time": "2023-07-27T00:10:50.994817200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "state_bounds = np.array([2.4, 2.5, 0.21, 2.5])\n",
    "n_actions = 2\n",
    "gamma = 0.99\n",
    "batch_size = 16\n",
    "n_episodes = 2000\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.02, amsgrad=True)\n",
    "\n",
    "# Assign the model parameters to each optimizer\n",
    "w_in, w_var, w_out = 1, 0, 2"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:10:52.779030100Z",
     "start_time": "2023-07-27T00:10:52.777026500Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished episode 16 Average rewards:  21.8\n",
      "Finished episode 32 Average rewards:  24.0\n",
      "Finished episode 48 Average rewards:  34.3\n",
      "Finished episode 64 Average rewards:  24.7\n",
      "WARNING:tensorflow:5 out of the last 5 calls to <function reinforce_update at 0x7fa1ac3504d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "Finished episode 80 Average rewards:  32.5\n",
      "WARNING:tensorflow:6 out of the last 6 calls to <function reinforce_update at 0x7fa1ac3504d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "Finished episode 96 Average rewards:  36.2\n",
      "Finished episode 112 Average rewards:  39.9\n",
      "Finished episode 128 Average rewards:  40.7\n",
      "Finished episode 144 Average rewards:  37.5\n",
      "Finished episode 160 Average rewards:  44.1\n",
      "Finished episode 176 Average rewards:  46.9\n",
      "Finished episode 192 Average rewards:  62.1\n",
      "Finished episode 208 Average rewards:  80.0\n",
      "Finished episode 224 Average rewards:  45.3\n",
      "Finished episode 240 Average rewards:  87.7\n",
      "Finished episode 256 Average rewards:  111.2\n",
      "Finished episode 272 Average rewards:  96.5\n",
      "Finished episode 288 Average rewards:  65.2\n",
      "Finished episode 304 Average rewards:  97.5\n",
      "Finished episode 320 Average rewards:  84.6\n",
      "Finished episode 336 Average rewards:  115.3\n",
      "Finished episode 352 Average rewards:  106.7\n",
      "Finished episode 368 Average rewards:  86.8\n",
      "Finished episode 384 Average rewards:  131.6\n",
      "Finished episode 400 Average rewards:  160.9\n",
      "Finished episode 416 Average rewards:  195.7\n",
      "Finished episode 432 Average rewards:  142.3\n",
      "Finished episode 448 Average rewards:  170.1\n",
      "Finished episode 464 Average rewards:  147.2\n",
      "Finished episode 480 Average rewards:  137.1\n",
      "Finished episode 496 Average rewards:  100.7\n",
      "Finished episode 512 Average rewards:  105.8\n",
      "Finished episode 528 Average rewards:  103.0\n",
      "Finished episode 544 Average rewards:  69.5\n",
      "Finished episode 560 Average rewards:  51.2\n",
      "Finished episode 576 Average rewards:  77.6\n",
      "Finished episode 592 Average rewards:  95.4\n",
      "Finished episode 608 Average rewards:  118.1\n",
      "Finished episode 624 Average rewards:  127.0\n",
      "Finished episode 640 Average rewards:  132.2\n",
      "Finished episode 656 Average rewards:  135.1\n",
      "Finished episode 672 Average rewards:  127.5\n",
      "Finished episode 688 Average rewards:  126.9\n",
      "Finished episode 704 Average rewards:  112.1\n",
      "Finished episode 720 Average rewards:  114.1\n",
      "Finished episode 736 Average rewards:  108.7\n",
      "Finished episode 752 Average rewards:  94.5\n",
      "Finished episode 768 Average rewards:  93.2\n",
      "Finished episode 784 Average rewards:  108.2\n",
      "Finished episode 800 Average rewards:  86.6\n",
      "Finished episode 816 Average rewards:  87.4\n",
      "Finished episode 832 Average rewards:  76.4\n",
      "Finished episode 848 Average rewards:  63.8\n",
      "Finished episode 864 Average rewards:  76.9\n",
      "Finished episode 880 Average rewards:  71.0\n",
      "Finished episode 896 Average rewards:  74.8\n",
      "Finished episode 912 Average rewards:  71.1\n",
      "Finished episode 928 Average rewards:  70.2\n",
      "Finished episode 944 Average rewards:  67.9\n",
      "Finished episode 960 Average rewards:  62.7\n",
      "Finished episode 976 Average rewards:  60.8\n",
      "Finished episode 992 Average rewards:  55.1\n",
      "Finished episode 1008 Average rewards:  40.7\n",
      "Finished episode 1024 Average rewards:  30.0\n",
      "Finished episode 1040 Average rewards:  24.6\n",
      "Finished episode 1056 Average rewards:  25.8\n",
      "Finished episode 1072 Average rewards:  27.9\n",
      "Finished episode 1088 Average rewards:  39.7\n",
      "Finished episode 1104 Average rewards:  40.8\n",
      "Finished episode 1120 Average rewards:  48.2\n",
      "Finished episode 1136 Average rewards:  60.4\n",
      "Finished episode 1152 Average rewards:  64.5\n",
      "Finished episode 1168 Average rewards:  68.6\n",
      "Finished episode 1184 Average rewards:  72.5\n",
      "Finished episode 1200 Average rewards:  84.6\n",
      "Finished episode 1216 Average rewards:  93.6\n",
      "Finished episode 1232 Average rewards:  109.8\n",
      "Finished episode 1248 Average rewards:  139.5\n",
      "Finished episode 1264 Average rewards:  163.0\n",
      "Finished episode 1280 Average rewards:  250.8\n",
      "Finished episode 1296 Average rewards:  271.2\n",
      "Finished episode 1312 Average rewards:  252.8\n",
      "Finished episode 1328 Average rewards:  176.4\n",
      "Finished episode 1344 Average rewards:  225.9\n",
      "Finished episode 1360 Average rewards:  150.9\n",
      "Finished episode 1376 Average rewards:  178.6\n",
      "Finished episode 1392 Average rewards:  164.0\n",
      "Finished episode 1408 Average rewards:  135.0\n",
      "Finished episode 1424 Average rewards:  130.9\n",
      "Finished episode 1440 Average rewards:  112.0\n",
      "Finished episode 1456 Average rewards:  102.5\n",
      "Finished episode 1472 Average rewards:  100.4\n",
      "Finished episode 1488 Average rewards:  91.1\n",
      "Finished episode 1504 Average rewards:  86.0\n",
      "Finished episode 1520 Average rewards:  95.2\n",
      "Finished episode 1536 Average rewards:  83.7\n",
      "Finished episode 1552 Average rewards:  80.1\n",
      "Finished episode 1568 Average rewards:  76.1\n",
      "Finished episode 1584 Average rewards:  88.5\n",
      "Finished episode 1600 Average rewards:  78.8\n",
      "Finished episode 1616 Average rewards:  86.5\n",
      "Finished episode 1632 Average rewards:  79.8\n",
      "Finished episode 1648 Average rewards:  85.8\n",
      "Finished episode 1664 Average rewards:  84.5\n",
      "Finished episode 1680 Average rewards:  87.1\n",
      "Finished episode 1696 Average rewards:  88.5\n",
      "Finished episode 1712 Average rewards:  96.7\n",
      "Finished episode 1728 Average rewards:  107.3\n",
      "Finished episode 1744 Average rewards:  114.5\n",
      "Finished episode 1760 Average rewards:  135.2\n",
      "Finished episode 1776 Average rewards:  158.9\n",
      "Finished episode 1792 Average rewards:  182.8\n",
      "Finished episode 1808 Average rewards:  217.7\n",
      "Finished episode 1824 Average rewards:  283.7\n",
      "Finished episode 1840 Average rewards:  360.2\n",
      "Finished episode 1856 Average rewards:  347.5\n",
      "Finished episode 1872 Average rewards:  332.7\n",
      "Finished episode 1888 Average rewards:  289.5\n",
      "Finished episode 1904 Average rewards:  284.3\n",
      "Finished episode 1920 Average rewards:  239.4\n",
      "Finished episode 1936 Average rewards:  218.9\n",
      "Finished episode 1952 Average rewards:  188.9\n",
      "Finished episode 1968 Average rewards:  192.3\n",
      "Finished episode 1984 Average rewards:  175.1\n",
      "Finished episode 2000 Average rewards:  160.8\n"
     ]
    }
   ],
   "source": [
    "#main training loop of the agent\n",
    "env_name = \"CartPole-v1\"\n",
    "\n",
    "# Start training the agent\n",
    "episode_reward_history = []\n",
    "for batch in range(n_episodes // batch_size):\n",
    "    # Gather episodes\n",
    "    episodes = gather_episodes(state_bounds, n_actions, model, batch_size, env_name)\n",
    "\n",
    "    # Group states, actions and returns in numpy arrays\n",
    "    states = np.concatenate([ep['states'] for ep in episodes])\n",
    "    actions = np.concatenate([ep['actions'] for ep in episodes])\n",
    "    rewards = [ep['rewards'] for ep in episodes]\n",
    "    returns = np.concatenate([compute_returns(ep_rwds, gamma) for ep_rwds in rewards])\n",
    "    returns = np.array(returns, dtype=np.float32)\n",
    "\n",
    "    id_action_pairs = np.array([[i, a] for i, a in enumerate(actions)])\n",
    "\n",
    "    # Update model parameters.\n",
    "    reinforce_update(states, id_action_pairs, returns, model)\n",
    "\n",
    "    # Store collected rewards\n",
    "    for ep_rwds in rewards:\n",
    "        episode_reward_history.append(np.sum(ep_rwds))\n",
    "\n",
    "    avg_rewards = np.mean(episode_reward_history[-10:])\n",
    "\n",
    "    print('Finished episode', (batch + 1) * batch_size,\n",
    "          'Average rewards: ', avg_rewards)\n",
    "\n",
    "    if avg_rewards >= 500.0:\n",
    "        break\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:11:18.703427200Z",
     "start_time": "2023-07-27T00:10:52.781584300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1000x500 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.plot(episode_reward_history)\n",
    "plt.xlabel('Epsiode')\n",
    "plt.ylabel('Collected rewards')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:11:18.815845900Z",
     "start_time": "2023-07-27T00:11:18.704434700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "# env = gym.make(\"CartPole-v1\")  # , render_mode=\"human\"\n",
    "# observation = env.reset()\n",
    "#\n",
    "# for _ in range(500):\n",
    "#     states = tf.convert_to_tensor(observation.reshape(1, -1) / state_bounds)\n",
    "#     action_probs = np.asarray(model(states)).astype('float64')  # issue with float32\n",
    "#     action_probs = action_probs/np.sum(action_probs)\n",
    "#     action = np.random.choice(n_actions, p=action_probs[0])\n",
    "#     observation, reward, terminated, truncated = env.step(action)\n",
    "#\n",
    "#     if terminated or truncated:\n",
    "#         observation = env.reset()\n",
    "#\n",
    "# env.close()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:12:24.918594100Z",
     "start_time": "2023-07-27T00:12:24.629138700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Deep Q Learning Agent"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "# Define the Q-network\n",
    "def build_q_network(state_size, action_size):\n",
    "    model = keras.Sequential()\n",
    "    model.add(layers.Dense(24, activation='relu', input_dim=state_size))\n",
    "    model.add(layers.Dense(24, activation='relu'))\n",
    "    model.add(layers.Dense(action_size, activation='linear'))\n",
    "    return model"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:12:55.933779800Z",
     "start_time": "2023-07-27T00:12:55.915487300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [],
   "source": [
    "# Define the DQN agent\n",
    "class DQNAgent:\n",
    "    def __init__(self, state_size, action_size, learning_rate=0.001, gamma=0.99, epsilon=1.0, epsilon_decay=0.995, epsilon_min=0.01):\n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.learning_rate = learning_rate\n",
    "        self.gamma = gamma\n",
    "        self.epsilon = epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.epsilon_min = epsilon_min\n",
    "        self.model = build_q_network(state_size, action_size)\n",
    "        self.target_model = build_q_network(state_size, action_size)\n",
    "        self.replay_memory = deque(maxlen=2000)\n",
    "        self.model.compile(loss='mse', optimizer=keras.optimizers.Adam(lr=learning_rate))\n",
    "\n",
    "    def choose_action(self, state):\n",
    "        if np.random.rand() <= self.epsilon:\n",
    "            return np.random.choice(self.action_size)\n",
    "        q_values = self.model.predict(state)\n",
    "        return np.argmax(q_values[0])\n",
    "\n",
    "    def remember(self, state, action, reward, next_state, done):\n",
    "        self.replay_memory.append((state, action, reward, next_state, done))\n",
    "\n",
    "    def train(self, batch_size):\n",
    "        if len(self.replay_memory) < batch_size:\n",
    "            return\n",
    "\n",
    "        minibatch = np.random.choice(len(self.replay_memory), batch_size, replace=False)\n",
    "        states = []\n",
    "        targets = []\n",
    "\n",
    "        for idx in minibatch:\n",
    "            state, action, reward, next_state, done = self.replay_memory[idx]\n",
    "            target = self.target_model.predict(state)\n",
    "            if done:\n",
    "                target[0][action] = reward\n",
    "            else:\n",
    "                q_future = np.max(self.target_model.predict(next_state)[0])\n",
    "                target[0][action] = reward + self.gamma * q_future\n",
    "\n",
    "            states.append(state[0])\n",
    "            targets.append(target[0])\n",
    "\n",
    "        self.model.fit(np.array(states), np.array(targets), epochs=1, verbose=0)\n",
    "\n",
    "        if self.epsilon > self.epsilon_min:\n",
    "            self.epsilon *= self.epsilon_decay\n",
    "\n",
    "    def update_target_model(self):\n",
    "        self.target_model.set_weights(self.model.get_weights())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:12:56.462625500Z",
     "start_time": "2023-07-27T00:12:56.452123900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [],
   "source": [
    "# Create the CartPole environment\n",
    "env = gym.make('CartPole-v1')\n",
    "state_size = env.observation_space.shape[0]\n",
    "action_size = env.action_space.n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:12:58.023681400Z",
     "start_time": "2023-07-27T00:12:58.002654600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/geeks_ubuntu/miniconda3/envs/py37_tfq_test_env/lib/python3.7/site-packages/keras/optimizer_v2/adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super(Adam, self).__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# Create the DQN agent\n",
    "agent = DQNAgent(state_size, action_size)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:13:00.175004200Z",
     "start_time": "2023-07-27T00:13:00.110815Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [],
   "source": [
    "# Training parameters\n",
    "n_episodes = 2000\n",
    "max_timesteps = 500\n",
    "batch_size = 16\n",
    "render = False"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-27T00:13:02.556187600Z",
     "start_time": "2023-07-27T00:13:02.526743600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode: 1 Total Reward: 17.0\n",
      "Episode: 2 Total Reward: 58.0\n",
      "Episode: 3 Total Reward: 10.0\n",
      "Episode: 4 Total Reward: 23.0\n",
      "Episode: 5 Total Reward: 8.0\n",
      "Episode: 6 Total Reward: 14.0\n",
      "Episode: 7 Total Reward: 18.0\n",
      "Episode: 8 Total Reward: 9.0\n",
      "Episode: 9 Total Reward: 10.0\n",
      "Episode: 10 Total Reward: 12.0\n",
      "Episode: 11 Total Reward: 8.0\n"
     ]
    }
   ],
   "source": [
    "# Episode reward history\n",
    "episode_reward_history = []\n",
    "\n",
    "# Main training loop\n",
    "for episode in range(n_episodes):\n",
    "    state = env.reset()\n",
    "    state = np.reshape(state, [1, state_size])\n",
    "    total_reward = 0\n",
    "\n",
    "    for timestep in range(max_timesteps):\n",
    "        if render:\n",
    "            env.render()\n",
    "\n",
    "        action = agent.choose_action(state)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        next_state = np.reshape(next_state, [1, state_size])\n",
    "        agent.remember(state, action, reward, next_state, done)\n",
    "        state = next_state\n",
    "        total_reward += reward\n",
    "\n",
    "        if done:\n",
    "            agent.update_target_model()\n",
    "            break\n",
    "\n",
    "        agent.train(batch_size)\n",
    "\n",
    "    episode_reward_history.append(total_reward)\n",
    "    print(\"Episode:\", episode+1, \"Total Reward:\", total_reward)"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true,
    "ExecuteTime": {
     "start_time": "2023-07-27T00:13:04.159092400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.plot(episode_reward_history)\n",
    "plt.xlabel('Epsiode')\n",
    "plt.ylabel('Collected rewards')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Evaluate the trained agent\n",
    "total_rewards = []\n",
    "n_eval_episodes = 10\n",
    "\n",
    "for _ in range(n_eval_episodes):\n",
    "    state = env.reset()\n",
    "    state = np.reshape(state, [1, state_size])\n",
    "    episode_reward = 0\n",
    "\n",
    "    while True:\n",
    "        env.render()\n",
    "        action = agent.choose_action(state)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        next_state = np.reshape(next_state, [1, state_size])\n",
    "        episode_reward += reward\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "\n",
    "    total_rewards.append(episode_reward)\n",
    "\n",
    "average_reward = np.mean(total_rewards)\n",
    "print(\"Average Reward:\", average_reward)\n",
    "\n",
    "# Close the environment\n",
    "env.close()"
   ],
   "metadata": {
    "collapsed": false,
    "is_executing": true
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Actor-Critic Agent"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "inputs = layers.Input(shape=(num_inputs,))\n",
    "common = layers.Dense(num_hidden, activation=\"relu\")(inputs)\n",
    "action = layers.Dense(num_actions, activation=\"softmax\")(common)\n",
    "critic = layers.Dense(1)(common)\n",
    "\n",
    "model = keras.Model(inputs=inputs, outputs=[action, critic])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "num_inputs = 4\n",
    "num_actions = 2\n",
    "num_hidden = 128"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Configuration parameters for the whole setup\n",
    "seed = 42\n",
    "gamma = 0.99  # Discount factor for past rewards\n",
    "max_steps_per_episode = 10000\n",
    "env = gym.make(\"CartPole-v1\")  # Create the environment\n",
    "env.seed(seed)\n",
    "eps = np.finfo(np.float32).eps.item()  # Smallest number such that 1.0 + eps != 1.0"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "optimizer = keras.optimizers.Adam(learning_rate=0.01)\n",
    "huber_loss = keras.losses.Huber()\n",
    "action_probs_history = []\n",
    "critic_value_history = []\n",
    "rewards_history = []\n",
    "running_reward = 0\n",
    "episode_count = 0"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "while True:  # Run until solved\n",
    "    state = env.reset()\n",
    "    episode_reward = 0\n",
    "    with tf.GradientTape() as tape:\n",
    "        for timestep in range(1, max_steps_per_episode):\n",
    "            # env.render(); Adding this line would show the attempts\n",
    "            # of the agent in a pop up window.\n",
    "\n",
    "            state = tf.convert_to_tensor(state)\n",
    "            state = tf.expand_dims(state, 0)\n",
    "\n",
    "            # Predict action probabilities and estimated future rewards\n",
    "            # from environment state\n",
    "            action_probs, critic_value = model(state)\n",
    "            critic_value_history.append(critic_value[0, 0])\n",
    "\n",
    "            # Sample action from action probability distribution\n",
    "            action = np.random.choice(num_actions, p=np.squeeze(action_probs))\n",
    "            action_probs_history.append(tf.math.log(action_probs[0, action]))\n",
    "\n",
    "            # Apply the sampled action in our environment\n",
    "            state, reward, done, _ = env.step(action)\n",
    "            rewards_history.append(reward)\n",
    "            episode_reward += reward\n",
    "\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        # Update running reward to check condition for solving\n",
    "        running_reward = 0.05 * episode_reward + (1 - 0.05) * running_reward\n",
    "\n",
    "        # Calculate expected value from rewards\n",
    "        # - At each timestep what was the total reward received after that timestep\n",
    "        # - Rewards in the past are discounted by multiplying them with gamma\n",
    "        # - These are the labels for our critic\n",
    "        returns = []\n",
    "        discounted_sum = 0\n",
    "        for r in rewards_history[::-1]:\n",
    "            discounted_sum = r + gamma * discounted_sum\n",
    "            returns.insert(0, discounted_sum)\n",
    "\n",
    "        # Normalize\n",
    "        returns = np.array(returns)\n",
    "        returns = (returns - np.mean(returns)) / (np.std(returns) + eps)\n",
    "        returns = returns.tolist()\n",
    "\n",
    "        # Calculating loss values to update our network\n",
    "        history = zip(action_probs_history, critic_value_history, returns)\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        for log_prob, value, ret in history:\n",
    "            # At this point in history, the critic estimated that we would get a\n",
    "            # total reward = `value` in the future. We took an action with log probability\n",
    "            # of `log_prob` and ended up recieving a total reward = `ret`.\n",
    "            # The actor must be updated so that it predicts an action that leads to\n",
    "            # high rewards (compared to critic's estimate) with high probability.\n",
    "            diff = ret - value\n",
    "            actor_losses.append(-log_prob * diff)  # actor loss\n",
    "\n",
    "            # The critic must be updated so that it predicts a better estimate of\n",
    "            # the future rewards.\n",
    "            critic_losses.append(\n",
    "                huber_loss(tf.expand_dims(value, 0), tf.expand_dims(ret, 0))\n",
    "            )\n",
    "\n",
    "        # Backpropagation\n",
    "        loss_value = sum(actor_losses) + sum(critic_losses)\n",
    "        grads = tape.gradient(loss_value, model.trainable_variables)\n",
    "        optimizer.apply_gradients(zip(grads, model.trainable_variables))\n",
    "\n",
    "        # Clear the loss and reward history\n",
    "        action_probs_history.clear()\n",
    "        critic_value_history.clear()\n",
    "        rewards_history.clear()\n",
    "\n",
    "    # Log details\n",
    "    episode_count += 1\n",
    "    if episode_count % 10 == 0:\n",
    "        template = \"running reward: {:.2f} at episode {}\"\n",
    "        print(template.format(running_reward, episode_count))\n",
    "\n",
    "    if running_reward > 195:  # Condition to consider the task solved\n",
    "        print(\"Solved at episode {}!\".format(episode_count))\n",
    "        break"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}