Dueling Deep Q Learning (+ DDQNs and PER).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf      # Deep Learning library\n",
    "import numpy as np           # Handle matrices\n",
    "import pandas as pd\n",
    "\n",
    "import random                # Handling random number generation\n",
    "import time                  # Handling time calculation\n",
    "from skimage import transform# Help us to preprocess the frames\n",
    "\n",
    "from collections import deque# Ordered collection with ends\n",
    "import matplotlib.pyplot as plt # Display graphs\n",
    "\n",
    "import warnings # This ignore all the warning messages that are normally printed during the training because of skiimage\n",
    "# warnings.filterwarnings('ignore') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Variables\n",
    "\n",
    "BATTERY_CAPACITY = 900\n",
    "BATTERY_DISCHARGE = 300\n",
    "\n",
    "MAXIMUM_DEMAND_LIMIT = 1000\n",
    "PENALITY_EXCEED_DEMAND =  0\n",
    "\n",
    "DATASET_DIR = 'dataset/aravali.csv'\n",
    "\n",
    "class env(object):\n",
    "    \n",
    "    \n",
    "    def __init__ (self):\n",
    "    \n",
    "        self.read_dataset()\n",
    "        self.iter = 0\n",
    "        \n",
    "        self.max_battery=BATTERY_CAPACITY\n",
    "        self.battery=BATTERY_CAPACITY\n",
    "        self.charge_battery=BATTERY_DISCHARGE\n",
    "        \n",
    "        self.reward = 0\n",
    "        self.exceed_demand = 0\n",
    "        \n",
    "        \n",
    "        self.obs=[]\n",
    "        self.set_observation()\n",
    "        self.done = False\n",
    "        self.info = \"\"\n",
    "        self.action_space = [[0,0,1],[0,1,0],[1,0,0]] #['grid', 'battery discharge', 'battery charge']\n",
    "        self.obs_space = len(self.obs)\n",
    "       \n",
    "\n",
    "    #function to change the pricing\n",
    "    def set_observation(self):\n",
    "        dict={}\n",
    "        price=[]\n",
    "        base_cost = 1\n",
    "        for x in range(24):\n",
    "            if(x<6):\n",
    "                price.append(base_cost)\n",
    "            elif(x<9):\n",
    "                price.append(base_cost - 0.75)\n",
    "            elif(x<12):\n",
    "                price.append(base_cost + 0) \n",
    "            elif(x<=18):\n",
    "                price.append(base_cost + 0.5)\n",
    "            elif(x<=22):\n",
    "                price.append(base_cost + 1)                \n",
    "            else:\n",
    "                price.append(base_cost - 0.75)\n",
    "        dict['price'] = price\n",
    "        dict['battery'] = self.battery\n",
    "        dict['load'] = self.dataset['load'][self.iter]\n",
    "        self.observation =  dict\n",
    "        self.obs = [p for p in price]\n",
    "        self.obs.append(self.observation['battery'])\n",
    "        self.obs.append(self.observation['load'])\n",
    "    \n",
    "    \n",
    "    def read_dataset(self):\n",
    "        file_location = DATASET_DIR\n",
    "        try:\n",
    "            df=pd.read_csv(file_location)\n",
    "        except e:\n",
    "            print(\"Error loading the file, check if file exists !\")\n",
    "\n",
    "        df['load']= df['W1'] + df['W2'] + df['W3']\n",
    "        for name in list(df):\n",
    "            if(name not in ['TS','load']):\n",
    "                df=df.drop(name,axis=1)\n",
    "\n",
    "        df.fillna(0)  \n",
    "        self.dataset =  df    \n",
    "    \n",
    "    \n",
    "    def step(self, action):\n",
    "        \n",
    "        #Making sure the action taken is valid\n",
    "        if action not in self.action_space:\n",
    "            raise ValueError('Invalid Action Space')\n",
    "        \n",
    "        #calc reward for the action based on the action choosen\n",
    "        curr_demand = self.dataset['load'][self.iter]\n",
    "        grid_price = self.observation['price'][0]\n",
    "        if(action==self.action_space[0]): #'grid'\n",
    "            self.reward = curr_demand * grid_price\n",
    "            if(curr_demand > MAXIMUM_DEMAND_LIMIT):\n",
    "                self.exceed_demand += 1\n",
    "            \n",
    "        if(action==self.action_space[1]): #'battery'\n",
    "            if(self.battery<=0): #after the battery is completly drained\n",
    "                self.reward = curr_demand * grid_price\n",
    "                if(curr_demand > MAXIMUM_DEMAND_LIMIT):\n",
    "                    self.exceed_demand += 1\n",
    "            else: \n",
    "                battery_satisfy = min(curr_demand, self.charge_battery, self.battery)\n",
    "                self.battery = self.battery - battery_satisfy\n",
    "                self.reward =  (curr_demand - battery_satisfy) * grid_price  \n",
    "                if((curr_demand - battery_satisfy) > MAXIMUM_DEMAND_LIMIT):\n",
    "                    self.exceed_demand += 1\n",
    "                \n",
    "        if(action==self.action_space[2]):  #'charge'\n",
    "            battery_charge = min(self.charge_battery, self.max_battery-self.battery)\n",
    "            self.battery = self.battery + battery_charge\n",
    "            self.reward = (curr_demand+battery_charge) * grid_price\n",
    "            if((curr_demand + battery_charge) > MAXIMUM_DEMAND_LIMIT):\n",
    "                    self.exceed_demand += 1\n",
    "        \n",
    "        \n",
    "        #adding the constrain for the Maximum demand\n",
    "        if(curr_demand >= MAXIMUM_DEMAND_LIMIT):\n",
    "#             print('Exceed Demand', (curr_demand - MAXIMUM_DEMAND_LIMIT))\n",
    "            self.reward += (curr_demand - MAXIMUM_DEMAND_LIMIT) * PENALITY_EXCEED_DEMAND\n",
    "        \n",
    "        \n",
    "        self.reward = -1 * self.reward\n",
    "        self.iter = self.iter+1\n",
    "        \n",
    "        #update the pricing for the next observation\n",
    "        price = self.observation['price'][1:]\n",
    "        price.append(self.observation['price'][0])\n",
    "        self.observation['price'] = price\n",
    "        self.observation['battery'] = self.battery\n",
    "        #fetch the next load\n",
    "        self.observation['load'] = self.dataset['load'][self.iter]\n",
    "        \n",
    "        \n",
    "        self.obs = [p for p in price]\n",
    "        self.obs.append(self.observation['battery'])\n",
    "        self.obs.append(self.observation['load'])\n",
    "        \n",
    "        return self.obs, self.reward, self.done, self.info\n",
    "    \n",
    "    \n",
    "    \n",
    "    def reset(self):\n",
    "        self.iter = 0\n",
    "        self.reward = 0\n",
    "        self.done = False\n",
    "        self.info = \"\"\n",
    "        self.set_observation()\n",
    "        self.exceed_demand = 0\n",
    "        return self.obs\n",
    "    \n",
    "\n",
    "    \n",
    "    def render(self):\n",
    "        df = self.dataset\n",
    "        avg=[0.0 for x in range(24)]\n",
    "        days= int(df.shape[0]/24)   \n",
    "        print(\"Number of days in dataset\" +str(days))  #The dataset is not good\n",
    "        days=10\n",
    "        for i in range(days):\n",
    "#             plt.plot([x for x in range(24)],df['load'][(i*24):(i*24)+24])\n",
    "            avg = [ float(a) + float(b) for a,b in zip(avg, df['load'][(i*24):(i*24)+24]) ]\n",
    "\n",
    "        \n",
    "        time_shift = self.iter %24\n",
    "        print(\"Time shift \" +str(time_shift))\n",
    "        avg = [x/days for x in avg]\n",
    "        print(\"Average consumption per day \" +str(sum(avg)))\n",
    "        curr_profile = list(df['load'][(self.iter):self.iter+24])\n",
    "        \n",
    "#         print(avg)\n",
    "#         print(curr_profile)\n",
    "#         print(\"Consumption for 10 days\")\n",
    "\n",
    "        x=[a for a in range(24)]\n",
    "        y=[avg, curr_profile]\n",
    "\n",
    "        labels = ['Average','Random Day']\n",
    "\n",
    "        for y_arr, label in zip(y, labels):\n",
    "            plt.plot(x, y_arr, label=label)\n",
    "        \n",
    "        plt.xlabel('time (hours)')\n",
    "        plt.ylabel('Consumption (Wh)')   \n",
    "        \n",
    "        plt.legend()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of days in dataset253\n",
      "Time shift 0\n",
      "Average consumption per day 5939.569130586826\n"
     ]
    },
    {
     "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": [
    "game = env()\n",
    "game.render()\n",
    "possible_actions = game.action_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Reward Grid Only -245355.1364631849\n",
      "Total Reward Grid with Random Battery -242480.72576912653\n",
      "Total Reward Rule Based -235160.50939930347\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "duration = 24 * 30\n",
    "\n",
    "\n",
    "# Consume only from grid\n",
    "a = env()\n",
    "r_grid = [0 for x in range(24)]\n",
    "for i in range(duration):\n",
    "    obs, reward, done, info = a.step(possible_actions[0])\n",
    "    r_grid[i%24] += reward  \n",
    "\n",
    "    \n",
    "# Take actions randomly    \n",
    "a = env()\n",
    "r_random = [0 for x in range(24)]\n",
    "for i in range(duration):\n",
    "    action = randint(1, 3)\n",
    "    if(action==1):\n",
    "        obs, reward, done, info = a.step(possible_actions[0])\n",
    "        r_random[i%24] += reward  \n",
    "\n",
    "    elif(action==2):  \n",
    "        obs, reward, done, info = a.step(possible_actions[1])\n",
    "        r_random[i%24] += reward \n",
    "        \n",
    "    if(action==3):  \n",
    "        obs, reward, done, info = a.step(possible_actions[2])\n",
    "        r_random[i%24] += reward     \n",
    "    \n",
    "\n",
    "# Best Action to choose    \n",
    "a = env()\n",
    "r_rule = [0 for x in range(24)]\n",
    "for i in range(duration):\n",
    "    time = i%24\n",
    "    action = 1\n",
    "    \n",
    "    if(time<9):\n",
    "        action = 3\n",
    "    else:\n",
    "        action = 2\n",
    "        \n",
    "    if(action==1):\n",
    "        obs, reward, done, info = a.step(possible_actions[0])\n",
    "        r_rule[i%24] += reward  \n",
    "\n",
    "    elif(action==2):  \n",
    "        obs, reward, done, info = a.step(possible_actions[1])\n",
    "        r_rule[i%24] += reward \n",
    "        \n",
    "    if(action==3):  \n",
    "        obs, reward, done, info = a.step(possible_actions[2])\n",
    "        r_rule[i%24] += reward    \n",
    "        \n",
    "\n",
    "\n",
    "plot_grid = [abs(x/10) for x  in r_grid]\n",
    "plot_random = [abs(x/10) for x in r_random]\n",
    "plot_rule = [abs(x/10) for x in r_rule]\n",
    "\n",
    "x = [a for a in range(24)]\n",
    "y = [plot_grid, plot_random, plot_rule]\n",
    "labels = ['Grid', 'Random : Grid with Battery', 'RuleBased : Grid with Battery']\n",
    "\n",
    "\n",
    "for y_arr, label in zip(y, labels):\n",
    "    plt.plot(x, y_arr, label=label)\n",
    "    \n",
    "plt.xlabel('time (hours)')\n",
    "plt.ylabel('Cost (x)')\n",
    "\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "print('Total Reward Grid Only', sum(r_grid))\n",
    "print('Total Reward Grid with Random Battery',sum(r_random))\n",
    "print('Total Reward Rule Based',sum(r_rule))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### MODEL HYPERPARAMETERS\n",
    "state_size = [game.obs_space]      \n",
    "action_size = 3           \n",
    "learning_rate = 0.01 #0.00025      # Alpha (aka learning rate)\n",
    "\n",
    "### TRAINING HYPERPARAMETERS\n",
    "total_episodes = 1000 #50000         # Total episodes for training\n",
    "max_steps = 24*30 #00              # Max possible steps in an episode\n",
    "batch_size = 32 #64             \n",
    "\n",
    "# FIXED Q TARGETS HYPERPARAMETERS \n",
    "max_tau = 5 #00 #Tau is the C step where we update our target network\n",
    "\n",
    "# EXPLORATION HYPERPARAMETERS for epsilon greedy strategy\n",
    "explore_start = 1.0            # exploration probability at start\n",
    "explore_stop = 0.01            # minimum exploration probability \n",
    "decay_rate = 0.05            # exponential decay rate for exploration prob\n",
    "\n",
    "# Q LEARNING hyperparameters\n",
    "gamma = 0.95               # Discounting rate\n",
    "\n",
    "### MEMORY HYPERPARAMETERS\n",
    "## If you have GPU change to 1million\n",
    "pretrain_length = 24*15 # 100000   # Number of experiences stored in the Memory when initialized for the first time\n",
    "memory_size = 10240 #100000       # Number of experiences the Memory can keep\n",
    "\n",
    "### MODIFY THIS TO FALSE IF YOU JUST WANT TO SEE THE TRAINED AGENT\n",
    "training = True\n",
    "\n",
    "## TURN THIS TO TRUE IF YOU WANT TO RENDER THE ENVIRONMENT\n",
    "episode_render = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDDQNNet:\n",
    "    def __init__(self, state_size, action_size, learning_rate, name):\n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.learning_rate = learning_rate\n",
    "        self.name = name\n",
    "        \n",
    "        \n",
    "        # We use tf.variable_scope here to know which network we're using (DQN or target_net)\n",
    "        # it will be useful when we will update our w- parameters (by copy the DQN parameters)\n",
    "        with tf.variable_scope(self.name):\n",
    "            \n",
    "            # We create the placeholders\n",
    "            # *state_size means that we take each elements of state_size in tuple hence is like if we wrote\n",
    "            # [None, 100, 120, 4]\n",
    "            \n",
    "            \n",
    "            self.inputs_ = tf.placeholder(tf.float32, [None, *state_size], name=\"inputs\")\n",
    "            \n",
    "            self.ISWeights_ = tf.placeholder(tf.float32, [None,1], name='IS_weights')\n",
    "            \n",
    "            self.actions_ = tf.placeholder(tf.float32, [None, action_size], name=\"actions_\")\n",
    "            \n",
    "            # Remember that target_Q is the R(s,a) + ymax Qhat(s', a')\n",
    "            self.target_Q = tf.placeholder(tf.float32, [None], name=\"target\")\n",
    "            \n",
    "            \n",
    "            self.dense1 = tf.layers.dense(inputs = self.inputs_,\n",
    "                      units = 25,\n",
    "                      activation = tf.keras.activations.relu,\n",
    "                           kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                    name=\"dense1\")\n",
    "            \n",
    "            self.dense2 = tf.layers.dense(inputs = self.dense1,\n",
    "                      units = 25,\n",
    "                      activation = tf.keras.activations.relu,\n",
    "                           kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                    name=\"dense2\")\n",
    "            \n",
    "            \n",
    "            ## Here we separate into two streams\n",
    "            # The one that calculate V(s)\n",
    "            self.value_fc = tf.layers.dense(inputs = self.dense1,\n",
    "                                  units = 25,\n",
    "                                  activation = tf.keras.activations.relu,\n",
    "                                       kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                                name=\"value_fc\")\n",
    "            \n",
    "            self.value = tf.layers.dense(inputs = self.value_fc,\n",
    "                                        units = 1,\n",
    "                                        activation = None, #tf.keras.activations.linear,\n",
    "                                        kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                                name=\"value\")\n",
    "            \n",
    "            # The one that calculate A(s,a)\n",
    "            self.advantage_fc = tf.layers.dense(inputs = self.dense1,\n",
    "                                  units = 25,\n",
    "                                  activation = tf.keras.activations.relu,\n",
    "                                  kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                                  name=\"advantage_fc\")\n",
    "            \n",
    "            self.advantage = tf.layers.dense(inputs = self.advantage_fc,\n",
    "                                units = self.action_size,\n",
    "                                activation = None, #tf.keras.activations.linear,\n",
    "                                kernel_initializer=tf.contrib.layers.xavier_initializer(),\n",
    "                                name=\"advantages\")\n",
    "            \n",
    "            # Agregating layer\n",
    "            # Q(s,a) = V(s) + (A(s,a) - 1/|A| * sum A(s,a'))\n",
    "            self.output = self.value + tf.subtract(self.advantage, tf.reduce_mean(self.advantage, axis=1, keepdims=True))\n",
    "              \n",
    "            # Q is our predicted Q value.\n",
    "            self.Q = tf.reduce_sum(tf.multiply(self.output, self.actions_), axis=1)\n",
    "            \n",
    "#             # The loss is modified because of PER \n",
    "            self.absolute_errors = tf.abs(self.target_Q - self.Q)# for updating Sumtree\n",
    "            \n",
    "            self.loss = tf.reduce_mean(self.ISWeights_ * tf.squared_difference(self.target_Q, self.Q))\n",
    "\n",
    "#             self.optimizer = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)\n",
    "            \n",
    "            self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate).minimize(self.loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "WARNING:tensorflow:From <ipython-input-6-4be6435cdbf2>:32: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "# Reset the graph\n",
    "tf.reset_default_graph()\n",
    "\n",
    "# Instantiate the DQNetwork\n",
    "DQNetwork = DDDQNNet(state_size, action_size, learning_rate, name=\"DQNetwork\")\n",
    "\n",
    "# Instantiate the target network\n",
    "TargetNetwork = DDDQNNet(state_size, action_size, learning_rate, name=\"TargetNetwork\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SumTree(object):\n",
    "    \"\"\"\n",
    "    This SumTree code is modified version of Morvan Zhou: \n",
    "    https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/5.2_Prioritized_Replay_DQN/RL_brain.py\n",
    "    \"\"\"\n",
    "    data_pointer = 0\n",
    "    \n",
    "    \"\"\"\n",
    "    Here we initialize the tree with all nodes = 0, and initialize the data with all values = 0\n",
    "    \"\"\"\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity # Number of leaf nodes (final nodes) that contains experiences\n",
    "        \n",
    "        # Generate the tree with all nodes values = 0\n",
    "        # To understand this calculation (2 * capacity - 1) look at the schema above\n",
    "        # Remember we are in a binary node (each node has max 2 children) so 2x size of leaf (capacity) - 1 (root node)\n",
    "        # Parent nodes = capacity - 1\n",
    "        # Leaf nodes = capacity\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        \n",
    "        \"\"\" tree:\n",
    "            0\n",
    "           / \\\n",
    "          0   0\n",
    "         / \\ / \\\n",
    "        0  0 0  0  [Size: capacity] it's at this line that there is the priorities score (aka pi)\n",
    "        \"\"\"\n",
    "        \n",
    "        # Contains the experiences (so the size of data is capacity)\n",
    "        self.data = np.zeros(capacity, dtype=object)\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    Here we add our priority score in the sumtree leaf and add the experience in data\n",
    "    \"\"\"\n",
    "    def add(self, priority, data):\n",
    "        # Look at what index we want to put the experience\n",
    "        tree_index = self.data_pointer + self.capacity - 1\n",
    "        \n",
    "        \"\"\" tree:\n",
    "            0\n",
    "           / \\\n",
    "          0   0\n",
    "         / \\ / \\\n",
    "tree_index  0 0  0  We fill the leaves from left to right\n",
    "        \"\"\"\n",
    "        \n",
    "        # Update data frame\n",
    "        self.data[self.data_pointer] = data\n",
    "        \n",
    "        # Update the leaf\n",
    "        self.update (tree_index, priority)\n",
    "        \n",
    "        # Add 1 to data_pointer\n",
    "        self.data_pointer += 1\n",
    "        \n",
    "        if self.data_pointer >= self.capacity:  # If we're above the capacity, you go back to first index (we overwrite)\n",
    "            self.data_pointer = 0\n",
    "            \n",
    "    \n",
    "    \"\"\"\n",
    "    Update the leaf priority score and propagate the change through tree\n",
    "    \"\"\"\n",
    "    def update(self, tree_index, priority):\n",
    "        # Change = new priority score - former priority score\n",
    "        change = priority - self.tree[tree_index]\n",
    "        self.tree[tree_index] = priority\n",
    "        \n",
    "        # then propagate the change through tree\n",
    "        while tree_index != 0:    # this method is faster than the recursive loop in the reference code\n",
    "            \n",
    "            \"\"\"\n",
    "            Here we want to access the line above\n",
    "            THE NUMBERS IN THIS TREE ARE THE INDEXES NOT THE PRIORITY VALUES\n",
    "            \n",
    "                0\n",
    "               / \\\n",
    "              1   2\n",
    "             / \\ / \\\n",
    "            3  4 5  [6] \n",
    "            \n",
    "            If we are in leaf at index 6, we updated the priority score\n",
    "            We need then to update index 2 node\n",
    "            So tree_index = (tree_index - 1) // 2\n",
    "            tree_index = (6-1)//2\n",
    "            tree_index = 2 (because // round the result)\n",
    "            \"\"\"\n",
    "            tree_index = (tree_index - 1) // 2\n",
    "            self.tree[tree_index] += change\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    Here we get the leaf_index, priority value of that leaf and experience associated with that index\n",
    "    \"\"\"\n",
    "    def get_leaf(self, v):\n",
    "        \"\"\"\n",
    "        Tree structure and array storage:\n",
    "        Tree index:\n",
    "             0         -> storing priority sum\n",
    "            / \\\n",
    "          1     2\n",
    "         / \\   / \\\n",
    "        3   4 5   6    -> storing priority for experiences\n",
    "        Array type for storing:\n",
    "        [0,1,2,3,4,5,6]\n",
    "        \"\"\"\n",
    "        parent_index = 0\n",
    "        \n",
    "        while True: # the while loop is faster than the method in the reference code\n",
    "            left_child_index = 2 * parent_index + 1\n",
    "            right_child_index = left_child_index + 1\n",
    "            \n",
    "            # If we reach bottom, end the search\n",
    "            if left_child_index >= len(self.tree):\n",
    "                leaf_index = parent_index\n",
    "                break\n",
    "            \n",
    "            else: # downward search, always search for a higher priority node\n",
    "                \n",
    "                if v <= self.tree[left_child_index]:\n",
    "                    parent_index = left_child_index\n",
    "                    \n",
    "                else:\n",
    "                    v -= self.tree[left_child_index]\n",
    "                    parent_index = right_child_index\n",
    "            \n",
    "        data_index = leaf_index - self.capacity + 1\n",
    "\n",
    "        return leaf_index, self.tree[leaf_index], self.data[data_index]\n",
    "    \n",
    "    @property\n",
    "    def total_priority(self):\n",
    "        return self.tree[0] # Returns the root node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we don't use deque anymore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Memory(object):  # stored as ( s, a, r, s_ ) in SumTree\n",
    "    \"\"\"\n",
    "    This SumTree code is modified version and the original code is from:\n",
    "    https://github.com/jaara/AI-blog/blob/master/Seaquest-DDQN-PER.py\n",
    "    \"\"\"\n",
    "    PER_e = 0.01  # Hyperparameter that we use to avoid some experiences to have 0 probability of being taken\n",
    "    PER_a = 0.6  # Hyperparameter that we use to make a tradeoff between taking only exp with high priority and sampling randomly\n",
    "    PER_b = 0.4  # importance-sampling, from initial value increasing to 1\n",
    "    \n",
    "    PER_b_increment_per_sampling = 0.001\n",
    "    \n",
    "    absolute_error_upper = 1.  # clipped abs error\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        # Making the tree \n",
    "        \"\"\"\n",
    "        Remember that our tree is composed of a sum tree that contains the priority scores at his leaf\n",
    "        And also a data array\n",
    "        We don't use deque because it means that at each timestep our experiences change index by one.\n",
    "        We prefer to use a simple array and to overwrite when the memory is full.\n",
    "        \"\"\"\n",
    "        self.tree = SumTree(capacity)\n",
    "        \n",
    "    \"\"\"\n",
    "    Store a new experience in our tree\n",
    "    Each new experience have a score of max_prority (it will be then improved when we use this exp to train our DDQN)\n",
    "    \"\"\"\n",
    "    def store(self, experience):\n",
    "        # Find the max priority\n",
    "        max_priority = np.max(self.tree.tree[-self.tree.capacity:])\n",
    "        \n",
    "        # If the max priority = 0 we can't put priority = 0 since this exp will never have a chance to be selected\n",
    "        # So we use a minimum priority\n",
    "        if max_priority == 0:\n",
    "            max_priority = self.absolute_error_upper\n",
    "        \n",
    "        self.tree.add(max_priority, experience)   # set the max p for new p\n",
    "\n",
    "        \n",
    "    \"\"\"\n",
    "    - First, to sample a minibatch of k size, the range [0, priority_total] is / into k ranges.\n",
    "    - Then a value is uniformly sampled from each range\n",
    "    - We search in the sumtree, the experience where priority score correspond to sample values are retrieved from.\n",
    "    - Then, we calculate IS weights for each minibatch element\n",
    "    \"\"\"\n",
    "    def sample(self, n):\n",
    "        # Create a sample array that will contains the minibatch\n",
    "        memory_b = []\n",
    "        \n",
    "        b_idx, b_ISWeights = np.empty((n,), dtype=np.int32), np.empty((n, 1), dtype=np.float32)\n",
    "        \n",
    "        # Calculate the priority segment\n",
    "        # Here, as explained in the paper, we divide the Range[0, ptotal] into n ranges\n",
    "        priority_segment = self.tree.total_priority / n       # priority segment\n",
    "    \n",
    "        # Here we increasing the PER_b each time we sample a new minibatch\n",
    "        self.PER_b = np.min([1., self.PER_b + self.PER_b_increment_per_sampling])  # max = 1\n",
    "        \n",
    "        # Calculating the max_weight\n",
    "        p_min = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total_priority\n",
    "        max_weight = (p_min * n) ** (-self.PER_b)\n",
    "        \n",
    "        for i in range(n):\n",
    "            \"\"\"\n",
    "            A value is uniformly sample from each range\n",
    "            \"\"\"\n",
    "            a, b = priority_segment * i, priority_segment * (i + 1)\n",
    "            value = np.random.uniform(a, b)\n",
    "            \n",
    "            \"\"\"\n",
    "            Experience that correspond to each value is retrieved\n",
    "            \"\"\"\n",
    "            index, priority, data = self.tree.get_leaf(value)\n",
    "            \n",
    "            #P(j)\n",
    "            sampling_probabilities = priority / self.tree.total_priority\n",
    "            \n",
    "            #  IS = (1/N * 1/P(i))**b /max wi == (N*P(i))**-b  /max wi\n",
    "            b_ISWeights[i, 0] = np.power(n * sampling_probabilities, -self.PER_b)/ max_weight\n",
    "                                   \n",
    "            b_idx[i]= index\n",
    "            \n",
    "            experience = [data]\n",
    "            \n",
    "            memory_b.append(experience)\n",
    "        \n",
    "        return b_idx, memory_b, b_ISWeights\n",
    "    \n",
    "    \"\"\"\n",
    "    Update the priorities on the tree\n",
    "    \"\"\"\n",
    "    def batch_update(self, tree_idx, abs_errors):\n",
    "        abs_errors += self.PER_e  # convert to abs and avoid 0\n",
    "        clipped_errors = np.minimum(abs_errors, self.absolute_error_upper)\n",
    "        ps = np.power(clipped_errors, self.PER_a)\n",
    "\n",
    "        for ti, p in zip(tree_idx, ps):\n",
    "            self.tree.update(ti, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll **deal with the empty memory problem**: we pre-populate our memory by taking random actions and storing the experience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate memory\n",
    "memory = Memory(memory_size)\n",
    "\n",
    "# Render the environment\n",
    "state = game.reset()\n",
    "\n",
    "for i in range(pretrain_length):\n",
    "    \n",
    "    # Random action\n",
    "    action = random.choice(possible_actions)\n",
    "    \n",
    "    # Get the rewards\n",
    "    state_next, reward, terminal, done = game.step(action)\n",
    "#     print(reward)\n",
    "    # Add experience to memory\n",
    "    experience = state, action, reward, state_next, done\n",
    "    \n",
    "    memory.store(experience)\n",
    "\n",
    "    # Our state is now the next_state\n",
    "    state = state_next"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 7: Set up Tensorboard 📊\n",
    "For more information about tensorboard, please watch this <a href=\"https://www.youtube.com/embed/eBbEDRsCmv4\">excellent 30min tutorial</a> <br><br>\n",
    "To launch tensorboard : `tensorboard --logdir=/tensorboard/dddqn/1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup TensorBoard Writer\n",
    "writer = tf.summary.FileWriter(\"./tensorboard/dddqn/2\")\n",
    "\n",
    "## Losses\n",
    "tf.summary.scalar(\"Loss\", DQNetwork.loss)\n",
    "# tf.summary.scalar(\"Rewards\", DQNetwork.rewards_obtained)\n",
    "\n",
    "# tf.summary.scalar(\"Abs_Error\", DQNetwork.absolute_errors)\n",
    "\n",
    "write_op = tf.summary.merge_all()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This function will do the part\n",
    "With ϵ select a random action atat, otherwise select at=argmaxaQ(st,a)\n",
    "\"\"\"\n",
    "def predict_action(explore_start, explore_stop, decay_rate, decay_step, state, actions):\n",
    "    ## EPSILON GREEDY STRATEGY\n",
    "    # Choose action a from state s using epsilon greedy.\n",
    "    ## First we randomize a number\n",
    "    exp_exp_tradeoff = np.random.rand()\n",
    "\n",
    "    # Here we'll use an improved version of our epsilon greedy strategy used in Q-learning notebook\n",
    "    explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step)\n",
    "    \n",
    "    if (explore_probability > exp_exp_tradeoff):\n",
    "        # Make a random action (exploration)\n",
    "        action = random.choice(possible_actions)\n",
    "        \n",
    "    else:\n",
    "        # Get action from Q-network (exploitation)\n",
    "        # Estimate the Qs values state\n",
    "        state = np.array([state])\n",
    "        Qs = sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: state})\n",
    "#         if(randint(0,100)>95):\n",
    "#             print(state[0][:4], Qs)\n",
    "        # Take the biggest Q value (= the best action)\n",
    "        choice = np.argmax(Qs)\n",
    "        action = possible_actions[int(choice)]\n",
    "                \n",
    "    return action, explore_probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function helps us to copy one set of variables to another\n",
    "# In our case we use it when we want to copy the parameters of DQN to Target_network\n",
    "# Thanks of the very good implementation of Arthur Juliani https://github.com/awjuliani\n",
    "def update_target_graph():\n",
    "    \n",
    "    # Get the parameters of our DQNNetwork\n",
    "    from_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, \"DQNetwork\")\n",
    "    \n",
    "    # Get the parameters of our Target_network\n",
    "    to_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, \"TargetNetwork\")\n",
    "\n",
    "    op_holder = []\n",
    "    \n",
    "    # Update our target_network parameters with DQNNetwork parameters\n",
    "    for from_var,to_var in zip(from_vars,to_vars):\n",
    "        op_holder.append(to_var.assign(from_var))\n",
    "    return op_holder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1326.6271,Exploring  0.9517171302557069,Current_reward 241940.48146822385\n",
      "Model Saved  0\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Saver will help us to save our model\n",
    "saver = tf.train.Saver()\n",
    "\n",
    "if training == True:\n",
    "    with tf.Session() as sess:\n",
    "        # Initialize the variables\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        \n",
    "        # Initialize the decay rate (that will use to reduce epsilon) \n",
    "        decay_step = 0\n",
    "        \n",
    "        # Set tau = 0\n",
    "        tau = 0\n",
    "\n",
    "        # Init the game\n",
    "        game.reset()\n",
    "        \n",
    "        # Update the parameters of our TargetNetwork with DQN_weights\n",
    "        update_target = update_target_graph()\n",
    "        sess.run(update_target)\n",
    "        \n",
    "        \n",
    "        total_rewards = []\n",
    "        for episode in range(total_episodes):\n",
    "            # Set step to 0\n",
    "            step = 0\n",
    "            \n",
    "            # Initialize the rewards of the episode\n",
    "            episode_rewards = []\n",
    "            \n",
    "            # Make a new episode and observe the first state\n",
    "            state = game.reset()\n",
    "            \n",
    "            curr_reward = 0\n",
    "            \n",
    "            decay_step +=1\n",
    "            \n",
    "            tau += 1\n",
    "            while step < max_steps:\n",
    "                step += 1\n",
    "                \n",
    "                # With ϵ select a random action atat, otherwise select a = argmaxQ(st,a)\n",
    "#                 print(explore_start, explore_stop, decay_rate, decay_step, state, possible_actions)\n",
    "                action, explore_probability = predict_action(explore_start, explore_stop, decay_rate, decay_step, state, possible_actions)\n",
    "                \n",
    "                # Do the action\n",
    "                state_next, reward, terminal, done = game.step(action)\n",
    "                \n",
    "                #to plot the rewards\n",
    "                curr_reward = curr_reward + abs(reward)\n",
    "                \n",
    "                # Add the reward to total reward\n",
    "                episode_rewards.append(reward)\n",
    "\n",
    "                # Add experience to memory\n",
    "                experience = state, action, reward, state_next, done\n",
    "                memory.store(experience)\n",
    "\n",
    "                # st+1 is now our current state\n",
    "                state = state_next\n",
    "\n",
    "                ### LEARNING PART            \n",
    "                # Obtain random mini-batch from memory\n",
    "                tree_idx, batch, ISWeights_mb = memory.sample(batch_size)\n",
    "                \n",
    "                states_mb = np.array([each[0][0] for each in batch])\n",
    "                actions_mb = np.array([each[0][1] for each in batch])\n",
    "                rewards_mb = np.array([each[0][2] for each in batch]) \n",
    "                next_states_mb = np.array([each[0][3] for each in batch])\n",
    "                dones_mb = np.array([each[0][4] for each in batch])\n",
    "\n",
    "                target_Qs_batch = []\n",
    "\n",
    "                \n",
    "                ### DOUBLE DQN Logic\n",
    "                # Use DQNNetwork to select the action to take at next_state (a') (action with the highest Q-value)\n",
    "                # Use TargetNetwork to calculate the Q_val of Q(s',a')\n",
    "                \n",
    "                # Get Q values for next_state \n",
    "                q_next_state = sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: next_states_mb})\n",
    "                \n",
    "                # Calculate Qtarget for all actions that state\n",
    "                q_target_next_state = sess.run(TargetNetwork.output, feed_dict = {TargetNetwork.inputs_: next_states_mb})\n",
    "                \n",
    "                \n",
    "                # Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma * Qtarget(s',a') \n",
    "                for i in range(0, len(batch)):\n",
    "                    \n",
    "                    # We got a'\n",
    "                    action = np.argmax(q_next_state[i])\n",
    "\n",
    "                    # Take the Qtarget for action a'\n",
    "                    target = rewards_mb[i] + gamma * q_target_next_state[i][action]\n",
    "                    target_Qs_batch.append(target)\n",
    "                        \n",
    "\n",
    "                targets_mb = np.array([each for each in target_Qs_batch])\n",
    "\n",
    "#                 print(states_mb.shape, targets_mb.shape, actions_mb.shape, ISWeights_mb.shape)                \n",
    "                \n",
    "                _, loss, absolute_errors = sess.run([DQNetwork.optimizer, DQNetwork.loss, DQNetwork.absolute_errors],\n",
    "                                    feed_dict={DQNetwork.inputs_: states_mb,\n",
    "                                               DQNetwork.target_Q: targets_mb,\n",
    "                                               DQNetwork.actions_: actions_mb,\n",
    "                                              DQNetwork.ISWeights_: ISWeights_mb})\n",
    "              \n",
    "\n",
    "                \n",
    "                # Update priority\n",
    "                memory.batch_update(tree_idx, absolute_errors)\n",
    "                \n",
    "                \n",
    "                \n",
    "                if tau > max_tau:\n",
    "                    # Update the parameters of our TargetNetwork with DQN_weights\n",
    "                    update_target = update_target_graph()\n",
    "                    sess.run(update_target)\n",
    "                    tau = 0\n",
    "                    print(\"Model update\")\n",
    "\n",
    "\n",
    "                # Write TF Summaries\n",
    "                summary = sess.run(write_op, feed_dict={DQNetwork.inputs_: states_mb,\n",
    "                                                   DQNetwork.target_Q: targets_mb,\n",
    "                                                   DQNetwork.actions_: actions_mb,\n",
    "                                              DQNetwork.ISWeights_: ISWeights_mb})\n",
    "                writer.add_summary(summary, episode)\n",
    "                writer.flush()\n",
    "                \n",
    "            print(episode, loss, end = ',')            \n",
    "            print(\"Exploring \", explore_probability, end = ',')\n",
    "            print(\"Current_reward\", curr_reward)\n",
    "\n",
    "            total_rewards.append(curr_reward)\n",
    "            \n",
    "            # Save model every 5 episodes\n",
    "            if episode % 50 == 0:\n",
    "                save_path = saver.save(sess, \"./models/\"+str(episode)+\"/model.ckpt\")\n",
    "                print(\"Model Saved \", episode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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"
    }
   ],
   "source": [
    "plt.plot(total_rewards)\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Cost')   \n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 9: Watch our Agent play 👀\n",
    "Now that we trained our agent, we can test it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./models/model.ckpt\n",
      "Score:  -7294.014239613884\n"
     ]
    },
    {
     "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": [
    "test_days = 10\n",
    "\n",
    "with tf.Session() as test_sess:\n",
    "\n",
    "    test_game = env()\n",
    "\n",
    "    # Load the model\n",
    "    saver.restore(test_sess, \"./models/model.ckpt\")\n",
    "\n",
    "    test_state = test_game.reset()\n",
    "\n",
    "\n",
    "    test_rewards = []\n",
    "    test_battery=[]\n",
    "\n",
    "    for i in range(24*test_days):\n",
    "        ## EPSILON GREEDY STRATEGY\n",
    "        # Choose action a from state s using epsilon greedy.\n",
    "        ## First we randomize a number\n",
    "        test_exp_exp_tradeoff = np.random.rand()\n",
    "\n",
    "        test_state = np.array([test_state])\n",
    "        test_Qs = test_sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: test_state})\n",
    "\n",
    "        # Take the biggest Q value (= the best action)\n",
    "        test_choice = np.argmax(test_Qs)\n",
    "        test_action = possible_actions[int(test_choice)]\n",
    "\n",
    "        test_state, test_reward, test_terminal, test_done = test_game.step(test_action)\n",
    "#         print(test_state[:4], test_Qs, test_choice)\n",
    "\n",
    "        test_battery.append(test_state[-2])\n",
    "        test_rewards.append(test_reward)\n",
    "\n",
    "    print(\"Score: \", sum(test_rewards)/test_days)\n",
    "\n",
    "\n",
    "\n",
    "test_battery_status = [[] for i in range(24)]\n",
    "test_time = -1\n",
    "\n",
    "for test_i in range(0, 24*test_days):\n",
    "    test_time +=1\n",
    "    test_battery_status[test_time%24].append(test_battery[test_i])\n",
    "\n",
    "\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.set_title('Battery_status')\n",
    "ax1.boxplot(test_battery_status)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Battery Charge')\n",
    "plt.show()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}