Deep_Reinforcement_Learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "43688151",
   "metadata": {},
   "source": [
    "# Deep Reinforcement Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55aab539",
   "metadata": {},
   "source": [
    "In this code, we implement the different DRL algorithms discussed in the thesis for different problems."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed20fb59",
   "metadata": {},
   "source": [
    "## General Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ce50b0ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries needed to import for this example\n",
    "\n",
    "import numpy as np                    # Basic numerical python library\n",
    "import scipy as sci                   # Algorithms for scientific computing\n",
    "import pandas as pd                   # Data analysis library\n",
    "import random                         # Random number generator\n",
    "\n",
    "from collections import deque         # Specialized contained datatypes\n",
    "\n",
    "import matplotlib.pyplot as plt       # Plotting library for python\n",
    "\n",
    "import gymnasium as gym               # Standard API for RL, with many environments\n",
    "\n",
    "import torch                          # Deep Learning library\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Categorical\n",
    "\n",
    "from stable_baselines3 import PPO, A2C # Reinforcement Learning library\n",
    "\n",
    "import optuna                          # Hyperparameter search library\n",
    "from optuna.pruners import MedianPruner\n",
    "from optuna.samplers import TPESampler\n",
    "\n",
    "from typing import Literal, Optional, Union, Any, Dict # Type hints\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1231221a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function definitions\n",
    "\n",
    "def tuple_or_list_to_str(list_tuple_list: list[Union[tuple, list]]) -> list[str]:\n",
    "    \n",
    "    # Store the elements of a list with tuples/lists into a list with strings.\n",
    "    \n",
    "    # Inputs\n",
    "\n",
    "    # list_tuple_list : list[Union[tuple, list]] List of tuples/lists to store into a list of strs.\n",
    "    \n",
    "    # Outputs\n",
    "    \n",
    "    # list[str]: Elements of the tuple/list stored in a str.\n",
    "    \n",
    "    return list(map(lambda x: \" \".join(map(str, x)), list_tuple_list))\n",
    "\n",
    "def eps_greedy(state,net,epsilon):\n",
    "    \n",
    "    val = net.forward(torch.from_numpy(state.astype(np.float32)))\n",
    "    \n",
    "    if epsilon > np.random.rand():\n",
    "        \n",
    "        action = torch.randint(val.shape[0],[])\n",
    "        \n",
    "    else:\n",
    "            \n",
    "        action = torch.argmax(val)\n",
    "            \n",
    "    return action, val\n",
    "\n",
    "# Environment class, needs to be a valid gym.Env class\n",
    "\n",
    "class HTC_env(gym.Env):\n",
    "    \n",
    "    # Inputs\n",
    "    \n",
    "    # size: Number of layers of the physical system, we use 16\n",
    "    \n",
    "    # Initialization of the environment\n",
    "    \n",
    "    def __init__(self,size):\n",
    "\n",
    "        super(HTC_env, self).__init__() # Initialize parent classes\n",
    "        \n",
    "        self.size = size # Number of layers of the physical system\n",
    "\n",
    "        self.observation_space = gym.spaces.Box(0, 1, shape = (self.size,), dtype = int) # Shape of the possible states\n",
    "        self.action_space = gym.spaces.Discrete(2*self.size) # Shape of the possibla actions\n",
    "\n",
    "        self.render_mode = None # In case something asks about rendering the environment\n",
    "\n",
    "        self._counter = 0 # Countdown to reset the episode\n",
    "        self._max_counter = 2*self.size # Length of episode\n",
    "\n",
    "        self.terminated = False # Checks if there is a need to reset the episode\n",
    "\n",
    "        self.seen = []           # Holds the states that have been visited by this environment instance\n",
    "        self.best = 0.0          # Holds the best state found of this environment instance\n",
    "        self.seen_recording = [] # Holds how many states have been seen as the environment is used\n",
    "        self.best_recording = [] # Holds which is the best state found yet, as the environment is used\n",
    "        \n",
    "    # Internal function to calculate the next state and return given an action\n",
    "        \n",
    "    def _take_action(self, action):\n",
    "\n",
    "        new_state_slice = np.copy(self._current_state[0]) # Copy the previous state\n",
    "    \n",
    "        if action < self.size:\n",
    "        \n",
    "            new_state_slice[action] = int(0) # Make the selected layer dielctric\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            new_state_slice[action-self.size] = int(1) # Make the selected layer metallic\n",
    "    \n",
    "        new_value = htc_series[tuple_or_list_to_str([new_state_slice.astype(int)])].values[0]/(norm) # HTC of the next state\n",
    "    \n",
    "        new_state = [new_state_slice,new_value] # New state tuple\n",
    "        reward = new_value.astype('float') - rew_base # Reward from new state\n",
    "        \n",
    "        self._current_state = new_state # Save this state as current\n",
    "    \n",
    "        return new_state, reward\n",
    "    \n",
    "    \n",
    "    # Function to reset the state after the episode ends\n",
    "    \n",
    "    def reset(self, seed = None, options = None):\n",
    "\n",
    "        self.terminated = False # Reset the flag\n",
    "\n",
    "        self._counter = 0 # Reset the countdown to reset the episode\n",
    "\n",
    "        super().reset(seed=seed) # So that self.np_random is seeded, in case its needed\n",
    "\n",
    "        self._reset_state = np.zeros((self.size,)).astype(int) # Seed for the starting state, all 0s\n",
    "        \n",
    "        self._current_state = [self._reset_state,htc_series[tuple_or_list_to_str([self._reset_state])].values[0]/(norm)] # Starting state, all 0s\n",
    "\n",
    "        state = self._current_state[0] # Current state, back to 0\n",
    "        HTC = self._current_state[1] # HTC of current state\n",
    "        \n",
    "        return state,{}\n",
    "\n",
    "    # Function to apply an action and recover the next state and rewards\n",
    "    \n",
    "    def step(self, action):\n",
    "\n",
    "        self._counter += 1 # Add one step to the counter\n",
    "\n",
    "        if self._counter == self._max_counter+1: # If next step would be outside episode, time to reset\n",
    "\n",
    "            next_state,_ = self.reset() # Reset episode\n",
    "            reward = htc_series[tuple_or_list_to_str([next_state])].values[0]/(norm) - rew_base # What the reward would have been\n",
    "            self.terminated = True # Put flag to true\n",
    "\n",
    "        else:\n",
    "            \n",
    "            next_state, reward = self._take_action(action) # Apply action to obtain new state and reward\n",
    "\n",
    "        if next_state[1] not in self.seen: # Check if it's a new state\n",
    "            \n",
    "            self.seen.append(next_state[1]) # Save the state to the list\n",
    "            \n",
    "            if next_state[1] > self.best: # If it's better than any before, save it as the best\n",
    "                \n",
    "                self.best = next_state[1]\n",
    "                    \n",
    "            self.seen_recording.append(len(self.seen)) # Save how many states we have seen so far\n",
    "            self.best_recording.append(self.best) # Save which is the best among them\n",
    "\n",
    "        return next_state[0], reward, self.terminated, False, {} # Output structure is the gym.Env structure\n",
    "    \n",
    "def act_on_env7(action, old_state, baseline):\n",
    "    \n",
    "    # Environment for the Reinforcement Learning Algorithm\n",
    "    \n",
    "    # Inputs\n",
    "    \n",
    "    # action: index describing the action to take: even index is a 0, odd ondex is a 1, in the floor(action/2) position\n",
    "    # old_state: vector of 0s and 1s describing the material\n",
    "    # baseline: HTC of the best system encountered so far, recorded in memory\n",
    "    \n",
    "    # Outputs\n",
    "    \n",
    "    # new_state: list of vector of 0s and 1s describing the material and the corresponding HTC\n",
    "    # reward: HTC of the new system, minus the baseline\n",
    "    \n",
    "    new_state_slice = np.copy(old_state[0]) # Copy the previous state\n",
    "    \n",
    "    if action < n_slice:\n",
    "        \n",
    "        new_state_slice[action] = int(0) # Make the selected layer dielctric\n",
    "        \n",
    "    else:\n",
    "            \n",
    "        new_state_slice[action-n_slice] = int(1) # Make the selected layer metallic\n",
    "    \n",
    "    new_value = htc_series[tuple_or_list_to_str([new_state_slice.astype(int)])].values[0]/(norm) # HTC of the next state\n",
    "    \n",
    "    new_state = [new_state_slice,new_value] # New state tuple\n",
    "    reward = (new_value.astype('float32') - baseline) # Reward from new state\n",
    "    \n",
    "    return new_state, reward\n",
    "\n",
    "class SumTree:\n",
    "    write = 0\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "        self.tree = np.zeros( 2*capacity - 1 )\n",
    "        self.data = np.zeros( capacity, dtype=object )\n",
    "\n",
    "    def _propagate(self, idx, change):\n",
    "        parent = (idx - 1) // 2\n",
    "\n",
    "        self.tree[parent] += change\n",
    "\n",
    "        if parent != 0:\n",
    "            self._propagate(parent, change)\n",
    "\n",
    "    def _retrieve(self, idx, s):\n",
    "        left = 2 * idx + 1\n",
    "        right = left + 1\n",
    "\n",
    "        if left >= len(self.tree):\n",
    "            return idx\n",
    "\n",
    "        if s <= self.tree[left]:\n",
    "            return self._retrieve(left, s)\n",
    "        else:\n",
    "            return self._retrieve(right, s-self.tree[left])\n",
    "\n",
    "    def total(self):\n",
    "        return self.tree[0]\n",
    "\n",
    "    def add(self, p, data):\n",
    "        idx = self.write + self.capacity - 1\n",
    "\n",
    "        self.data[self.write] = data\n",
    "        self.update(idx, p)\n",
    "\n",
    "        self.write += 1\n",
    "        if self.write >= self.capacity:\n",
    "            self.write = 0\n",
    "\n",
    "    def update(self, idx, p):\n",
    "        change = p - self.tree[idx]\n",
    "\n",
    "        self.tree[idx] = p\n",
    "        self._propagate(idx, change)\n",
    "\n",
    "    def get(self, s):\n",
    "        idx = self._retrieve(0, s)\n",
    "        dataIdx = idx - self.capacity + 1\n",
    "\n",
    "        return (idx, self.tree[idx], self.data[dataIdx], dataIdx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c13aefd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_6655/2002588383.py:11: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  rew_base = htc_series[tuple_or_list_to_str([base_seed.astype(int)])][0]/(norm) # Baseline for the rewards\n"
     ]
    }
   ],
   "source": [
    "# Defining and loading the datasets\n",
    "\n",
    "vect = np.genfromtxt('Datasets/16layers_index.txt').astype(int) # Combination of materials\n",
    "htc_vals = np.genfromtxt('Datasets/16layer_data.txt', dtype = 'float64') # Associated HTC\n",
    "\n",
    "htc_series = pd.Series(data = htc_vals, index = tuple_or_list_to_str(vect)) # Series form, for much faster searching\n",
    "\n",
    "norm = 1e5 # Normalization constant for HTC, units (10^5 W/m^2 K)\n",
    "\n",
    "base_seed = np.array([1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]) # State to use as baseline for the rewards\n",
    "rew_base = htc_series[tuple_or_list_to_str([base_seed.astype(int)])][0]/(norm) # Baseline for the rewards"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c201150",
   "metadata": {},
   "source": [
    "## DRL Algorithms for RHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6446292-b512-4f66-a94e-fda25167ef30",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SARSA\n",
    "\n",
    "# Actions: component x is 0 if action is x in [0,n), component x is 1 if action is x+n in [n,2n)\n",
    "# Reward: htc of next state\n",
    "\n",
    "# Parameters\n",
    "\n",
    "seed = 0 # Seed for the random variables\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(0) # Seed the numpy library\n",
    "\n",
    "N_layers_data = 16 # Number of layers the system has\n",
    "\n",
    "N_inputs = 16 # Number of elements on the input layer\n",
    "N_layers = 4 # Number of hidden layers for the network\n",
    "N_neurons = 64 # Number of neurons per layer\n",
    "N_outputs = 32 # Number of elements on the output layer\n",
    "\n",
    "lr = 1e-5 # Learning rate of the network\n",
    "gamma = 0.99 # Discount factor\n",
    "\n",
    "norm = 1e5 # Normalization for the htc values\n",
    "start_state_seed = np.zeros((N_layers_data,)) # Starting state when resetting\n",
    "start_state = [start_state_seed,htc_series[tuple_or_list_to_str([start_state_seed.astype(int)])][0]/(norm)]\n",
    "baseline_seed = np.array([1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]) # Baseline state \n",
    "baseline = [baseline_seed,htc_series[tuple_or_list_to_str([baseline_seed.astype(int)])][0]/(norm)]\n",
    "\n",
    "eps0 = 1 # Initial epsilon for the epsilon greedy algorithm\n",
    "eps1 = 0.1 # Final epsilon for the epsilon greedy algorithm\n",
    "steps_eps = 60000 # Number of steps until epsilon reaches its final value\n",
    "\n",
    "steps_training = 60000 # Number of training steps to perform on the network\n",
    "len_episode = 32 # Length of an epsiode, after which it resets\n",
    "\n",
    "# Pre-allocate variables\n",
    "\n",
    "y_current = [] # Holds the current output of Q values\n",
    "y_target = [] # Holds the predicted target Q values\n",
    "\n",
    "loss_recording = [] # Records the loss for each training step\n",
    "episode_recording = [] # Records the last state for trial episodes run greedily\n",
    "best_recording = [] # Records the best state found so far\n",
    "\n",
    "# Step 1: define the network\n",
    "\n",
    "layers = [nn.Linear(N_inputs, N_neurons), nn.SELU()] # List of all the layers that will have the future network\n",
    "\n",
    "for i in range(N_layers):\n",
    "    \n",
    "    layers.append(nn.Linear(N_neurons,N_neurons))\n",
    "    layers.append(nn.SELU())\n",
    "\n",
    "layers.append(nn.Linear(N_neurons,N_outputs)) \n",
    "\n",
    "q_net = nn.Sequential(*layers) # Network for behavior in Q\n",
    "q_net_target = nn.Sequential(*layers) # Target network for Q\n",
    "\n",
    "losss = nn.L1Loss() # Loss for the training of the network\n",
    "\n",
    "opt = optim.Adam(q_net.parameters(), lr) # Optimizer to update the network\n",
    "\n",
    "# Step 3: perform the training and exploration \n",
    "\n",
    "for i in range(steps_training): # Total number of explore-train loops\n",
    "    \n",
    "    state1 = start_state # Initialize to the reset state\n",
    "    \n",
    "    epsilon = np.maximum(eps0 - i*(eps0-eps1)/steps_eps,eps1) # Define the current value of epsilon, decays\n",
    "\n",
    "    epsiode_recording = [] # Holds the states visited in this episode\n",
    "        \n",
    "    # Perform the exploration steps\n",
    "\n",
    "    for j in range(len_episode):\n",
    "    \n",
    "        state = state1 # The current state is the ending state of the previous step\n",
    "    \n",
    "        # Choose an action given the state\n",
    "    \n",
    "        q_values = q_net.forward(torch.from_numpy(state[0].astype(np.float32))) # Prediction of Q values\n",
    "    \n",
    "        rand = random.uniform(0,1) # To do the random result\n",
    "    \n",
    "        if epsilon > rand:\n",
    "        \n",
    "            action = random.randint(0,2*N_layers_data-1) # Choose action randomly\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            action = torch.argmax(q_values).item() # Choose action with highest Q \n",
    "        \n",
    "        # Obtain the rewards and next state, given the state and action\n",
    "    \n",
    "        state1_seed = np.copy(state[0]) # Copy the current state\n",
    "    \n",
    "        if action < N_layers_data:\n",
    "        \n",
    "            state1_seed[action] = int(0) # The element becomes 0\n",
    "        \n",
    "        else:\n",
    "        \n",
    "            state1_seed[action-N_layers_data] = int(1) # The element becomes 1\n",
    "        \n",
    "        state1 = [state1_seed,htc_series[tuple_or_list_to_str([state1_seed.astype(int)])][0]/(norm)]\n",
    "        \n",
    "        reward = state1[1] - baseline[1]\n",
    "\n",
    "        q_values1 = q_net.forward(torch.from_numpy(state[0].astype(np.float32))) # Prediction of Q values\n",
    "    \n",
    "        rand = random.uniform(0,1) # To do the random result\n",
    "    \n",
    "        if epsilon > rand:\n",
    "        \n",
    "            action1 = random.randint(0,2*N_layers_data-1) # Choose action randomly\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            action1 = torch.argmax(q_values).item() # Choose action with highest Q \n",
    "    \n",
    "        # Save the step to memory\n",
    "    \n",
    "        episode_recording.append([state,action,reward,state1,action1])\n",
    "    \n",
    "        if state1[1] > best_so_far[1]:\n",
    "        \n",
    "            best_so_far = state1 # Update the best state found \n",
    "        \n",
    "        best_recording.append(best_so_far)\n",
    "        \n",
    "    # Perform the training steps\n",
    "                    \n",
    "    for j in range(len_batch):\n",
    "            \n",
    "        state_batch = episode_recording[j][0] # State of the given experience of the batch\n",
    "        action_batch = episode_recording[j][1] # Action taken of the given experience of the batch\n",
    "        reward_batch = episode_recording[j][2] # Reward obtained of the given experience of the batch\n",
    "        state1_batch = episode_recording[j][3] # Next state of the given experience of the batch\n",
    "        action1_batch = episode_recording[j][3] # Next action of the given experience of the batch\n",
    "            \n",
    "        # Obtain current value\n",
    "            \n",
    "        q_pred_current = q_net.forward(torch.from_numpy(state_batch[0].astype(np.float32)))\n",
    "            \n",
    "        # Obtain the Q values according to both networks\n",
    "            \n",
    "        q_pred = q_net.forward(torch.from_numpy(state1_batch[0].astype(np.float32)))\n",
    "            \n",
    "        # Predict the current Q value and target Q value\n",
    "                        \n",
    "        Q_target = torch.squeeze(torch.Tensor([reward_batch]) + gamma*q_pred[action1_batch]) # Calculate target Q\n",
    "            \n",
    "        # Save the values\n",
    "            \n",
    "        y_current.append(q_pred_current[action_batch])\n",
    "        y_target.append(Q_target)\n",
    "            \n",
    "    # Calculate the loss\n",
    "        \n",
    "    loss = losss(torch.stack(y_current),torch.stack(y_target).detach())\n",
    "    loss_recording.append(loss.item()) # Record the value of the loss\n",
    "            \n",
    "    # Update the network\n",
    "        \n",
    "    opt.zero_grad() # set gradients to 0\n",
    "    loss.backward() # backpropagation\n",
    "    opt.step() # gradient descent\n",
    "                \n",
    "    # Reset for next training step\n",
    "        \n",
    "    y_current = [] \n",
    "    y_target = [] \n",
    "        \n",
    "    if i%10 == 0:\n",
    "        \n",
    "        state1_trial = start_state # Initialize to the reset state\n",
    "        \n",
    "        for j in range(len_episode):\n",
    "            \n",
    "            state_trial = state1_trial\n",
    "            \n",
    "            # Choose an action given the state\n",
    "    \n",
    "            q_values_trial = q_net.forward(torch.from_numpy(state_trial[0].astype(np.float32))) # Prediction of Q values\n",
    "                                    \n",
    "            action_trial = torch.argmax(q_values_trial).item() # Choose action with highest Q \n",
    "        \n",
    "            # Obtain the rewards and next state, given the state and action\n",
    "    \n",
    "            state1_trial_seed = np.copy(state_trial[0]) # Copy the current state\n",
    "    \n",
    "            if action_trial < N_layers_data:\n",
    "        \n",
    "                state1_trial_seed[action_trial] = int(0) # The element becomes 0\n",
    "        \n",
    "            else:\n",
    "        \n",
    "                state1_trial_seed[action_trial-N_layers_data] = int(1) # The element becomes 1\n",
    "        \n",
    "            state1_trial = [state1_trial_seed,htc_series[tuple_or_list_to_str([state1_trial_seed.astype(int)])][0]/(norm)]\n",
    "    \n",
    "            reward_trial = state1_trial[1] - baseline[1]\n",
    "        \n",
    "        episode_recording.append(reward_trial + baseline[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b01a38-11f1-4395-8510-5ace7c94b024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# DDQN\n",
    "\n",
    "# Actions: component x is 0 if action is x in [0,n), component x is 1 if action is x+n in [n,2n)\n",
    "# Reward: htc of next state\n",
    "\n",
    "# Parameters\n",
    "\n",
    "seed = 0 # Seed for the random variables\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(0) # Seed the numpy library\n",
    "\n",
    "N_layers_data = 16 # Number of layers the system has\n",
    "\n",
    "N_inputs = 16 # Number of elements on the input layer\n",
    "N_layers = 4 # Number of hidden layers for the network\n",
    "N_neurons = 64 # Number of neurons per layer\n",
    "N_outputs = 32 # Number of elements on the output layer\n",
    "\n",
    "lr = 1e-5 # Learning rate of the network\n",
    "gamma = 0.99 # Discount factor\n",
    "\n",
    "norm = 1e5 # Normalization for the htc values\n",
    "start_state_seed = np.zeros((N_layers_data,)) # Starting state when resetting\n",
    "start_state = [start_state_seed,htc_series[tuple_or_list_to_str([start_state_seed.astype(int)])][0]/(norm)]\n",
    "baseline_seed = np.array([1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]) # Baseline state \n",
    "baseline = [baseline_seed,htc_series[tuple_or_list_to_str([baseline_seed.astype(int)])][0]/(norm)]\n",
    "\n",
    "eps0 = 1 # Initial epsilon for the epsilon greedy algorithm\n",
    "eps1 = 0.1 # Final epsilon for the epsilon greedy algorithm\n",
    "steps_eps = 60000 # Number of steps until epsilon reaches its final value\n",
    "\n",
    "mem_size = 10000 # Size of the memory of states to save during training\n",
    "N_prefill = 32 # Number of experiences to add to the memory before starting the training loop\n",
    "\n",
    "steps_training = 60000 # Number of training steps to perform on the network\n",
    "steps_double = 5000 # Number of training steps until update of target net, periodic\n",
    "len_episode = 32 # Length of an epsiode, after which it resets\n",
    "N_batch = 4 # Number of batches to take for training each time\n",
    "len_batch = 32 # Number of experiences to include in a batch\n",
    "n_explore = 4 # Number of steps to explore before training\n",
    "\n",
    "# Pre-allocate variables\n",
    "\n",
    "memory = deque([], maxlen = mem_size) # Memory of states, deque deletes the oldest one when maxlen is reached\n",
    "\n",
    "y_current = [] # Holds the current output of Q values\n",
    "y_target = [] # Holds the predicted target Q values\n",
    "\n",
    "loss_recording = [] # Records the loss for each training step\n",
    "episode_recording = [] # Records the last state for trial episodes run greedily\n",
    "best_recording = [] # Records the best state found so far\n",
    "\n",
    "# Step 1: define the network\n",
    "\n",
    "layers = [nn.Linear(N_inputs, N_neurons), nn.SELU()] # List of all the layers that will have the future network\n",
    "\n",
    "for i in range(N_layers):\n",
    "    \n",
    "    layers.append(nn.Linear(N_neurons,N_neurons))\n",
    "    layers.append(nn.SELU())\n",
    "\n",
    "layers.append(nn.Linear(N_neurons,N_outputs)) \n",
    "\n",
    "q_net = nn.Sequential(*layers) # Network for behavior in Q\n",
    "q_net_target = nn.Sequential(*layers) # Target network for Q\n",
    "\n",
    "losss = nn.L1Loss() # Loss for the training of the network\n",
    "\n",
    "opt = optim.Adam(q_net.parameters(), lr) # Optimizer to update the network\n",
    "\n",
    "# Step 2: populate the memory with some examples\n",
    "\n",
    "state1 = start_state # Initialize to the reset state\n",
    "\n",
    "for i in range(N_prefill):\n",
    "    \n",
    "    state = state1 # The current state is the ending state of the previous step\n",
    "    \n",
    "    # Choose an action given the state\n",
    "            \n",
    "    action = random.randint(0,2*N_layers_data-1) # Choose action with highest Q (random for the prefill)\n",
    "        \n",
    "    # Obtain the rewards and next state, given the state and action\n",
    "    \n",
    "    state1_seed = np.copy(state[0]) # Copy the current state\n",
    "    \n",
    "    if action < N_layers_data:\n",
    "        \n",
    "        state1_seed[action] = int(0) # The element becomes 0\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        state1_seed[action-N_layers_data] = int(1) # The element becomes 1\n",
    "        \n",
    "    state1 = [state1_seed,htc_series[tuple_or_list_to_str([state1_seed.astype(int)])][0]/(norm)]\n",
    "    \n",
    "    reward = state1[1] - baseline[1]\n",
    "    \n",
    "    # Save the step to memory\n",
    "    \n",
    "    memory.append([state,action,reward,state1])\n",
    "    \n",
    "    if state1[1] > best_so_far[1]:\n",
    "        \n",
    "        best_so_far = state1 # Update the best state found \n",
    "\n",
    "# Step 3: perform the training and exploration \n",
    "\n",
    "state1 = start_state # Initialize to the reset state\n",
    "\n",
    "episode_counter = 0 # Count until the episode resets\n",
    "\n",
    "for i in range(steps_training): # Total number of explore-train loops\n",
    "    \n",
    "    if i%steps_double == 0:\n",
    "        \n",
    "        q_net_target.load_state_dict(q_net.state_dict()) # Copy the current state of the net onto the target net\n",
    "                \n",
    "    epsilon = np.maximum(eps0 - i*(eps0-eps1)/steps_eps,eps1) # Define the current value of epsilon, decays\n",
    "        \n",
    "    # Perform the exploration steps\n",
    "\n",
    "    for j in range(n_explore):\n",
    "    \n",
    "        state = state1 # The current state is the ending state of the previous step\n",
    "    \n",
    "        # Choose an action given the state\n",
    "    \n",
    "        q_values = q_net.forward(torch.from_numpy(state[0].astype(np.float32))) # Prediction of Q values\n",
    "    \n",
    "        rand = random.uniform(0,1) # To do the random result\n",
    "    \n",
    "        if epsilon > rand:\n",
    "        \n",
    "            action = random.randint(0,2*N_layers_data-1) # Choose action randomly\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            action = torch.argmax(q_values).item() # Choose action with highest Q \n",
    "        \n",
    "        # Obtain the rewards and next state, given the state and action\n",
    "    \n",
    "        state1_seed = np.copy(state[0]) # Copy the current state\n",
    "    \n",
    "        if action < N_layers_data:\n",
    "        \n",
    "            state1_seed[action] = int(0) # The element becomes 0\n",
    "        \n",
    "        else:\n",
    "        \n",
    "            state1_seed[action-N_layers_data] = int(1) # The element becomes 1\n",
    "        \n",
    "        state1 = [state1_seed,htc_series[tuple_or_list_to_str([state1_seed.astype(int)])][0]/(norm)]\n",
    "        \n",
    "        reward = state1[1] - baseline[1]\n",
    "    \n",
    "        # Save the step to memory\n",
    "    \n",
    "        memory.append([state,action,reward,state1])\n",
    "    \n",
    "        if state1[1] > best_so_far[1]:\n",
    "        \n",
    "            best_so_far = state1 # Update the best state found \n",
    "        \n",
    "        best_recording.append(best_so_far)\n",
    "    \n",
    "        # Counter for the episode\n",
    "    \n",
    "        episode_counter += 1\n",
    "        \n",
    "        if episode_counter == len_episode: # End of episode, reset to start\n",
    "        \n",
    "            episode_counter = 0\n",
    "        \n",
    "            state1 = start_state \n",
    "        \n",
    "    # Perform the training steps\n",
    "    \n",
    "    for j in range(N_batch): # Number of batches\n",
    "        \n",
    "        batch_content = random.sample(memory, len_batch) # Obtain the batch\n",
    "        \n",
    "        for k in range(len_batch):\n",
    "            \n",
    "            state_batch = batch_content[k][0] # State of the given experience of the batch\n",
    "            action_batch = batch_content[k][1] # Action taken of the given experience of the batch\n",
    "            reward_batch = batch_content[k][2] # Reward obtained of the given experience of the batch\n",
    "            state1_batch = batch_content[k][3] # Next state of the given experience of the batch\n",
    "            \n",
    "            # Obtain current value\n",
    "            \n",
    "            q_pred_current = q_net.forward(torch.from_numpy(state_batch[0].astype(np.float32)))\n",
    "            \n",
    "            # Obtain the Q values according to both networks\n",
    "            \n",
    "            q_pred = q_net.forward(torch.from_numpy(state1_batch[0].astype(np.float32)))\n",
    "            q_pred_tar = q_net_target.forward(torch.from_numpy(state1_batch[0].astype(np.float32)))\n",
    "            \n",
    "            # Predict the current Q value and target Q value\n",
    "            \n",
    "            best_option = torch.argmax(q_pred).item() # Choose a' action\n",
    "            \n",
    "            Q_target = torch.squeeze(torch.Tensor([reward_batch]) + gamma*q_pred_tar[best_option]) # Calculate target Q\n",
    "            \n",
    "            # Save the values\n",
    "            \n",
    "            y_current.append(q_pred_current[action_batch])\n",
    "            y_target.append(Q_target)\n",
    "            \n",
    "        # Calculate the loss\n",
    "        \n",
    "        loss = losss(torch.stack(y_current),torch.stack(y_target).detach())\n",
    "        loss_recording.append(loss.item()) # Record the value of the loss\n",
    "            \n",
    "        # Update the network\n",
    "        \n",
    "        opt.zero_grad() # set gradients to 0\n",
    "        loss.backward() # backpropagation\n",
    "        opt.step() # gradient descent\n",
    "                \n",
    "        # Reset for next training step\n",
    "        \n",
    "        y_current = [] \n",
    "        y_target = [] \n",
    "        \n",
    "    if i%10 == 0:\n",
    "        \n",
    "        state1_trial = start_state # Initialize to the reset state\n",
    "        \n",
    "        for j in range(len_episode):\n",
    "            \n",
    "            state_trial = state1_trial\n",
    "            \n",
    "            # Choose an action given the state\n",
    "    \n",
    "            q_values_trial = q_net.forward(torch.from_numpy(state_trial[0].astype(np.float32))) # Prediction of Q values\n",
    "                                    \n",
    "            action_trial = torch.argmax(q_values_trial).item() # Choose action with highest Q \n",
    "        \n",
    "            # Obtain the rewards and next state, given the state and action\n",
    "    \n",
    "            state1_trial_seed = np.copy(state_trial[0]) # Copy the current state\n",
    "    \n",
    "            if action_trial < N_layers_data:\n",
    "        \n",
    "                state1_trial_seed[action_trial] = int(0) # The element becomes 0\n",
    "        \n",
    "            else:\n",
    "        \n",
    "                state1_trial_seed[action_trial-N_layers_data] = int(1) # The element becomes 1\n",
    "        \n",
    "            state1_trial = [state1_trial_seed,htc_series[tuple_or_list_to_str([state1_trial_seed.astype(int)])][0]/(norm)]\n",
    "    \n",
    "            reward_trial = state1_trial[1] - baseline[1]\n",
    "        \n",
    "        episode_recording.append(reward_trial + baseline[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dfca689",
   "metadata": {},
   "outputs": [],
   "source": [
    "# REINFORCE algorithm\n",
    "\n",
    "# Step 1: pre-allocating, loading and previous steps\n",
    "\n",
    "# Defining and loading the datasets\n",
    "\n",
    "vect = np.genfromtxt('16layers_index.txt').astype(int) # Combination of materials\n",
    "htc_vals = np.genfromtxt('16layer_data.txt', dtype = 'float64') # Associated HTC\n",
    "\n",
    "htc_series = pd.Series(data = htc_vals, index = tuple_or_list_to_str(vect)) # Series form, for much faster searching\n",
    "\n",
    "# Fix the random seed\n",
    "\n",
    "seed = 42\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(int(seed)) # Seed the numpy library\n",
    "\n",
    "# NN hyperparameters\n",
    "\n",
    "n_hidden = 4 # number of hidden layers\n",
    "n_neurons = 64 # number of neurons per layer\n",
    "lr = 0.00003 # NN learning rate\n",
    "\n",
    "# RL hyperparameters\n",
    "\n",
    "n_slice = 16 # Number of modifiable layers\n",
    "norm = 1e5 # Normalization constant for HTC, units (10^5 W/m^2 K)\n",
    "\n",
    "gamma = 0.99 # Discount rate\n",
    "\n",
    "n_steps = n_slice*2 # Length of each episode\n",
    "n_episode = 100000 # Number of episodes to train for\n",
    "\n",
    "# Initializations and Preallocations\n",
    "\n",
    "b = 0.0 # Baseline to subtract from the return\n",
    "\n",
    "base_seed = np.array([1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]) # State to use as baseline for the rewards\n",
    "rew_base = htc_series[tuple_or_list_to_str([base_seed.astype(int)])][0]/(norm) # Baseline for the rewards\n",
    "\n",
    "start_seed = np.zeros((n_slice,)) # State to use as starting point for each episode\n",
    "start_state = [start_state_seed,htc_series[tuple_or_list_to_str([start_seed.astype(int)])][0]/(norm)] # Reset each episode\n",
    "   \n",
    "best_so_far = start_state[1] # Holds the best state found so far\n",
    "\n",
    "log_probs = [] # Will hold the log of the probabilities\n",
    "rewards = [] # Will hold the rewards for checking\n",
    "seen_so_far = [] # Will hold a list of all the states found in a training run\n",
    "\n",
    "last_state_record = [] # Will hold the last state of each episode\n",
    "best_state_record = [] # Will hold the best state found until up to episode\n",
    "loss_record = [] # Will hold the loss of each episode\n",
    "all_rewards_sum = [] # Will hold the sum of all rewards in each episode\n",
    "\n",
    "# Step 2: create the NN\n",
    "\n",
    "in_dim = n_slice # Number of neurons in the input layer\n",
    "out_dim = 2*n_slice # NUmber of neurons in the output layer\n",
    "\n",
    "layers = [nn.Linear(in_dim, n_neurons), nn.SELU()] # Create a list of all the layers, starting with input\n",
    "\n",
    "for i in range(n_hidden): # Include the hidden layers\n",
    "        \n",
    "    layers.append(nn.Linear(n_neurons,n_neurons))\n",
    "    layers.append(nn.SELU())\n",
    "    \n",
    "layers.append(nn.Linear(n_neurons,out_dim)) # Add the output layer\n",
    "    \n",
    "pi = nn.Sequential(*layers) # Create the final NN\n",
    "    \n",
    "opt = optim.Adam(pi.parameters(), lr) # Define the optimizer\n",
    "\n",
    "# Step 3: train the policy network\n",
    "\n",
    "for eps in range(n_episode):\n",
    "    \n",
    "    state = start_state # Reset the environment each episode\n",
    "    \n",
    "    for t in range(n_steps): \n",
    "        \n",
    "        # a) Choose the action given the state\n",
    "            \n",
    "        pdparam = pi.forward(torch.from_numpy(state[0].astype(np.float32))) # Forward pass, obtain output\n",
    "        pd = Categorical(logits = pdparam) # Obtain a probability distribution over the variables using the output\n",
    "        action = pd.sample() # Choose an action from the policy distribution\n",
    "        log_probss = pd.log_prob(action) # Obtain the log_prob of the chosen action\n",
    "        log_probs.append(log_probss) # Save the log_prob for the loss\n",
    "        \n",
    "        # b) Obtain the next state and reward from the action\n",
    "                    \n",
    "        state, reward = act_on_env7(action.item(), state, rew_base) # Response from environment\n",
    "        rewards.append(reward) # Save the reward for checking\n",
    "        \n",
    "        if state[1] not in seen_so_far: # Check if it's a new state\n",
    "            \n",
    "            seen_so_far.append(state[1]) # Save the state to the list\n",
    "            \n",
    "            if state[1] > best_so_far: # If it's better than any before, save it as the best\n",
    "                \n",
    "                best_so_far = state[1]\n",
    "                    \n",
    "    last_state_record.append(state[1]) # Save the last state HTC for monitoring\n",
    "    best_state_record.append(best_so_far) # Save the best state for monitoring\n",
    "    \n",
    "    total_reward = sum(rewards) # Sum of rewards of the episode\n",
    "    all_rewards_sum.append(total_reward) # Save the sum of all rewards for monitoring\n",
    "\n",
    "    # c) Obtain the loss\n",
    "        \n",
    "    returnss = np.empty(n_steps, dtype = np.float32) # Will hold all the returns\n",
    "    next_ret = 0.0 \n",
    "    \n",
    "    for t in reversed(range(n_steps)): # From last to first, we compute backwards the sum to get each return\n",
    "            \n",
    "        next_ret = rewards[t] + gamma*next_ret\n",
    "        returnss[t] = next_ret\n",
    "        \n",
    "    b = np.mean(returnss) # Baseline: average of the returns of the episode\n",
    "    returnss = returnss - b # Returns with baseline\n",
    "    returnss = torch.tensor(returnss) # Turn into a pytorch tensor\n",
    "    \n",
    "    log_props = torch.stack(log_probs) # Obtain the tensors from the list\n",
    "    \n",
    "    loss = -log_props*returnss # Calculate the gradient term, negative for maximization\n",
    "    \n",
    "    loss = torch.sum(loss) # Obtain the final loss\n",
    "    \n",
    "    loss_record.append(loss.item()) # Save the loss for monitoring\n",
    "    \n",
    "    opt.zero_grad() # Reset the gradients\n",
    "    loss.backward() # Backpropagation\n",
    "    opt.step() # Gradient descent (ascent)\n",
    "        \n",
    "    # clear memory for next episode\n",
    "        \n",
    "    log_probs = [] \n",
    "    rewards = [] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "317b655b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optuna\n",
    "\n",
    "# We choose A2C for the search, almost the same code is valid for PPO\n",
    "\n",
    "# Step 1: hyperparameters of the optuna search, random seeding and preallocations\n",
    "\n",
    "N_TRIALS = 100  # Maximum number of trials\n",
    "N_TIMESTEPS = int(1e5)  # Training budget\n",
    "N_EVAL_EPISODES = 32 # Length of each evaluation episode\n",
    "N_STARTUP_TRIALS = 5  # Stop random sampling after N_STARTUP_TRIALS\n",
    "TIMEOUT = int(60 * 30 * 8)  # How long to wait for until stopping, in seconds\n",
    "\n",
    "seed = 42 # Random seed\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(int(seed)) # Seed the numpy library\n",
    "\n",
    "# Dictionary that holds the hyperparameters that all trials will share and never explore\n",
    "\n",
    "DEFAULT_HYPERPARAMS = {  \n",
    "    \"policy\": \"MlpPolicy\",\n",
    "    \"env\": HTC_env(16),\n",
    "    \"use_rms_prop\":False, # Delete in case of PPO\n",
    "}\n",
    "\n",
    "# Step 2: define external functions: evaluation of the model, sampling of hyperparams and the goal of the search\n",
    "\n",
    "# Function 1: evaluation for the performance of the model: stop and run 10 episodes, then average over them\n",
    "\n",
    "def custom_evaluation(env,model,len_eps):\n",
    "\n",
    "    # Will return the mean last reward of an episode\n",
    "\n",
    "    last_rewards = np.zeros((10,))\n",
    "\n",
    "    # Step 1: reset the environment\n",
    "\n",
    "    obs_evals,_ = env.reset()\n",
    "\n",
    "    # Step 2 (repeated 10 times): train the model for an episode, record the last reward\n",
    "\n",
    "    for i in range(10):\n",
    "\n",
    "        for j in range(len_eps):\n",
    "            \n",
    "            action,_ = model.predict(obs_evals)\n",
    "            obs_evals,reward_evals,_,_,_ = env.step(action)\n",
    "\n",
    "        last_rewards[i] = reward_evals\n",
    "        obs_evals,_ = env.reset()\n",
    "\n",
    "    # Step 3: return the mean of the last rewards\n",
    "\n",
    "    return np.mean(last_rewards)\n",
    "\n",
    "# Function 2: parameter sampling for optuna\n",
    "\n",
    "def sample_a2c_params(trial: optuna.Trial) -> Dict[str, Any]:\n",
    "\n",
    "    # Hyperparameters we are searching for\n",
    "    \n",
    "    gamma = 1.0 - trial.suggest_float(\"gamma\", 0.0001, 0.1, log=True)\n",
    "    max_grad_norm = trial.suggest_float(\"max_grad_norm\", 0.5, 5.0, log=True)\n",
    "    \n",
    "    gae_lambda = trial.suggest_float(\"gae_lambda\",0.0,1.0)\n",
    "\n",
    "    learning_rate = trial.suggest_float(\"lr\", 1e-6, 1e-3, log=True)\n",
    "    #activation_fn = trial.suggest_categorical(\"activation_fn\", [\"selu\"])\n",
    "    \n",
    "    # Hyperparameters we will leave fixed\n",
    "    \n",
    "    activation_fn = nn.SELU\n",
    "    net_arch = {\"pi\": [100,100,100,100], \"vf\": [100,100,100,100]}\n",
    "    n_steps = 2 ** 5\n",
    "\n",
    "    # Display true values\n",
    "    \n",
    "    trial.set_user_attr(\"gamma_\", gamma)\n",
    "    trial.set_user_attr(\"n_steps\", n_steps)\n",
    "\n",
    "    # Return dictionary with all chosen hyperparameters\n",
    "    \n",
    "    return {\n",
    "        \"n_steps\": n_steps,                 # Steps per episode\n",
    "        \"gamma\": gamma,                     # Discount factor for RL\n",
    "        \"learning_rate\": learning_rate,     # Learning rate\n",
    "        \"max_grad_norm\": max_grad_norm,     # Maximum gradient\n",
    "        \"gae_lambda\": gae_lambda,           # GAE exponential factor\n",
    "        #\"batch_size\": n_steps,             # Size of the batches considered # Add in case of PPO\n",
    "        \"policy_kwargs\": {\n",
    "            \"net_arch\": net_arch,           # Network architecture (actor and critic)\n",
    "            \"activation_fn\": activation_fn, # Activation function\n",
    "        },\n",
    "    }\n",
    "\n",
    "# Function 3: objective for optuna to search and evaluate configurations\n",
    "# Given a configuration, it will sample hyperparameters, evaluate it and report the result \n",
    "\n",
    "def objective(trial: optuna.Trial) -> float:\n",
    "    \n",
    "    # 1. Sample hyperparameters and update the keyword arguments, adding the new ones to the default\n",
    "    \n",
    "    kwargs = DEFAULT_HYPERPARAMS.copy()\n",
    "    kwargs.update(sample_a2c_params(trial))\n",
    "\n",
    "    # Create the RL model\n",
    "    \n",
    "    model = A2C(**kwargs)\n",
    "\n",
    "    # 2. Create envs used for evaluation \n",
    "\n",
    "    eval_env =  HTC_env(16)\n",
    "\n",
    "    # 3. Train the model\n",
    "    \n",
    "    model.learn(N_TIMESTEPS)\n",
    "    \n",
    "    # 4. Evaluate the trained model\n",
    "    \n",
    "    score = custom_evaluation(eval_env,model,N_EVAL_EPISODES)\n",
    "    \n",
    "    model.env.close() # Reset environment\n",
    "    eval_env.close()  # Reset environment\n",
    "\n",
    "    return score\n",
    "\n",
    "# Step 3: Perform the optuna search\n",
    "\n",
    "# Set pytorch num threads to 1 for faster training\n",
    "\n",
    "torch.set_num_threads(1)\n",
    "\n",
    "# Select the sampler, can be random, TPESampler, CMAES, ...\n",
    "\n",
    "sampler = TPESampler(n_startup_trials=N_STARTUP_TRIALS)\n",
    "\n",
    "# Do not prune before 1/5 of the max budget is used\n",
    "\n",
    "pruner = MedianPruner(n_startup_trials=N_STARTUP_TRIALS, n_warmup_steps=N_TIMESTEPS//5)\n",
    "\n",
    "# Create the study and start the hyperparameter optimization\n",
    "\n",
    "study = optuna.create_study(sampler=sampler, pruner=pruner, direction=\"maximize\")\n",
    "\n",
    "try:\n",
    "    study.optimize(objective, n_trials=N_TRIALS, n_jobs=1, timeout=TIMEOUT)\n",
    "    \n",
    "except KeyboardInterrupt:\n",
    "    \n",
    "    pass\n",
    "\n",
    "# Step 4: print results\n",
    "\n",
    "print(\"Number of finished trials: \", len(study.trials))\n",
    "\n",
    "print(\"Best trial:\")\n",
    "trial = study.best_trial #(.trials for all of them)\n",
    "\n",
    "print(f\"  Value: {trial.value}\")\n",
    "\n",
    "print(\"  Params: \")\n",
    "for key, value in trial.params.items():\n",
    "    print(f\"    {key}: {value}\")\n",
    "\n",
    "print(\"  User attrs:\")\n",
    "for key, value in trial.user_attrs.items():\n",
    "    print(f\"    {key}: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5bc16bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A2C\n",
    "\n",
    "# Step 1: pre-allocating, loading and previous steps\n",
    "\n",
    "seed = 42 # Fix the random seed\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(int(seed)) # Seed the numpy library\n",
    "\n",
    "torch.backends.cudnn.deterministic = True # Set cuda parameters\n",
    "torch.backends.cudnn.benchmark = False    # Set cuda parameters\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") # Use GPU if available\n",
    "\n",
    "n_eval_episodes = 32 # Number of steps per evaluation episode\n",
    "N_timesteps = int(4000*32) # Number of steps (4000 episodes of 32 steps each)\n",
    "\n",
    "torch.set_num_threads(1) # Set pytorch num threads to 1 for faster training\n",
    "\n",
    "# Step 2: set the environment and the model hyperparameters\n",
    "\n",
    "our_env = HTC_env(16) # Set environment (using the custom class)\n",
    "\n",
    "# Hyperparameters chosen by optuna\n",
    "\n",
    "n_steps = 2 ** 5                                                # Steps per episode\n",
    "gamma = 1.0 - 0.05354748279639477                               # Discount factor for RL\n",
    "learning_rate = 0.0003529867715614526                           # Learning rate\n",
    "gae_lambda = 0.9972303247713417                                 # GAE exponential factor\n",
    "max_grad_norm = 1.2858503485554726                              # Maximum gradient\n",
    "net_arch = {\"pi\": [100,100,100,100], \"vf\": [100,100,100,100]}   # Network architecture (actor and critic)\n",
    "activation_fn = nn.SELU                                         # Activation function\n",
    "\n",
    "# Hyperparameter dictionary\n",
    "\n",
    "DEFAULT_HYPERPARAMS = {\n",
    "\"policy\": \"MlpPolicy\",\n",
    "\"env\": our_env,\n",
    "\"use_rms_prop\": False,\n",
    "\"device\": device\n",
    "}\n",
    "\n",
    "Hyperparams = {\n",
    "\"n_steps\": n_steps,\n",
    "\"gamma\": gamma,\n",
    "\"learning_rate\": learning_rate,\n",
    "\"max_grad_norm\": max_grad_norm,\n",
    "\"gae_lambda\": gae_lambda,\n",
    "\"policy_kwargs\": {\n",
    "    \"net_arch\": net_arch,\n",
    "    \"activation_fn\": activation_fn,\n",
    "    }\n",
    "}\n",
    "\n",
    "kwargs = DEFAULT_HYPERPARAMS.copy() # Start the dictionary with the default ones\n",
    "kwargs.update(Hyperparams)          # Add the ones found by optuna \n",
    "\n",
    "# Step 3: train the model\n",
    "\n",
    "model = A2C(**kwargs) # Create the model, using the previous hyperparams\n",
    "\n",
    "model.learn(N_timesteps) # Train the model\n",
    "    \n",
    "model.env.close() # Close the env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bcb9c70-6236-4a74-ba9c-32ee1bb00f98",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PPO\n",
    "\n",
    "# Step 1: pre-allocating, loading and previous steps\n",
    "\n",
    "seed = 42 # Fix the random seed\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(int(seed)) # Seed the numpy library\n",
    "\n",
    "torch.backends.cudnn.deterministic = True # Set cuda parameters\n",
    "torch.backends.cudnn.benchmark = False    # Set cuda parameters\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") # Use GPU if available\n",
    "\n",
    "n_eval_episodes = 32 # Number of steps per evaluation episode\n",
    "N_timesteps = int(4000*32) # Number of steps (4000 episodes of 32 steps each)\n",
    "\n",
    "torch.set_num_threads(1) # Set pytorch num threads to 1 for faster training\n",
    "\n",
    "# Step 2: set the environment and the model hyperparameters\n",
    "\n",
    "our_env = HTC_env(16) # Set environment (using the custom class)\n",
    "\n",
    "# Hyperparameters chosen by optuna\n",
    "\n",
    "n_steps = 2 ** 5                                                # Steps per episode\n",
    "gamma = 1.0 - 0.00012343188973544484                            # Discount factor for RL\n",
    "learning_rate = 6.24161237241945e-05                            # Learning rate\n",
    "gae_lambda = 0.8714387482390391                                 # GAE exponential factor\n",
    "max_grad_norm = 4.042358248277151                               # Maximum gradient\n",
    "net_arch = {\"pi\": [100,100,100,100], \"vf\": [100,100,100,100]}   # Network architecture (actor and critic)\n",
    "activation_fn = nn.SELU                                         # Activation function\n",
    "\n",
    "# Hyperparameter dictionary\n",
    "\n",
    "DEFAULT_HYPERPARAMS = {\n",
    "\"policy\": \"MlpPolicy\",\n",
    "\"env\": our_env,\n",
    "\"device\": device\n",
    "}\n",
    "\n",
    "Hyperparams = {\n",
    "\"n_steps\": n_steps,\n",
    "\"gamma\": gamma,\n",
    "\"learning_rate\": learning_rate,\n",
    "\"max_grad_norm\": max_grad_norm,\n",
    "\"gae_lambda\": gae_lambda,\n",
    "\"batch_size\": n_steps,\n",
    "\"policy_kwargs\": {\n",
    "    \"net_arch\": net_arch,\n",
    "    \"activation_fn\": activation_fn,\n",
    "    }\n",
    "}\n",
    "\n",
    "kwargs = DEFAULT_HYPERPARAMS.copy() # Start the dictionary with the default ones\n",
    "kwargs.update(Hyperparams)          # Add the ones found by optuna \n",
    "\n",
    "# Step 3: train the model\n",
    "\n",
    "model = PPO(**kwargs) # Create the model, using the previous hyperparams\n",
    "\n",
    "model.learn(N_timesteps) # Train the model\n",
    "    \n",
    "model.env.close() # Close the env"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af923e03",
   "metadata": {},
   "source": [
    "## DRL Algorithms for the cartpole problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "81ce5bc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1617.577\n",
      "2000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Code created by me, should train the system in a similar fashion (hardcoded b for this problem)\n",
    "\n",
    "# parameters\n",
    "\n",
    "n_hidden = 0 # number of hidden layers\n",
    "n_neurons = 64 # number of neurons per layer\n",
    "lr = 0.002 # NN learning rate\n",
    "\n",
    "gamma = 0.99 # gamma term in the sum\n",
    "n_episode = 2000 # number of episodes to train for\n",
    "n_steps = 200 # max length of each episode, ends earlier if it fails the task\n",
    "b = 0.0 # baseline to subtract from the return\n",
    "\n",
    "# initialize the variables\n",
    "\n",
    "log_probs = [] # Will hold the log of the probs\n",
    "rewards = [] # Will hold the rewards\n",
    "\n",
    "recording = [] # Will hold the evolution of the training\n",
    "recording2 = [] # Will hold the loss\n",
    "\n",
    "# Step 1: define the environment\n",
    "\n",
    "env = gym.make('CartPole-v0') # environment, the cartpole problem\n",
    "in_dim = env.observation_space.shape[0] # 4 state parameters\n",
    "out_dim = env.action_space.n # 2 action parameters\n",
    "\n",
    "# Step 2: define the network\n",
    "\n",
    "layers = [nn.Linear(in_dim, n_neurons), nn.ReLU()]\n",
    "\n",
    "for i in range(n_hidden):\n",
    "    \n",
    "    layers.append(nn.Linear(n_neurons,n_neurons))\n",
    "    layers.append(nn.ReLU())\n",
    "\n",
    "layers.append(nn.Linear(n_neurons,out_dim))\n",
    "\n",
    "pi = nn.Sequential(*layers)\n",
    "\n",
    "opt = optim.Adam(pi.parameters(), lr)\n",
    "\n",
    "# Step 3: train the policy\n",
    "\n",
    "for eps in range(n_episode):\n",
    "    \n",
    "    state = env.reset()[0] # Reset the environment each episode\n",
    "    \n",
    "    for t in range(n_steps):\n",
    "        \n",
    "        # a) Perform the action\n",
    "        \n",
    "        pdparam = pi.forward(torch.from_numpy(state.astype(np.float32))) # forward pass\n",
    "        pd = Categorical(logits = pdparam) # Obtain a probability distribution over the variables from the output\n",
    "        action = pd.sample() # Choose an action from the policy distribution\n",
    "        log_probss = pd.log_prob(action) # Obtain the log_prob of the chosen action\n",
    "        log_probs.append(log_probss) # Save the log_prob for the loss\n",
    "        \n",
    "        # b) Obtain the result from the state\n",
    "        \n",
    "        state, reward, done, _, _ = env.step(action.item()) # Response from environment\n",
    "        rewards.append(reward) # Save the reward for the loss\n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # c) Obtain the loss\n",
    "    \n",
    "    T = len(rewards) # How long the episode was, max 200\n",
    "    returnss = np.empty(T, dtype = np.float32) # To introduce the returns\n",
    "    next_ret = 0.0\n",
    "    for t in reversed(range(T)): # from last to first, we compute backwards the sum because of the return\n",
    "        \n",
    "        next_ret = rewards[t] + gamma*next_ret\n",
    "        returnss[t] = next_ret\n",
    "    \n",
    "    b = np.mean(returnss) # Baseline: average of the returns of the episode\n",
    "    returnss = returnss - b\n",
    "    returnss = torch.tensor(returnss)\n",
    "    log_props = torch.stack(log_probs)\n",
    "    loss = -log_props*returnss # Gradient term, negative for max\n",
    "    loss = torch.sum(loss)\n",
    "    recording2.append(loss.item())\n",
    "    opt.zero_grad()\n",
    "    loss.backward() # backpropagation\n",
    "    opt.step() # gradient descent (ascent)\n",
    "    total_reward = sum(rewards)\n",
    "    solved = total_reward > 195.0\n",
    "    # clear memory\n",
    "    log_probs = [] \n",
    "    rewards = [] \n",
    "    #print(f'Episode {eps}, loss: {loss}, \\\n",
    "    #total_reward: {total_reward}, solved: {solved}') # Training on screen\n",
    "    recording.append(total_reward)\n",
    "    \n",
    "env.reset()\n",
    "env.close()\n",
    "\n",
    "print(np.mean(recording))\n",
    "recording2 = np.array(recording)\n",
    "print(np.mean(recording2[np.linspace(len(recording)-101,len(recording)-1,100).astype(int)]))\n",
    "\n",
    "plt.rcParams['font.family'] = ['Times New Roman']\n",
    "fig,axs = plt.subplots(1,1,figsize=(7,5))\n",
    "axs.plot(recording)\n",
    "axs.set_ylabel('Steps without falling', fontsize = 15)\n",
    "axs.set_xlabel('Training episode', fontsize = 15)\n",
    "axs.axhline(y=200,color='k',linestyle='--')\n",
    "axs.tick_params(axis='both', labelsize = 17)\n",
    "fig.savefig('DRL_REINFORCE_2.png', format='png', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6af4b2a8-27bd-45f1-885c-9d0f4ba3ea9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "168.10800000000003\n",
      "198.13\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Code created by me, should train the system in a similar fashion (hardcoded b for this problem)\n",
    "\n",
    "# parameters\n",
    "\n",
    "n_hidden = 0 # number of hidden layers\n",
    "n_neurons = 64 # number of neurons per layer\n",
    "lr = 0.002 # NN learning rate\n",
    "\n",
    "gamma = 0.99 # gamma term in the sum\n",
    "n_episode = 2000 # number of episodes to train for\n",
    "n_steps = 200 # max length of each episode, ends earlier if it fails the task\n",
    "b = 0.0 # baseline to subtract from the return\n",
    "\n",
    "# initialize the variables\n",
    "\n",
    "log_probs = [] # Will hold the log of the probs\n",
    "rewards = [] # Will hold the rewards\n",
    "\n",
    "recording = [] # Will hold the evolution of the training\n",
    "recording2 = [] # Will hold the loss\n",
    "\n",
    "# Step 1: define the environment\n",
    "\n",
    "env = gym.make('CartPole-v0') # environment, the cartpole problem\n",
    "in_dim = env.observation_space.shape[0] # 4 state parameters\n",
    "out_dim = env.action_space.n # 2 action parameters\n",
    "\n",
    "# Step 2: define the network\n",
    "\n",
    "layers = [nn.Linear(in_dim, n_neurons), nn.ReLU()]\n",
    "\n",
    "for i in range(n_hidden):\n",
    "    \n",
    "    layers.append(nn.Linear(n_neurons,n_neurons))\n",
    "    layers.append(nn.ReLU())\n",
    "\n",
    "layers.append(nn.Linear(n_neurons,out_dim))\n",
    "\n",
    "pi = nn.Sequential(*layers)\n",
    "\n",
    "opt = optim.Adam(pi.parameters(), lr)\n",
    "\n",
    "# Step 3: train the policy\n",
    "\n",
    "for eps in range(n_episode):\n",
    "    \n",
    "    state = env.reset()[0] # Reset the environment each episode\n",
    "    \n",
    "    for t in range(n_steps):\n",
    "        \n",
    "        # a) Perform the action\n",
    "        \n",
    "        pdparam = pi.forward(torch.from_numpy(state.astype(np.float32))) # forward pass\n",
    "        pd = Categorical(logits = pdparam) # Obtain a probability distribution over the variables from the output\n",
    "        action = pd.sample() # Choose an action from the policy distribution\n",
    "        log_probss = pd.log_prob(action) # Obtain the log_prob of the chosen action\n",
    "        log_probs.append(log_probss) # Save the log_prob for the loss\n",
    "        \n",
    "        # b) Obtain the result from the state\n",
    "        \n",
    "        state, reward, done, _, _ = env.step(action.item()) # Response from environment\n",
    "        rewards.append(reward) # Save the reward for the loss\n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # c) Obtain the loss\n",
    "    \n",
    "    T = len(rewards) # How long the episode was, max 200\n",
    "    returnss = np.empty(T, dtype = np.float32) # To introduce the returns\n",
    "    next_ret = 0.0\n",
    "    for t in reversed(range(T)): # from last to first, we compute backwards the sum because of the return\n",
    "        \n",
    "        next_ret = rewards[t] + gamma*next_ret\n",
    "        returnss[t] = next_ret\n",
    "    \n",
    "    b = np.mean(returnss) # Baseline: average of the returns of the episode\n",
    "    returnss = returnss - b\n",
    "    returnss = torch.tensor(returnss)\n",
    "    log_props = torch.stack(log_probs)\n",
    "    loss = -log_props*returnss # Gradient term, negative for max\n",
    "    loss = torch.sum(loss)\n",
    "    recording2.append(loss.item())\n",
    "    opt.zero_grad()\n",
    "    loss.backward() # backpropagation\n",
    "    opt.step() # gradient descent (ascent)\n",
    "    total_reward = sum(rewards)\n",
    "    solved = total_reward > 195.0\n",
    "    # clear memory\n",
    "    log_probs = [] \n",
    "    rewards = [] \n",
    "    #print(f'Episode {eps}, loss: {loss}, \\\n",
    "    #total_reward: {total_reward}, solved: {solved}') # Training on screen\n",
    "    #recording.append(total_reward)\n",
    "\n",
    "    if eps%10 == 0:\n",
    "        \n",
    "        total_reward = np.zeros((10,))\n",
    "        eval_rew = [] # Save the rewards for the current evaluation step\n",
    "        \n",
    "        for n in range(10):\n",
    "            \n",
    "            eval_rew = [] # Save the rewards for the current evaluation step\n",
    "            state_ev = env.reset()[0]\n",
    "            \n",
    "            for arp in range(n_steps):\n",
    "\n",
    "                # a) Perform the action\n",
    "        \n",
    "                pdparam = pi.forward(torch.from_numpy(state_ev.astype(np.float32))) # forward pass\n",
    "                pd = Categorical(logits = pdparam) # Obtain a probability distribution over the variables from the output\n",
    "                action_ev = pd.sample() # Choose an action from the policy distribution\n",
    "        \n",
    "                # b) Obtain the result from the state\n",
    "        \n",
    "                state_ev, reward_ev, done_ev, _, _ = env.step(action_ev.item()) # Response from environment\n",
    "                eval_rew.append(reward_ev) # Save the reward for the loss\n",
    "                env.render() # Creates the video\n",
    "                \n",
    "                if done_ev:\n",
    "                    break\n",
    "                    \n",
    "            total_reward[n] = sum(eval_rew)\n",
    "            eval_rew = [] # Save the rewards for the current evaluation step\n",
    "            \n",
    "        mean_reward = sum(total_reward)/10\n",
    "        recording.append(mean_reward)\n",
    "    \n",
    "env.reset()\n",
    "env.close()\n",
    "\n",
    "print(np.mean(recording))\n",
    "recording2 = np.array(recording)\n",
    "print(np.mean(recording2[np.linspace(len(recording)-11,len(recording)-1,10).astype(int)]))\n",
    "\n",
    "plt.rcParams['font.family'] = ['Times New Roman']\n",
    "fig,axs = plt.subplots(1,1,figsize=(7,5))\n",
    "axs.plot(np.linspace(0,len(recording)-1,len(recording))*10,recording)\n",
    "axs.set_ylabel('Steps without falling', fontsize = 15)\n",
    "axs.set_xlabel('Training episode', fontsize = 15)\n",
    "axs.axhline(y=200,color='k',linestyle='--')\n",
    "axs.tick_params(axis='both', labelsize = 17)\n",
    "fig.savefig('DRL_REINFORCE_3.png', format='png', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "54169b6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "172.16666666666666\n",
      "96.45\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# DQN with double network and prioritized experience replay\n",
    "# Note that it can only work on single action update\n",
    "\n",
    "# Code created by me\n",
    "\n",
    "# parameters\n",
    "\n",
    "n_hidden = 1 # number of hidden layers\n",
    "n_neurons = 64 # number of neurons per layer\n",
    "lr0 = 0.01 # NN starting learning rate 0.01\n",
    "lr1 = 0.0001 # NN final learning rate 0.0001\n",
    "n_lr = 10000 # Steps until final learning rate\n",
    "#gradient_clip = 0.5 # Clipping 0.5\n",
    "counter = 0 # Resets when there has been 200 steps\n",
    "\n",
    "n_training_steps = 6000 # N of full training steps\n",
    "n_episode = 4 # N of steps to add to memory before training\n",
    "n_steps = 200 # N of maximum steps in an episode in evaluation\n",
    "n_batches = 4 # N of batches to use for training each time\n",
    "n_batches_iter = 4 # N of updates to make per batch 8\n",
    "waitr = 64 # Wait steps before starting to wait 32\n",
    "\n",
    "mem_size = 10000 # N of examples that fit the memory 10000\n",
    "l_batch = 64 # Size of each of the batches 32\n",
    "gamma = 0.99 # Gamma of the training\n",
    "\n",
    "#T0 = 5 # Starting value of the T 5\n",
    "#T1 = 0.5 # Final value of the T 0.5\n",
    "#n_T = 8000 # Time to reach the final value\n",
    "\n",
    "eps0 = 1 # Starting value of the epsilon\n",
    "eps1 = 0.01 # Final value of the epsilon\n",
    "n_eps = 4000 # Time to reach the final value\n",
    "\n",
    "F = 100 # Update time for target network\n",
    "\n",
    "ee = 1/(mem_size*10) # Minimum probability for any example\n",
    "eta = 1.5 # Exponent for the probability formula\n",
    "\n",
    "# initialize the variables\n",
    "\n",
    "results = [] # Store the current Q values for a batch\n",
    "y = [] # Store the target values for a batch\n",
    "\n",
    "recording = [] # Store the mean values of the runs evaluated every so many steps\n",
    "recording2 = [] # Store the evolution of the loss\n",
    "\n",
    "un_prob = [] # Store the unnormalized priorities, if needed\n",
    "indexx = [] # Store the indices of the examples chosen in the batch, so we can update the probabilities\n",
    "\n",
    "# Step 1: define the environment and memory\n",
    "\n",
    "env = gym.make('CartPole-v0') # environment, the cartpole problem\n",
    "in_dim = env.observation_space.shape[0] # 4 state parameters\n",
    "out_dim = env.action_space.n # 2 action parameters\n",
    "\n",
    "tree = SumTree(mem_size) # SumTree for the memory\n",
    "\n",
    "# Step 2: define the NN of the Q function\n",
    "\n",
    "layers = [nn.Linear(in_dim, n_neurons), nn.SELU()]\n",
    "\n",
    "for i in range(n_hidden):\n",
    "    \n",
    "    layers.append(nn.Linear(n_neurons,n_neurons))\n",
    "    layers.append(nn.SELU())\n",
    "    #layers.append(nn.Dropout(p=0.2))\n",
    "\n",
    "layers.append(nn.Linear(n_neurons,out_dim))\n",
    "\n",
    "q_net = nn.Sequential(*layers) # Network for behavior in Q\n",
    "\n",
    "opt = optim.Adam(q_net.parameters(), lr0)\n",
    "\n",
    "losss = nn.MSELoss()\n",
    "\n",
    "q_net_target = nn.Sequential(*layers) # Target network for Q\n",
    "\n",
    "# Step 3: perform the training steps\n",
    "\n",
    "state_exp = env.reset()[0] # Initialize the environment\n",
    "\n",
    "for step in range(n_training_steps):\n",
    "    \n",
    "    if step%F == 0:\n",
    "        \n",
    "        q_net_target.load_state_dict(q_net.state_dict())\n",
    "    \n",
    "    opt = optim.Adam(q_net.parameters(), np.maximum(lr0 - step*(lr0-lr1)/n_lr,lr1)) # lr decay\n",
    "    epsilon = np.maximum(eps0 - step*(eps0 - eps1)/(n_eps), eps1)\n",
    "    #T = np.maximum(T0 - step*(T0 - T1)/(n_T), T1)\n",
    "    \n",
    "    # a) Gather the experiences through a number of steps, and save them to memory\n",
    "    \n",
    "    for i in range(n_episode):\n",
    "        \n",
    "        state0_exp = state_exp # Starting state for this step\n",
    "        \n",
    "        #action_exp,_ = boltz(state0_exp,q_net,T) # Obtain the action\n",
    "        action_exp,_ = eps_greedy(state0_exp,q_net,epsilon) # Obtain the action\n",
    "        \n",
    "        #print(q_net.forward(torch.from_numpy(state0.astype(np.float32))))\n",
    "        \n",
    "        state_exp, reward_exp, done_exp, _, _ = env.step(action_exp.item()) # Obtain the rewards and new state\n",
    "        \n",
    "        # Save to memory\n",
    "        \n",
    "        q_prior = q_net.forward(torch.from_numpy(state0_exp.astype(np.float32)))[action_exp.item()]\n",
    "        \n",
    "        if done_exp:\n",
    "            \n",
    "            y_prior = torch.tensor(0.0)\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            action2 = torch.argmax(q_net.forward(torch.from_numpy(state_exp.astype(np.float32))))\n",
    "            y_prior = reward_exp + gamma*q_net_target.forward(torch.from_numpy(state_exp.astype(np.float32)))[action2.item()]\n",
    "            \n",
    "        prior = (np.abs(y_prior.detach().numpy()-q_prior.detach().numpy())+ee)**eta\n",
    "        \n",
    "        un_prob.append(prior) # Store the priority, used later to obtain the probability\n",
    "        \n",
    "        tree.add(prior/np.sum(np.array(un_prob)),[state0_exp,action_exp,reward_exp,state_exp,done_exp])\n",
    "        \n",
    "        # Check if it needs to reset the run\n",
    "        \n",
    "        counter = counter + 1\n",
    "        \n",
    "        if done_exp:\n",
    "            \n",
    "            state_exp = env.reset()[0]\n",
    "            \n",
    "        if counter == n_steps - 1:\n",
    "            \n",
    "            state_exp = env.reset()[0]\n",
    "            counter = 0\n",
    "    \n",
    "    if step > waitr-1:\n",
    "        \n",
    "        # b) Select a number of batches from memory, and train using them\n",
    "    \n",
    "        for i in range(n_batches):\n",
    "        \n",
    "            # Create the batch\n",
    "        \n",
    "            batch_states0 = [] # List to store the batch previous states\n",
    "            batch_action = [] # List to store the batch taken actions\n",
    "            batch_reward = [] # List to store the batch obtained rewards\n",
    "            batch_states2 = [] # List to store the batch next states\n",
    "            batch_dones = [] # List to store the batch done flags\n",
    "            batch_indices = [] # List to store the batch indices of chosen examples\n",
    "            batch_indices2 = [] # List to store the batch indices of chosen examples, v2\n",
    "            \n",
    "            segment = tree.total()/l_batch\n",
    "            \n",
    "            for i in range(l_batch):\n",
    "                \n",
    "                a = segment*i\n",
    "                b = segment*(i+1)\n",
    "                \n",
    "                s = np.random.uniform(a,b)\n",
    "                (idx, p, data, dataIdx) = tree.get(s)\n",
    "                \n",
    "                batch_states0.append(data[0])\n",
    "                batch_action.append(data[1])\n",
    "                batch_reward.append(data[2])\n",
    "                batch_states2.append(data[3])\n",
    "                batch_dones.append(data[4])\n",
    "                batch_indices.append(dataIdx)\n",
    "                batch_indices2.append(idx)\n",
    "            \n",
    "            # Perform the training updates of this batch\n",
    "        \n",
    "            for j in range(n_batches_iter):\n",
    "            \n",
    "                for a in range(l_batch):\n",
    "                \n",
    "                    # Obtain the Q values for the states in the batch, save them as current output of net\n",
    "                \n",
    "                    q_val_current = q_net.forward(torch.from_numpy(batch_states0[a].astype(np.float32)))\n",
    "                    results.append(q_val_current)\n",
    "                \n",
    "                    # Obtain the target Q values (only the corresponding action will be changed)\n",
    "                \n",
    "                    objc = torch.clone(q_val_current)\n",
    "                \n",
    "                    with torch.no_grad():\n",
    "                        \n",
    "                        if batch_dones[a]:\n",
    "                            \n",
    "                            objc[batch_action[a].item()] = torch.tensor(0.0)\n",
    "                            \n",
    "                        else:\n",
    "                            \n",
    "                            q_val_next = q_net.forward(torch.from_numpy(batch_states2[a].astype(np.float32)))\n",
    "                            action_adv = torch.argmax(q_val_next)\n",
    "                            q_val_next_target = q_net_target.forward(torch.from_numpy(batch_states2[a].astype(np.float32)))\n",
    "                            objc[batch_action[a].item()] = batch_reward[a] + gamma*q_val_next_target[action_adv.item()]\n",
    "                    \n",
    "                    del(un_prob[batch_indices[a]])\n",
    "                    un_prob.append((np.abs(objc[batch_action[a].item()].detach().numpy()-q_val_current[batch_action[a].item()].detach().numpy())+ee)**eta/np.sum(np.array(un_prob)))\n",
    "                    \n",
    "                    tree.update(batch_indices2[a], (np.abs(objc[batch_action[a].item()].detach().numpy()-q_val_current[batch_action[a].item()].detach().numpy())+ee)**eta/np.sum(np.array(un_prob)))\n",
    "    \n",
    "                    y.append(objc)\n",
    "                \n",
    "                # Obtain the loss of this batch\n",
    "            \n",
    "                loss = losss(torch.stack(results),torch.stack(y).detach())\n",
    "                recording2.append(loss.item())\n",
    "            \n",
    "                # Update the network\n",
    "            \n",
    "                opt.zero_grad()\n",
    "                loss.backward() # backpropagation\n",
    "                #torch.nn.utils.clip_grad_norm_(q_net.parameters(),gradient_clip)\n",
    "                opt.step() # gradient descent\n",
    "            \n",
    "                # Reset memory\n",
    "            \n",
    "                results = [] # Reset memory of the Q values\n",
    "                y = [] # Reset memory of the target Q values\n",
    "                \n",
    "    env.state = env.unwrapped.state = state_exp\n",
    "            \n",
    "    # Evaluate every 100 steps, a mean of 10 runs\n",
    "            \n",
    "    if step%100 == 0:\n",
    "        \n",
    "        total_reward = np.zeros((10,))\n",
    "        eval_rew = [] # Save the rewards for the current evaluation step\n",
    "        \n",
    "        for n in range(10):\n",
    "            \n",
    "            eval_rew = [] # Save the rewards for the current evaluation step\n",
    "            state_ev = env.reset()[0]\n",
    "            \n",
    "            for arp in range(n_steps):\n",
    "                \n",
    "                state0_ev = state_ev # Starting state for this step\n",
    "                action_ev, _ = eps_greedy(state0_ev,q_net,0) # Obtain the action\n",
    "                state_ev, reward_ev, done_ev, _, _ = env.step(action_ev.item()) # Obtain the rewards and new state\n",
    "                \n",
    "                eval_rew.append(reward_ev)\n",
    "                \n",
    "                #env.render()\n",
    "                \n",
    "                if done_ev:\n",
    "                    \n",
    "                    break\n",
    "                    \n",
    "            total_reward[n] = sum(eval_rew)\n",
    "            eval_rew = [] # Save the rewards for the current evaluation step\n",
    "            \n",
    "        mean_reward = sum(total_reward)/10\n",
    "        recording.append(mean_reward)\n",
    "\n",
    "env.reset()\n",
    "env.close()\n",
    "\n",
    "print(np.mean(recording))\n",
    "recording2 = np.array(recording)\n",
    "print(np.mean(recording2[np.linspace(len(recording)-11,len(recording)-1,10).astype(int)]))\n",
    "\n",
    "plt.rcParams['font.family'] = ['Times New Roman']\n",
    "fig,axs = plt.subplots(1,1,figsize=(7,5))\n",
    "axs.plot(np.linspace(0,len(recording)-1,len(recording))*100,recording)\n",
    "axs.set_ylabel('Steps without falling', fontsize = 15)\n",
    "axs.set_xlabel('Training episode', fontsize = 15)\n",
    "axs.axhline(y=200,color='k',linestyle='--')\n",
    "axs.tick_params(axis='both', labelsize = 17)\n",
    "fig.savefig('DRL_DDQN_1.png', format='png', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "6d7da161",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1999.9\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAooAAAHOCAYAAAAfVShrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABr50lEQVR4nO3deVxU5f4H8M8sCIqCmoKoqEmgoCBioWYqbri04NbVuuYu2s1b5hampqaImkumlZFrenMpM5fcy+V6U7PF5Ye5gAsKiiKr7DPz/P7AOTLMDAwDyHD8vF8vXjXn+c45z8wZhy/PqhBCCBARERERFaKs6AoQERERkW1iokhEREREJjFRJCIiIiKTmCgSERERkUlMFImIiIjIJCaKRERERGQSE0UiIiIiMomJIhERERGZpK7oChCg0+kQHx+PGjVqQKFQVHR1iIiISOaEEEhPT0f9+vWhVJpvN2SiaAPi4+Ph7u5e0dUgIiKip8ytW7fQsGFDs+VMFG1AjRo1AOTfLCcnpwquDREREcldWloa3N3dpRzEHCaKNkDf3ezk5MREkYiIiJ6Y4oa8cTILEREREZnERJGIiIiITGKiSEREREQmMVEkIiIiIpOYKBIRERGRSUwUiYiIiMgkJopEREREZJLNJoppaWmYMGEC3N3dUaVKFXh4eGD69OnIysoyGX/u3Dn06dMHrVu3hp+fHyIiIqDVas2ef8eOHWjXrh0CAgIQGBiIHTt2lLiO9+/fR2hoKPz8/NCyZUuMHj0aSUlJJT4PERERkS2yyURRo9GgR48eWL58OXQ6HVQqFa5du4b58+cjKCgImZmZBvHHjh1Dx44dMXjwYPz11184fvw4Nm/ejDfeeANCCKPzL126FKNGjUJkZCT+/PNPREZGYujQofj8888trmN8fDw6duwIAPjrr79w7tw5aDQadOjQAQ8ePCjdG0BERERkA2wyUVy2bBmcnJwQExODuLg4pKenY+HChVAoFPjtt9/wySefSLHp6ekYNGgQXnrpJQwdOhQAULNmTSxatAjfffcdIiMjDc596tQpTJ48GWFhYfDz8wMA+Pv745133sH777+PCxcuWFTHUaNGITExEcuXL4dKpYJKpcLSpUtx8+ZNjB8/vozeCSIiIqKKY5OJ4oULF7B79240bdoUAKBWqzF16lSEhoYCAHbt2iXFfvLJJ0hISMCgQYMMzhEcHIwaNWpg1qxZyMvLk45PnToVQgij+AEDBiAvLw+zZ88utn6//PIL9u/fj1dffRVVq1aVjteuXRtdunTBli1bLE44iYiIiGyVzSWKQgi88847cHBwMCobPHgwACA3N1c6tm3bNgBAmzZtDGKVSiWef/55JCQk4ODBgwCAO3fu4MSJE3jmmWfQuHFjg/hWrVrB3t4eu3btQkpKSpF1NHdNAGjbti0A4JtvvinyHERERES2Tl3RFShMoVBIyVZhrq6uACB1GcfGxuLy5csAYJT4AUDTpk1x5MgR/Prrr3j55Zdx6NAhCCFMxlapUgUNGzZETEwMzpw5gx49epitoz7xNHdNAPj111+LepkmZWRkQKVSGR1XqVQGiXNGRobZcyiVSoNWzpLEZmZmmhzTCeTfl2rVqlkVm5WVBZ1OZ7Yejo6OVsVmZ2cXOWGpJLHVqlWTNkbPycmBRqMpk9iqVatCqcz/eyw3N9egdbs0sQ4ODtJnpSSxeXl5Bn9oFWZvbw+1Wl3iWI1Gg5ycHLOxVapUgZ2dXYljtVotsrOzzcba2dmhSpUqJY7V6XRmJ8aVNFatVsPe3h5A/h+6hcdQWxtbkn/3/I4wHcvvCH5H8DvCfGxR8QZ1sijKRuiTwmHDhgEArl+/DgCoXr06atSoYRTv7OwMAIiOjjaIr1+/vsnzF4w3lygKIRAbG2v2PIWvaUpOTo7BP4K0tLQi69WnTx/89NNP0mMXFxezH57OnTvj6NGj0uMmTZogMTHRZKyTezO0n/h4DOexjwchO/muyVhH1yZ4KWyD9PjEgmHISLhhMtahVj10/mir9Pjk0lCk3bpsMtbO0Rld5z0eSvDbyveQHHPWZKyqigO6LzwgPf4j8gMk/n3KZCwA9Fx2TPr/s+s/QsK5Y2Zjuy3YD7V9/i/EC99GIP7MfrOxXebuRJXqNQEAF79fhlv/+9FsbKeZW1C1thsA4PKuL3HjyBazsR2mrkd1t2cBANH71yHmwHqzse3eXwXnRt4AgOu/bMaV3avMxr7wzqeo/VxrAEDsiR34e/unZmMDRi9A3RbtAQBxv+3D/21eYDa21bDZqOffBQBw9+wRnNsw22xsyzfC0CCwNwDgftRJ/Lk6zGys94AJaPRSPwBAUvRfOPP5BLOxXq+Ow7Nd3wAApMb+jVPLxpmN9eg5HM/1GgEAeHjnOv63aLjZ2CZdBqPZa28DALKS7uD43MFmY9079IXPwPcBALkPU3BkZojZ2Pov9ILvm9MAAJqcLPwc1stsrGurzvAf/rH0+MD7nc3G1vFuhzahC6XHhz/oCW2u6V+ItTz8ETh+ufT4lxmvIS8j1WQsvyMe039HODnYQXt0JX7Y+q3Z2D2n/0bkb4nI0ej4HcHvCKu/IxyVGvzwXjezsQMHDsR3330nPa5evbrZ2JLkEYVVqkRx27ZtCAoKQnBwMABICVDBvwoL0h/XdyWXNN6UpKQk6a9OU+ex5BwRERGYM2eO2fInJTtPh0t306XHeVrzf6XnagxjczXmY/O0hrHZeeZjtTphEJuZa/4vb50wjM3IMR8LwCA2Pbvo2CsJD6Gskh+TmmX+L28AuHrvIVQP8//6Ts4sOjbmfgbUufn1SM4w/5c3AFxLzEAVRX5sykPzf00DwI0HmbCvkh+bml50bGxSJu49ei/S08z/NQ0At1Ky8OBR7MPUomPjUrKR8ig2I6Xo2Dup2Uh/FJuZYv4vbwBISMtG5qPY7KSiv8jupecg51FszoOiYxMf5kDzKDY3sei/pJMycqXPjya16NjkzDwpVpv5sMjY1KzHsToziZxeerbG4DNclIwcw1idmZY8IP/fWMFYrc58LL8jHiv4HVGvmM/wrnPxOHc7P4bfEfyOsPY7olYV8y3cT5JCmOsbsDGXLl3Ciy++iNOnT8PT0xMA8O233+Kf//wnGjVqhJs3bxo958MPP0RERAReeeUV7N69G6Ghofj6668xdOhQbNiwwSj+xRdfxMmTJ7F48WJMmjTJZD3i4+PRoEEDAMC1a9fw7LPPGpQfPHgQPXv2RPXq1ZGebvpL3lSLoru7O+Lj4+Hk5GQUX9pupXtp2Yi+Z/zhVCqVsHd4HJudVXRXkUPValbF5mQX3VVUtZqjdbE52dAV0VVUkliHqo+7inJzc6AtoquoJLH2Do+7ivJyc6HRmP+lUZLYKvYFuopKEKvJy0NenvlfRnZVCnQVlSRWo0FervlfRnZ2VaAu0K1kaaxWq0VujvlfMGq1HewKdCtZGqvT6ZCTXVRXkeWxKrUaVao87irKziqiq6gEsUqVCvb2j//dZ2UW8e++JLGF/t2XJPZp/45Y/+sN/HzpHsZ3aoy3Oz9rNnbKj5ew98JdDG3fGEHP1eJ3BPgdYc13hFoJ+Naraj62lF3PaWlpqF+/PlJTU03mHnqVokVRq9UiNDQUkZGRUpIIPO7mNTeWQf+m1alTx6p4U/TnMHceS85hb28vjUEoyNHR0WxrZ+E4Szk6OuJZR0c86/aMxc8hIltk/jvlycU+3Q7/nQAAUKjtivwe1uexnq410LVFgydRNaIS5wZFjcktyOZmPZsSFhaG1157DQMHDjQ43qxZMwDAgwcPTP6FqV/4ukmTJgbx9+/fN3mdwvGmODo6Si2Kps5jyTmIiKjyUSrzexI0RXTXFyxXPep5IKrMbD5R/PLLL6FWqzF58mSjMg8PDzRo0AAajUaaYFKQfvJK9+7dAeRP9ACAmJgYo9icnBzcuXMHjo6OaN++fZF16tSpk9nzFL4mERHJg/pRoqgrJlHUjxHVxxNVZjadKG7evBlRUVGIiIgwKsvMzIRCocA///lPAPk7rhSk1Wpx/vx51KtXD+3atQMAeHp6IjAwEDdv3sTdu4Yz986ePQudTofevXtLU97Neeutt0xeEwD+/PNPAEBIiPlZTUREVPmoHo0PtLhFkYkiyYDNJoqbN2/GkSNHsGLFCqOyY8eOYcaMGQCASZMmoVatWtIi2Hr79u3Dw4cPMX36dIO1CefNmwcARvHfffcdVCoVpk+fbnB8woQJ6N27N1JTHy8f0bt3b3To0AE7d+40WEPqwYMHOHLkCAYMGICWLVta+cqJiMgWqR79xixqpnh+ue5RPBNFqvxsMlFcvXo13nrrLRw7dgze3t5o3rw5mjdvDi8vL7i6uiIoKAgvv/wygPy1gNasWYM9e/Zg7969APIX4p4wYQIGDhyIf/3rXwbn7tGjByZOnIiIiAjcuHEDAPDzzz/j888/x9KlS+Hv7y/F3r9/H8uXL8f+/ftx6NAhg/Ns2LABOp0Os2bNApDfwjlq1Cg0adIEX375ZTm9M0REVFH0LYrFJ4psUST5sLlZz1u3bsWYMWMAAFeuXDEZ4+bmhi5dukiP+/Xrh71792LmzJmYOXMmFAoFpkyZgjFjxkhLCRS0ZMkSPPvss3jttddgZ2cHJycn7NmzB926GS5sWadOHQQHB+Pq1avo0KGDQZmHhwd+/fVXTJo0CX5+flAqlejZsyc2bNhgMDOaiIjkQW3hZBZ9osgxiiQHlWYdRTlLS0uDs7NzsWsZERFRxfn8SDQ+OXAZ/3i+IRYNbGU2rt8X/8NfsSn46q026Nmi3hOsIZHlLM09bLLrmYiIyNbou5KL2KAGwONZ0WxRJDlgokhERGQBtZQoFp0pctYzyQkTRSIiIgsoHy2grS1mwBYns5CcMFEkIiKygFplWYsiE0WSEyaKREREFtAnfppimhQfz3rmr1iq/PgpJiIisoB+72ZdMYuFaIW+RbHcq0RU7vgxJiIisoDKwnUU9S2OKrYokgzwU0xERGSBx8vjWLgzi4JjFKnyY6JIRERkAYsTRcHJLCQfTBSJiIgsoJ+cYvEWfiomilT5MVEkIiKygH5ySnEtippHW7co2fVMMsBEkYiIyAL6ySnFJYr6Ym7hR3LARJGIiMgCagvHKGoeLcjNMYokB0wUiYiILKAs6axnJookA0wUiYiILGBpi+LjnVmYKFLlx0SRiIjIAo8X3Da/17NOJ6QximxRJDlgokhERGQBfeJXVIOitsD2fkwUSQ6YKBIREVnAkhbFgt3STBRJDpgoEhERWUAao6g136RYMFFUc69nkgF+iomIiCygX0C7YPdyYQXLmCeSHPBjTEREZAH9lnxFzXou2NrIFkWSA36KiYiILKCWxiiaTxQLlnGIIskBE0UiIiILSF3PRSSKOvF4sW0F93omGWCiSEREZAG1BXs9a7grC8kME0UiIiIL6IccFtX1rB+jqGJrIskEE0UiIiIL6FsUdUUlioLb95G8MFEkIiKygMqCySzaR4txq1RMFEkemCgSERFZoOC4Q3OtitIYRXY9k0wwUSQiIrJAwUTRXKuilpNZSGaYKBIREVmg4LhDczOf9cc5RpHkgokiERGRBQq2Eprbxk/f0qhkokgywUSRiIjIAgaJotZ0oqhjiyLJDBNFIiIiCxScoKJ5NLu5MC64TXLDRJGIiMgCSqUC+lzRXNezjokiyQwTRSIiIgvpu5TNTWZ53KLIX68kD/wkExERWUhadNvMGEXOeia5YaJIRERkIf04RZ2ZrmctZz2TzDBRJCIislBx2/hp2KJIMsNEkYiIyEKqYsYoarmFH8kME0UiIiIL6SepmE0UBWc9k7wwUSQiIrJQcbOetY/WV1SrmCiSPDBRJCIislBxXc/62dBKdj2TTDBRJCIislBxk1n0s6E5mYXkgokiERGRhSxfcJuJIskDE0UiIiILKS2d9cxEkWSCiSIREZGFip/MwkSR5IWJIhERkYUej1HUmSznFn4kN0wUiYiILKRPFM1t4afhFn4kM0wUiYiILCS1KGqL7npmiyLJBRNFIiIiC1k+RpG/Xkke+EkmIiKykH4hba2ZrufHieITqxJRueJHmYiIyEL6rfmKa1FUs0WRZIKfZCIiIgvpu5TNjVHkgtskNzafKCYmJmLGjBnw9/c3G5OZmYnp06fDz88PLVq0gJeXFyIiIpCXl2cy/ubNmxg6dCh8fX3h4eGBwMBAbN++vcR1i4yMREBAAFq0aIFmzZqhR48eOH78eInPQ0RElcOjBkWzXc/62dBMFEkubDZRTElJwbx58+Dv74/w8HCkpKSYjEtPT0fnzp0RHR2N06dPIyoqCpGRkZg3bx769+8PXaG1rqKiohAQEAB/f39cuHABMTExeP311zFw4EAsWrTI4vpNmDABc+fOxYYNGxAVFYXLly9jwIAB6Nq1K3bv3l2al05ERDZK36Jodgs/LRNFkhebTRQdHR0RFhaGAwcOFBk3ZcoUREdHIzIyElWrVgUABAUFITw8HHv27MHixYulWK1Wi0GDBsHPzw8TJ040OEdISAimTZuGkydPFlu3y5cv47PPPsOcOXPg6+srHR83bhwCAgIwZcqUkr5cIiKqBPSTVMyPUcxvnFApmCiSPNhsomhnZwe1Wg0vLy+zMUlJSVi3bh3atGkDZ2dng7KRI0fCzs4OCxcuRFZWFgBg3759iIqKQrdu3YzONW7cOOh0OsydO7fYuv31118QQuCZZ54xKmvatCni4uKKPQcREVU+6mJaFLXseiaZsdlEUc/Ozs5s2cmTJ5Gbm4t69eoZlTk5OaF169ZISkrCiRMnAADHjh0DAJPxHTt2hFKpxOHDh5GRkVFknRo0aAAAWL16tVHZ1atX0atXryKfT0REldPjLfy44DY9HWw+USyKftxiamqqyfJGjRoBAC5evFhsvKOjI2rXro28vDxER0cXed0OHTrAx8cHe/bsMWiB3L17Nx48eIClS5eW9KUQEVElIG3hV8wYRW7hR3KhrugKlEb9+vUBPO4KVhQaE6KfyPLw4UOD+D/++MPk+QrHm6NUKrF9+3YEBQXho48+QmxsLIYMGYINGzbg9OnTcHV1LfL5OTk5yMnJkR6npaUVGU9ERLah2BZFwRZFkpdK3aLYvn17uLi4IC4uDnv37jUqj4+PBwDUqlULABASEgIA2LVrF+7du2cQm52djeTkZIP4ojRv3hwnTpyAl5cXVq9ejZ49e2L06NHFJokAEBERAWdnZ+nH3d292OcQEVHFe7yFn85kuZbrKJLMVOpE0cHBAatWrYJarcaYMWOkGctJSUkIDw/H2bNnAUCamRwQEICJEyciIyMD/fr1kyadxMTEYOzYsRBCwN7eHp6enhZd/8GDB3j77bexZMkSaDQavPLKK/j888+Lfd60adOQmpoq/dy6dcuKV09ERE+aUkoUTZdzwW2Sm0rd9QwA/fr1w9GjR7FgwQIMGTIEXl5e8PHxgaenJ7Kzs1G7dm20a9dOil+yZAl8fX2xevVqBAUFwdfXF23btkWNGjUAAMHBwUVOoNE7ePAgIiIi8Msvv0ChUKBp06YYPHgwxo8fj2rVqmHEiBFmn2tvbw97e/vSv3giInqiimtR1HEyC8lMpU8UgfzJJYUXuR4zZgwAYOzYsUaJ3/DhwzF8+HDpsRACzZs3BwCMHz++2OvFx8djwIAB+Prrr6VxkX379sW2bdvQr18/TJ48GQMGDICTk1NpXhYREdmY4sYoPm5RrNQddkQSWX6Sz58/j/Xr18PNzc2ixa9XrVqFK1euoFevXggODi42fs2aNXj48CH8/PwMjr/22msYN24ckpKScOrUKavrT0REtkm/kLbZLfykRPGJVYmoXMnuo5yRkYERI0ZAoVBg06ZNxU5MuXTpEsLCwtCwYUOsXbvWomskJSUByN8+sLA+ffqYLSMiospN9WizZ62WLYr0dLD5T7J+yRqtVltsbHp6OkJCQhAVFYXNmzeja9euRcZfvXoVPXr0gLOzMw4ePAg3NzejmAkTJqB3794Gay8GBQUByB+nWNiNGzfg4OCAjh07FltfIiKqXKQximZaFLngNsmNzSeKly5dAgAkJiYiMTHRZExmZiY2b94MX19f3L59GydOnMCAAQPMnjMhIQELFy6Ev78/WrVqhTNnzsDb29so7v79+1i+fDn279+PQ4cOScdDQkLQt29fLFy4ED/99JN0/Pfff8fcuXOxdOlSuLi4WPuSiYjIRkldz8XszMIFt0kubHoyS6tWraRdUrKzs+Hp6YmgoCDs2LEDQP5OK4GBgXj48CF8fHwwc+ZMDB061Oys5cOHDyM0NBQajQbt2rXDjh07ihyTWKdOHQQHB+Pq1avo0KGDQdm2bduwdOlSTJ06Fe+++y4cHR3h4uKCDRs2oGfPnmX0DhARkS3RdylzCz96Wth0onju3Lkiy2vWrIkrV65YfL7u3bvj2rVrFscrFAocOHDAZJmdnR0++OADfPDBBxafj4iIKjf9JBWzW/g9Gi6lVDBRJHmw+a5nIiIiW1Fsi+Kjw2xRJLlgokhERGShxwtum+t6zm9R1M+OJqrsmCgSERFZSFlMoqh51KSoYtczyQQTRSIiIgsV16KoE5zMQvLCRJGIiMhCj7fwM73X8+MFt5kokjwwUSQiIrKQSmpRNF2uZaJIMsNEkYiIyEKPE0XTmSITRZIbJopEREQWUktdz8UtuM1fryQP/CQTERFZSN9SqCtmr2fmiSQXVn+UY2JiLIpLTk5Gbm6utZchIiKyGdJkFi1bFOnpYPUnOTQ0tMjyBw8eoH379vDz88OIESMwd+5cZGdnW3s5IiKiCqcupkWRs55JbqxOFK9fv44ePXqgdu3acHV1Rb9+/XDp0iWpfM6cOfjtt9+wc+dO/Oc//8HEiRMRGRkJnZkBwERERLZOv4ezuTGKOiaKJDNWJ4o3btzAzz//DABo1KgRLl++jOeffx5nz54FAPz+++8AAF9fXwCAo6MjBg0ahA0bNpSyykRERBVDrSpmZxYdF9wmeSnVIIoFCxYgISEBZ86cwcWLF/Gf//wHc+fOBQA8fPgQAGBnZyfFu7q64vjx46W5JBERUYVRPRp7aH6vZ7YokrxYnSj6+vpi6tSpBolgSEgIEhISAAAajQZqtdroebGxsdZekoiIqELp93A2mygKJookL1Ynimq1Gjk5OQbHfvvtNzg4OAAAtFotatSoYfS8q1evWntJIiKiCqUqYh1FIQRbFEl2jJv8LBQUFISXXnoJ//znP2FnZ4dz585h06ZN6Ny5M06ePIn4+Hg888wz0Gq1UKlUAICffvoJtWvXLrPKExERPUnSOoomEsWCrYz6lkeiys7qRDE8PBz9+vXDxIkTpWPvvPMO5s6di969eyMjIwODBg1Cz5490aNHD9SsWRNz587Fu+++WyYVJyIietKKalHUFlgyR6ViokjyYHWi6ODggH379uHUqVO4efMm/Pz84O3tDQD43//+hytXrqB58+ZITEzE+PHjsW3bNnTu3Bnvv/9+mVWeiIjoSVIrzY9RLHiMs55JLqxOFPXatWuHdu3aGRxTKpVo3rw5bt68icaNG2PLli346quv4OzsXNrLERERVRhVEYliwVZGJbueSSbKbY8hnU6H3r17S4+ZJBIRUWVXVNezji2KJENWtyhqNBp8+eWXOHr0KFJTUw12XBFC4Pbt27h27VqZVJKIiMgWPO56Nt5lrGDyyFnPJBdWJ4qjRo3Cxo0bi4xRsOmdiIhkRGnBGEWlgr//SD6s7nr+6aefsGXLFiQnJ0On0xn9xMXFoV69emVZVyIiogplyWQWtbLcRnURPXFWtyj26NED//jHP8yWu7m5Yf78+daenoiIyOZIk1mE+USR3c4kJ1b/2fPSSy/hwYMHRcbcuHHD2tMTERHZnKJmPTNRJDmyOlHs2bMn5syZgxs3biA2Ntbg5+bNmzh27Bg+++yzsqwrERFRhSpq1rOGiSLJkNVdzy+88ALS0tLw+eefl2V9iIiIbJZ+/KEQ+cvhKAskhY/HKDJRJPmwOlHs3r07atWqhXr16kl7OetptVpER0dj69atpa4gERGRrSi4h7NWCChhnCgqmSiSjFidKI4YMQJ9+vQpMiYpKcna0xMREdmcgns4a3UCdgXaSdiiSHJk9RjF4pJEAFiyZIm1pyciIrI5Bi2KhcYpah4tws3t+0hOym2xJ61WiwEDBpTX6YmIiJ64ghNVCk9o0T1aMketYqJI8mFR13OPHj0QHx+P33//HVWrVgWQP+s5Ly/PZDy38CMiIjlSm5i8oqfRctYzyY9FieKdO3eQkJAAjUYjHatevTp27NhR5PO4hREREcmJqVnOhR+r+LuPZMSiruc///wTsbGxqFGjhnRs7NixmDFjBjIyMkxu4RcdHQ03N7dyqzgREVFFMLeNn363FrYokpxY1KJYpUoVVKlSxeBYcHAwXF1dpa7owpo2bYr169eXuoJERES2RKVUQKMTRtv46ccscowiyUmpJrO0atWqyPK4uLjSnJ6IiMjmSNv4aQu1KGrZ9UzyU26znm/evIlp06aV1+mJiIgqxONt/HQGx9n1THJkUddzzZo1kZ6eXt51ISIisnn6MYo6YXoyi36bPyI5sChRfOutt7B27Vr4+fnB3t6+2NnMQgjExsbi5s2bZVJJIiIiW/G4RdF0osg8keTEokTx7bffhre3N/71r39ZfGKtVgtfX1+rK0ZERGSLpESx8BhFtiiSDFmUKPr4+KBOnTolOrFKpcKRI0esqhQREZGt0ieChbue9S2MHKNIcmLxnz0uLi4lPnl4eHiJn0NERGTL9A2GRlv4MVEkGbKoRfH48eMlOqkQAjdv3sTatWvx2WefWVUxIiIiW6RvUTTawo+JIsmQRYnisGHDEBsbW951ISIisnkqczuzPFouR81EkWTEokQxNDQU3377LV555RWLZz1fu3YN3377bZlUkoiIyFboF9Q2t9ezkokiyYhFieKoUaPg4uKCUaNGlejkXHuRiIjkxtzyONIWfkwUSUYsmsxiTZL4+++/Y8eOHVZVioiIyFbpE0WdmRZFbuFHclJuiz3duXMHn3/+eXmdnoiIqEKYXXCbW/iRDFnU9WxKRkYGIiIicPbsWWRlZUEUWE9KCIEbN24gPT0d77zzTplUlIiIyBaozU1mebQAt1rFRJHkw+pE8f3338fq1atRo0YN2NvbQ6lUomrVqgDyE8Xk5GS8/vrrZVZRIiIiW6A0kyjqWxiV7HomGbG66/nAgQM4dOgQUlNTcfLkSYSGhuL69eu4fv06bty4gZCQEMyfP78s60pERFTh1FLXs87guH6nFk5mITmxOlFs0qQJunXrBgDw8PBATEwMcnJypPJhw4ZhypQppa8hERGRDZEms5jdwo97PZN8WP1pzs3NxeXLl6XHb775JqZOnSo9vnPnDvbt21e62gFITEzEjBkz4O/vbzYmMzMT06dPh5+fH1q0aAEvLy9EREQgLy/PZPzNmzcxdOhQ+Pr6wsPDA4GBgdi+fXup6hkdHY0JEyagb9++mDRpEg4dOlSq8xERkW2SJrNozcx6Zp5IMmLxx/nOnTsGj4cPHw5vb29Ur14dW7Zswcsvv4zz58+jQ4cO6NevH0aPHo0aNWpYXbGUlBTMmzcP/v7+CA8PR0pKism49PR0dO7cGdHR0Th9+jSioqIQGRmJefPmoX///tAV6hqIiopCQEAA/P39ceHCBcTExOD111/HwIEDsWjRohLXU6vVYurUqejQoQNefPFF/Pjjj1iyZAl69OhhzcsmIiIbZ3YyC1sUSYYs+jT/8MMPcHd3x8qVK6VjY8eOxapVq9CzZ088++yzAID//Oc/yMrKws6dO1G9enWsWLHC6oo5OjoiLCwMBw4cKDJuypQpiI6ORmRkpDSZJigoCOHh4dizZw8WL14sxWq1WgwaNAh+fn6YOHGiwTlCQkIwbdo0nDx50uI6ZmVloVevXti4cSNOnDiBf/zjHyV8lUREVNlIW/gJ04kixyiSnFiUKM6aNQtNmjTByy+/bHA8NDQU27dvR9u2bQEA9evXx59//om7d+/i3r176NOnj9UVs7Ozg1qthpeXl9mYpKQkrFu3Dm3atIGzs7NB2ciRI2FnZ4eFCxciKysLALBv3z5ERUVJYysLGjduHHQ6HebOnWtR/bRaLd544w0cPXoUu3btgqenZwleHRERVVbm93rmFn4kPxYliikpKfjtt9+klkMAePvtt83Gu7i4QKlUYvXq1aWuoJ2dndmykydPIjc3F/Xq1TMqc3JyQuvWrZGUlIQTJ04AAI4dOwYAJuM7duwIpVKJw4cPIyMjo9h6rVy5Ejt37sS///1vvPDCC5a+HCIiquT0XcuFxyhyCz+SI4sSxZdeegm1a9c2OFZwIos5X331lXW1spB+3GJqaqrJ8kaNGgEALl68WGy8o6Mjateujby8PERHRxd53aSkJMyZMwdqtZozu4mInjJqM7OetY/GxHNnFpITixbcHjBgAN5880289NJLcHR0hEKhwN27d7Fx40aDHVn0cnNz8eeff+LPP/8s8woXVL9+fQDAX3/9BSEEFIUWOdVPZHn48KFB/B9//GHyfIXjzdm2bRuSk5PRsWNH/PLLL9i3bx8uXrwInU6H/v37Y+rUqXBwcDD7/JycHIOlhNLS0oq8HhER2Q79gtpGW/g9mjvJRJHkxKJEceDAgUhJScGHH36IxMRE6fiwYcOKfF7hxK2stW/fHi4uLoiLi8PevXuNxlDGx8cDAGrVqgUACAkJwccff4xdu3bh3r17cHFxkWKzs7ORnJxsEG/Ojz/+KD3H3d0dGzduRGZmJiZOnIhZs2bh2LFjOHDgANRq029vREQE5syZY9VrJiKiimV+1rPOoJxIDiyewz969GjcvXsX//d//4ejR4+iVatWOHLkiMmfQ4cOITw8HMpyXiLAwcEBq1atglqtxpgxY6QZy0lJSQgPD8fZs2cBAL6+vgCAgIAATJw4ERkZGejXrx/i4uIAADExMRg7diyEELC3ty92YsqlS5cAAB9//DE6deoEhUIBR0dHfPHFF/Dy8sIvv/yCVatWmX3+tGnTkJqaKv3cunWrtG8FERE9IdzCj54mJdrrWalUwsfHBwBQs2ZNdO7c2Wxst27d8MMPP5Sudhbo168fjh49igULFmDIkCHw8vKCj48PPD09kZ2djdq1a6Ndu3ZS/JIlS+Dr64vVq1cjKCgIvr6+aNu2rbTmY3BwcJETaADg7t27AB53ZeupVCqMGjUKH3zwAbZv347x48ebfL69vT3s7e1L87KJiKiCPN7CzzBRlLbwUzFRJPkoUaJY0J49e4qNOXPmjLWnL5EOHTpg9+7dBsfGjBkDIH+9x8KJ3/DhwzF8+HDpsRACzZs3BwCzyV1B1apVQ05OjsmuZf0MaH1rJRERyYu0hV/hFkWtMCgnkgOr+4YdHR3Lsh5l6vz581i/fj3c3NwsmpW8atUqXLlyBb169UJwcHCx8c2aNQMA3L5926jMzc0NQPHjHImIqHJSmWlRlHZmYdczyYjs9hnKyMjAiBEjoFAosGnTpmITtkuXLiEsLAwNGzbE2rVrLbpGSEgIAODIkSNGZffu3QMAdO3atYQ1JyKiyuDxZBbDLWL1O7WwRZHkxOYTRf2SNVqtttjY9PR0hISEICoqCps3by42Wbt69Sp69OgBZ2dnHDx4UGoNLGjChAno3bu3wdqL//rXv+Di4oJ169ZJu77oHTx4ENWrV8c777xjycsjIqJK5vHOLIbHpS38OEaRZMTmE0X9DOPExESDpXkKyszMxObNm+Hr64vbt2/jxIkTGDBggNlzJiQkYOHChfD390erVq1w5swZeHt7G8Xdv38fy5cvx/79+3Ho0CHpuJOTE77//nukpKRg2LBhyM7OBpCfJH722WdYv349GjZsWJqXTURENkplpkVRP0aRs55JTqyezPIktGrVStolJTs7G56enggKCsKOHTsA5O+0EhgYiIcPH8LHxwczZ87E0KFDzc5aPnz4MEJDQ6HRaNCuXTvs2LGjyDGJderUQXBwMK5evYoOHToYlHXs2BHHjx/HtGnT4OHhARcXF7i5ueHgwYMGs6yJiEhezI5R1M96Luel4YieJKsTxTlz5mDWrFlmy/ft24cmTZqYbKmz1Llz54osr1mzJq5cuWLx+bp3745r165ZHK9QKHDgwAGz5YGBgfj5558tPh8REVV+5rfw4xhFkh+r/+w5duxYkeW9e/fG4sWLrT09ERGRTdIvuK3vatZjokhyVKIWxaVLl0r7IN+4cQNz5841udezEAI3b97EDz/8gDVr1pRNTYmIiGyA+S38hEE5kRyUKFEcPXo05s2bh8WLF0OhUBTZ9axWq9miSEREsqN6NAZRK0xv4ccWRZKTEiWKTk5OWLRoEby9vfH1119j8+bNJuNUKhXq1KkDBweHMqkkERGRrdCvfmO0hR8TRZIhqyazjBgxAnXq1EHjxo3NxuTk5FhdKSIiIlulUj1qUdQWblHMXy6HiSLJidWTWV599dUiy//8808cP37c2tMTERHZJGmMoplZzxyjSHJi9fI4I0eONFuWm5uLM2fOoHPnzujUqZO1lyAiIrI5+r2cjSazPEoclUwUSUasThTXr19fbMy9e/cQGRlp7SWIiIhsjsrcrGctWxRJfqzueq5Tpw5iY2Oh0+mMfm7fvo0PPvgAycnJZVlXIiKiCmcuUdRPbuEWfiQnVieKCxYsMLufcf369eHt7Y0VK1ZYXTEiIiJb9HgLP8O9nvU7tahVTBRJPqxOFIsaowgAPj4+XEeRiIhkR9rCzzBPlFoU2fVMcmL1GMXY2FiTx3U6He7evYvZs2cjJSXF2tMTERHZJKWZFkX9GEV2PZOcWJ0oNmnSBIoi/jEIITBx4kRrT09ERGSTzG7hp+96VlrdWUdkc6xOFAEgKCgIjRo1MjimUqng7OyMF198EQMGDChV5YiIiGyNysw6itIWfhyjSDJidaLo4+ODn3/+uSzrQkREZPOkySxa0wtuq9j1TDJidfv4Dz/8UJb1ICIiqhRMLY8jhHicKHIyC8mI1Ymil5cXdDodVqxYgdatW6NatWqoV68e+vbti3379pVlHYmIiGyGfgxiwa7ngsMVOeuZ5MTqRDE7OxvBwcF47733cO7cOQCAQqHA0aNH8fLLL2PEiBFlVkkiIiJboXr0m7Ngi2LB/+cWfiQnVieK8+fPx6+//oqwsDBcvHgRmZmZuHPnDlJSUnDjxg3k5eVxwW0iIpIdlb5F0UyiyBZFkhOrE8Vvv/0Wu3fvxvz589G8eXODskaNGmH9+vXYs2dPqStIRERkS0wtj1NwTUWOUSQ5sTpRrFmzJrp162a2XK1W4+HDh9aenoiIyCbpF9TWFEgUC669zUSR5KRUiaJWqzVbfuDAAcTFxVl7eiIiIpuk38tZZ65FkcvjkIxYnSi+8sorGDx4MK5duyYd02g0OH36NMaNG4fXXnsNb775ZplUkoiIyFaYalHUd0MrFJzMQvJi9YLb7733Hk6dOgVPT084OTmhSpUqePDgAYQQEEKga9eu+Oijj8qyrkRERBXO1BjFx9v3MUkkebG6RVGhUGDLli3YunUrnn/+eWg0GtjZ2aF169ZYuXIlDhw4AAcHh7KsKxERUYUzteC2fpcWjk8kuSnVXs8AMHDgQAwcONBk2Z07d+Dm5lbaSxAREdkMU4kit+8jubK6RbE4Qgh07969vE5PRERUIfTdywUnsOi7ntmiSHJjdYuiVqtFZGQkjhw5gpSUFGi1WohH/1CEELh9+7bBRBciIiI50CeDOpH/+06hUEgtimpVubW/EFUIqxPFUaNG4ZtvvikyRsEmeCIikpmCrYZanYBapZDGKCr5e49kxuo/fXbt2oUffvgBaWlp0Ol0Rj/x8fGoX79+WdaViIiowhVMFPVL5Og465lkyuoWxT59+qBv375my+vVq4dFixZZe3oiIiKbpFY+bmPRJ4j6hJFjFElurG5R7N69O27dulVkzOnTp609PRERkU0qkCdKCaKWiSLJlEUtisePHzc69uyzz2Lq1KkIDQ2FSqUyKBNCIDY2FqtXr8ann35aJhUlIiKyBQYtioUSRXY9k9xYlCgOGzYMsbGxRseFENi2bVuZV4qIiMhWFcwF9S2K+qVy2KJIcmNRohgaGooNGzagb9++cHBwKHY2sxAC169fx6ZNm8qkkkRERLZCoVBApcxfEkffkqhfUpGJIsmNRYni6NGj4eTkhHfeeadEJy9uDCMREVFlVDhRZIsiyZVFk1nq1q1rlCR+9dVXRT5n3759bFEkIiJZ0m/Vp+VkFpI5q2c9b926tcjy3r17Y/78+daenoiIyGY93saPiSLJW4nWUdy4caO0Td/du3cNHhckhMDNmzexefNmrFy5smxqSkREZCNUKtMtipz1THJTokSxffv2mD59Or777jsoFAoMGzasyPhJkyaVqnJERES2qHDXs75lkVv4kdyUKFF87rnnsHXrVnh7e2Pnzp1m10hUqVRwc3ODh4dHWdSRiIjIpqikruf8SSzSFn4qJookL1Zt4Td79mw0aNAAnTt3Luv6EBER2Tx9F7N+WRyNVj9G0eqh/0Q2yepP9JgxY4qN+eSTT6w9PRERkc1SFmpRlCazsEGRZMaiFsWLFy8iNTUV7du3l46Z2qlFT7/gdkREBKZMmVL6WhIREdkQfYuiNJlFsEWR5MmiRLFTp05ITU1FfHw86tatCwAIDAzE/fv3y7VyREREtkilND2ZhbOeSW4sShTfffdd3LlzB3Xq1JGODR8+HJs2bUKHDh1QtWpVg239hBC4du0a/ve//5V9jYmIiCpY4URRq+XOLCRPFiWKH330kdGxsWPH4tlnn8XYsWPNPi8wMND6mhEREdkofRezvsv50VwWJookO1YPpqhXrx5GjhxZZMxvv/1m7emJiIhslvHOLDqD40RyYXWi6O7ujuTk5LKsCxERUaWgn/Ws1eoTRcPjRHJhdaKYlJSEVq1aISwsDFeuXCnLOhEREdk0adazYIsiyZvViWKvXr1w+/Zt9OnTBwsWLEDv3r2xbt06ZGZmlmX9iIiIbI65Wc8co0hyY9XOLACwd+9eAPlL53Tq1AkZGRn47rvv8I9//AP169fHyJEj0a5duzKrKBERka3Q7/WsTxB1TBRJpspsZVBHR0f4+PigXr160rI5L730UlmdnoiIyGbo93TWsUWRZM7qRFG/9E1KSgpWrlyJVq1aoX379li3bh1efPFFbNq0Cb/88kupK5iYmIgZM2bA39/fbExmZiamT58OPz8/tGjRAl5eXoiIiEBeXp7J+Js3b2Lo0KHw9fWFh4cHAgMDsX379lLVUwiB4OBgNGnSpFTnISIi26dUFJ71rN/Cj4kiyYvVieLvv/+O559/Hg0aNMB7772H5ORkfPjhh4iOjsbhw4fxxhtvoEqVKlZXLCUlBfPmzYO/vz/Cw8ORkpJiMi49PR2dO3dGdHQ0Tp8+jaioKERGRmLevHno378/dPod2x+JiopCQEAA/P39ceHCBcTExOD111/HwIEDsWjRIqvru2zZMhw6dMjq5xMRUeXxeAu/Qns9c7NnkplSdT2fP38e3bt3x1tvvYW2bduiT58+ePbZZ8ukYo6OjggLC8OBAweKjJsyZQqio6MRGRmJqlWrAgCCgoIQHh6OPXv2YPHixVKsVqvFoEGD4Ofnh4kTJxqcIyQkBNOmTcPJkydLXNfz589j9erVJX4eERFVTo8ns+Q/5hZ+JFdWJ4q1a9fGxYsXsXPnTqxfvx6fffYZdu7ciVdeeQU//vhjqStmZ2cHtVoNLy8vszFJSUlYt24d2rRpA2dnZ4OykSNHws7ODgsXLkRWVhYAYN++fYiKikK3bt2MzjVu3DjodDrMnTu3RPXMzs7G0KFDsW7duhI9j4iIKi+VuRZFdj2TzFidKH7++ed47rnnpMdubm5YsGABZs6ciffeew/NmjXDqlWrSl1BOzs7s2UnT55Ebm4u6tWrZ1Tm5OSE1q1bIykpCSdOnAAAHDt2DABMxnfs2BFKpRKHDx9GRkaGxfWbPHkyBg0ahLZt21r8HCIiqtyM9noW+sksZTZHlMgmWP2J9vHxkf4/KSkJn3/+OQIDA/Hiiy/i1q1bcHV1lbqCy4t+3GJqaqrJ8kaNGgEALl68WGy8o6Mjateujby8PERHR1t0/b179+Lvv//GBx98UMKaExFRZWa0hd+jHVrUHKNIMmP1OorBwcEICwvD8ePH8dNPPyE3NxcNGjRAWFgYRowYYdDaWF7q168PAPjrr78ghICiUJO/fiLLw4cPDeL/+OMPk+crHF+UhIQETJ48GYcOHYKyhH9B5uTkICcnR3qclpZWoucTEVHFUppZcFvJrmeSGatbFBMSEjBx4kTs3bsXISEh2Lt3L2JjYxEeHv5EkkQAaN++PVxcXBAXFyctAF5QfHw8AKBWrVoAgJCQEADArl27cO/ePYPY7Oxsae9qfXxRRo4ciYiICDRo0KDE9Y6IiICzs7P04+7uXuJzEBFRxSm8hZ9OcDILyVOpBlNMnz4d8fHx2Lp1K3r16mXUolfeHBwcsGrVKqjVaowZM0aasZyUlITw8HCcPXsWAODr6wsACAgIwMSJE5GRkYF+/fohLi4OABATE4OxY8dCCAF7e3t4enoWed0VK1agSZMmUuJZUtOmTUNqaqr0c+vWLavOQ0REFUM/FlHf5cwFt0murO56njJlCj7++OOyrItV+vXrh6NHj2LBggUYMmQIvLy84OPjA09PT2RnZ6N27doGWwkuWbIEvr6+WL16NYKCguDr64u2bduiRo0aAPK71IuaQBMVFYVvvvkG//3vf62us729Pezt7a1+PhERVSzVo2YWbuFHcmd1orhw4cKyrEepdOjQAbt37zY4NmbMGADA2LFjjRK/4cOHY/jw4dJjIQSaN28OABg/fnyR11q2bBl+//13sxN1bt68KbWsikddEUREJC/qRy2K+i5nzaMx7kwUSW6sThRt2fnz57F+/Xq4ublhypQpxcavWrUKV65cQa9evRAcHFxkbN26ddGsWTOTZZcvX4ZarYaHh4dV9SYiospBVXjWMxfcJpmSXaKYkZGBESNGQKFQYNOmTcVOTLl06RLCwsLQsGFDrF27ttjzR0REICIiwmSZQqFAgwYNcOnSJavqTkRElYPROor6Wc9MFElmbH5lUP2SNVqtttjY9PR0hISEICoqCps3b0bXrl2LjL969Sp69OgBZ2dnHDx4EG5ubkYxEyZMQO/evc2u1UhERE+fwokit/AjubL5RFHfOpeYmIjExESTMZmZmdi8eTN8fX1x+/ZtnDhxAgMGDDB7zoSEBCxcuBD+/v5o1aoVzpw5A29vb6O4+/fvY/ny5di/fz8OHTpUNi+IiIgqPf1WfYVbFDlGkeSmzLue4+LikJqaCm9v71Ivl9OqVStpl5Ts7Gx4enoiKCgIO3bsAJC/00pgYCAePnwIHx8fzJw5E0OHDjU7a/nw4cMIDQ2FRqNBu3btsGPHjiLHJNapUwfBwcG4evUqOnToUKrXQkRE8vF4jGKhvZ6ZKJLMWJ0oTp06FQBQs2ZNfPjhhwCAWbNmYf78+dDpdGjZsiX27dsn7YZijXPnzhVZXrNmTVy5csXi83Xv3h3Xrl2zOF6hUODAgQMWx3OWMxHR00FacDs/T+RkFpItq7ueFy9ejLy8PEyYMAEAsH//fsydOxeNGzfG1q1b0a9fP0yaNKms6klERGQzHm/hl58pcgs/kiurWxQbNGiAZcuWSY+nT58OOzs77Nq1Cz4+Phg4cCC6dOlSJpUkIiKyJYVbFKUt/FRMFElerG5RLLjN3c6dO/HXX39h9OjR8PHxkY7fuXOndLUjIiKyQarCLYpa/RhFm58jSlQiVrcoVq9eHT/++CNq1qyJf/3rX3BycsJHH30klf/888+4evVqmVSSiIjIlphbcFvFrmeSGasTxc8++wwDBw7En3/+CWdnZ6xbtw6urq4A8rf3mz9/fplVkoiIyJbou571Xc5awVnPJE9WJ4pNmjTB77//juTkZFSvXt1gSZrRo0dj9OjRZVJBIiIiW6PvYtZ3OUuznjlGkWSm1Oso1qpVC7m5ubh79y4cHR1Ro0YNPPPMM2VRNyIiIpukejQU0WgLP3Y9k8yUatTtsWPH0KVLF9SoUQMNGjRAzZo10bRpU8yZMwdZWVllVUciIiKbom9R1Hc5cx1FkiurWxS///57vPHGG9BqtXjuuefQsmVLVK1aFbdv38bSpUvx3Xff4ejRo6hTp05Z1peIiKjCqY32es6f/cwxiiQ3VieK06ZNQ926dbFlyxZ06tTJoCw1NRUffvghJk+ejPXr15e2jkRERDZFv+D24zGK+ceZKJLcWJ0o3rlzBxs3bjRKEgHA2dkZK1euREBAQKkqR0REZIukFkWp61lncJxILqweo9ijRw+4uLiYLVcoFKhbt67R8V9//dXaSxIREdkElVHXM5fHIXmyOlH86quvsGnTJjx8+NBk+Z49e9CoUSODYxqNBkOHDrX2kkRERDZBv7C2PkHUMVEkmbK663no0KFITU1Fq1at0LhxY+m4EAIPHjxAVFQUAgMD0bVrVwCATqfDrVu3cOPGjVJXmoiIqCKpHq2XqGOLIsmc1YminZ0dTp8+DQC4fv26yRh9eUEKrjFFRESVXOEWRS0TRZIpq7ue33zzTWzbtg1arRY6na7YH61Wi5iYGFSvXr0s609ERPTESVv46biFH8mb1S2KISEhuH//vsUthAqFAs8++yw++OADay9JRERkE/QJoUang04n8ChPhFpZqn0siGyO1Z/oatWqITExEYMHD0bPnj2l48uXL8fy5cuh1WpNPu/DDz+09pJEREQ2oeCsZ333M/C4S5pILqxOFI8cOYIXX3wR27Ztw9WrV6Xj7733HvLy8vDCCy/g/v37ZVJJIiIiW6IqsI6iThRIFFVMFElerE4Uw8LC0LVrV+zatQv16tUzKJs4cSKuXbuG9957r9QVJCIisjX6Lmat1rBFkQtuk9xYnSjevXsXu3btwiuvvAIHBwfDkyqVqFmzJvbs2VPqChIREdka/VBEjU5Aq32cKCrZ9UwyY3Wi6OvrCzs7O5NlFy9eRGxsrNlyIiKiykzfoqgTQprxnH+ciSLJi9WJopeXF86dO2d0/O7du3jzzTehUCjw6quvlqpyREREtujxrGcBzaN9nhUKQMlEkWTG6uVxZs2ahVdffRXt2rXDnTt38OWXX+LcuXPYunUrUlNT0bRpUyxatKgs60pERGQTpMksWoFHeSJnPJMsWd2i6OzsjAMHDsDJyQn29vaYPHky1q9fD1dXV0ydOhW///47XFxcyrKuRERENkFdYNazvkWRi22THFndopiTk4OqVatixowZmDFjhlF5QkJCqSpGRERkqwp2Peu37+P4RJIjq1sUe/fuXWT5nTt3sHHjRmtPT0REZLMKLritTxQ5PpHkqNz2GmrevDm++uqr8jo9ERFRhTG1MwtbFEmOStT1/NFHH2Hr1q3Iy8vD3bt30bRpU5NxQgjcv38frq6uZVJJIiIiW1Jw4kqelmMUSb5KlCh+/PHH6N+/P0JCQuDg4IDGjRubjFOpVHjppZcwc+bMMqkkERGRLSm4VV+uhokiyVeJJ7P4+/vjv//9L95//31s3769POpERERk0wp2M+c8ShT1i3ATyYlVn+pGjRrhyy+/LOu6EBERVQoFt+rTtygyTyQ5snp5nMJrJGZkZOCHH37A3bt30b59e7z00kulrhwREZEtKtiimMsWRZIxixPFWbNmISsrS3pcq1YtTJs2DQBw6dIl9OzZE7dv34YQAgqFAsOHD8eaNWvKvsZEREQVTGWi65ljFEmOLE4UW7RogcGDB2Po0KGYPHkyWrZsCQDIzc1Fv379cOvWLTg7O+P999+HWq3Gp59+iq+++gpjx44tt8oTERFVBIVCAaUC0AkgV6sFwC38SJ4sThR///13TJo0CZ988onB8eXLl+Py5cuwt7fHL7/8gtatWwMAevXqhdDQUCaKREQkS2qlErlaHWc9k6xZnCj+97//xc8//2xwLDU1FQsWLIBCocCkSZOkJBEAAgICIIQou5oSERHZEJVSAWgLzHpWMVEk+bF45K29vT2qVatmcCwiIgLJycmoW7cuwsLCjJ6jUqlKX0MiIiIbpG9BlGY9s+uZZMjiRDEtLc3g8d9//41PP/0UCoUCc+bMQfXq1Q3KHz58iEuXLpVNLYmIiGyMPlF8vI4iE0WSH4sTRV9fX3z00UcAgLt372Lw4MHIzc1FmzZtEBoaahQfERGBjIyMsqspERGRDVEXalHkGEWSI4vHKM6fPx9t27bFihUrkJWVhdzcXLi4uGDz5s1QFGhuv3XrFhYvXowVK1YYHCciIpITpT5R5F7PJGMWJ4oNGjTAmTNnsGjRIvz9999o3rw5pkyZggYNGkgxH3/8MW7cuAEhBIYNG1YuFSYiIrIF+hbFnDwmiiRfJdqZxc3NDcuWLTNbru+aJiIikjtpMsujdRQ5RpHkiPsNERERWaHwrGe2KJIcMVEkIiKyQuFZz0wUSY6YKBIREVlBv2UfWxRJzpgoEhERWcG465m/Ukl++KkmIiKygn7LPi64TXLGRJGIiMgKhbueuYUfyRETRSIiIitIk1m0bFEk+WKiSEREZAX1ozGJOXn56yiqVEwUSX6YKBIREVlBP3dF2sKPXc8kQ0wUiYiIrKBvUeTyOCRnNp8oJiYmYsaMGfD39zcbk5mZienTp8PPzw8tWrSAl5cXIiIikJeXZzL+5s2bGDp0KHx9feHh4YHAwEBs3769RPVKS0vDhAkT4O7ujipVqsDDwwPTp09HVlZWic5DRESVU+HlcThGkeTIZhPFlJQUzJs3D/7+/ggPD0dKSorJuPT0dHTu3BnR0dE4ffo0oqKiEBkZiXnz5qF///7Q6XQG8VFRUQgICIC/vz8uXLiAmJgYvP766xg4cCAWLVpkUd00Gg169OiB5cuXQ6fTQaVS4dq1a5g/fz6CgoKQmZlZ2pdPREQ27vFez2xRJPmy2UTR0dERYWFhOHDgQJFxU6ZMQXR0NCIjI1G1alUAQFBQEMLDw7Fnzx4sXrxYitVqtRg0aBD8/PwwceJEg3OEhIRg2rRpOHnyZLF1W7ZsGZycnBATE4O4uDikp6dj4cKFUCgU+O233/DJJ59Y+aqJiKiykGY95zFRJPmy2UTRzs4OarUaXl5eZmOSkpKwbt06tGnTBs7OzgZlI0eOhJ2dHRYuXCh1B+/btw9RUVHo1q2b0bnGjRsHnU6HuXPnFlu3CxcuYPfu3WjatCkAQK1WY+rUqQgNDQUA7Nq1y+LXSURElZO6UIsiu55Jjmw2UdSzs7MzW3by5Enk5uaiXr16RmVOTk5o3bo1kpKScOLECQDAsWPHAMBkfMeOHaFUKnH48GFkZGSYvaYQAu+88w4cHByMygYPHgwAyM3NLfpFERFRpad8lBhqdcLgMZGc2HyiWBT9uMXU1FST5Y0aNQIAXLx4sdh4R0dH1K5dG3l5eYiOjjZ7TYVCgbZt25osc3V1BQD4+flZVH8iIqq8CrcgskWR5Ehd0RUojfr16wMA/vrrLwghoCi0hpV+IsvDhw8N4v/44w+T5yscX1KXL18GAAwbNqzIuJycHOTk5EiP09LSrLoeERFVnMLrJrJFkeSoUrcotm/fHi4uLoiLi8PevXuNyuPj4wEAtWrVAgCEhIQAyB9DeO/ePYPY7OxsJCcnG8SX1LZt2xAUFITg4OAi4yIiIuDs7Cz9uLu7W3U9IiKqOIUnr7BFkeSoUieKDg4OWLVqFdRqNcaMGSPNWE5KSkJ4eDjOnj0LAPD19QUABAQEYOLEicjIyEC/fv0QFxcHAIiJicHYsWMhhIC9vT08PT1LXJdLly5h//79iIyMLDZ22rRpSE1NlX5u3bpV4usREVHFUhfask+lrNS/UolMqtRdzwDQr18/HD16FAsWLMCQIUPg5eUFHx8feHp6Ijs7G7Vr10a7du2k+CVLlsDX1xerV69GUFAQfH190bZtW9SoUQMAEBwcXOQEGlO0Wi1CQ0MRGRlpUZJpb28Pe3v7kr1QIiKyKcpCXc/c6pnkqNInigDQoUMH7N692+DYmDFjAABjx441SvyGDx+O4cOHS4+FEGjevDkAYPz48SW+flhYGF577TUMHDiwxM8lIqLKqXBXs0rFFkWSH1l+qs+fP4/169fDzc0NU6ZMKTZ+1apVuHLlCnr16lXs+MLCvvzyS6jVakyePNna6hIRUSVUuKuZYxRJjmTRolhQRkYGRowYAYVCgU2bNhU7MeXSpUsICwtDw4YNsXbt2hJda/PmzYiKisLKlSuNyjIzM1GtWrUSnY+IiCqPwg2IhWdBE8mBzbco6pes0Wq1xcamp6cjJCQEUVFR2Lx5M7p27Vpk/NWrV9GjRw84Ozvj4MGDcHNzM4qZMGECevfubbT24ubNm3HkyBGsWLHC6DnHjh3DjBkziq0vERFVXoVbFLmFH8mRzbcoXrp0CQCQmJiIxMRE1KlTxygmMzMTO3fuxLRp0+Dg4IATJ07g+eefN3vOhIQErF+/Hh9//DG6dOmCNWvWSItlF3T//n0sX74cAHDo0CFpDOLq1asxbtw4eHh4wNvbW4rX6XRITU3FvXv3cPjw4VK9biIism1GC25zNgvJkE0niq1atZJ2ScnOzoanpyeCgoKwY8cOAPk7rQQGBuLhw4fw8fHBzJkzMXToULOzlg8fPozQ0FBoNBq0a9cOO3bsKHJMYp06dRAcHIyrV6+iQ4cOAICtW7dKE2WuXLli8nlubm7o0qWL1a+biIhsX+EFtgvPgiaSA4UQQlR0JZ52aWlpcHZ2RmpqKpycnCq6OkREZIHPfr6KpYceNxh8+c8A9PY1HsJEZIsszT1sfowiERGRLSo8JpFjFEmOmCgSERFZgYkiPQ2YKBIREVnBaMFtJookQ0wUiYiIrFA4MVRzr2eSIX6qiYiIrFA4UWSeSHLEjzUREZEV2KJITwN+qomIiKxQeMu+wlv6EckBP9ZERERWMJ71zF+pJD/8VBMREVmh8JZ9hWdBE8kBE0UiIiIrFN6yj1v4kRwxUSQiIrJC4ckrhVsYieSAiSIREZEVuDMLPQ2YKBIREVnBKFFk1zPJEBNFIiIiK3ALP3oaMFEkIiKygtGC2xyjSDLERJGIiMgK7HqmpwETRSIiIitwMgs9DZgoEhERWaHwGEXu9UxyxE81ERGRFZSFEkXmiSRH/FgTERFZgS2K9DTgp5qIiMgKRlv48TcqyRA/1kRERFYovBwOWxRJjvipJiIiskLhrmdOeiY5YqJIRERkhYJdzyqlAgquo0gyxESRiIjICgW7mrmGIskVE0UiIiIrqAqMUSzcDU0kF0wUiYiIrFBwyz5u30dyxUSRiIjICgW7m1UqJookT0wUiYiIrFCwu5ldzyRXTBSJiIisUHALv8KLbxPJBRNFIiIiK7BFkZ4GTBSJiIiswDGK9DRgokhERGQFg0SRXc8kU0wUiYiIrKAqtDMLkRwxUSQiIrKCUqmQ9ncuuEsLkZzwk01ERGQlfUuiki2KJFNMFImIiKykTxQ565nkiokiERGRlfTjFNmiSHLFRJGIiMhKbFEkuWOiSEREZCW1Kv/XKGc9k1wxUSQiIrKSfus+rqNIcsVEkYiIyEr6Lmc1d2YhmWKiSEREZCV9lzO7nkmumCgSERFZSUoU2fVMMsVEkYiIyEpqtiiSzDFRJCIispKKYxRJ5pgoEhERWUnawo9dzyRTTBSJiIisxAW3Se6YKBIREVnp8RhF/joleeInm4iIyEpKKVGs4IoQlRN+tImIiKzEFkWSO36yiYiIrCRt4cffpiRT/GgTERFZSb8sjpotiiRTNv/JTkxMxIwZM+Dv7282JjMzE9OnT4efnx9atGgBLy8vREREIC8vz2T8zZs3MXToUPj6+sLDwwOBgYHYvn17iet2//59hIaGws/PDy1btsTo0aORlJRU4vMQEVHlpO9y5oLbJFc2myimpKRg3rx58Pf3R3h4OFJSUkzGpaeno3PnzoiOjsbp06cRFRWFyMhIzJs3D/3794dOpzOIj4qKQkBAAPz9/XHhwgXExMTg9ddfx8CBA7Fo0SKL6xcfH4+OHTsCAP766y+cO3cOGo0GHTp0wIMHD6x+3UREVHno19lmokhyZbOJoqOjI8LCwnDgwIEi46ZMmYLo6GhERkaiatWqAICgoCCEh4djz549WLx4sRSr1WoxaNAg+Pn5YeLEiQbnCAkJwbRp03Dy5EmL6jdq1CgkJiZi+fLlUKlUUKlUWLp0KW7evInx48db8YqJiKiyYYsiyZ3NJop2dnZQq9Xw8vIyG5OUlIR169ahTZs2cHZ2NigbOXIk7OzssHDhQmRlZQEA9u3bh6ioKHTr1s3oXOPGjYNOp8PcuXOLrdsvv/yC/fv349VXX5WSUwCoXbs2unTpgi1btuDChQuWvlQiIqqk1Fxwm2TOZhNFPTs7O7NlJ0+eRG5uLurVq2dU5uTkhNatWyMpKQknTpwAABw7dgwATMZ37NgRSqUShw8fRkZGRpF12rZtGwCgTZs2RmVt27YFAHzzzTdFnoOIiCo/buFHcmfziWJR9OMWU1NTTZY3atQIAHDx4sVi4x0dHVG7dm3k5eUhOjq6yOsePHgQANC4cWOjsqZNmwIAfv311+JfABERVWrcwo/kTl3RFSiN+vXrA8ifTCKEgKLQX3T6iSwPHz40iP/jjz9Mnq9wvClCCMTGxhqcryB9F3hRyWZOTg5ycnKkx2lpaWZjiYjIdkkLbquYKJI8VeoWxfbt28PFxQVxcXHYu3evUXl8fDwAoFatWgCAkJAQAMCuXbtw7949g9js7GwkJycbxJuSlJQErVYLIL8VsjD9MXOztAEgIiICzs7O0o+7u7vZWCIisl3utavl/7dWtQquCVH5qNSJooODA1atWgW1Wo0xY8ZIM5aTkpIQHh6Os2fPAgB8fX0BAAEBAZg4cSIyMjLQr18/xMXFAQBiYmIwduxYCCFgb28PT09Ps9cs2BJob29vVK7RaAAAVapUMXuOadOmITU1Vfq5detWyV44ERHZhHe7eeLwxE54xc+toqtCVC4qddczAPTr1w9Hjx7FggULMGTIEHh5ecHHxweenp7Izs5G7dq10a5dOyl+yZIl8PX1xerVqxEUFARfX1+0bdsWNWrUAAAEBwcXOYGm4Ozqgkmjnn4iTJ06dcyew97e3mSSSURElYtKqcBzLjUquhpE5abSJ4oA0KFDB+zevdvg2JgxYwAAY8eONUr8hg8fjuHDh0uPhRBo3rw5ABS7BqKjoyMaNGiAuLg43L9/X3qenn6x7SZNmljzUoiIiIhsRqXuejbn/PnzWL9+Pdzc3DBlypRi41etWoUrV66gV69eCA4OLja+U6dOAPK7rAu7fv06AKB79+4lrDURERGRbZFdopiRkYERI0ZAoVBg06ZNRU5MAYBLly4hLCwMDRs2xNq1ay26xltvvQUAOHXqlFHZn3/+CeDxxBkiIiKiysrmE0X9kjX6mcZFSU9PR0hICKKiorB582Z07dq1yPirV6+iR48ecHZ2xsGDB+HmZjwYecKECejdu7fB2ou9e/dGhw4dsHPnTuTm5krHHzx4gCNHjmDAgAFo2bKlpS+RiIiIyCbZfKJ46dIlAEBiYiISExNNxmRmZmLz5s3w9fXF7du3ceLECQwYMMDsORMSErBw4UL4+/ujVatWOHPmDLy9vY3i7t+/j+XLl2P//v04dOiQQdmGDRug0+kwa9YsqQ6jRo1CkyZN8OWXX1r7comIiIhshk0niq1atcILL7wAIH+dQ09PT/Tr108qT0lJgZeXF5577jmsWbMGM2fOxIULF/D888+bPN/hw4fRtGlTvPDCC/jjjz+wY8cO7NmzB66uribj69Spg+DgYDz77LPo0KGDQZmHhwd+/fVX/P333/Dz88OLL76IZs2a4fTp06hbt24ZvQNEREREFUchhBAVXYmnXVpaGpydnZGamgonJ6eKrg4RERHJnKW5h023KBIRERFRxWGiSEREREQmMVEkIiIiIpOYKBIRERGRSUwUiYiIiMgkJopEREREZBITRSIiIiIySV3RFSBAv5RlWlpaBdeEiIiIngb6nKO45bSZKNqA9PR0AIC7u3sF14SIiIieJunp6XB2djZbzp1ZbIBOp0N8fDxq1KgBhUJRLtdIS0uDu7s7bt26xd1fKhjvhW3h/bAtvB+2g/fCtpT1/RBCID09HfXr14dSaX4kIlsUbYBSqUTDhg2fyLWcnJz4D95G8F7YFt4P28L7YTt4L2xLWd6PoloS9TiZhYiIiIhMYqJIRERERCYxUXxK2NvbY9asWbC3t6/oqjz1eC9sC++HbeH9sB28F7alou4HJ7MQERERkUlsUSQiIiIik5goEhEREZFJTBSJiIiIyCQmikRERERkEhPFp8D9+/cRGhoKPz8/tGzZEqNHj0ZSUlJFV0u20tLSMGHCBLi7u6NKlSrw8PDA9OnTkZWVZTL+3Llz6NOnD1q3bg0/Pz9ERERAq9U+4Vo/PYQQCA4ORpMmTUyW8348OdHR0ZgwYQL69u2LSZMm4dChQ0YxvB/lKzIyEgEBAWjRogWaNWuGHj164Pjx4yZjeS/KVmJiImbMmAF/f/8i40r6vu/YsQPt2rVDQEAAAgMDsWPHjtJVVJCsxcXFiWbNmokxY8YIjUYjNBqNGDZsmGjevLlITEys6OrJTl5enggMDBQARP369YWDg4MAIACIwMBAkZGRYRB/9OhRUaNGDbFhwwYhhBDJycnC19dXvP7660Kn01XES5C9JUuWCACicePGRmW8H0+GRqMRU6ZMES4uLmLr1q1m43g/ytd7770nGjZsKM6fPy8d+/LLL4VKpRK7du0yiOW9KDvJycli7ty5okGDBma/i/RK+r4vWbJE1KpVS5w7d04IIcRff/0lqlevLlauXGl1fZkoylyvXr3EM888IzIzM6VjDx48EFWrVhWDBw+uwJrJ06JFi0T37t1FTEyMECI/cVy4cKFQKBQCgJg9e7YUm5aWJlxdXUXv3r0NzrFv3z4BQKxateqJ1v1pcO7cOeHt7W3yy5n348nIzMwU3bt3F/Xq1RNXrlwxG8f7Ub4uXbokFAqFWLNmjVHZCy+8IJo1ayY95r0oW7m5uSIvL0/83//9X5GJYknf95MnTwqFQiEWLlxocPyDDz4QdnZ2Bn8QlAQTRRn7+eefBQAxfPhwo7I+ffoIAFZ/cMi0t956S2RlZRkdHzt2rAAgAgICpGMzZ84UAMT69esNYrVarahRo4ZwdXUVubm55V7np0VWVpZo1aqVOHXqlMkvZ96P8qfRaERISIhQq9Xit99+KzKW96N8bd68WQAQP/74o1HZoEGDRPXq1aXHvBflIzc3t8hEsaTve8eOHQUAcePGDYP43377TQAQ/fv3t6qeHKMoY9u2bQMAtGnTxqisbdu2AIBvvvnmidZJzoQQeOedd+Dg4GBUNnjwYABAbm6udMzc/VEqlXj++eeRkJCAgwcPlmONny6TJ0/GoEGDpM9+Ybwf5W/lypXYuXMn/v3vf+OFF14oMpb3o3w1aNAAALB69WqjsqtXr6JXr17SY96L8mFnZ1dkeUne9zt37uDEiRN45pln0LhxY4P4Vq1awd7eHrt27UJKSkqJ68lEUcb0H6DCHxoAaNq0KQDg119/faJ1kjOFQmE2CXF1dQUA+Pn5AQBiY2Nx+fJlALw/T8LevXvx999/44MPPjBZzvtR/pKSkjBnzhyo1WpMmTKlyFjej/LXoUMH+Pj4YM+ePZg7d650fPfu3Xjw4AGWLl0KgPeiopT0fT906BCEECZjq1SpgoYNG0Kj0eDMmTMlrgsTRZkSQiA2NhYAUL9+faNyZ2dnAPmzDqn86f/BDxs2DABw/fp1AED16tVRo0YNo3jen7KTkJCAyZMn45tvvoFSaforj/ej/G3btg3Jyclo3749fvnlFwwZMgQBAQHw9/fHxx9/jOzsbCmW96P8KZVKbN++Ha6urvjoo48wZswYHDt2DBs2bMDp06fh7u4OgPeiopT0fdfHm/p9byq+JJgoylRSUpI0fd7R0dGoXH/MmmZoKrlt27YhKCgIwcHBAPKXRQBM35uCx3l/Sm/kyJGIiIiQutpM4f0ofz/++CMAIDs7G+7u7ti4cSP++9//om3btpg1axZefvllaDQaALwfT0rz5s1x4sQJeHl5YfXq1ejZsydGjx4t9YAAvBcVpaTve3neJyaKMpWTkyP9v729vVG5/gu5SpUqT6xOT6tLly5h//79iIyMlI7p74+pewPw/pSVFStWoEmTJggJCSkyjvej/F26dAkA8PHHH6NTp05QKBRwdHTEF198AS8vL/zyyy9YtWoVAN6PJ+nBgwd4++23sWTJEmg0Grzyyiv4/PPPpXLei4pR0ve9PO8TE0WZ0jczA4ZJo15GRgYAoE6dOk+sTk8jrVaL0NBQREZGwtPTUzquvz+m7g3A+1MWoqKi8M0332DJkiXFxvJ+lL+7d+8CMO4aU6lUGDVqFABg+/btAHg/npSDBw8iLCwM7733HiZOnIjvv/8earUa48ePx7p16wDwXlSUkr7v5XmfmCjKlKOjo9TVdv/+faPyBw8eAIDZ3SmobISFheG1117DwIEDDY43a9YMQP590Ol0Rs/j/Sm9ZcuW4ffff0fVqlWhUCgMfgDg5s2b0mPej/JXrVo1AIBarTYq08+AjouLA8B/H09CfHw8BgwYgLFjx0r/Jvr27Ytt27ZBqVRi8uTJSEtL472oICV93/Xxpn7fm4ovCSaKMtapUycAQExMjFGZfuBr9+7dn2idniZffvkl1Go1Jk+ebFTm4eGBBg0aQKPRSJOOCuL9Kb26deuiWbNmJn+A/IRF/5j3o/zp3/fbt28blbm5uQEAatWqBYD/Pp6ENWvW4OHDh9JKDHqvvfYaxo0bh6SkJJw6dYr3ooKU9H3v3LkzANO/73NycnDnzh04Ojqiffv2Ja4LE0UZe+uttwAAp06dMir7888/AaDYsVtknc2bNyMqKgoRERFGZZmZmVAoFPjnP/8JwPj+aLVanD9/HvXq1UO7du2eSH3lKCIiApcuXTL5A+SvI6d/zPtR/vTfNUeOHDEqu3fvHgCga9euAMD78QQkJSUBANLT043K+vTpI5XxXlSMkr7vnp6eCAwMxM2bN6VhHnpnz56FTqdD7969rRtLatUy3VRpdOjQQdSrV0/k5ORIxxITE4W9vb0YMGBABdZMvr799lsxZswYk/twHj16VLz//vtCCCESEhJErVq1RL9+/Qxidu/eLQCIFStWPJH6Po1gYjcE3o/ylZqaKlxcXISrq6vBlqJCCDF9+nRRvXp1cevWLekY70f5+vHHHwUA8fHHHxuVrVy5Ujg4OIiEhAQhBO9FedFqtQKAaNiwocnykr7vBw8eFADE8uXLDY5PmjRJqFQq8ddff1lVTyaKMhcdHS1cXFxEWFiYEEKIjIwMERISIpo1aybu3btXwbWTn6+//lqoVCrh5eUlmjVrJv14enoKFxcXAUAcPnxYiv/hhx+EnZ2d+Omnn4QQQty8eVN4eHiIgQMHCq1WW1EvQ/ZMJYpC8H6Ut+PHjwt7e3vx+uuvS1tdHjhwQNSoUUN8//33RvG8H+Wrb9++wtHRUezZs0c6dubMGeHq6iq++OILg1jei7IXFRUlAAgHBwdx//59kzElfd8nTpwo6tWrJ65fvy6EEOLw4cPCwcHBKHksCSaKT4Ho6GgREhIifH19RatWrcTUqVNFSkpKRVdLdrZs2SIAFPnj5uZm9I/70KFDol27diIgIEC0adNGrFq1il+85cxcoigE70d5O336tOjatauoX7++8Pf3F7179xYnT540G8/7UX5yc3PFggULhI+Pj2jatKnw9fUV3bp1E/v37zcZz3tRdvz8/ES1atWk3w01a9YUffv2NRlb0vd9xYoVwtfXVwQEBIigoCCDxglrKIQQouQd1kREREQkd5zMQkREREQmMVEkIiIiIpOYKBIRERGRSUwUiYiIiMgkJopEREREZBITRSIiIiIyiYkiEREREZnERJGIiIiITGKiSEREREQmMVEkIgJw48YNfPjhh3B1dcWNGzee+PXXrVsHJycnHDp06IlfuzyMGjUKDRs2REJCwhO5nhAC+/fvx8svv4yRI0c+kWsSPQ3UFV0BIqL//e9/OHDgAD755BNkZ2fD29sbTk5OUrlGo8G1a9eQnJyMnJwcVKlSpUyvn5WVhX379mH9+vW4d+9emZ7bUgkJCUhPT0diYmKFXL+sxcXFITExEVlZWU/ker/++iv279+PvXv3YtiwYU/kmkRPA+71TEQ245VXXsFPP/2EQ4cOoXv37gZl2dnZ6N69O3788UfUqVOnXK4/ePBgbN26FdevX0eTJk3K5RoAMHPmTMydO9foeHx8POrXr19u132ScnNzkZaWVm73ypTMzEw4Ojpi2LBhWL9+/RO7LpGcseuZiGzGM888Y7bMwcEBEydORGZmZrld397evtzOrXf79m18/vnnJsvkkiQCQJUqVZ5okgjkf0aIqGyx65mIbIZCoSiyvH///hV6/dJKTk7Ga6+9huTk5HK9ztNKqWTbB1FZ478qIqoUli1bJv1/bGwsXFxcoFAooFAo4O7ujosXL0plzZo1g0KhQKdOnQDkj3EMDw9Hu3bt8OKLL6Jx48aYOnUqNBpNkdcMCgqCWq2GQqGQujLPnj2Lpk2bQqFQGHVPnz17Fr169UL37t3x3HPPoVOnTjh58iSA/HGQ//73vxEfHy+dOygoCNevX8fdu3cRHh6OJk2a4OjRowbn1Ol0WLZsGbp164Y2bdrAw8MDM2fOlMb+CSHw008/YeDAgahZsyauXr2KlStXYvDgwXjmmWcwdOhQ5ObmFvv+6nQ6LF26FK+99hpatmwJDw8PqeVTq9Xi8OHDGDVqFGrWrAmNRoMpU6agdu3aqFu3LmbOnImCo5guXLiA8ePHw9nZ2eAaiYmJeOONN9ClSxd4eHhAoVBg4MCBBjHZ2dn46KOP0K1bN/j6+sLb2xtLly6FVqs1qvP58+fRp08ftG3bFm3btsUnn3xi8rXFxcUhNDQUvXr1gpubG7p27YqzZ88W+54QEQBBRGQjhg0bJgCIQ4cOGRxPTEwU3bp1MziWmpoqfHx8BABx5swZg7LLly+LDh06CK1WK4QQYtq0acLR0VHcu3dPCCHE119/LQCIr776yuT1r1+/Lh2bPXu2ACDWrVsnHdPpdMLDw0M0btxYOnbnzh1Rq1YtMWXKFCGEEBkZGcLLy0vUr19f6HQ6o2sUtG7dOtGyZUsBQBw5csSgbNCgQaJ///4iNzdXCCHEwYMHhYODg+jSpYvIy8uT4kaPHi0AiHfeeUd6nVu2bBEAxKeffiqKM3r0aBEZGSk9njVrlgAgli1bJh48eCB+/fVXUbduXQFAzJgxQ2zfvl0cPXpUtG/fXgAQs2fPFkIIcf/+ffHFF1+IqlWrGr3O/v37i8WLF0uPP/nkEzFgwADpcV5ennjppZfEu+++K71n33zzjVAoFOKtt94yONeZM2dE9erVxX/+8x8hhBA5OTnilVdeEQDEsGHDpLg7d+6Idu3aiWvXrgkhhEhOThb+/v7C2dlZ3Lhxo9j3hehpx0SRiGyGPony8/MTnTt3Fp07dxaBgYHCwcHBICnTW79+vclEaMGCBWLXrl3S49atWwtvb2/p8YMHDwQA8fbbb5u8fsFEcd26dUaJohBCdO7c2aBOO3fuFADE1q1bpWP//ve/BQCRkJBgdI3CpkyZYpQofvfddwKAuHLlikFsWFiY0eueMWOGACCio6OlY8nJyQKA6Nu3r9H1Cjp+/Lho06aNwbG0tDQBQLi4uEhJW8eOHQUAceHCBSkuKSlJ1KpVSzg6Ooq0tDTp+AsvvGD0OqtXry7WrFkjPdbpdGLatGnS408++URUqVJFpKenGzxv8ODBAoD48ccfhRBCaDQa0bx5c9G/f3+DuJMnTxoliiNHjhQrVqwwiPvss88EACmpJyLz2PVMRDZnyZIlOHr0KI4ePYrTp0/jypUraNy4sVHcoEGDUKdOHaxatUo6ptPppPX09MLDw7FkyRLp8a1btwCgTJdu6dKlCyIiItC7d28AQEZGBpKSkiy+TtWqVY2OffXVV3BycoKnp6fB8aFDhwIA1q5dKx1TqVQG/wUgdf2mpqYWee3vv/8et27dkrrDg4KC8Oqrr6Jx48aoWrUqHjx4AODxGMCWLVtKz61Vqxb69++PjIwMnD59usjX07BhQ7z//vtYu3YttFotFAoF5s+fb/B6mzdvjurVqxf5evft24dLly6hT58+BnGBgYEGj4UQ+OGHH/D1118bvLYNGzagcePGFbYUElFlwsksRGTz3N3dMWDAAKPjDg4OGD16NBYsWIBffvkFXbt2xYEDB9CjRw+DiQ29e/eGVqvFpk2bsGvXLgQEBACAwbi60qpRowbCwsJw7do1zJgxA+np6cjIyLD4OqYm0vzxxx8m14xs3rw5HBwccPnyZYvOqdPpioy7evUqOnXqhO+++67Yepri6+sLAAaJl6nX8/XXX2PgwIEYNWoUIiIiMHv2bPzzn/8EAKSlpSE6OhrPP/+80fP8/f0BQHq9x48fB2A8S7zwZJb79+8jJSUFmzZtMvjDgYgsxxZFIqoU3n33XZPH3377bahUKmnixZo1azBq1CiDmL///htt2rRBbGwsvv32W4SFhZVLHefMmYOBAwdi3LhxWLt2LVq1alWq82VmZuLBgwdGk1EUCgWcnZ0NFiUvDa1Wi3Pnzln9fH3roaOjY5FxL730Ei5fvowPP/wQ8fHxGDJkCN566y0AkJY90k/2KahWrVoAIL1e/azx4iYj6SfAlOa1ET3tmCgSUaVy6tQpg67URo0a4dVXX8XOnTtx8uRJODg4wNXVVSrPzMxEjx494O3tjQ8//BBqdck6UvRducW1yi1fvhyzZ8/G5s2b4e3tXaJrmNOiRQsIIfDHH38YlWVlZaFt27Zlcp0mTZrg6tWr+Omnn4zKVq1ahZycHINjhVtIb9++DQAWJcbOzs4IDw/H33//jeeffx6bNm3C//73P7i6uqJOnTq4e/cu4uLiDJ6j77rXv143NzcAKLZFtW7duqhWrRq+/vprqXW34Gv47LPPiq0v0dOOiSIR2Yziumhzc3Px6aefGi27Mn78eGi1WvTr1w+hoaEGZRcuXEBcXBxcXFyMrlP4eqaO66919+5dg3okJiYatPTt378fAIq9jj7xtOTa+j2L161bZxAbGxuLtLQ0jB07Vjqmbz0z9R4W97727dsXADBkyBDs2bNHOn7w4EGcOHHCaCFy/ZhFvaNHj6Jjx44GywWZej2TJ0+W/r9Ro0b44osvAOS3ECoUCgwfPhw6nQ4bNmwwOP+FCxegVCoxevRoAPk7+ADAt99+azKB17c0qtVqvPLKK7hx4wZeffVVxMbGAshfguf999+Hu7t7ke8LEYHL4xCR7QgJCREAxPfff29UlpWVJYYMGSJmzZpl8rne3t7Cx8fH6HhCQoKws7MTNWvWFLt27RK7du0S//jHP4RSqRSBgYFi48aNIiYmRgjxeFZvwZnH8fHxws7OTjRu3Fj8/PPPYv/+/WLcuHGiZcuWQqlUigMHDohbt26Jd999VwAQQ4YMEadOnRKzZ88W3t7eAoBYvXq1+Prrr4UQQkyfPl2aWR0bGyvOnz8vhBDirbfeEgDE2rVrpWvn5eWJrl27CrVaLfbt2ycde/PNN42Wi3njjTdM1h2AaNq0qdBoNEW+9/379xcABABRt25d4erqKqpXry69N0Lkz/QGICZNmiTNhN6yZYtwdHSUXocQ+bOSn332WQFAWpZGCCFq1qwpNm3aJD1et26dqF+/vkhOThZC5M+0btGihXBychJ//PGHEEKIhw8fii5duoiZM2ca1HfkyJECgJgwYYL02nbs2CEAiMDAQJGeni40Go24du2aeOaZZwQAoVQqRePGjUW1atVEnz59inw/iCgfE0UiqnCnTp0SU6dOFSqVSgAQtWvXFp06dZKWyGnbtq2oWbOmACCioqJMnuPzzz83WgZFb82aNcLV1VW4ubmJ8ePHi9TUVNGtWzfh5uYmtm3bJoQQwt/fX0qUatasKcLDw6Xnb9y4Ubi5uQlnZ2cxbtw4kZaWJrp37y5efvllsWXLFpGVlSXu3bsnevToIRwdHUXbtm3FgQMHxKFDh0T16tVF3759pWQoISFB+Pn5iZYtW4qlS5cKnU4n+vfvL5RKpQAgqlatKt59913p2hkZGeKDDz4Q7u7uol27dqJ79+7i008/NVibMTg42KDuH330kVi3bp1wc3OTjjdr1swgaSssNzdXzJw5UzRs2FBUqVJFvPjii+K3334ziNEniosWLRJdu3YVzz//vOjatauU1AkhxL1796QEGY+W19mwYYMQQghHR0cBQDRq1Eh07txZ9O7d2+h+PnjwQIwdO1bUr19fdOzYUQQHB4uNGzca1Vej0YjZs2eL+vXri+bNm4thw4aJb7/9VlSrVk28/PLL4osvvhCZmZlCCCGuXLkiXnvtNeHo6Chq1qwpQkNDjZbgISLTFEKU4bQ/IiKSraCgIBw7dqxMZ4sTkW3jGEUiIiIiMomJIhERWUQ/caS4GeBEJB9MFImIqFharVZatiYmJqaCa0NETwoTRSIiKtL+/fvRqFEjXLt2DQDQvn17rkFI9JTgZBYiIiIiMoktikRERERkEhNFIiIiIjKJiSIRERERmcREkYiIiIhMYqJIRERERCYxUSQiIiIik5goEhEREZFJTBSJiIiIyCQmikRERERk0v8DADL16mRd+jsAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PPO\n",
    "\n",
    "# Step 1: pre-allocating, loading and previous steps\n",
    "\n",
    "seed = 42 # Fix the random seed\n",
    "\n",
    "random.seed(seed) # Seed the random library\n",
    "torch.manual_seed(seed) # Seed the pytorch library\n",
    "np.random.seed(int(seed)) # Seed the numpy library\n",
    "\n",
    "torch.backends.cudnn.deterministic = True # Set cuda parameters\n",
    "torch.backends.cudnn.benchmark = False    # Set cuda parameters\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") # Use GPU if available\n",
    "\n",
    "n_eval_episodes = 200 # Number of steps per evaluation episode\n",
    "N_timesteps = int(4000*200) # Number of steps (4000 episodes of 32 steps each)\n",
    "\n",
    "torch.set_num_threads(1) # Set pytorch num threads to 1 for faster training\n",
    "\n",
    "# Step 2: set the environment and the model hyperparameters\n",
    "\n",
    "our_env = gym.make('CartPole-v0') # Set environment \n",
    "\n",
    "# Hyperparameters chosen by optuna\n",
    "\n",
    "n_steps = 200                                                   # Steps per episode\n",
    "gamma = 1.0 - 0.00012343188973544484                            # Discount factor for RL\n",
    "learning_rate = 6.24161237241945e-05                            # Learning rate\n",
    "gae_lambda = 0.8714387482390391                                 # GAE exponential factor\n",
    "max_grad_norm = 4.042358248277151                               # Maximum gradient\n",
    "net_arch = {\"pi\": [100,100,100,100], \"vf\": [100,100,100,100]}   # Network architecture (actor and critic)\n",
    "activation_fn = nn.SELU                                         # Activation function\n",
    "\n",
    "# Hyperparameter dictionary\n",
    "\n",
    "DEFAULT_HYPERPARAMS = {\n",
    "\"policy\": \"MlpPolicy\",\n",
    "\"env\": our_env,\n",
    "\"device\": device\n",
    "}\n",
    "\n",
    "Hyperparams = {\n",
    "\"n_steps\": n_steps,\n",
    "\"gamma\": gamma,\n",
    "\"learning_rate\": learning_rate,\n",
    "\"max_grad_norm\": max_grad_norm,\n",
    "\"gae_lambda\": gae_lambda,\n",
    "\"batch_size\": n_steps,\n",
    "\"policy_kwargs\": {\n",
    "    \"net_arch\": net_arch,\n",
    "    \"activation_fn\": activation_fn,\n",
    "    }\n",
    "}\n",
    "\n",
    "kwargs = DEFAULT_HYPERPARAMS.copy() # Start the dictionary with the default ones\n",
    "kwargs.update(Hyperparams)          # Add the ones found by optuna \n",
    "\n",
    "# Step 3: train the model\n",
    "\n",
    "model = PPO(**kwargs) # Create the model, using the previous hyperparams\n",
    "\n",
    "model.learn(N_timesteps) # Train the model\n",
    "    \n",
    "model.env.close() # Close the env\n",
    "\n",
    "# Now we run a series of runs to see how well it could learn\n",
    "\n",
    "total_reward = np.zeros((100,))\n",
    "eval_rew = [] # Save the rewards for the current evaluation step\n",
    "        \n",
    "for n in range(100):\n",
    "            \n",
    "    eval_rew = [] # Save the rewards for the current evaluation step\n",
    "    state_ev = env.reset()[0]\n",
    "            \n",
    "    for arp in range(n_steps):\n",
    "                \n",
    "        state0_ev = state_ev # Starting state for this step\n",
    "        action_ev, _ = eps_greedy(state0_ev,q_net,0) # Obtain the action\n",
    "        state_ev, reward_ev, done_ev, _, _ = env.step(action_ev.item()) # Obtain the rewards and new state\n",
    "                \n",
    "        eval_rew.append(reward_ev)\n",
    "                                \n",
    "        if done_ev:\n",
    "                    \n",
    "            break\n",
    "                    \n",
    "    total_reward[n] = sum(eval_rew)\n",
    "    eval_rew = [] # Save the rewards for the current evaluation step\n",
    "            \n",
    "mean_reward = sum(total_reward)/10\n",
    "\n",
    "print(mean_reward)\n",
    "\n",
    "plt.rcParams['font.family'] = ['Times New Roman']\n",
    "fig,axs = plt.subplots(1,1,figsize=(7,5))\n",
    "axs.plot(total_reward)\n",
    "axs.set_ylabel('Steps without falling', fontsize = 15)\n",
    "axs.set_xlabel('Evaluation episode', fontsize = 15)\n",
    "axs.axhline(y=200,color='k',linestyle='--')\n",
    "axs.tick_params(axis='both', labelsize = 17)\n",
    "fig.savefig('DRL_PPO_1.png', format='png', dpi=600)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}