{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving Stock Trading Environment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Task:\n", "\n", "In this part, you need to apply a Q-learning agent that you implemented in Part 2.1 to learn the trends in stock price and perform a series of trades over a period of time to end up with a profit. You can modify your Q-learning code, if needed." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Collecting gymnasium\n", " Downloading gymnasium-0.29.1-py3-none-any.whl.metadata (10 kB)\n", "Requirement already satisfied: numpy>=1.21.0 in c:\\users\\91740\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.8_qbz5n2kfra8p0\\localcache\\local-packages\\python38\\site-packages (from gymnasium) (1.24.3)\n", "Requirement already satisfied: cloudpickle>=1.2.0 in c:\\users\\91740\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.8_qbz5n2kfra8p0\\localcache\\local-packages\\python38\\site-packages (from gymnasium) (3.0.0)\n", "Requirement already satisfied: typing-extensions>=4.3.0 in c:\\users\\91740\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.8_qbz5n2kfra8p0\\localcache\\local-packages\\python38\\site-packages (from gymnasium) (4.5.0)\n", "Collecting farama-notifications>=0.0.1 (from gymnasium)\n", " Downloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n", "Requirement already satisfied: importlib-metadata>=4.8.0 in c:\\users\\91740\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.8_qbz5n2kfra8p0\\localcache\\local-packages\\python38\\site-packages (from gymnasium) (6.9.0)\n", "Requirement already satisfied: zipp>=0.5 in c:\\users\\91740\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.8_qbz5n2kfra8p0\\localcache\\local-packages\\python38\\site-packages (from importlib-metadata>=4.8.0->gymnasium) (3.17.0)\n", "Downloading gymnasium-0.29.1-py3-none-any.whl (953 kB)\n", " ---------------------------------------- 0.0/953.9 kB ? eta -:--:--\n", " ---- ----------------------------------- 102.4/953.9 kB 2.0 MB/s eta 0:00:01\n", " ----------------------------- ---------- 696.3/953.9 kB 7.3 MB/s eta 0:00:01\n", " ---------------------------------------- 953.9/953.9 kB 8.6 MB/s eta 0:00:00\n", "Installing collected packages: farama-notifications, gymnasium\n", "Successfully installed farama-notifications-0.0.4 gymnasium-0.29.1\n" ] } ], "source": [ "!pip install gymnasium" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Imports\n", "import gymnasium\n", "from gymnasium import spaces\n", "import math\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Defining the Stock Trading Environment.\n", "\"\"\"DON'T MAKE ANY CHANGES TO THE ENVIRONMENT.\"\"\"\n", "\n", "\n", "class StockTradingEnvironment(gymnasium.Env):\n", " \"\"\"This class implements the Stock Trading environment.\"\"\"\n", "\n", " def __init__(self, file_path, train=True, number_of_days_to_consider=10):\n", " \"\"\"This method initializes the environment.\n", "\n", " :param file_path: - Path of the CSV file containing the historical stock data.\n", " :param train: - Boolean indicating whether the goal is to train or test the performance of the agent.\n", " :param number_of_days_to_consider = Integer representing the number of days the for which the agent\n", " considers the trend in stock price to make a decision.\"\"\"\n", "\n", " self.file_path = file_path\n", " self.stock_data = pd.read_csv(self.file_path)\n", " self.train = train\n", "\n", " # Splitting the data into train and test datasets.\n", " self.training_stock_data = self.stock_data.iloc[:int(0.8 * len(self.stock_data))]\n", " self.testing_stock_data = self.stock_data.iloc[int(0.8 * len(self.stock_data)):].reset_index()\n", "\n", " self.observation_space = spaces.Discrete(4)\n", " self.action_space = spaces.Discrete(3)\n", "\n", " self.investment_capital = 100000 # This defines the investment capital that the agent starts with.\n", " self.number_of_shares = 0 # This defines number of shares currently held by the agent.\n", " self.stock_value = 0 # This defines the value of the stock currently held by the agent.\n", " self.book_value = 0 # This defines the total value for which the agent bought the shares.\n", " # This defines the agent's total account value.\n", " self.total_account_value = self.investment_capital + self.stock_value\n", " # List to store the total account value over training or evaluation.\n", " self.total_account_value_list = []\n", " # This defines the number of days for which the agent considers the data before taking an action.\n", " self.number_of_days_to_consider = number_of_days_to_consider\n", " # The maximum timesteps the agent will take before the episode ends.\n", " if self.train:\n", " self.max_timesteps = len(self.training_stock_data) - self.number_of_days_to_consider\n", " else:\n", " self.max_timesteps = len(self.testing_stock_data) - self.number_of_days_to_consider\n", " # Initializing the number of steps taken to 0.\n", " self.timestep = 0\n", " self.reset()\n", "\n", " def reset(self):\n", " \"\"\"This method resets the environment and returns the observation.\n", "\n", " :returns observation: - Integer in the range of 0 to 3 representing the four possible observations that the\n", " agent can receive. The observation depends upon whether the price increased on average\n", " in the number of days the agent considers, and whether the agent already has the stock\n", " or not.\n", "\n", " info: - info: - A dictionary that can be used to provide additional implementation information.\"\"\"\n", "\n", " self.investment_capital = 100000 # This defines the investment capital that the agent starts with.\n", " self.number_of_shares = 0 # This defines number of shares currently held by the agent.\n", " self.stock_value = 0 # This defines the value of the stock currently held by the agent.\n", " self.book_value = 0 # This defines the total value for which the agent bought the shares.\n", " # This defines the agent's total account value.\n", " self.total_account_value = self.investment_capital + self.stock_value\n", " # List to store the total account value over training or evaluation.\n", " self.total_account_value_list = []\n", " # Initializing the number of steps taken to 0.\n", " self.timestep = 0\n", "\n", " # Getting the observation vector.\n", " if self.train:\n", " # If the task is to train the agent the maximum timesteps will be equal to the number of days considered\n", " # subtracted from the length of the training stock data.\n", " self.max_timesteps = len(self.training_stock_data) - self.number_of_days_to_consider\n", "\n", " # Calculating whether the price increased or decreased/remained the same on the majority of days the agent\n", " # considers.\n", " price_increase_list = []\n", " for i in range(self.number_of_days_to_consider):\n", " if self.training_stock_data['Close'][self.timestep + 1 + i] \\\n", " - self.training_stock_data['Close'][self.timestep + i] > 0:\n", " price_increase_list.append(1)\n", " else:\n", " price_increase_list.append(0)\n", "\n", " if (np.sum(price_increase_list) / self.number_of_days_to_consider) >= 0.5:\n", " price_increase = True\n", " else:\n", " price_increase = False\n", "\n", " stock_held = False\n", "\n", " # Observation vector that will be passed to the agent.\n", " observation = [price_increase, stock_held]\n", "\n", " else:\n", " # If the task is to evaluate the trained agent's performance the maximum timesteps will be equal to the\n", " # number of days considered subtracted from the length of the testing stock data.\n", " self.max_timesteps = len(self.testing_stock_data) - self.number_of_days_to_consider\n", "\n", " # Calculating whether the price increased or decreased/remained the same on the majority of days the agent\n", " # considers.\n", " price_increase_list = []\n", " for i in range(self.number_of_days_to_consider):\n", " if self.testing_stock_data['Close'][self.timestep + 1 + i] \\\n", " - self.testing_stock_data['Close'][self.timestep + i] > 0:\n", " price_increase_list.append(1)\n", " else:\n", " price_increase_list.append(0)\n", "\n", " if (np.sum(price_increase_list) / self.number_of_days_to_consider) >= 0.5:\n", " price_increase = True\n", " else:\n", " price_increase = False\n", "\n", " stock_held = False\n", "\n", " # Observation vector.\n", " observation = [price_increase, stock_held]\n", "\n", " if np.array_equal(observation, [True, False]):\n", " observation = 0\n", " if np.array_equal(observation, [True, True]):\n", " observation = 1\n", " if np.array_equal(observation, [False, False]):\n", " observation = 2\n", " if np.array_equal(observation, [False, True]):\n", " observation = 3\n", "\n", " info = None\n", "\n", " return observation, info\n", "\n", " def step(self, action):\n", " \"\"\"This method implements what happens when the agent takes the action to Buy/Sell/Hold.\n", "\n", " :param action: - Integer in the range 0 to 2 inclusive.\n", "\n", " :returns observation: - Integer in the range of 0 to 3 representing the four possible observations that the\n", " agent can receive. The observation depends upon whether the price increased on average\n", " in the number of days the agent considers, and whether the agent already has the stock\n", " or not.\n", " reward: - Integer/Float value that's used to measure the performance of the agent.\n", " terminated: - Boolean describing whether the episode has terminated.\n", " truncated: - Boolean describing whether a truncation condition outside the scope of the MDP is satisfied.\n", " info: - A dictionary that can be used to provide additional implementation information.\"\"\"\n", "\n", " # We give the agent a penalty for taking actions such as buying a stock when the agent doesn't have the\n", " # investment capital and selling a stock when the agent doesn't have any shares.\n", " penalty = 0\n", "\n", " if self.train:\n", " if action == 0: # Buy\n", " if self.number_of_shares > 0:\n", " penalty = -10\n", " # Determining the number of shares the agent can buy.\n", " number_of_shares_to_buy = math.floor(self.investment_capital / self.training_stock_data[\n", " 'Open'][self.timestep + self.number_of_days_to_consider])\n", " # Adding to the number of shares the agent has.\n", " self.number_of_shares += number_of_shares_to_buy\n", "\n", " # Computing the stock value, book value, investment capital and reward.\n", " if number_of_shares_to_buy > 0:\n", " self.stock_value +=\\\n", " self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * number_of_shares_to_buy\n", " self.book_value += \\\n", " self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider]\\\n", " * number_of_shares_to_buy\n", " self.investment_capital -= \\\n", " self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * number_of_shares_to_buy\n", "\n", " reward = 1 + penalty\n", "\n", " else:\n", " # Computing the stock value and reward.\n", " self.stock_value = \\\n", " self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", " reward = -10\n", "\n", " if action == 1: # Sell\n", " # Computing the investment capital, sell value and reward.\n", " self.investment_capital += \\\n", " self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", " sell_value = self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", "\n", " if self.book_value > 0:\n", " reward = (sell_value - self.book_value) / self.book_value * 100\n", " else:\n", " reward = -10\n", "\n", " self.number_of_shares = 0\n", " self.stock_value = 0\n", " self.book_value = 0\n", "\n", " if action == 2: # Hold\n", " # Computing the stock value and reward.\n", " self.stock_value = self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", "\n", " if self.book_value > 0:\n", " reward = (self.stock_value - self.book_value) / self.book_value * 100\n", " else:\n", " reward = -1\n", "\n", " else:\n", " if action == 0: # Buy\n", " if self.number_of_shares > 0:\n", " penalty = -10\n", " # Determining the number of shares the agent can buy.\n", " number_of_shares_to_buy = math.floor(self.investment_capital / self.testing_stock_data[\n", " 'Open'][self.timestep + self.number_of_days_to_consider])\n", " # Adding to the number of shares the agent has.\n", " self.number_of_shares += number_of_shares_to_buy\n", "\n", " # Computing the stock value, book value, investment capital and reward.\n", " if number_of_shares_to_buy > 0:\n", " self.stock_value += \\\n", " self.testing_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * number_of_shares_to_buy\n", " self.book_value += \\\n", " self.testing_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * number_of_shares_to_buy\n", " self.investment_capital -= \\\n", " self.testing_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * number_of_shares_to_buy\n", "\n", " reward = 1 + penalty\n", "\n", " else:\n", " # Computing the stock value and reward.\n", " self.stock_value = self.training_stock_data['Open'][\n", " self.timestep + self.number_of_days_to_consider] * self.number_of_shares\n", " reward = -10\n", "\n", " if action == 1: # Sell\n", " # Computing the investment capital, sell value and reward.\n", " self.investment_capital += \\\n", " self.testing_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", " sell_value = self.training_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", "\n", " if self.book_value > 0:\n", " reward = (sell_value - self.book_value) / self.book_value * 100\n", " else:\n", " reward = -10\n", "\n", " self.number_of_shares = 0\n", " self.stock_value = 0\n", " self.book_value = 0\n", "\n", " if action == 2: # Hold\n", " # Computing the stock value and reward.\n", " self.stock_value = self.testing_stock_data['Open'][self.timestep + self.number_of_days_to_consider] \\\n", " * self.number_of_shares\n", "\n", " if self.book_value > 0:\n", " reward = (self.stock_value - self.book_value) / self.book_value * 100\n", " else:\n", " reward = -1\n", "\n", " # Determining if the agent currently has shares of the stock or not.\n", " if self.number_of_shares > 0:\n", " stock_held = True\n", " else:\n", " stock_held = False\n", "\n", " # Getting the observation vector.\n", " if self.train:\n", " # If the task is to train the agent the maximum timesteps will be equal to the number of days considered\n", " # subtracted from the length of the training stock data.\n", " self.max_timesteps = len(self.training_stock_data) - self.number_of_days_to_consider\n", "\n", " # Calculating whether the price increased or decreased/remained the same on the majority of days the agent\n", " # considers.\n", " price_increase_list = []\n", " for i in range(self.number_of_days_to_consider):\n", " if self.training_stock_data['Close'][self.timestep + 1 + i] \\\n", " - self.training_stock_data['Close'][self.timestep + i] > 0:\n", " price_increase_list.append(1)\n", " else:\n", " price_increase_list.append(0)\n", "\n", " if (np.sum(price_increase_list) / self.number_of_days_to_consider) >= 0.5:\n", " price_increase = True\n", " else:\n", " price_increase = False\n", "\n", " # Observation vector.\n", " observation = [price_increase, stock_held]\n", "\n", " else:\n", " # If the task is to evaluate the trained agent's performance the maximum timesteps will be equal to the\n", " # number of days considered subtracted from the length of the testing stock data.\n", " self.max_timesteps = len(self.testing_stock_data) - self.number_of_days_to_consider\n", "\n", " # Calculating whether the price increased or decreased/remained the same on the majority of days the agent\n", " # considers.\n", " price_increase_list = []\n", " for i in range(self.number_of_days_to_consider):\n", " if self.testing_stock_data['Close'][self.timestep + 1 + i] \\\n", " - self.testing_stock_data['Close'][self.timestep + i] > 0:\n", " price_increase_list.append(1)\n", " else:\n", " price_increase_list.append(0)\n", "\n", " if (np.sum(price_increase_list) / self.number_of_days_to_consider) >= 0.5:\n", " price_increase = True\n", " else:\n", " price_increase = False\n", "\n", " # Observation vector.\n", " observation = [price_increase, stock_held]\n", "\n", " self.timestep += 1 # Increasing the number of steps taken by the agent by 1.\n", "\n", " if np.array_equal(observation, [True, False]):\n", " observation = 0\n", " if np.array_equal(observation, [True, True]):\n", " observation = 1\n", " if np.array_equal(observation, [False, False]):\n", " observation = 2\n", " if np.array_equal(observation, [False, True]):\n", " observation = 3\n", "\n", " # Computing the total account value.\n", " self.total_account_value = self.investment_capital + self.stock_value\n", " # Appending the total account value of the list to plot the graph.\n", " self.total_account_value_list.append(self.total_account_value)\n", "\n", " # The episode terminates when the maximum timesteps have been reached.\n", " terminated = True if (self.timestep >= self.max_timesteps) \\\n", " else False\n", " truncated = False\n", " info = {}\n", "\n", " return observation, reward, terminated, truncated, info\n", "\n", " def render(self, mode='human'):\n", " \"\"\"This method renders the agent's total account value over time.\n", "\n", " :param mode: 'human' renders to the current display or terminal and returns nothing.\"\"\"\n", "\n", " plt.figure(figsize=(15, 10))\n", " plt.plot(self.total_account_value_list, color='lightseagreen', linewidth=7)\n", " plt.xlabel('Days', fontsize=32)\n", " plt.ylabel('Total Account Value', fontsize=32)\n", " plt.title('Total Account Value over Time', fontsize=38)\n", " plt.grid()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# NOTE: You can adjust the parameter 'number_of_days_to_consider'\n", "\n", "stock_trading_environment = StockTradingEnvironment('./NVDA.csv', number_of_days_to_consider=10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TO DO: Implement the Q-learning algorithm" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Episode: 100\n", "Q-table:\n", "[[-31.9870633 -45.21306394 -33.6876846 ]\n", " [-43.67929859 -31.7151073 -30.71695686]\n", " [-35.98883942 -45.79807296 -39.08467538]\n", " [-47.06896287 -37.21875512 -44.15799499]]\n", "Episode: 100, Average Steps: 393.0\n", "Episode: 200\n", "Q-table:\n", "[[ -7.62066169 -24.03188748 -15.63259724]\n", " [-16.20563075 -10.24756123 -5.39984911]\n", " [-11.85278059 -23.86119667 -17.43063706]\n", " [-26.39002031 -16.91664432 -18.96436319]]\n", "Episode: 200, Average Steps: 393.0\n", "Episode: 300\n", "Q-table:\n", "[[23.23773896 9.09745082 18.37994456]\n", " [16.55430359 22.40055806 20.83510445]\n", " [17.50066 9.44095086 16.94126495]\n", " [ 8.2563531 12.8550612 11.73434525]]\n", "Episode: 300, Average Steps: 393.0\n", "Episode: 400\n", "Q-table:\n", "[[35.90912455 26.9478593 34.71061233]\n", " [32.29476023 35.5972779 37.87727299]\n", " [34.09220202 25.54207272 33.17681459]\n", " [29.49038201 30.89597686 27.94076596]]\n", "Episode: 400, Average Steps: 393.0\n", "Episode: 500\n", "Q-table:\n", "[[48.87745046 34.98088636 37.44049201]\n", " [41.28592311 40.48186918 56.54628247]\n", " [41.91415908 36.37441269 39.83752962]\n", " [33.82050046 38.11170565 34.8711785 ]]\n", "Episode: 500, Average Steps: 393.0\n", "Episode: 600\n", "Q-table:\n", "[[70.901666 43.64459009 44.96120982]\n", " [66.21101586 49.0542815 93.17261381]\n", " [63.49342404 45.01777383 45.70131045]\n", " [42.91684727 59.46765211 45.24892439]]\n", "Episode: 600, Average Steps: 393.0\n", "Episode: 700\n", "Q-table:\n", "[[ 74.84913329 55.85816451 59.96850504]\n", " [ 71.81514381 74.06187399 106.92720973]\n", " [ 72.87514803 65.23659396 67.57537063]\n", " [ 59.82928054 66.97379157 57.34758479]]\n", "Episode: 700, Average Steps: 393.0\n", "Episode: 800\n", "Q-table:\n", "[[76.30600579 63.52837319 69.83605264]\n", " [75.35968193 77.32949941 97.30942059]\n", " [75.5447407 71.32861778 71.97481335]\n", " [71.71038687 71.33739567 68.5588378 ]]\n", "Episode: 800, Average Steps: 393.0\n", "Episode: 900\n", "Q-table:\n", "[[103.92791151 67.07048527 76.08217103]\n", " [ 76.18724995 70.95258913 127.21916697]\n", " [ 95.59063961 69.27653577 71.40325607]\n", " [ 69.60826118 89.67670273 65.86689108]]\n", "Episode: 900, Average Steps: 393.0\n", "Episode: 1000\n", "Q-table:\n", "[[102.40411788 51.4634794 49.58764138]\n", " [ 71.87467015 80.86263528 128.50987777]\n", " [ 95.98307075 53.39134049 59.36989047]\n", " [ 44.96809622 90.07853591 55.54965608]]\n", "Episode: 1000, Average Steps: 393.0\n" ] } ], "source": [ "epsilon = 1.0 # Initial exploration rate\n", "epsilon_min = 0.01 # Minimum exploration rate\n", "gamma = 0.95 # Discount factor\n", "alpha = 0.15 # Learning rate\n", "decay_rate = 0.995 # Epsilon decay rate per episode\n", "total_episodes = 1000\n", "max_timestamp = 10\n", "\n", "# Initialize Q-table with zeros\n", "qt = np.zeros((stock_trading_environment.observation_space.n, stock_trading_environment.action_space.n))\n", "\n", "# Lists to store rewards, epsilon values, steps per episode, and penalties per episode\n", "rewards_epi = []\n", "epsilon_values = []\n", "steps_per_episode = []\n", "penalties_per_episode = []\n", "\n", "# Training loop over episodes\n", "for episode in range(total_episodes):\n", " # Reset the environment for a new episode\n", " state, _ = stock_trading_environment.reset()\n", " state_index = state # Assuming the state is directly usable as an index\n", " total_rewards = 0\n", " total_steps = 0\n", "\n", " # Choose an action using epsilon-greedy strategy\n", " action = stock_trading_environment.action_space.sample() if np.random.uniform(0, 1) < epsilon else np.argmax(qt[state_index])\n", "\n", " while True:\n", " # Take a step in the environment\n", " next_state, reward, terminated, truncated, _ = stock_trading_environment.step(action)\n", " total_steps += 1\n", " next_strt_idx = next_state # Assuming the state is directly usable as an index\n", "\n", " # Choose the next action using epsilon-greedy strategy\n", " next_action = stock_trading_environment.action_space.sample() if np.random.uniform(0, 1) < epsilon else np.argmax(qt[next_strt_idx])\n", "\n", " # Update Q-table using the Q-learning update rule\n", " qt[state_index, action] = qt[state_index, action] + alpha * (reward + gamma * qt[next_strt_idx, next_action] - qt[state_index, action])\n", "\n", " # Move to the next state and action\n", " state_index, action = next_strt_idx, next_action\n", " total_rewards += reward\n", "\n", " # Check if the episode is terminated or truncated\n", " if terminated or truncated:\n", " break\n", "\n", " # Q-table update for every 100 episodes\n", " if (episode + 1) % 100 == 0:\n", " print(f\"Episode: {episode + 1}\")\n", " print(\"Q-table:\")\n", " print(qt)\n", "\n", " # Update epsilon using the decay rate\n", " epsilon = max(epsilon_min, epsilon * decay_rate)\n", " epsilon_values.append(epsilon)\n", " rewards_epi.append(total_rewards)\n", " steps_per_episode.append(total_steps)\n", "\n", " # Print average steps for every 100 episodes\n", " if (episode + 1) % 100 == 0:\n", " average_steps = np.mean(steps_per_episode[-100:])\n", " print(f\"Episode: {episode + 1}, Average Steps: {average_steps}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Step 2:\n", "Save the Q-table/Policy table as a pickle file or h5 of the trained model and attach it to your assignment submission." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pickle\n", "with open(\"charviku_assignment1_q_table_stock_price.pkl\", 'wb') as file:\n", " pickle.dump(qt, file)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. Show and discuss the results after applying the Q-learning algorithm to solve the stock trading problem. Plots should include epsilon decay and total reward per episode.\n", "\n", "2. Provide the evaluation results. Evaluate your trained agent’s performance (you will have to set the train parameter set to False), by only choosing greedy actions from the learnt policy. Plot should include the agent’s account value over time. Code for generating this plot is provided in the environment’s render method. Just call environment.render after termination." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAIjCAYAAAB/OVoZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5yElEQVR4nO3dd3gUVd/G8XvTC4RQkwChiFRpAoIICEjHBwSxIdIUeChRJCqCSrOFIogIgqiABaRYsNFC9UGQXqVKVSR0CBBI23n/mDcLSwImkGR2k+/nuubK7Ozs7G83x3LnnDnHZhiGIQAAAAAAYDkPqwsAAAAAAAAmQjoAAAAAAC6CkA4AAAAAgIsgpAMAAAAA4CII6QAAAAAAuAhCOgAAAAAALoKQDgAAAACAiyCkAwAAAADgIgjpAAAAAAC4CEI6ACBHadSokRo1auR4fPjwYdlsNs2YMcOympBzlSpVSt26dcvW9xw+fLhsNlu2vicAIPsQ0gEAWWLGjBmy2Ww33X7//XerS8xy3bp1c/rMefLk0V133aXHHntM3377rex2u9Ul5iqNGjW6aXusUKGC1eUBACBJ8rK6AABAzvbmm2+qdOnSqY7ffffdWfJ+S5YsyZLr3i5fX199+umnkqQrV67oyJEj+umnn/TYY4+pUaNG+uGHHxQUFGRxlblH8eLFFRUVlep4vnz5but6e/fulYcHfR4AgMxDSAcAZKlWrVqpVq1a2fZ+Pj4+2fZe6eHl5aVnnnnG6djbb7+tkSNHavDgwerZs6fmzJljUXU5i91uV0JCgvz8/G56Tr58+VL9Pu6Er69vpl0LAACJ4e4AAIul3DP+3nvv6f3331fJkiXl7++vhg0baufOnU7nxsTEqHv37ipevLh8fX0VFhamRx55RIcPH3acc+M96TezfPlyNWjQQIGBgQoODtYjjzyi3bt3O52Tcu/vn3/+qW7duik4OFj58uVT9+7dFRcXd0efe9CgQWrevLnmzZunffv2OT23cOFCR2158+bVww8/rD/++CPVNfbs2aMnnnhChQsXlr+/v8qXL6/XX3/d8fyRI0fUt29flS9fXv7+/ipYsKAef/xxp+/r4MGDstlsev/991Ndf82aNbLZbPr6669v+VlOnjyp5557TiEhIfLz81O1atX0+eefO55PTExUgQIF1L1791SvjY2NlZ+fn15++WXHsfj4eA0bNkx33323fH19FR4eroEDByo+Pt7ptTabTREREZo5c6buuece+fr6atGiRbesNT1Sfu8p329QUJAKFiyo/v376+rVq07n3nhPemJiokaMGKGyZcvKz89PBQsWVP369RUdHe30uvS0P0lavXq17rvvPvn5+alMmTL6+OOPb1r3V199pZo1a8rf318FChTQU089pb/++svpnP3796tDhw4KDQ2Vn5+fihcvrqeeekoXLly4jW8KAJAV6EkHAGSpCxcu6PTp007HbDabChYs6HTsiy++0MWLF9WvXz9dvXpVH3zwgR566CHt2LFDISEhkqQOHTrojz/+0PPPP69SpUrp5MmTio6O1tGjR1WqVKl017R06VK1atVKd911l4YPH64rV67oww8/VL169bR58+ZU13riiSdUunRpRUVFafPmzfr0009VpEgRjRo16ra+kxSdO3fWkiVLFB0drXLlykmSvvzyS3Xt2lUtWrTQqFGjFBcXp8mTJ6t+/frasmWLo7bt27erQYMG8vb2Vq9evVSqVCkdOHBAP/30k9555x1J0oYNG7RmzRo99dRTKl68uA4fPqzJkyerUaNG2rVrlwICAnTXXXepXr16mjlzpgYMGOBU38yZM5U3b1498sgjN/0MV65cUaNGjfTnn38qIiJCpUuX1rx589StWzedP39e/fv3l7e3t9q3b6/vvvtOH3/8sdNoh/nz5ys+Pl5PPfWUJLM3vG3btlq9erV69eqlihUraseOHXr//fe1b98+zZ8/3+n9ly9frrlz5yoiIkKFChX613aQnJycqj1Kkr+/vwIDA52OPfHEEypVqpSioqL0+++/a8KECTp37py++OKLm15/+PDhioqKUo8ePVS7dm3FxsZq48aN2rx5s5o1ayYp/e1vx44dat68uQoXLqzhw4crKSlJw4YNc/zzcL133nlHQ4YM0RNPPKEePXro1KlT+vDDD/Xggw9qy5YtCg4OVkJCglq0aKH4+Hg9//zzCg0N1bFjx/Tzzz/r/Pnztz3kHwCQyQwAALLA9OnTDUlpbr6+vo7zDh06ZEgy/P39jb///ttxfN26dYYkY8CAAYZhGMa5c+cMScaYMWNu+b4NGzY0GjZsmOr606dPdxyrXr26UaRIEePMmTOOY9u2bTM8PDyMLl26OI4NGzbMkGQ8++yzTu/Rvn17o2DBgv/6HXTt2tUIDAy86fNbtmxx+owXL140goODjZ49ezqdFxMTY+TLl8/p+IMPPmjkzZvXOHLkiNO5drvdsR8XF5fqPdeuXWtIMr744gvHsY8//tiQZOzevdtxLCEhwShUqJDRtWvXW37G8ePHG5KMr776yum1devWNfLkyWPExsYahmEYixcvNiQZP/30k9PrW7dubdx1112Ox19++aXh4eFh/O9//3M6b8qUKYYk47fffnMck2R4eHgYf/zxxy1rTNGwYcObtsn//ve/jvNSfu9t27Z1en3fvn0NSca2bdscx0qWLOn0HVWrVs14+OGHb1lHettfu3btDD8/P6ff8a5duwxPT0/j+v+FO3z4sOHp6Wm88847Tu+zY8cOw8vLy3E8pb3NmzfvlvUBAKzFcHcAQJaaNGmSoqOjnbaFCxemOq9du3YqVqyY43Ht2rVVp04dLViwQJLZ0+nj46OVK1fq3Llzt13P8ePHtXXrVnXr1k0FChRwHK9ataqaNWvmeL/r9e7d2+lxgwYNdObMGcXGxt52HZKUJ08eSdLFixclSdHR0Tp//rw6duyo06dPOzZPT0/VqVNHK1askCSdOnVKv/76q5599lmVKFHC6ZrXL83l7+/v2E9MTNSZM2d09913Kzg4WJs3b3Y898QTT8jPz08zZ850HFu8eLFOnz79r/dvL1iwQKGhoerYsaPjmLe3t1544QVdunRJq1atkiQ99NBDKlSokNP99+fOnVN0dLSefPJJx7F58+apYsWKqlChgtN38NBDD0mS4ztI0bBhQ1WqVOmWNV6vVKlSqdpjdHS0XnzxxVTn9uvXz+nx888/7/jMNxMcHKw//vhD+/fvT/P59La/5ORkLV68WO3atXP6HVesWFEtWrRwuuZ3330nu92uJ554wuk7Cw0NVdmyZR3fWUpP+eLFi+/4dg0AQNZhuDsAIEvVrl07XRPHlS1bNtWxcuXKae7cuZLMCbpGjRqll156SSEhIbr//vv1n//8R126dFFoaGi66zly5IgkqXz58qmeq1ixohYvXqzLly87DX2+MQjnz59fkhky72Rm9kuXLkmS8ubNK0mOYJcSSG+U8l4HDx6UJFWuXPmW179y5YqioqI0ffp0HTt2TIZhOJ67/h7k4OBgtWnTRrNmzdJbb70lyRzqXqxYsZvWkuLIkSMqW7ZsqhnOK1as6HheMifQ69Chg2bNmqX4+Hj5+vrqu+++U2JiolNI379/v3bv3q3ChQun+X4nT550epzWygG3EhgYqKZNm6br3BvbZJkyZeTh4eF0T/+N3nzzTT3yyCMqV66cKleurJYtW6pz586qWrWqpPS3v4sXL+rKlStp/nNRvnx5pz8U7N+/X4ZhpHmuZP7RRDK/q8jISI0bN04zZ85UgwYN1LZtWz3zzDMMdQcAF0JIBwC4jRdffFFt2rTR/PnztXjxYg0ZMkRRUVFavny57r333ix7X09PzzSPXx96b0fKxHgpy9GlrJv+5ZdfpvmHBy+vjP1n+/nnn9f06dP14osvqm7dusqXL59sNpueeuqpVGu0d+nSRfPmzdOaNWtUpUoV/fjjj+rbt2+mLi/21FNP6eOPP9bChQvVrl07zZ07VxUqVFC1atUc59jtdlWpUkXjxo1L8xrh4eFOj68fLZDVrh+lcDMPPvigDhw4oB9++EFLlizRp59+qvfff19TpkxRjx49sqQuu90um82mhQsXptlWU0ZsSNLYsWPVrVs3R30vvPCC45774sWLZ0l9AICMIaQDAFxCWsOD9+3bl2oisDJlyuill17SSy+9pP3796t69eoaO3asvvrqq3S9T8mSJSWZ61vfaM+ePSpUqFCqCcSyypdffimbzeaYUKxMmTKSpCJFityyt/euu+6SpFSz39/om2++UdeuXTV27FjHsatXr+r8+fOpzm3ZsqUKFy6smTNnqk6dOoqLi1Pnzp3/9TOULFlS27dvl91udwr0e/bscTyf4sEHH1RYWJjmzJmj+vXra/ny5U6z0Uvmd7Bt2zY1adIkXaE4K+3fv9+pp/7PP/+U3W7/18npUmay7969uy5duqQHH3xQw4cPV48ePdLd/vz8/OTv75/mPxc3vrZMmTIyDEOlS5d2TEB4K1WqVFGVKlX0xhtvaM2aNapXr56mTJmit99++19fCwDIetyTDgBwCfPnz9exY8ccj9evX69169apVatWkqS4uLhUy1+VKVNGefPmTbU0162EhYWpevXq+vzzz53C6s6dO7VkyRK1bt36zj5IOo0cOVJLlizRk08+6Rim3KJFCwUFBendd99VYmJiqtecOnVKklS4cGE9+OCDmjZtmo4ePep0zvW9+56enql6+z/88EMlJyenuraXl5c6duyouXPnasaMGapSpYpjiPattG7dWjExMU73miclJenDDz9Unjx51LBhQ8dxDw8PPfbYY/rpp5/05ZdfKikpyWmou2TeH3/s2DF98sknqd7rypUrunz58r/WlFkmTZrk9PjDDz+UJEebTMuZM2ecHufJk0d33323o42mt/15enqqRYsWmj9/vtPvePfu3Vq8eLHTezz66KPy9PTUiBEjUv2+DcNw1BQbG6ukpCSn56tUqSIPD48M/TMEAMha9KQDALLUwoULHb2q13vggQccPcKSOeS7fv366tOnj+Lj4zV+/HgVLFhQAwcOlGT2qjdp0kRPPPGEKlWqJC8vL33//fc6ceKEY/mu9BozZoxatWqlunXr6rnnnnMsgZUvXz4NHz78jj7vjZKSkhy9/FevXtWRI0f0448/avv27WrcuLGmTp3qODcoKEiTJ09W586dVaNGDT311FMqXLiwjh49ql9++UX16tXTxIkTJUkTJkxQ/fr1VaNGDfXq1UulS5fW4cOH9csvv2jr1q2SpP/85z/68ssvlS9fPlWqVElr167V0qVLUy1/l6JLly6aMGGCVqxYke7l5Xr16qWPP/5Y3bp106ZNm1SqVCl98803+u233zR+/HjH/fYpnnzySX344YcaNmyYqlSp4rh3PUXnzp01d+5c9e7dWytWrFC9evWUnJysPXv2aO7cuVq8eHG65ji4mQsXLtx01MWNk+QdOnRIbdu2VcuWLbV27Vp99dVXevrpp52G59+oUqVKatSokWrWrKkCBQpo48aN+uabbxQREeE4J73tb8SIEVq0aJEaNGigvn37Ov74cc8992j79u2O88qUKaO3335bgwcP1uHDh9WuXTvlzZtXhw4d0vfff69evXrp5Zdf1vLlyxUREaHHH39c5cqVU1JSkr788kt5enqqQ4cOt/mNAgAynXUTywMAcrJbLcGm65ZES1kibcyYMcbYsWON8PBww9fX12jQoIHTUlenT582+vXrZ1SoUMEIDAw08uXLZ9SpU8eYO3eu0/umZwk2wzCMpUuXGvXq1TP8/f2NoKAgo02bNsauXbuczklZiuvUqVNpfrZDhw7d8jvo2rWr02cOCAgwSpUqZXTo0MH45ptvjOTk5DRft2LFCqNFixZGvnz5DD8/P6NMmTJGt27djI0bNzqdt3PnTqN9+/ZGcHCw4efnZ5QvX94YMmSI4/lz584Z3bt3NwoVKmTkyZPHaNGihbFnz55Uy4Zd75577jE8PDyclsP7NydOnHC8j4+Pj1GlSpVU33cKu91uhIeHG5KMt99+O81zEhISjFGjRhn33HOP4evra+TPn9+oWbOmMWLECOPChQuO8yQZ/fr1S3edt1qC7fr/JUr5ve/atct47LHHjLx58xr58+c3IiIijCtXrjhd88bv8u233zZq165tBAcHG/7+/kaFChWMd955x0hISHB6XXran2EYxqpVq4yaNWsaPj4+xl133WVMmTLFUd+Nvv32W6N+/fpGYGCgERgYaFSoUMHo16+fsXfvXsMwDOPgwYPGs88+a5QpU8bw8/MzChQoYDRu3NhYunRpur9DAEDWsxnGHc56AwDAHTh8+LBKly6tMWPG6OWXX7a6nFzv3nvvVYECBbRs2TKrS7HM8OHDNWLECJ06dUqFChWyuhwAQC7DPekAAECStHHjRm3dulVdunSxuhQAAHIt7kkHACCX27lzpzZt2qSxY8cqLCws1WRuAAAg+9CTDgBALvfNN9+oe/fuSkxM1Ndffy0/Pz+rSwIAINfinnQAAAAAAFwEPekAAAAAALgIQjoAAAAAAC4i100cZ7fb9c8//yhv3ryy2WxWlwMAAAAAyOEMw9DFixdVtGhReXjcuq8814X0f/75R+Hh4VaXAQAAAADIZf766y8VL178lufkupCeN29eSeaXExQUZHE1t5aYmKglS5aoefPm8vb2trocIBXaKFwdbRSujjYKd0A7hatzhzYaGxur8PBwRx69lVwX0lOGuAcFBblFSA8ICFBQUJDLNjbkbrRRuDraKFwdbRTugHYKV+dObTQ9t1wzcRwAAAAAAC6CkA4AAAAAgIsgpAMAAAAA4CJy3T3pAAAAAHA9wzCUlJSk5ORkq0vBbUhMTJSXl5euXr1q6e/Q29tbnp6ed3wdQjoAAACAXCshIUHHjx9XXFyc1aXgNhmGodDQUP3111/pmpgtq9hsNhUvXlx58uS5o+sQ0gEAAADkSna7XYcOHZKnp6eKFi0qHx8fS0Mebo/dbtelS5eUJ08eeXhYc0e3YRg6deqU/v77b5UtW/aOetQJ6QAAAABypYSEBNntdoWHhysgIMDqcnCb7Ha7EhIS5OfnZ1lIl6TChQvr8OHDSkxMvKOQzsRxAAAAAHI1K4Mdco7MGoVBawQAAAAAwEUQ0gEAAAAAcBGEdAAAAABAKjabTfPnz5ckHT58WDabTVu3brW0ptyAkA4AAAAAbqZbt26y2WyptpYtW2baexw/flytWrXKtOulx/Dhwx2fxcvLS4UKFdKDDz6o8ePHKz4+PltrsYqlIf3XX39VmzZtVLRoUae/0tzKypUrVaNGDfn6+uruu+/WjBkzsrxOAAAAAHA1LVu21PHjx522r7/+OtOuHxoaKl9f30y7Xnrdc889On78uI4ePaoVK1bo8ccfV1RUlB544AFdvHgx2+vJbpaG9MuXL6tatWqaNGlSus4/dOiQHn74YTVu3Fhbt27Viy++qB49emjx4sVZXCkAAACA3MAwpMuXrdkMI2O1+vr6KjQ01GnLnz+/43mbzabJkyerVatW8vf311133aVvvvnG8XxCQoIiIiIUFhYmPz8/lSxZUlFRUU6vv1VH6qpVq1S7dm35+voqLCxMgwYNUlJSkuP5Ro0a6YUXXtDAgQNVoEABhYaGavjw4f/6uby8vBQaGqqiRYuqSpUqev7557Vq1Srt3LlTo0aNcpwXHx+vl19+WeHh4SpWrJjq1q2rlStXOl3rt99+U6NGjRQQEKD8+fOrRYsWOnfunCRp0aJFql+/voKDg1WwYEH95z//0YEDBxyvfeihhxQREeF0vVOnTsnHx0fLli37189xuywN6a1atdLbb7+t9u3bp+v8KVOmqHTp0ho7dqwqVqyoiIgIPfbYY3r//fezuFIAAAAAuUFcnJQnjzVbXFzmf54hQ4aoQ4cO2rZtmzp16qSnnnpKu3fvliRNmDBBP/74o+bOnau9e/dq5syZKlWqVLque+zYMbVu3Vr33Xeftm3bpsmTJ+uzzz7T22+/7XTe559/rsDAQK1bt06jR4/Wm2++qejo6Ax/jgoVKqhVq1b67rvvHMciIiK0du1azZo1S6tXr9Zjjz2mli1bav/+/ZKkrVu3qkmTJqpUqZLWrl2r1atXq02bNkpOTpZkdhpHRkZq48aNWrZsmTw8PNS+fXvZ7XZJUo8ePTRr1iynYfZfffWVihUrpoceeijDnyG9vLLsyllg7dq1atq0qdOxFi1a6MUXX7zpa+Lj452+1NjYWElSYmKiEhMTs6TOzJJSn6vXidyLNgpXRxuFq6ONwh3k5HaamJgowzBkt9sdwcz8YU1fpllH+s41DEM///yz8uTJ43R88ODBGjx4sOPxY489pmeffVaSNGLECEVHR2vChAmaNGmSjhw5orJly+qBBx6QzWZTeHi4ow7nmq7/fsz9SZMmKTw8XBMmTJDNZlO5cuV07NgxDRo0SG+88YZj7fmqVatqyJAhkqQyZcpo4sSJWrp0qZo0aXLTz3VjDSnKly+vJUuWyG636+jRo5o+fboOHz6ssLAwXbx4UZGRkVq8eLGmTZumd955R6NGjVKtWrU0ceJExzUqVqzouP6NncWffvqpQkJCtHPnTlWuXFnt2rVTRESEvv/+ez3xxBOSpBkzZqhr164yDMNR6/XflWEYSkxMlKenp9NzGfnnx61CekxMjEJCQpyOhYSEKDY2VleuXJG/v3+q10RFRWnEiBGpji9ZskQBAQFZVuudunrVU6tXF1P58nlu6y9NQHaijcLV0Ubh6mijcAc5sZ2mDKu+dOmSEhISJJlDzv/+25p6kpKk/+9T/FeJiYlq0KCBxo4d63Q8f/78jo5JSapevbrT4xo1amjHjh2KjY3VY489pvbt26t8+fJq0qSJWrRokaqH+MqVK4qNjdWlS5ckmb3PsbGx2rFjh2rWrOl0j3jVqlV16dIl7d69W+Hh4UpKSlKFChWc3r9QoUI6duyY07HrxcfHKzk5Oc3nr169KpvNptjYWK1bt07JycmqUKFCqtcHBQUpNjZWW7Zs0SOPPHLT9zpw4IDeffddbdq0SWfPnnX8YWDPnj0qUaKEJOmJJ57Qp59+qpYtW2rbtm3auXOnvvzyyzSvmZCQoCtXrujXX391GvYvSXEZGCbhViH9dgwePFiRkZGOx7GxsQoPD1fz5s0VFBRkYWW31r27p2bO9FDLlof07bch8vb2trokIJXExERFR0erWbNmtFG4JNooXB1tFO4gJ7fTq1ev6q+//lKePHnk5+fnOJ4vn4VFpZO3t7eCgoJUvXr1W57n5+fnlHt8fHzk5eWloKAgNWjQQAcPHtTChQu1bNkyPfvss2rSpInmzZvnON/f319BQUGOHvvAwEAFBQXJy8vLUUOKlHPy5s3rOCfl/Ovr9vT0vGkW8/X1venzBw8eVOnSpRUUFCS73S5PT09t2LBBHh4eunz5sgIDA2Wz2ZQnTx4FBQUpMDBQvr6+N32vTp06qUSJEvrkk09UtGhR2e12Va1a1fH9SFKfPn1Uo0YNxcbGat68eWrcuLEqV66c5vWuXr0qf39/Pfjgg07tSdJN/1CQFrcK6aGhoTpx4oTTsRMnTigoKCjNXnTJ/CWnNSOht7e3S/9L5tlnpZkzpZUrw3X1qqGAANetFXD1f54A2ihcHW0U7iAnttPk5GTZbDZ5eHg4hme7i5Rlyv6t7vXr16tbt26Ox+vWrdO9997reF1wcLA6duyojh076vHHH1fLli11/vx5FShQQJIc303K+Sn7lSpV0rfffuuoQzJvT86bN69KlCjhOP/GGv+t7pRr3fj8nj17tHjxYg0ePFgeHh6qWbOmkpOTdfr0adWrV0+xsbEKCgpyel3VqlW1fPlyvfnmm6ne58yZM9q7d68++eQTNWjQQJK0evVqp88oSdWqVVOtWrX02Wef6euvv9bEiRNvWruHh4dsNlua/6xk5J8dtwrpdevW1YIFC5yORUdHq27duhZVlHUaN5bKljW0f7+X5sxJUp8+VlcEAAAAwJXEx8crJibG6VjK2uIp5s2bp1q1aql+/fqaOXOm1q9fr88++0ySNG7cOIWFhTlC+7x58xQaGqrg4OB/fe++fftq/Pjxev755xUREaG9e/dq2LBhioyMvOM/eCQlJSkmJkZ2u11nzpzRypUr9fbbb6t69ep65ZVXJEnlypVTp06d1KVLF40ZM0Zly5bVlStXtGLFClWtWlUPP/ywBg8erCpVqqhv377q3bu3fHx8HEu6FShQQAULFtTUqVMVFhamo0ePatCgQWnW06NHD0VERCgwMDDdk57fCUv/XHTp0iVt3bpVW7dulWQusbZ161YdPXpUkjlUvUuXLo7ze/furYMHD2rgwIHas2ePPvroI82dO1cDBgywovwsZbNJPXua90RMneqZ4eUYAAAAAORsixYtUlhYmNNWv359p3NGjBih2bNnq2rVqvriiy/09ddfq1KlSpLMYemjR49WrVq1dN999+nw4cNasGBBukJ2sWLFtGDBAq1fv17VqlVT79699dxzz+mNN96448/1xx9/KCwsTCVKlFCjRo00d+5cDR48WP/73/+cJsqbPn26unTpoldeeUX33XefHn30UW3YsMFxP3m5cuW0ZMkSbdu2TbVr11bdunX1ww8/yMvLSx4eHpo9e7Y2bdqkypUra8CAARozZkya9XTs2FFeXl7q2LFjqmHsWcFm3DglXTZauXKlGjdunOp4165dNWPGDHXr1k2HDx92Wutu5cqVGjBggHbt2qXixYtryJAhTsM3/k1sbKzy5cunCxcuuPQ96ZIUE5OoEiU8lJjoqfXrpfvus7oiwFliYqIWLFig1q1b57jhb8gZaKNwdbRRuIOc3E6vXr2qQ4cOqXTp0tkSvrKbzWbT999/r3bt2lldSpay2+1pDnfPLIcPH1aZMmW0YcMG1ahR46bn3ao9ZSSHWjrcvVGjRqmmrb/ejBkz0nzNli1bsrAq11GwoFSv3j9auTJcU6YQ0gEAAAAguyQmJurMmTN64403dP/9998yoGcm95odIRdq2fKQJOnrr6Xz562tBQAAAAByi99++01hYWHasGGDpkyZkm3v61YTx+VG5cuf0z33GPrjD5u+/FJ6/nmrKwIAAADgDiy8szlH+LeR31mFnnQXZ7NJvXqZE8hNmSImkAMAAACAHIyQ7gaeftqugABp1y7p/5fuAwAAAJBJ6HFGZsisdkRIdwP58klPP23uZ+OtEAAAAECOljJbfVxcnMWVICdISEiQJHl6et7Rdbgn3U307i19+qn0zTfS+PFS4cJWVwQAAAC4N09PTwUHB+vkyZOSpICAANlsNourQkbZ7XYlJCTo6tWrWbIEW3prOHXqlAICAuTldWcxm5DuJmrWlGrVkjZulGbMkF55xeqKAAAAAPcXGhoqSY6gDvdjGIauXLkif39/S//I4uHhoRIlStxxDYR0N9K7t9Sjh/Txx9JLL0kW/ZEIAAAAyDFsNpvCwsJUpEgRJSYmWl0ObkNiYqJ+/fVXPfjgg45bGKzg4+OTKT35hHQ38tRTUmSkdOCAtGyZ1KyZ1RUBAAAAOYOnp+cd30sMa3h6eiopKUl+fn6WhvTMQl+sGwkMlLp0MfeZQA4AAAAAch5Cupv573/Nnz/8IP3zj7W1AAAAAAAyFyHdzVSuLNWvLyUnS598YnU1AAAAAIDMREh3Q337mj+nTJH+fyk+AAAAAEAOQEh3Qx06SKGhUkyM9P33VlcDAAAAAMgshHQ35ONz7d70iROtrQUAAAAAkHkI6W6qVy/Jy0tavVrautXqagAAAAAAmYGQ7qaKFjWHvUvSpEnW1gIAAAAAyByEdDcWEWH+nDlTOnvW2loAAAAAAHeOkO7G6tWTqleXrlyRpk2zuhoAAAAAwJ0ipLsxm+1ab/pHH5lrpwMAAAAA3Bch3c117Cjlzy8dOiQtXGh1NQAAAACAO0FId3MBAdJzz5n7LMcGAAAAAO6NkJ4D9OljDn1fvFjat8/qagAAAAAAt4uQngPcdZf0n/+Y+x99ZG0tAAAAAIDbR0jPIVImkJs+Xbp0ydpaAAAAAAC3h5CeQzRtKpUrJ8XGSl9+aXU1AAAAAIDbQUjPITw8pH79zP2JEyXDsLYeAAAAAEDGEdJzkK5dpcBAadcuadkyq6sBAAAAAGQUIT0HyZdP6t7d3B8/3tJSAAAAAAC3gZCew/Tvby7H9ssv0t69VlcDAAAAAMgIQnoOc/fdUps25v6ECdbWAgAAAADIGEJ6DvTii+bPGTOks2etrAQAAAAAkBGE9ByoUSOpWjUpLk765BOrqwEAAAAApBchPQey2a71pk+cKCUmWloOAAAAACCdCOk5VMeOUpEi0t9/S99+a3U1AAAAAID0IKTnUL6+Ut++5j7LsQEAAACAeyCk52B9+kg+PtK6ddLatVZXAwAAAAD4N4T0HKxIEalTJ3P//fetrQUAAAAA8O8I6TlcygRy334rHTliaSkAAAAAgH9BSM/hqlaVHnpIstvNmd4BAAAAAK6LkJ4LDBhg/vzkE+nSJWtrAQAAAADcHCE9F2jdWipbVrpwQZoxw+pqAAAAAAA3Q0jPBTw8pP79zf3x46XkZEvLAQAAAADcBCE9l+jWTcqfXzpwQJo/3+pqAAAAAABpIaTnEoGBUt++5v6YMZJhWFsPAAAAACA1Qnou8vzzkq+vtG6dtHq11dUAAAAAAG5ESM9FQkKkLl3M/TFjrK0FAAAAAJAaIT2XeeklyWaTfvpJ2r3b6moAAAAAANcjpOcy5ctLjzxi7r/3nrW1AAAAAACcEdJzoVdeMX9+9ZV0/Li1tQAAAAAAriGk50IPPGBuCQnShAlWVwMAAAAASEFIz6UGDjR/Tp4sXbxobS0AAAAAABMhPZdq08a8P/3CBenTT62uBgAAAAAgEdJzLQ8Pc6Z3SXr/fSkx0dp6AAAAAACE9Fytc2dz7fS//pLmzLG6GgAAAAAAIT0X8/OTnn/e3B8zRjIMa+sBAAAAgNyOkJ7L9ekjBQZK27dL0dFWVwMAAAAAuRshPZcrUEDq0cPcHzXK2loAAAAAILcjpEORkZKXl7R8ubRundXVAAAAAEDuRUiHSpQwJ5GTpHfftbYWAAAAAMjNCOmQJL36qmSzST/+KO3YYXU1AAAAAJA7EdIhSSpfXnrsMXN/5EhrawEAAACA3IqQDofBg82fs2dLBw5YWwsAAAAA5EaEdDjce6/UqpVkt0ujR1tdDQAAAADkPoR0OHntNfPnjBnSsWOWlgIAAAAAuQ4hHU7q15caNJASEqRx46yuBgAAAAByF0I6UknpTZ8yRTpzxtpaAAAAACA3IaQjlRYtzPvT4+KkCROsrgYAAAAAcg9COlKx2a71pk+YIF28aG09AAAAAJBbENKRpvbtzbXTz583h70DAAAAALIeIR1p8vSUBg0y98eOla5etbYeAAAAAMgNCOm4qU6dpBIlpBMnpM8+s7oaAAAAAMj5COm4KW9vaeBAc3/kSCk+3tp6AAAAACCnI6Tjlp57TipaVPr7b2n6dKurAQAAAICczfKQPmnSJJUqVUp+fn6qU6eO1q9ff8vzx48fr/Lly8vf31/h4eEaMGCArnLDdJbx87t2b3pUlJSQYG09AAAAAJCTWRrS58yZo8jISA0bNkybN29WtWrV1KJFC508eTLN82fNmqVBgwZp2LBh2r17tz777DPNmTNHr6WsF4Ys0bOnFBYmHT0qzZhhdTUAAAAAkHNZGtLHjRunnj17qnv37qpUqZKmTJmigIAATZs2Lc3z16xZo3r16unpp59WqVKl1Lx5c3Xs2PFfe99xZ/z8pFdfNffffZfedAAAAADIKl5WvXFCQoI2bdqkwYMHO455eHioadOmWrt2bZqveeCBB/TVV19p/fr1ql27tg4ePKgFCxaoc+fON32f+Ph4xV8341lsbKwkKTExUYmJiZn0abJGSn2uUGf37tLIkV46csSm6dOT9OyzhtUlwQW4UhsF0kIbhaujjcId0E7h6tyhjWakNstC+unTp5WcnKyQkBCn4yEhIdqzZ0+ar3n66ad1+vRp1a9fX4ZhKCkpSb17977lcPeoqCiNGDEi1fElS5YoICDgzj5ENomOjra6BElS69Z3adq0Kho6NF6FCi2TlxdBHSZXaaPAzdBG4epoo3AHtFO4Olduo3Fxcek+17KQfjtWrlypd999Vx999JHq1KmjP//8U/3799dbb72lIUOGpPmawYMHKzIy0vE4NjZW4eHhat68uYKCgrKr9NuSmJio6OhoNWvWTN7e3laXo0aNpF9+MXTiRKDOnm2tbt0I6bmdq7VR4Ea0Ubg62ijcAe0Urs4d2mjKiO70sCykFypUSJ6enjpx4oTT8RMnTig0NDTN1wwZMkSdO3dWjx49JElVqlTR5cuX1atXL73++uvy8Eh9i72vr698fX1THff29nbZX+CNXKXWfPmkV16RXn7ZHPrerZu5ljrgKm0UuBnaKFwdbRTugHYKV+fKbTQjdVk2cZyPj49q1qypZcuWOY7Z7XYtW7ZMdevWTfM1cXFxqYK4p6enJMkw6NXNDr17S4ULSwcPSjNnWl0NAAAAAOQsls7uHhkZqU8++USff/65du/erT59+ujy5cvq3r27JKlLly5OE8u1adNGkydP1uzZs3Xo0CFFR0dryJAhatOmjSOsI2sFBpq96ZL09ttSUpK19QAAAABATmLpPelPPvmkTp06paFDhyomJkbVq1fXokWLHJPJHT161Knn/I033pDNZtMbb7yhY8eOqXDhwmrTpo3eeecdqz5CrtS3rzR6tHTggDRrltSli9UVAQAAAEDOYPnEcREREYqIiEjzuZUrVzo99vLy0rBhwzRs2LBsqAw3Exho3pc+aJDZm/7005KX5S0JAAAAANyfpcPd4b769ZMKFpT27zd70wEAAAAAd46QjtuSJ480cKC5P3y4lJhoaTkAAAAAkCMQ0nHbIiKkkBDp0CFp2jSrqwEAAAAA90dIx20LCJBef93cf+st6epVa+sBAAAAAHdHSMcd6dVLCg+Xjh2TPv7Y6moAAAAAwL0R0nFHfH2lIUPM/XfflS5ftrYeAAAAAHBnhHTcsW7dpDJlpJMnpYkTra4GAAAAANwXIR13zNvbnOFdkkaNki5csLQcAAAAAHBbhHRkio4dpYoVpXPnpPfft7oaAAAAAHBPhHRkCk9P6c03zf1x46QzZ6ytBwAAAADcESEdmebRR6Xq1aWLF6UxY6yuBgAAAADcDyEdmcbDQ3r7bXN/wgQpJsbaegAAAADA3RDSkalat5buv1+6ckWKirK6GgAAAABwL4R0ZCqb7Vpv+pQp0pEj1tYDAAAAAO6EkI5M99BDUpMmUkKCNHSo1dUAAAAAgPsgpCPT2WzSyJHm/pdfStu3W1sPAAAAALgLQjqyRK1a0hNPSIYhvfaa1dUAAAAAgHsgpCPLvP225OUl/fKLtGqV1dUAAAAAgOsjpCPLlC0r9exp7r/6qtmrDgAAAAC4OUI6stTQoVJAgLRunTR/vtXVAAAAAIBrI6QjS4WGSpGR5v7gwVJSkrX1AAAAAIArI6Qjy73yilSwoLR3rzR9utXVAAAAAIDrIqQjywUFSW+8Ye4PGybFxVlbDwAAAAC4KkI6skWfPlLJktLx49KECVZXAwAAAACuiZCObOHray7JJkkjR0pnzlhbDwAAAAC4IkI6ss3TT0tVq0oXLkjvvmt1NQAAAADgegjpyDYeHmYvuiRNnCgdPGhtPQAAAADgagjpyFYtW0pNm0oJCdKgQVZXAwAAAACuhZCObGWzSe+9Z/6cN09as8bqigAAAADAdRDSke2qVZO6dzf3X3pJMgxr6wEAAAAAV0FIhyXeeksKDJR+/12aO9fqagAAAADANRDSYYmiRaWBA839QYOkq1etrQcAAAAAXAEhHZZ56SUzrB8+LE2YYHU1AAAAAGA9QjosExgovfOOuf/OO9KpU9bWAwAAAABWI6TDUl26SPfeK8XGSiNGWF0NAAAAAFiLkA5LeXhIY8ea+1OmSHv2WFsPAAAAAFiJkA7LNW4stWkjJSdLr7xidTUAAAAAYB1COlzC6NGSp6f088/SsmVWVwMAAAAA1iCkwyVUqCD16WPuv/iilJRkaTkAAAAAYAlCOlzG8OFS/vzSzp3Sxx9bXQ0AAAAAZD9COlxGwYLSW2+Z+0OGSGfOWFsPAAAAAGQ3Qjpcyn//K1WpIp07Jw0danU1AAAAAJC9COlwKV5e0gcfmPtTpkjbt1tbDwAAAABkJ0I6XE7jxtJjj0l2u9S/v2QYVlcEAAAAANmDkA6X9N57kp+ftHKl9O23VlcDAAAAANmDkA6XVLKkNHCguf/yy9KVK9bWAwAAAADZgZAOl/Xqq1J4uHTkiDRmjNXVAAAAAEDWI6TDZQUEXAvnI0dKR49aWw8AAAAAZDVCOlzaE09IDz5oDndPGf4OAAAAADkVIR0uzWYzl2Tz8JDmzJFWrbK6IgAAAADIOoR0uLzq1aX//tfc79dPSky0tBwAAAAAyDKEdLiFt9+WChWS/vjD7FkHAAAAgJyIkA63UKDAtUnkhg+X/v7b0nIAAAAAIEsQ0uE2unSR6tWTLl+WIiOtrgYAAAAAMh8hHW7Dw0P66CPJ01OaN09assTqigAAAAAgcxHS4VaqVpWef97cj4iQ4uOtrQcAAAAAMhMhHW5nxAgpLEzav//afeoAAAAAkBMQ0uF2goKkcePM/XfekQ4dsrYeAAAAAMgshHS4pSeflB56SLp6Verf3+pqAAAAACBzENLhlmw2adIkydtb+ukn6ccfra4IAAAAAO4cIR1uq0IF6aWXzP0XXjCXZgMAAAAAd0ZIh1t74w2pRAnpyBFzQjkAAAAAcGeEdLi1wEBp8mRzf9w4acsWa+sBAAAAgDtBSIfba91aeuIJKTlZ6tXL/AkAAAAA7oiQjhzhgw+kfPmkjRuliROtrgYAAAAAbg8hHTlCaKg0erS5//rr0tGj1tYDAAAAALeDkI4co0cPqV49c5b3fv0kw7C6IgAAAADIGEI6cgwPD2nqVHPt9J9/lr791uqKAAAAACBjCOnIUSpVkgYNMveff146f97ScgAAAAAgQwjpyHFee00qV06KiZEGD7a6GgAAAABIP0I6chw/P+njj839KVOk336zth4AAAAASC9COnKkRo2kZ58193v2lOLjLS0HAAAAANKFkI4ca8wYKSRE2r1beustq6sBAAAAgH9HSEeOVaCA9NFH5v7IkdKWLdbWAwAAAAD/xvKQPmnSJJUqVUp+fn6qU6eO1q9ff8vzz58/r379+iksLEy+vr4qV66cFixYkE3Vwt08+qj0+ONScrLUvbuUkGB1RQAAAABwc7cV0s+fP69PP/1UgwcP1tmzZyVJmzdv1rFjxzJ0nTlz5igyMlLDhg3T5s2bVa1aNbVo0UInT55M8/yEhAQ1a9ZMhw8f1jfffKO9e/fqk08+UbFixW7nYyCX+PBDqWBBads2adQoq6sBAAAAgJvLcEjfvn27ypUrp1GjRum9997T+f9fiPq7777T4AyudzVu3Dj17NlT3bt3V6VKlTRlyhQFBARo2rRpaZ4/bdo0nT17VvPnz1e9evVUqlQpNWzYUNWqVcvox0AuEhIiTZhg7r/1lrRzp7X1AAAAAMDNeGX0BZGRkerWrZtGjx6tvHnzOo63bt1aTz/9dLqvk5CQoE2bNjkFew8PDzVt2lRr165N8zU//vij6tatq379+umHH35Q4cKF9fTTT+vVV1+Vp6dnmq+Jj49X/HVTe8fGxkqSEhMTlZiYmO56rZBSn6vX6Q4ee0yaNctTv/zioe7d7fr112R5Zbj140a0Ubg62ihcHW0U7oB2ClfnDm00I7VlOKZs2LBBH6csQn2dYsWKKSYmJt3XOX36tJKTkxUSEuJ0PCQkRHv27EnzNQcPHtTy5cvVqVMnLViwQH/++af69u2rxMREDRs2LM3XREVFacSIEamOL1myRAEBAemu10rR0dFWl5AjdOjgpxUrHtLGjd7q02e32rf/0+qScgzaKFwdbRSujjYKd0A7hatz5TYaFxeX7nMzHNJ9fX0dvdHX27dvnwoXLpzRy2WI3W5XkSJFNHXqVHl6eqpmzZo6duyYxowZc9OQPnjwYEVGRjoex8bGKjw8XM2bN1dQUFCW1nunEhMTFR0drWbNmsnb29vqcnKE5GSbevaUZs+upJdfLqfy5a2uyL3RRuHqaKNwdbRRuAPaKVydO7TRtDL0zWQ4pLdt21Zvvvmm5s6dK0my2Ww6evSoXn31VXXo0CHd1ylUqJA8PT114sQJp+MnTpxQaGhomq8JCwuTt7e309D2ihUrKiYmRgkJCfLx8Un1Gl9fX/n6+qY67u3t7bK/wBu5U62u7rnnpHnzpCVLbOrd21u//ip5WL7GgfujjcLV0Ubh6mijcAe0U7g6V26jGakrw/Fk7NixunTpkooUKaIrV66oYcOGuvvuu5U3b16988476b6Oj4+PatasqWXLljmO2e12LVu2THXr1k3zNfXq1dOff/4pu93uOLZv3z6FhYWlGdCBG9ls0tSpUp480m+/mTO/AwAAAICryHBIz5cvn6Kjo/XTTz9pwoQJioiI0IIFC7Rq1SoFBgZm6FqRkZH65JNP9Pnnn2v37t3q06ePLl++rO7du0uSunTp4jSxXJ8+fXT27Fn1799f+/bt0y+//KJ3331X/fr1y+jHQC5WsqQ0Zoy5P2iQtHevtfUAAAAAQIrbnt+6fv36ql+//h29+ZNPPqlTp05p6NChiomJUfXq1bVo0SLHZHJHjx6Vx3VjkcPDw7V48WINGDBAVatWVbFixdS/f3+9+uqrd1QHcp///lf67jspOlrq0sXsVWe2dwAAAABWy3AsefPNN2/5/NChQzN0vYiICEVERKT53MqVK1Mdq1u3rn7//fcMvQdwI5tNmjZNqlxZWr9eGjVKev11q6sCAAAAkNtlOKR///33To8TExN16NAheXl5qUyZMhkO6YBVihc370nv0kUaMUJ6+GGpenWrqwIAAACQm2U4pG/ZsiXVsdjYWHXr1k3t27fPlKKA7PLMM9L335tb587Sxo1SGosBAAAAAEC2yJTFp4KCgjRixAgNGTIkMy4HZBubTfr4Y6lwYWnnTmnYMKsrAgAAAJCbZdoK0RcuXNCFCxcy63JAtilc2FyWTZJGjzYnkQMAAAAAK2R4uPuECROcHhuGoePHj+vLL79Uq1atMq0wIDu1a2fem/7FF1LXrtLWreZa6gAAAACQnTIc0t9//32nxx4eHipcuLC6du3qtKY54G4++EBavlw6cEAaOFD66COrKwIAAACQ22Q4pB86dCgr6gAsFxwsTZ8uNWsmTZ4sPfKI1KKF1VUBAAAAyE0y7Z50ICdo2lSKiDD3u3WTTp2ytBwAAAAAuUy6etIfffTRdF/wu+++u+1iAFcwerQ57H3XLum556QffjBngQcAAACArJaukJ4vX76srgNwGf7+0qxZUu3a0k8/mUu09e5tdVUAAAAAcoN0hfTp06dndR2AS6lWTRo5UoqMNLeGDaWKFa2uCgAAAEBOxz3pwE30729OInflivT001J8vNUVAQAAAMjpMjy7uyR98803mjt3ro4ePaqEhASn5zZv3pwphQFW8/CQZsyQqlY1100fMsS8Xx0AAAAAskqGe9InTJig7t27KyQkRFu2bFHt2rVVsGBBHTx4UK1atcqKGgHLFC0qffaZuT9mjLRsmbX1AAAAAMjZMhzSP/roI02dOlUffvihfHx8NHDgQEVHR+uFF17QhQsXsqJGwFKPPCL997/mfpcu0pkz1tYDAAAAIOfKcEg/evSoHnjgAUmSv7+/Ll68KEnq3Lmzvv7668ytDnARY8dK5ctL//wj9ewpGYbVFQEAAADIiTIc0kNDQ3X27FlJUokSJfT7779Lkg4dOiSD5IIcKjDQXJbN21v6/ntzWTYAAAAAyGwZDukPPfSQfvzxR0lS9+7dNWDAADVr1kxPPvmk2rdvn+kFAq6iRg0pKsrcf/FFaft2S8sBAAAAkAOle3b3n3/+Wa1bt9bUqVNlt9slSf369VPBggW1Zs0atW3bVv9NuXEXyKEGDJBWrJB++UV64glp40YpTx6rqwIAAACQU6S7J71du3YKDw/XkCFDdOTIEcfxp556ShMmTNDzzz8vHx+fLCkScBUpy7IVKybt3Sv162d1RQAAAAByknSH9EOHDum///2vZs+erXLlyqlhw4b68ssvdeXKlaysD3A5hQpJX39tBvYvvpA+/9zqigAAAADkFOkO6eHh4Ro6dKgOHDigpUuXqlSpUurTp4/CwsLUu3dvbdiwISvrBFxKgwbSiBHmft++0p491tYDAAAAIGfI8MRxktS4cWN9/vnnOn78uMaMGaMdO3bo/vvvV7Vq1TK7PsBlDR4sNWkixcWZ96czqAQAAADAnbqtkJ4ib968atKkiRo3bqzg4GDt2rUrs+oCXJ6np/TVV1KRItKOHVJkpNUVAQAAAHB3txXSr1y5oi+++EKNGjVS2bJlNXv2bEVGRurw4cOZXB7g2kJDzaBus0lTpkhz51pdEQAAAAB3lqGQ/vvvv6tXr16O+9CLFy+upUuX6s8//9Trr7+uYsWKZVWdgMtq1swc+i5JPXpI+/ZZWw8AAAAA95XuddIrVaqkvXv36t5771VUVJSefvpp5cuXLytrA9zGiBHS//5nbo89Jv3+uxQQYHVVAAAAANxNukN606ZN9fXXXzM5HJAGLy9pzhzp3nvN+9N79zaXZrPZrK4MAAAAgDtJ93D3CRMmENCBWwgLM4O6p6f05ZfS1KlWVwQAAADA3dzR7O4AnDVsKL37rrn/wgvSxo3W1gMAAADAvRDSgUz2yitSu3ZSQoJ5f/qZM1ZXBAAAAMBdENKBTGazSdOnS2XKSEeOSJ07S3a71VUBAAAAcAeEdCALBAdL334r+flJCxdeGwIPAAAAALeS7tndr7ds2TItW7ZMJ0+elP2GLsJp06ZlSmGAu6tWTZo8WereXRo6VKpTx1xTHQAAAABuJsM96SNGjFDz5s21bNkynT59WufOnXPaAFzTrZvUo4dkGNJTT0mHDlldEQAAAABXluGe9ClTpmjGjBnq3LlzVtQD5Dgffiht2yZt2CC1by/99psUGGh1VQAAAABcUYZ70hMSEvTAAw9kRS1AjuTnJ333nVSkiBnWn3vO7FkHAAAAgBtlOKT36NFDs2bNyopagByreHHpm28kLy9pzhzpvfesrggAAACAK8rwcPerV69q6tSpWrp0qapWrSpvb2+n58eNG5dpxQE5SYMG0oQJUt++0qBB5sRyzZtbXRUAAAAAV5LhkL59+3ZVr15dkrRz506n52w2W6YUBeRUvXtLmzZJn31mTiS3YYO5njoAAAAASLcR0lesWJEVdQC5gs0mTZok/fGH9PvvUrt20tq1Up48VlcGAAAAwBVk+J706/3999/6+++/M6sWIFfw9ZW+/VYKDZV27jTXUWciOQAAAADSbYR0u92uN998U/ny5VPJkiVVsmRJBQcH66233pLdbs+KGoEcp2hRM6h7e5sTyr3zjtUVAQAAAHAFGQ7pr7/+uiZOnKiRI0dqy5Yt2rJli9599119+OGHGjJkSFbUCORIDzwgffSRuT9kiBnaAQAAAORuGb4n/fPPP9enn36qtm3bOo5VrVpVxYoVU9++ffUOXYJAuvXoYd6fPn681LmzVLq0VKOG1VUBAAAAsEqGe9LPnj2rChUqpDpeoUIFnT17NlOKAnKTMWOkli2lK1ektm2lf/6xuiIAAAAAVslwSK9WrZomTpyY6vjEiRNVrVq1TCkKyE28vKTZs6WKFaVjx6RHHpHi4qyuCgAAAIAVMjzcffTo0Xr44Ye1dOlS1a1bV5K0du1a/fXXX1qwYEGmFwjkBvnyST/9JNWpI23caM74Pnu2uWQbAAAAgNwjwz3pDRs21L59+9S+fXudP39e58+f16OPPqq9e/eqQYMGWVEjkCuUKSN995054/vcudKbb1pdEQAAAIDsluGedEkqWrQoE8QBWeDBB6XJk80J5YYPlypUkJ580uqqAAAAAGSXdIX07du3p/uCVatWve1iAEjPPSft3i2NHSt16yaVLCndf7/VVQEAAADIDukK6dWrV5fNZpNhGLc8z2azKTk5OVMKA3KzUaOkvXuln382Z3xfu9YcDg8AAAAgZ0tXSD906FBW1wHgOp6e0tdfSw0bSps3S61bS2vWSAULWl0ZAAAAgKyUrpBesmTJrK4DwA3y5DF70uvUkfbtk9q1k6KjJT8/qysDAAAAkFXSFdJ//PFHtWrVSt7e3vrxxx9veW7btm0zpTAAUliYtGCBVK+etHq1uTTbzJmSR4bXZQAAAADgDtIV0tu1a6eYmBgVKVJE7dq1u+l53JMOZL7Klc2l2Vq2NNdOL1VKioqyuioAAAAAWSFd/XF2u11FihRx7N9sI6ADWaNJE+nTT839kSOlqVOtrQcAAABA1siUQbPnz5/PjMsAuIWuXaVhw8z9vn2lhQutrQcAAABA5stwSB81apTmzJnjePz444+rQIECKlasmLZt25apxQFwNmyYGdaTk6XHH5c2brS6IgAAAACZKcMhfcqUKQoPD5ckRUdHa+nSpVq0aJFatWqlV155JdMLBHCNzWYOdW/aVLp82Vyabf9+q6sCAAAAkFnSNXHc9WJiYhwh/eeff9YTTzyh5s2bq1SpUqpTp06mFwjAmY+POZFco0bmGuotWki//WbOBA8AAADAvWW4Jz1//vz666+/JEmLFi1S06ZNJUmGYTBxHJBN8uY1l2YrU0Y6dEhq1Uq6cMHqqgAAAADcqQyH9EcffVRPP/20mjVrpjNnzqhVq1aSpC1btujuu+/O9AIBpC0kRFq82Py5bZvUrp109arVVQEAAAC4ExkO6e+//74iIiJUqVIlRUdHK0+ePJKk48ePq2/fvpleIICbK1PGnOU9b15p5Uqpc2dzUjkAAAAA7inD96R7e3vr5ZdfTnV8wIABmVIQgIy5915p/nxzyPs330gvvCBNnGhOMgcAAADAvdzWOul79+5VRESEmjRpoiZNmigiIkJ79+7N7NoApNNDD0lffWUG848+kt580+qKAAAAANyODIf0b7/9VpUrV9amTZtUrVo1VatWTZs3b1blypX17bffZkWNANLh8celDz8094cPlz74wNJyAAAAANyGDA93HzhwoAYPHqw3b+iqGzZsmAYOHKgOHTpkWnEAMqZfP+nsWWnoUOnFF8171Z991uqqAAAAAKRXhnvSjx8/ri5duqQ6/swzz+j48eOZUhSA2/fGG1LKtBE9e0pz51pbDwAAAID0y3BIb9Sokf73v/+lOr569Wo1aNAgU4oCcPtsNmn0aKlXL8lulzp1MtdUBwAAAOD6MjzcvW3btnr11Ve1adMm3X///ZKk33//XfPmzdOIESP0448/Op0LIPulTCB36ZI0a5bUoYO5VFujRlZXBgAAAOBWMhzSU9ZC/+ijj/TRRx+l+Zwk2Ww2JbNgM2AZT09pxgzp4kXpp5+kNm2kZcuk2rWtrgwAAADAzWR4uLvdbk/XRkAHrOftbd6T/tBDZq96y5bSjh1WVwUAAADgZm5rnXQA7sPPT/rhB+n++6Vz56RmzaR9+6yuCgAAAEBa0h3SW7durQsXLjgejxw5UufPn3c8PnPmjCpVqpSpxQHIHHnymJPHVasmnTghNW4s/fmn1VUBAAAAuFG6Q/rixYsVHx/vePzuu+/q7NmzjsdJSUnau3fvbRUxadIklSpVSn5+fqpTp47Wr1+frtfNnj1bNptN7dq1u633BXKT/Pml6Gjpnnukf/4xg/qBA1ZXBQAAAOB66Q7phmHc8vHtmjNnjiIjIzVs2DBt3rxZ1apVU4sWLXTy5Mlbvu7w4cN6+eWXWfYNyIDChc3J4ypWlP7+2wzqhw5ZXRUAAACAFBme3T2zjRs3Tj179lT37t0lSVOmTNEvv/yiadOmadCgQWm+Jjk5WZ06ddKIESP0v//9z2nY/Y3i4+OdRgDExsZKkhITE5WYmJh5HyQLpNTn6nXCvRQoIC1eLDVr5qW9e21q3NhQdHSSSpXK+LVoo3B1tFG4Otoo3AHtFK7OHdpoRmpLd0i32Wyy2Wypjt2JhIQEbdq0SYMHD3Yc8/DwUNOmTbV27dqbvu7NN99UkSJF9Nxzz+l///vfLd8jKipKI0aMSHV8yZIlCggIuP3is1F0dLTVJSAHevVVX73xRn0dOZJH9esn6J13flPhwldu61q0Ubg62ihcHW0U7oB2Clfnym00Li4u3eemO6QbhqFu3brJ19dXknT16lX17t1bgYGBkuTUW51ep0+fVnJyskJCQpyOh4SEaM+ePWm+ZvXq1frss8+0devWdL3H4MGDFRkZ6XgcGxur8PBwNW/eXEFBQRmuOTslJiYqOjpazZo1k7e3t9XlIAdq3Fhq1szQn38GKiqqmaKjkxQenv7X00bh6mijcHW0UbgD2ilcnTu00ZQR3emR7pDetWtXp8fPPPNMqnO6dOmS7je+HRcvXlTnzp31ySefqFChQul6ja+vr+MPC9fz9vZ22V/gjdypVriXUqWkFSukRo2kAwdsat7cW6tWScWKZew6tFG4OtooXB1tFO6AdgpX58ptNCN1pTukT58+/baKuZVChQrJ09NTJ06ccDp+4sQJhYaGpjr/wIEDOnz4sNq0aeM4ZrfbJUleXl7au3evypQpk+l1AjlZ8eJmUG/Y0JztvVEjaflyZahHHQAAAEDmSPfs7lnBx8dHNWvW1LJlyxzH7Ha7li1bprp166Y6v0KFCtqxY4e2bt3q2Nq2bavGjRtr69atCidVALclPNwM6qVKmeunP/ggs74DAAAAVrB8dvfIyEh17dpVtWrVUu3atTV+/HhdvnzZMdt7ly5dVKxYMUVFRcnPz0+VK1d2en1wcLAkpToOIGNKlpR+/VV66KFrQX3ZMqlcOasrAwAAAHIPy0P6k08+qVOnTmno0KGKiYlR9erVtWjRIsdkckePHpWHh6Ud/kCuER5uBvUmTaTdu80h8MuWSZUqWV0ZAAAAkDtYHtIlKSIiQhEREWk+t3Llylu+dsaMGZlfEJCLhYVJK1dKzZpJ27ebQX3pUqlaNasrAwAAAHI+uqgBpFKkiHmPes2a0unT5lJtGzZYXRUAAACQ8xHSAaSpQAFzqHvdutK5c1LTptKaNVZXBQAAAORshHQAN5Uvn7R4sTmJXGys1Ly52cMOAAAAIGsQ0gHcUt680sKF5j3qly9LrVpJ8+dbXRUAAACQMxHSAfyrgADpxx+ldu2k+HipQweJORsBAACAzEdIB5Aufn7SvHlS9+6S3W7+HD+ef4UAAAAAmYn/wwaQbl5e0mefSS+9ZD4eONBTX35ZUYZhbV0AAABATkFIB5AhNps0ZowUFWU+/vbbcurXz0PJydbWBQAAAOQEhHQAGWazSYMGSR99lCSbzdCnn3qqY0fzfnUAAAAAt4+QDuC29ehh6OWXN8rb29C8eVKbNtKlS1ZXBQAAALgvQjqAO1Kv3j+aPz9ZAQFSdLTUsKEUE2N1VQAAAIB7IqQDuGPNmhlasUIqXFjavFmqW1fas8fqqgAAAAD3Q0gHkClq15bWrJHuvls6fFiqV0/67TerqwIAAADcCyEdQKa5+24zqNepI509KzVpIn37rdVVAQAAAO6DkA4gUxUuLC1fbk4iFx8vPf64NGGC1VUBAAAA7oGQDiDTBQRI330n9ekjGYbUv7/08suS3W51ZQAAAIBrI6QDyBJeXtKkSVJUlPl47FipY0fpyhVr6wIAAABcGSEdQJax2aRBg6SvvpK8vaW5c6VGjViiDQAAALgZQjqALNepk7mGeoEC0vr15kzw27dbXRUAAADgegjpALJFw4bS779L5cpJf/1lLtH2889WVwUAAAC4FkI6gGxTtqwZ1B96SLp0SWrbVnr/fXNyOQAAAACEdADZLH9+adEiqWdPM5xHRkq9e0uJiVZXBgAAAFiPkA4g23l7Sx9/bM74brNJU6dKrVpJ585ZXRkAAABgLUI6AEvYbGYv+g8/SIGB0rJl0n33SX/8YXVlAAAAgHUI6QAs1aaN9NtvUsmS0oED0v33S/PnW10VAAAAYA1COgDLVasmbdhgrqF+6ZLUvr00fLhkt1tdGQAAAJC9COkAXELhwtKSJdILL5iPR4yQHn1Uio21ti4AAAAgOxHSAbgMb2/pgw+kadMkHx/zfvX775f277e6MgAAACB7ENIBuJzu3aVff5WKFpV275Zq1zaXbQMAAAByOkI6AJdUp460caNUt650/rzUurX05pvcpw4AAICcjZAOwGWFhUkrVki9ekmGIQ0bJv3nP9KZM1ZXBgAAAGQNQjoAl+brK338sTR9uuTnJy1cKNWsafayAwAAADkNIR2AW+jWTfr9d6lMGenIEalePTO8G4bVlQEAAACZh5AOwG1Uq2b2oLdrJyUkSL17m+E9Ls7qygAAAIDMQUgH4FaCg6XvvpNGj5Y8PKQvvjCXadu3z+rKAAAAgDtHSAfgdmw26ZVXpGXLpJAQaccO8z71mTOtrgwAAAC4M4R0AG6rUSNpyxapYUPp0iXpmWekZ5+VLl+2ujIAAADg9hDSAbi1sDCzR334cHP4+/Tp0n33mb3rAAAAgLshpANwe56e5hrqy5dLRYtKu3dLtWsz+zsAAADcDyEdQI7RsKG0davUurV09ao5+/uTT0rnz1tdGQAAAJA+hHQAOUrhwtJPP0nvvSd5eUnz5kk1akhr1lhdGQAAAPDvCOkAchwPD+mll6TffpNKl5YOHZIaNJCGDpUSE62uDgAAALg5QjqAHKt2bXP2986dJbtdeustqX59af9+qysDAAAA0kZIB5Cj5csnffGFNHu2FBwsrV8vVa8uffIJk8oBAADA9RDSAeQKTz5pLsv20ENSXJzUq5fUrp106pTVlQEAAADXENIB5BrFi0vR0dLYsZKPj/Tjj1KVKtKCBVZXBgAAAJgI6QByFQ8PKTJS2rBBqlxZOnFCevhhqU8f6eJFq6sDAABAbkdIB5ArVa1qBvUBA8zHU6aYx5Yvt7YuAAAA5G6EdAC5lp+fNG6cGcxLlZIOH5aaNJH69ZMuXbK6OgAAAORGhHQAuV7jxtL27eaQd0n66COzV33lSkvLAgAAQC5ESAcASXnzmuF86VKpZEnp0CEzvD//vHT5stXVAQAAILcgpAPAdZo0MZdq++9/zccTJ5q96r/+am1dAAAAyB0I6QBwg7x5zYnkliyRwsOlgwelhg3N4fAXLlhdHQAAAHIyQjoA3ESzZtLOnVLPnubjKVOkSpWk77+3ti4AAADkXIR0ALiFoCBp6lRzErmyZaV//pEefVRq3146dszq6gAAAJDTENIBIB0aNjRngH/9dcnLS5o/3+xVnzxZstutrg4AAAA5BSEdANLJz096+21p82apTh0pNlbq21dq0EDatcvq6gAAAJATENIBIIOqVJF++0364AMpMFBas0aqXl0aMkSKi7O6OgAAALgzQjoA3AZPT+mFF8we9IcflhITzV72e+6RfvrJ6uoAAADgrgjpAHAHSpQwQ/k330jFi0uHD0tt25rboUNWVwcAAAB3Q0gHgDtks0kdOki7d0sDB5oTy/30kzmx3NtvS/HxVlcIAAAAd0FIB4BMkiePNGqUtG2b1KiRdPWqeZ96lSrSkiVWVwcAAAB3QEgHgExWqZK0fLk0c6YUGirt3y+1aCE9/rh05IjV1QEAAMCVEdIBIAvYbNLTT0t79kgvvmhONPfNN1KFCtLQodLly1ZXCAAAAFdESAeALJQvn/T+++ba6o0bm0Pg33pLKl9e+uoryW63ukIAAAC4EkI6AGSDqlWlZcukb7+VSpeWjh2TOneW6tWT1q+3ujoAAAC4CkI6AGQTm0169FFzbfV335UCA6Xff5fq1JG6dDGDOwAAAHI3QjoAZDM/P2nwYHNCuW7dzGNffimVKye9+aZ06ZKl5QEAAMBChHQAsEhYmDR9ujnc/YEHpLg4adgwqWxZaepUKSnJ6goBAACQ3QjpAGCx++6TVq+W5syR7rpLiomR/vtf8z72n36SDMPqCgEAAJBdCOkA4AJsNumJJ6Tdu6UPPpAKFjT327Y1Z4VncjkAAIDcgZAOAC7Ex0d64QXpzz+lQYPM+9dXrTInl3vqKenAAasrBAAAQFYipAOACwoOlqKipH37zMnlbDZzOHyFClKfPswEDwAAkFMR0gHAhYWHm5PLbd0qtWxpTiY3ZYp0993SSy9Jp05ZXSEAAAAyk0uE9EmTJqlUqVLy8/NTnTp1tP4WN19+8sknatCggfLnz6/8+fOradOmtzwfAHKCqlWlhQvNoe8NGkhXr0rjxpkTzQ0ZIp0/b3WFAAAAyAyWh/Q5c+YoMjJSw4YN0+bNm1WtWjW1aNFCJ0+eTPP8lStXqmPHjlqxYoXWrl2r8PBwNW/eXMcY+wkgF3jwQTOoL1ok1axprqn+9ttS6dLm8HjWWAcAAHBvlof0cePGqWfPnurevbsqVaqkKVOmKCAgQNOmTUvz/JkzZ6pv376qXr26KlSooE8//VR2u13Lli3L5soBwBo2m9SihbRhg/Tdd9I995g96a+9JpUpI40fL125YnWVAAAAuB1eVr55QkKCNm3apMGDBzuOeXh4qGnTplq7dm26rhEXF6fExEQVKFAgzefj4+MVHx/veBwbGytJSkxMVGJi4h1Un/VS6nP1OpF70Uat95//SK1aSXPm2PTWW546cMCmAQOkUaMMvfSSXT172hUQYHWV1qGNwtXRRuEOaKdwde7QRjNSm80wDCMLa7mlf/75R8WKFdOaNWtUt25dx/GBAwdq1apVWrdu3b9eo2/fvlq8eLH++OMP+fn5pXp++PDhGjFiRKrjs2bNUkBu/j9XADlOUpJNy5eX0Lx55XTqlPnvt3z5rqpduwNq2fKQ/P2TLa4QAAAgd4qLi9PTTz+tCxcuKCgo6JbnunVIHzlypEaPHq2VK1eqatWqaZ6TVk96eHi4Tp8+/a9fjtUSExMVHR2tZs2aydvb2+pygFRoo64pIUGaOdOmkSM9deiQTZJUsKChF1+0q08fu1z8X32ZijYKV0cbhTugncLVuUMbjY2NVaFChdIV0i0d7l6oUCF5enrqxIkTTsdPnDih0NDQW772vffe08iRI7V06dKbBnRJ8vX1la+vb6rj3t7eLvsLvJE71YrciTbqWry9pV69pO7dpVmzzInl/vzTpiFDPDVunKdefFF64QVzLfbcgjYKV0cbhTugncLVuXIbzUhdlk4c5+Pjo5o1azpN+pYyCdz1Pes3Gj16tN566y0tWrRItWrVyo5SAcDteHtLXbtKu3dLX30lVaggnTsnDRsmlSwpvf66dMPfSAEAAGAxy2d3j4yM1CeffKLPP/9cu3fvVp8+fXT58mV1795dktSlSxenieVGjRqlIUOGaNq0aSpVqpRiYmIUExOjS6w7BABp8vKSOnWSdu6UZs+WKleWYmOld981w3qfPtKBA1ZXCQAAAMkFQvqTTz6p9957T0OHDlX16tW1detWLVq0SCEhIZKko0eP6vjx447zJ0+erISEBD322GMKCwtzbO+9955VHwEA3IKnp/Tkk9K2bebSbXXqSPHx0pQpUrly5nObN1tdJQAAQO5m6T3pKSIiIhQREZHmcytXrnR6fPjw4awvCAByMA8PqX17qV076ddfpVGjpIULpblzza1pU2nQIOmhh8w12QEAAJB9LO9JBwBYw2aTGjaUFiwwe9c7dTJ725cuNYP6ffdJc+ZISUlWVwoAAJB7ENIBAKpa1Zxc7s8/pYgIyd9f2rRJeuopqUwZ6b33pPPnra4SAAAg5yOkAwAcSpWSPvxQOnLEnAW+cGHp6FHplVek4sWl5583gzwAAACyBiEdAJBK4cLS8OFmQP/sM3NG+MuXpYkTzUnmHnlEWrlSMgyrKwUAAMhZCOkAgJvy85OefVbavl2KjpZatzaD+Y8/So0bSzVqSJ9/Ll29anWlAAAAOQMhHQDwr2w2czK5X36R9uwx11b395e2bpW6dZPCw80Z4Q8dsrpSAAAA90ZIBwBkSPny0kcfSX//LUVFmQH99GlzKbcyZaT//Mdc0s1ut7pSAAAA90NIBwDclgIFzN7zgwel+fOl5s3NofC//GIOiy9bVhozRjpzxupKAQAA3AchHQBwR7y8zInkFi+W9u2TBgyQgoPN8D5woFSsmDkkfv16JpoDAAD4N4R0AECmKVtWGjdOOnZM+vRT6d57pfh4c3K5OnXMieYmTZLOnbO6UgAAANdESAcAZLqAAOm556RNm6Tff5c6d5Z8fc2J5iIipKJFzWO//krvOgAAwPUI6QCALGOzmT3oX3xh9q5/8IG55vrVq9JXX0kNG5oT0Y0eLZ04YXW1AAAA1iOkAwCyRcGC0gsvmGuur1sn9ewp5ckj7d8vvfqqVLy41KGDOTN8crLV1QIAAFiDkA4AyFY2m1S7tjR1qnT8uHnv+v33S0lJ0nffmTPDlyhhTjr3xx9WVwsAAJC9COkAAMvkyWPeu752rbRjh/Tii+bSbv/8Yy7fVrmyVLOmOUz+5EmrqwUAAMh6hHQAgEuoXFl6/32zd/3776V27SRvb2nzZjO8FysmtW0rffONeU87AABATkRIBwC4FB8fM6B//73Zoz5xonTffeZw+J9+kh5/XAoLk/r0kVavlux2qysGAADIPIR0AIDLKlRI6tdPWr9e2rVLGjzYnGDu/HlpyhSpQQOpdGnz/vXNm1nODQAAuD9COgDALVSsKL37rnT4sLR0qdSli5Q3r3T0qHn/es2aUoUK0vDh0p49VlcLAABwewjpAAC34ukpNWkiff65ubb6t99Kjz0m+flJ+/ZJI0aYgf7ee6X33vPQyZP+VpcMAACQbl5WFwAAwO3y95cefdTcYmOlH3+Uvv5aWrJE2rpV2rrVU1JzTZ9u15NPmueFh1tdNQAAwM3Rkw4AyBGCgqRnnpF++UWKiZE+/lhq2NAum83Q2rUeevFFc/31OnWk0aOlAwesrhgAACA1QjoAIMcpWFDq1UuKjk7WZ58t0dixyapfX7LZzEnoXn1VuvtuqXp16a23zEnpAAAAXAEhHQCQoxUocFXPP2/X//5nLun20UfmPe2entK2bdLQodI995j3sb/xhrRlC7PEAwAA6xDSAQC5Rmioub760qXmkPjPPpNat5a8vc0Z4d95R6pRw1zW7YUXzPMSEqyuGgAA5CaEdABArlSokPTss+Y97KdOSV99JbVvb05Gd+SI9OGHUrNmUuHC0pNPSjNnSmfPWl01AADI6QjpAIBcL18+qVMn6bvvpNOnpR9+kJ57TipSxJw1fu5cc1K6IkWkxo2lceOkP/+0umoAAJATEdIBALhOQIDUtq306afS8ePS2rXSa69JlStLycnSypXSSy9JZctKlSpJr7wiLV/OsHgAAJA5COkAANyEh4d0//3mveo7dpjLto0fb0485+Ul7d4tvfee+bhAAemRR6QpU8zh8gAAALeDkA4AQDrddZfUv785odypU9LXX0tdupjD4C9fln780ZyYrlQpc7b4yEgpOlq6etXqygEAgLvwsroAAADcUXCw9NRT5ma3S1u3SgsXmtvateZs8Xv2SO+/bw6hb9xYatVKat7cXKPdZrP6EwAAAFdESAcA4A55eJhLt9WoIb3+unTunNnbvnChtGiReW/7L7+YmySVKGEOkW/a1PwZEmJt/QAAwHUQ0gEAyGT580uPP25uhiFt334tsK9ZIx09Kk2fbm6SVKXKtdD+4INS3rzW1g8AAKxDSAcAIAvZbFK1auY2aJB57/rq1WZP+9Kl5jD5HTvMbfx4c0K6+++/1steu7bk42P1pwAAANmFkA4AQDYKDJRatDA3yZyAbsWKa6H90CEzxK9eLQ0fLvn7S3XrSg0bmludOpKfn6UfAQAAZCFCOgAAFipcWHriCXOTpIMHpWXLzMC+fLl0+rT5c/ly83lfXzOop4T2unXNiekAAEDOQEgHAMCF3HWXufXsad7PvmuXtGrVte3ECenXX83trbckb2/pvvuuhfZ69aQ8eaz+FAAA4HYR0gEAcFE2m3TPPebWt68Z2vftcw7tx46Zk9GtWSNFRUmenub97w88YAb2Bx4wZ5MHAADugZAOAICbsNmk8uXNrVcvM7QfPOgc2o8ckTZvNreJE83XFS9uhvWU4F6tmtkDDwAAXA8hHQAAN2WzSWXKmNuzz5rH/v7b7FX/7Tfz55Yt5rG5c81NMu9hr137WmivU0cqWNC6zwEAAK4hpAMAkIMUL+48Ed3ly9KGDddC+5o10vnz0sqV5paiTBkzrNeubW7Vq5szywMAgOxFSAcAIAcLDJQaNTI3SbLbpT17rvW2//abtH+/dOCAuc2aZZ7n5SVVrXottNepYw6z9/S06pMAAJA7ENIBAMhFPDykSpXMrUcP89jZs9LGjdL69ea2bp108uS1e9unTDHPy5tXqlXLDO333SfVrCmVLGkOuwcAAJmDkA4AQC5XoIDUvLm5SeaEdH/9ZYb1lOC+caN08aK0YoW5pcifX6pRw3m7+27zjwEAACDjCOkAAMCJzWYu21aihPT44+axpCRp9+5roX39eumPP6Rz56Rly8wtRZ480r33Ogf3ChXMIfQAAODW+M8lAAD4V15eUpUq5vbcc+ax+HgzqKcMi9+8Wdq2Tbp0Sfrf/8wthZ+feY/7vfeaP6tWNa+VL581nwcAAFdFSAcAALfF1/daT3mKpCRp717n4L5lizlUPqUH/nolS14L7Snb3XfT6w4AyL34TyAAAMg0Xl7SPfeYW+fO5jG73Zw5fvNmafv2a9vRo9KRI+b200/XruHnZ77++uBepYpUuLA1nwkAgOxESAcAAFnKw0MqW9bcnnzy2vFz56SdO52D+44d5trumzaZ2/UKF742M/31W0gIM8wDAHIOQjoAALBE/vxSgwbmlsJulw4dcg7u27ebPfGnTkmrVpnbjddJK7wXK0Z4BwC4H0I6AABwGR4eUpky5ta+/bXjly+b97rv2uW8HThg9sj/9pu5XS9v3muBvXx5cytXzry2r2/2fi4AANKLkA4AAFxeYGDqSeok6epVad++a6H9jz/Mn/v3m5PVrVtnbtfz8JBKlboW2suVu7ZfrBhrvAMArEVIBwAAbitlabeqVZ2PJySYQT0lvO/bZ/bE79tnhveDB81t4ULn1wUEmPfOXx/cy5c3e98LFGD4PAAg6xHSAQBAjuPjc22W+esZhnTixLXAnvJz3z5z6HxcnLnW+7Ztqa+ZL58Z1u+669qQ/JSteHHJ0zN7PhsAIGcjpAMAgFzDZpNCQ82tYUPn5xITpcOHnYN7yv4//0gXLlxb+/1G3t7mEPqU0H59kL/rLrOHHgCA9CCkAwAAyAzaKUvF3Sguzpx1/sABc5j8gQPXtkOHzIC/f7+5pSU0VCpdWipZ0txKlTJ/FismxcfTBQ8AuIaQDgAA8C8CAtIePi9JycnSsWPOwf36IH/+vBQTY25r1974am9J/1HhwkaqAJ/ys2RJc6g9ACB3IKQDAADcAU9PqUQJc2vcOPXzZ8+aof3wYenIEXNL2T982FBsrE2nTtl06pS0cWPa7xEcfC2wh4eb98AXL35tv1gxcxI9AID7I6QDAABkoQIFzK1WrdTPJSYmae7cJSpXrrn++cc7zSB/5ozZG3/+fNoT2qUoVMg5wKcV5Lk3HgBcHyEdAADAQnnyJKl6dem++9J+/tKla8H9yBHp77+dt7/+kq5ckU6fNrctW27+XgUKXAvuRYtKYWHXfqZsISHm/fkAAGsQ0gEAAFxYnjw3vx9eMpeVO3cudXC/8fHly+bQ+7Nnpe3bb/5+NptUuLBzcE8rzIeFSb6+WfOZASA3I6QDAAC4MZvt2pD6qlXTPscwpNjYa+H9r7+k48fNpeWOH7+2xcRISUnSyZPmdqvh9ZKUP/+18F6kiNkLn9bPIkW4Zx4A0ouQDgAAkMPZbOYM8fnySZUr3/w8u90cMn99cL8xyKccS0gwe/DPnZP++OPfawgKSh3cbxbqg4PNmgEgNyKkAwAAQJLk4XEtQFerdvPzUobYXx/cT56UTpy41gufsn/ihLmOfGysuf3557/X4e1tToRXqJBUsOC1/Vs9zpOHYA8gZyCkAwAAIEOuH2J/s3vlUxiGdOHCrUP89ccuXDBDfUr4Ty8fn/QF+gIFzGH6BQqYPfaennf0VQBApiOkAwAAIMvYbGYYDg6WypX79/Pj483Afvq0ufxcyqz1N3t86pR09ao5/D6jwV4yh+GnBPeULT2Pg4LMkQcAkNkI6QAAAHAZvr7mEnHh4el/TVxc2iE+rWPnzpkz3F+6ZL42ZRj+4cMZq9PDw7zH/8YQn3Lv/622oCDzJ0vdAUgLIR0AAABuLSBAKlHC3NIrMVE6f/5aaE+ZBC89j+PizEn2Uh4fPHh7dfv7py/U3xjwg4KkvHnNLSCAHn0gpyGkAwAAINfx9jbXgy9cOOOvjY+/eYi/cCHtLTb22v7ly+Z1rlwxt5iY2/8cNpsUGHgttOfNa06id6vHtzoWGEjoB6xGSAcAAAAywNdXCg01t9uRlOQc2tMT7K/fLl40N7vdnJjv0iVzy+j9+Gm5PvTnyWNuAQGeiou7XzNmeDqC/PVbQED6jvn78wcAID0I6QAAAEA28vK6Njv+7TIMsxc+JbBfunRt/1bHbnXujaH/Gg9JIdqy5Q4/uMygnp6A7+9/Zxv3+8OdEdIBAAAAN2OzmWE2IEAKCbnz690Y+lO2y5elCxeStHbtdpUtW01Xr3rq8mU5trg4OT1O69iVK9feJ2WI/+nTd17zrXh63lnI9/MzR0yk/Lx+P61j1+97e5u/H+B2EdIBAACAXO5WoT8x0ZC//19q3bqKvL0zvrC83W4G838L89cfSwnzGdmuXr32nsnJaY0IyB42261D/L+F/BuP+fiYf3Tw8kr7J7cQSElJNnl55Zy/jBDSAQAAAGQZD49rQ9mzkmGYQf12Av6NW3y8uV296vzzZvuJianruHrVnEMA2cFLX3+dc/5a4RIhfdKkSRozZoxiYmJUrVo1ffjhh6pdu/ZNz583b56GDBmiw4cPq2zZsho1apRat26djRUDAAAAcCU227Xh6tnNbr91iM9I4L/xWEKCOTIgKSn1z6Qk848CuZ1h2HPUiALLQ/qcOXMUGRmpKVOmqE6dOho/frxatGihvXv3qkiRIqnOX7NmjTp27KioqCj95z//0axZs9SuXTtt3rxZlStXtuATAAAAAMjNPDys+wMBpMTEZC1YkGx1GZnG8r83jBs3Tj179lT37t1VqVIlTZkyRQEBAZo2bVqa53/wwQdq2bKlXnnlFVWsWFFvvfWWatSooYkTJ2Zz5QAAAAAAZC5Le9ITEhK0adMmDR482HHMw8NDTZs21dq1a9N8zdq1axUZGel0rEWLFpo/f36a58fHxys+Pt7xODY2VpKUmJioxOtvHnFBKfW5ep3IvWijcHW0Ubg62ijcAe0Urs4d2mhGarM0pJ8+fVrJyckKuWEKyZCQEO3ZsyfN18TExKR5fkxMTJrnR0VFacSIEamOL1myRAEBAbdZefaKjo62ugTglmijcHW0Ubg62ijcAe0Urs6V22hcXFy6z7X8nvSsNnjwYKee99jYWIWHh6t58+YKCgqysLJ/l5iYqOjoaDVr1kze3t5WlwOkQhuFq6ONwtXRRuEOaKdwde7QRlNGdKeHpSG9UKFC8vT01IkTJ5yOnzhxQqGhoWm+JjQ0NEPn+/r6ytfXN9Vxb29vl/0F3sidakXuRBuFq6ONwtXRRuEOaKdwda7cRjNSl6UTx/n4+KhmzZpatmyZ45jdbteyZctUt27dNF9Tt25dp/Mlc1jDzc4HAAAAAMBdWD7cPTIyUl27dlWtWrVUu3ZtjR8/XpcvX1b37t0lSV26dFGxYsUUFRUlSerfv78aNmyosWPH6uGHH9bs2bO1ceNGTZ061cqPAQAAAADAHbM8pD/55JM6deqUhg4dqpiYGFWvXl2LFi1yTA539OhReVy3Mv0DDzygWbNm6Y033tBrr72msmXLav78+ayRDgAAAABwe5aHdEmKiIhQREREms+tXLky1bHHH39cjz/+eBZXBQAAAABA9rL0nnQAAAAAAHANIR0AAAAAABdBSAcAAAAAwEUQ0gEAAAAAcBGEdAAAAAAAXAQhHQAAAAAAF0FIBwAAAADARRDSAQAAAABwEYR0AAAAAABchJfVBWQ3wzAkSbGxsRZX8u8SExMVFxen2NhYeXt7W10OkAptFK6ONgpXRxuFO6CdwtW5QxtNyZ8pefRWcl1Iv3jxoiQpPDzc4koAAAAAALnJxYsXlS9fvlueYzPSE+VzELvdrn/++Ud58+aVzWazupxbio2NVXh4uP766y8FBQVZXQ6QCm0Uro42CldHG4U7oJ3C1blDGzUMQxcvXlTRokXl4XHru85zXU+6h4eHihcvbnUZGRIUFOSyjQ2QaKNwfbRRuDraKNwB7RSuztXb6L/1oKdg4jgAAAAAAFwEIR0AAAAAABdBSHdhvr6+GjZsmHx9fa0uBUgTbRSujjYKV0cbhTugncLV5bQ2musmjgMAAAAAwFXRkw4AAAAAgIsgpAMAAAAA4CII6QAAAAAAuAhCOgAAAAAALoKQ7qImTZqkUqVKyc/PT3Xq1NH69eutLgm5RFRUlO677z7lzZtXRYoUUbt27bR3716nc65evap+/fqpYMGCypMnjzp06KATJ044nXP06FE9/PDDCggIUJEiRfTKK68oKSkpOz8KcomRI0fKZrPpxRdfdByjjcJqx44d0zPPPKOCBQvK399fVapU0caNGx3PG4ahoUOHKiwsTP7+/mratKn279/vdI2zZ8+qU6dOCgoKUnBwsJ577jldunQpuz8KcqDk5GQNGTJEpUuXlr+/v8qUKaO33npL188nTRtFdvv111/Vpk0bFS1aVDabTfPnz3d6PrPa5Pbt29WgQQP5+fkpPDxco0ePzuqPlmGEdBc0Z84cRUZGatiwYdq8ebOqVaumFi1a6OTJk1aXhlxg1apV6tevn37//XdFR0crMTFRzZs31+XLlx3nDBgwQD/99JPmzZunVatW6Z9//tGjjz7qeD45OVkPP/ywEhIStGbNGn3++eeaMWOGhg4dasVHQg62YcMGffzxx6patarTcdoorHTu3DnVq1dP3t7eWrhwoXbt2qWxY8cqf/78jnNGjx6tCRMmaMqUKVq3bp0CAwPVokULXb161XFOp06d9Mcffyg6Olo///yzfv31V/Xq1cuKj4QcZtSoUZo8ebImTpyo3bt3a9SoURo9erQ+/PBDxzm0UWS3y5cvq1q1apo0aVKaz2dGm4yNjVXz5s1VsmRJbdq0SWPGjNHw4cM1derULP98GWLA5dSuXdvo16+f43FycrJRtGhRIyoqysKqkFudPHnSkGSsWrXKMAzDOH/+vOHt7W3MmzfPcc7u3bsNScbatWsNwzCMBQsWGB4eHkZMTIzjnMmTJxtBQUFGfHx89n4A5FgXL140ypYta0RHRxsNGzY0+vfvbxgGbRTWe/XVV4369evf9Hm73W6EhoYaY8aMcRw7f/684evra3z99deGYRjGrl27DEnGhg0bHOcsXLjQsNlsxrFjx7KueOQKDz/8sPHss886HXv00UeNTp06GYZBG4X1JBnff/+943FmtcmPPvrIyJ8/v9N/61999VWjfPnyWfyJMoaedBeTkJCgTZs2qWnTpo5jHh4eatq0qdauXWthZcitLly4IEkqUKCAJGnTpk1KTEx0aqMVKlRQiRIlHG107dq1qlKlikJCQhzntGjRQrGxsfrjjz+ysXrkZP369dPDDz/s1BYl2iis9+OPP6pWrVp6/PHHVaRIEd1777365JNPHM8fOnRIMTExTm00X758qlOnjlMbDQ4OVq1atRznNG3aVB4eHlq3bl32fRjkSA888ICWLVumffv2SZK2bdum1atXq1WrVpJoo3A9mdUm165dqwcffFA+Pj6Oc1q0aKG9e/fq3Llz2fRp/p2X1QXA2enTp5WcnOz0P46SFBISoj179lhUFXIru92uF198UfXq1VPlypUlSTExMfLx8VFwcLDTuSEhIYqJiXGck1YbTnkOuFOzZ8/W5s2btWHDhlTP0UZhtYMHD2ry5MmKjIzUa6+9pg0bNuiFF16Qj4+Punbt6mhjabXB69tokSJFnJ738vJSgQIFaKO4Y4MGDVJsbKwqVKggT09PJScn65133lGnTp0kiTYKl5NZbTImJkalS5dOdY2U566/LclKhHQAN9WvXz/t3LlTq1evtroUwOGvv/5S//79FR0dLT8/P6vLAVKx2+2qVauW3n33XUnSvffeq507d2rKlCnq2rWrxdUB0ty5czVz5kzNmjVL99xzj7Zu3aoXX3xRRYsWpY0CLoDh7i6mUKFC8vT0TDUL8YkTJxQaGmpRVciNIiIi9PPPP2vFihUqXry443hoaKgSEhJ0/vx5p/Ovb6OhoaFptuGU54A7sWnTJp08eVI1atSQl5eXvLy8tGrVKk2YMEFeXl4KCQmhjcJSYWFhqlSpktOxihUr6ujRo5KutbFb/bc+NDQ01YSxSUlJOnv2LG0Ud+yVV17RoEGD9NRTT6lKlSrq3LmzBgwYoKioKEm0UbiezGqT7vLff0K6i/Hx8VHNmjW1bNkyxzG73a5ly5apbt26FlaG3MIwDEVEROj777/X8uXLUw0Jqlmzpry9vZ3a6N69e3X06FFHG61bt6527Njh9C/K6OhoBQUFpfofVyCjmjRpoh07dmjr1q2OrVatWurUqZNjnzYKK9WrVy/V0pX79u1TyZIlJUmlS5dWaGioUxuNjY3VunXrnNro+fPntWnTJsc5y5cvl91uV506dbLhUyAni4uLk4eHcwzw9PSU3W6XRBuF68msNlm3bl39+uuvSkxMdJwTHR2t8uXLu8xQd0nM7u6KZs+ebfj6+hozZswwdu3aZfTq1csIDg52moUYyCp9+vQx8uXLZ6xcudI4fvy4Y4uLi3Oc07t3b6NEiRLG8uXLjY0bNxp169Y16tat63g+KSnJqFy5stG8eXNj69atxqJFi4zChQsbgwcPtuIjIRe4fnZ3w6CNwlrr1683vLy8jHfeecfYv3+/MXPmTCMgIMD46quvHOeMHDnSCA4ONn744Qdj+/btxiOPPGKULl3auHLliuOcli1bGvfee6+xbt06Y/Xq1UbZsmWNjh07WvGRkMN07drVKFasmPHzzz8bhw4dMr777jujUKFCxsCBAx3n0EaR3S5evGhs2bLF2LJliyHJGDdunLFlyxbjyJEjhmFkTps8f/68ERISYnTu3NnYuXOnMXv2bCMgIMD4+OOPs/3z3goh3UV9+OGHRokSJQwfHx+jdu3axu+//251ScglJKW5TZ8+3XHOlStXjL59+xr58+c3AgICjPbt2xvHjx93us7hw4eNVq1aGf7+/kahQoWMl156yUhMTMzmT4Pc4saQThuF1X766SejcuXKhq+vr1GhQgVj6tSpTs/b7XZjyJAhRkhIiOHr62s0adLE2Lt3r9M5Z86cMTp27GjkyZPHCAoKMrp3725cvHgxOz8GcqjY2Fijf//+RokSJQw/Pz/jrrvuMl5//XWnZaloo8huK1asSPP/Qbt27WoYRua1yW3bthn169c3fH19jWLFihkjR47Mro+YbjbDMAxr+vABAAAAAMD1uCcdAAAAAAAXQUgHAAAAAMBFENIBAAAAAHARhHQAAAAAAFwEIR0AAAAAABdBSAcAAAAAwEUQ0gEAAAAAcBGEdAAAAAAAXAQhHQAA6PDhw7LZbNq6dWuWvUe3bt3Url27LLs+AAA5ASEdAIAcoFu3brLZbKm2li1bpuv14eHhOn78uCpXrpzFlQIAgFvxsroAAACQOVq2bKnp06c7HfP19U3Xaz09PRUaGpoVZQEAgAygJx0AgBzC19dXoaGhTlv+/PklSTabTZMnT1arVq3k7++vu+66S998843jtTcOdz937pw6deqkwoULy9/fX2XLlnX6A8COHTv00EMPyd/fXwULFlSvXr106dIlx/PJycmKjIxUcHCwChYsqIEDB8owDKd67Xa7oqKiVLp0afn7+6tatWpONQEAkBsR0gEAyCWGDBmiDh06aNu2berUqZOeeuop7d69+6bn7tq1SwsXLtTu3bs1efJkFSpUSJJ0+fJltWjRQvnz59eGDRs0b948LV26VBEREY7Xjx07VjNmzNC0adO0evVqnT17Vt9//73Te0RFRemLL77QlClT9Mcff2jAgAF65plntGrVqqz7EgAAcHE248Y/awMAALfTrVs3ffXVV/Lz83M6/tprr+m1116TzWZT7969NXnyZMdz999/v2rUqKGPPvpIhw8fVunSpbVlyxZVr15dbdu2VaFChTRt2rRU7/XJJ5/o1Vdf1V9//aXAwEBJ0oIFC9SmTRv9888/CgkJUdGiRTVgwAC98sorkqSkpCSVLl1aNWvW1Pz58xUfH68CBQpo6dKlqlu3ruPaPXr0UFxcnGbNmpUVXxMAAC6Pe9IBAMghGjdu7BTCJalAgQKO/evDcMrjm83m3qdPH3Xo0EGbN29W8+bN1a5dOz3wwAOSpN27d6tatWqOgC5J9erVk91u1969e+Xn56fjx4+rTp06jue9vLxUq1Ytx5D3P//8U3FxcWrWrJnT+yYkJOjee+/N+IcHACCHIKQDAJBDBAYG6u67786Ua7Vq1UpHjhzRggULFB0drSZNmqhfv3567733MuX6Kfev//LLLypWrJjTc+md7A4AgJyIe9IBAMglfv/991SPK1aseNPzCxcurK5du+qrr77S+PHjNXXqVElSxYoVtW3bNl2+fNlx7m+//SYPDw+VL19e+fLlU1hYmNatW+d4PikpSZs2bXI8rlSpknx9fXX06FHdfffdTlt4eHhmfWQAANwOPekAAOQQ8fHxiomJcTrm5eXlmPBt3rx5qlWrlurXr6+ZM2dq/fr1+uyzz9K81tChQ1WzZk3dc889io+P188//+wI9J06ddKwYcPUtWtXDR8+XKdOndLzzz+vzp07KyQkRJLUv39/jRw5UmXLllWFChU0btw4nT9/3nH9vHnz6uWXX9aAAQNkt9tVv359XbhwQb/99puCgoLUtWvXLPiGAABwfYR0AAByiEWLFiksLMzpWPny5bVnzx5J0ogRIzR79mz17dtXYWFh+vrrr1WpUqU0r+Xj46PBgwfr8OHD8vf3V4MGDTR79mxJUkBAgBYvXqz+/fvrvvvuU0BAgDp06KBx48Y5Xv/SSy/p+PHj6tq1qzw8PPTss8+qffv2unDhguOct956S4ULF1ZUVJQOHjyo4OBg1ahRQ6+99lpmfzUAALgNZncHACAXsNls+v7779WuXTurSwEAALfAPekAAAAAALgIQjoAAAAAAC6Ce9IBAMgFuLsNAAD3QE86AAAAAAAugpAOAAAAAICLIKQDAAAAAOAiCOkAAAAAALgIQjoAAAAAAC6CkA4AAAAAgIsgpAMAAAAA4CII6QAAAAAAuIj/A+wEEf4/9Qm4AAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot epsilon decay\n", "plt.figure(figsize=(12, 6))\n", "plt.plot(epsilon_values, label='Epsilon Decay', color='blue')\n", "plt.xlabel('Episode')\n", "plt.ylabel('Epsilon Value')\n", "plt.title('Epsilon Decay over Episodes')\n", "plt.legend()\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot total reward per episode\n", "plt.figure(figsize=(12, 6))\n", "plt.plot(rewards_epi, label='Total Reward per Episode', color='green')\n", "plt.xlabel('Episode')\n", "plt.ylabel('Total Reward')\n", "plt.title('Total Reward per Episode')\n", "plt.legend()\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "stock_trading_environment.train = False\n", "state, _ = stock_trading_environment.reset()\n", "state_index = state\n", "total_account_value_list_eval = []\n", "\n", "while True:\n", " action = np.argmax(qt[state_index])\n", " next_state, reward, terminated, truncated, _ = stock_trading_environment.step(action)\n", " next_strt_idx = next_state\n", " state_index = next_strt_idx\n", " total_account_value_list_eval.append(stock_trading_environment.total_account_value)\n", " if terminated or truncated:\n", " stock_trading_environment.render() # Call render to generate the plot\n", " break" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 2 }