diff --git "a/rx_rover_DDQN.ipynb" "b/rx_rover_DDQN.ipynb" new file mode 100644--- /dev/null +++ "b/rx_rover_DDQN.ipynb" @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double Deep Q Network" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "from gym import spaces\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Rectangle\n", + "\n", + "import os\n", + "import random\n", + "import imageio\n", + "from tqdm import tqdm \n", + "from itertools import count\n", + "from collections import namedtuple,deque\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hospital Environment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class RoverGridEnv(gym.Env):\n", + " metadata={'render.modes': ['human']} \n", + " def __init__(self,max_ts=20): \n", + " super(RoverGridEnv,self).__init__()\n", + " self.max_ts=max_ts # Note: The Max_Timestamps is set to 20 by default.\n", + " self.grid_size=(15,15) \n", + " self.action_space=spaces.Discrete(5) \n", + " self.observation_space=spaces.MultiDiscrete([15,15,15,15,15,15])\n", + " self.rover_positions=np.array([[6,4],[10,4]])\n", + " self.operation_desks=np.array([[6,3],[10,3]])\n", + " self.rooms=np.array([[4,7],[4,10],[4,13],[8,7],[8,10],[8,13],[12,7],[12,10],[12,13]])\n", + " self.human_position=np.array([8,9])\n", + " self.targets=np.array([[5,10],[9,13]])\n", + " self.actions=[(0,-1),(0,1),(-1,0),(1,0),(0,0)] # Down,Up,Left,Right,Wait\n", + " self.rover_done=[False,False] \n", + " self.reset()\n", + " \n", + " def seed(self,seed=None):\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " \n", + " def reset(self):\n", + " self.current_step=0\n", + " self.rover_positions=np.array([[6,4],[10,4]])\n", + " self.rover_done=[False,False]\n", + " self.human_position=np.array([7,8])\n", + " self.current_step=0\n", + " return self._get_obs()\n", + " \n", + " def _get_obs(self):\n", + " return np.concatenate((self.rover_positions.flatten(),self.human_position))\n", + " \n", + " def step(self,actions):\n", + " rewards=np.zeros(2)\n", + " done=[False,False]\n", + " info={'message': ''} \n", + " for i,action in enumerate(actions):\n", + " if self.rover_done[i]:\n", + " done[i]=True \n", + " continue\n", + " prev_distance=np.linalg.norm(self.targets[i]-self.rover_positions[i])\n", + " if self._is_human_adjacent(self.rover_positions[i]):\n", + " rewards[i] -= 5\n", + " else:\n", + " delta=np.array(self.actions[action])\n", + " new_position=self.rover_positions[i]+delta\n", + " if self._out_of_bounds(new_position):\n", + " rewards[i] -= 15\n", + " continue\n", + " if self._collision(new_position,i):\n", + " rewards[i] -= 15\n", + " continue\n", + " self.rover_positions[i]=new_position\n", + " new_distance=np.linalg.norm(self.targets[i]-new_position)\n", + " if new_distance < prev_distance:\n", + " rewards[i]+=30 \n", + " else:\n", + " rewards[i] -= 20 \n", + " if np.array_equal(new_position,self.targets[i]):\n", + " rewards[i]+=100\n", + " self.rover_done[i]=True \n", + " done[i]=True\n", + "\n", + " # move human randomly\n", + " self._move_human()\n", + " self.current_step+=1\n", + " all_done=all(done) or self.current_step >= self.max_ts\n", + " if all_done and not all(done): # if the maximum number of steps is reached but not all targets were reached\n", + " info['message']='Maximum number of timestamps reached'\n", + " return self._get_obs(),rewards,all_done,info\n", + "\n", + " def _is_human_adjacent(self,position):\n", + " for delta in [(1,1),(1,-1),(-1,1),(-1,-1)]:\n", + " adjacent_position=position+np.array(delta)\n", + " if np.array_equal(adjacent_position,self.human_position):\n", + " return True\n", + " return False\n", + "\n", + " def _out_of_bounds(self,position):\n", + " return not (0 <= position[0] < self.grid_size[0] and 0 <= position[1] < self.grid_size[1])\n", + " \n", + " def _collision(self,new_position,rover_index):\n", + " if any(np.array_equal(new_position,pos) for pos in np.delete(self.rover_positions,rover_index,axis=0)):\n", + " return True # Collision with the other rover\n", + " if any(np.array_equal(new_position,pos) for pos in self.rooms):\n", + " return True # Collision with a room\n", + " if any(np.array_equal(new_position,pos) for pos in self.operation_desks):\n", + " return True # Collision with an operation desk\n", + " if np.array_equal(new_position,self.human_position):\n", + " return True # Collision with the human\n", + " return False\n", + " \n", + " def _move_human(self):\n", + " valid_moves=[move for move in self.actions if not self._out_of_bounds(self.human_position+np.array(move))]\n", + " self.human_position+=np.array(valid_moves[np.random.choice(len(valid_moves))])\n", + " \n", + " def render(self,mode='human',save_path=None):\n", + " fig,ax=plt.subplots(figsize=(7,7))\n", + " ax.set_xlim(0,self.grid_size[0])\n", + " ax.set_ylim(0,self.grid_size[1])\n", + " ax.set_xticks(np.arange(0,15,1))\n", + " ax.set_yticks(np.arange(0,15,1))\n", + " ax.grid(which='both')\n", + "\n", + " # draw elements\n", + " for pos in self.rover_positions:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='blue'))\n", + " for pos in self.operation_desks:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='darkgreen'))\n", + " for pos in self.rooms:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='black'))\n", + " ax.add_patch(Rectangle((self.human_position[0]-0.5,self.human_position[1]-0.5),1,1,color='purple'))\n", + " for pos in self.targets:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='yellow',alpha=0.5))\n", + "\n", + " if save_path is not None:\n", + " plt.savefig(save_path)\n", + " plt.close()\n", + " \n", + " def close(self):\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Setup\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env=RoverGridEnv()\n", + "print(\"Initial Setup\")\n", + "observation=env.reset()\n", + "env.render()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DDQN" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class rover_DDQN(nn.Module):\n", + " def __init__(self,input_dim,output_dim):\n", + " super(rover_DDQN,self).__init__()\n", + " self.net=nn.Sequential(\n", + " nn.Linear(input_dim,256),nn.ReLU(),\n", + " nn.Linear(256,128),nn.ReLU(),\n", + " nn.Linear(128,output_dim)) \n", + " def forward(self,x):\n", + " return self.net(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Transition=namedtuple('Transition',('stt','action','nxt_stt','rwd','done'))\n", + "class ReplayMemory(object):\n", + " def __init__(self,capacity):\n", + " self.memory=deque([],\n", + " maxlen=capacity)\n", + " def push(self,*args):\n", + " self.memory.append(Transition(*args))\n", + " def sample(self,\n", + " batch_size):\n", + " return random.sample(self.memory,\n", + " batch_size)\n", + " def __len__(self):\n", + " return len(self.memory)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def select_act(stt,policy_net,n_actions,stps_done,eps_begin,eps_end,eps_decay):\n", + " sample=random.random()\n", + " eps_threshold=eps_end+(eps_begin-eps_end)*np.exp(-1.*stps_done/eps_decay)\n", + " stps_done+=1\n", + " if sample>eps_threshold:\n", + " with torch.no_grad():\n", + " return policy_net(stt).max(1)[1].view(1,1),stps_done\n", + " else:\n", + " return torch.tensor([[random.randrange(n_actions)]],dtype=torch.long),stps_done" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def optimize_model_ddqn(memory,policy_net,target_net,optimizer,batch_size,gma):\n", + " if len(memory) < batch_size:\n", + " return\n", + " transitions=memory.sample(batch_size)\n", + " batch=Transition(*zip(*transitions))\n", + "\n", + " not_final_mask=torch.tensor(tuple(map(lambda s: s is not None,\n", + " batch.nxt_stt)),\n", + " dtype=torch.bool)\n", + " not_final_nxt_stt=torch.cat([s for s in batch.nxt_stt if s is not None])\n", + " stt_batch=torch.cat(batch.state)\n", + " act_batch=torch.tensor([list(act) for act in batch.action],\n", + " dtype=torch.long)\n", + " rwd_batch=torch.cat(batch.reward)\n", + "\n", + " stt_act_values=policy_net(stt_batch).gather(1,\n", + " act_batch)\n", + " nxt_stt_act=policy_net(not_final_nxt_stt).max(1)[1].unsqueeze(1)\n", + " nxt_stt_values=torch.zeros(batch_size)\n", + " nxt_stt_values[not_final_mask]=target_net(not_final_nxt_stt).gather(1,\n", + " nxt_stt_act).squeeze().detach()\n", + " expected_stt_act_values=(nxt_stt_values.unsqueeze(1)*gma)+rwd_batch\n", + "\n", + " criterion=torch.nn.SmoothL1Loss()\n", + " loss=criterion(stt_act_values,\n", + " expected_stt_act_values)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " for param in policy_net.parameters():\n", + " param.grad.data.clamp_(-1,1)\n", + " optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_epis=1000\n", + "target_update=10\n", + "batch_size=256\n", + "gma=0.9\n", + "learning_r=0.001\n", + "eps_begin=1\n", + "eps_end=0.05\n", + "eps_decay=10000\n", + "steps_done=0\n", + "memory=ReplayMemory(10000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "env_ddqn=RoverGridEnv(max_ts=30)\n", + "\n", + "policy_net_ddqn=rover_DDQN(env_ddqn.observation_space.shape[0],\n", + " env_ddqn.action_space.n).float()\n", + "target_net_ddqn=rover_DDQN(env_ddqn.observation_space.shape[0],\n", + " env_ddqn.action_space.n).float()\n", + "target_net_ddqn.load_state_dict(policy_net_ddqn.state_dict())\n", + "target_net_ddqn.eval()\n", + "optimizer=optim.Adam(policy_net_ddqn.parameters(),\n", + " learning_r=learning_r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training Episodes: 100%|██████████| 1000/1000 [03:45<00:00, 4.43it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Complete\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "episode_rwds_ddqn=[]\n", + "epsilon_values_ddqn=[]\n", + "\n", + "for episode in tqdm(range(num_epis),desc=\"Training Episodes\"):\n", + " state=env_ddqn.reset()\n", + " state=torch.tensor(np.array([state]),dtype=torch.float)\n", + " total_reward=0 \n", + " \n", + " for t in count():\n", + " action_1,steps_done=select_act(state,policy_net_ddqn,\n", + " env_ddqn.action_space.n,\n", + " steps_done,\n", + " eps_begin,\n", + " eps_end,\n", + " eps_decay)\n", + " action_2,steps_done=select_act(state,policy_net_ddqn,\n", + " env_ddqn.action_space.n,\n", + " steps_done,\n", + " eps_begin,\n", + " eps_end,\n", + " eps_decay) \n", + " \n", + " nxt_stt,reward,done,_=env_ddqn.step((action_1.item(),\n", + " action_2.item())) \n", + " nxt_stt=torch.tensor([nxt_stt],\n", + " dtype=torch.float)\n", + " reward=torch.tensor([reward],\n", + " dtype=torch.float)\n", + " \n", + " total_reward+=reward.sum().item() \n", + " memory.push(state,\n", + " (action_1,action_2),\n", + " nxt_stt,\n", + " reward,\n", + " torch.tensor([done]))\n", + " \n", + " state=nxt_stt\n", + " optimize_model_ddqn(memory,\n", + " policy_net_ddqn,\n", + " target_net_ddqn,\n", + " optimizer,\n", + " batch_size,\n", + " gma)\n", + " if done:\n", + " break\n", + " if episode % target_update == 0:\n", + " target_net_ddqn.load_state_dict(policy_net_ddqn.state_dict())\n", + " \n", + " episode_rwds_ddqn.append(total_reward)\n", + " epsilon_values_ddqn.append(eps_end+(eps_begin-eps_end)*np.exp(-1.*steps_done/eps_decay))\n", + "print('Complete')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHWCAYAAABACtmGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABnDUlEQVR4nO3dd3hUddrG8XtKMukJJCSBEAhFKdJBIAJWyoKCWMFCc0VRWFF8LeiioqtY1rIWrAvYQXRVVCwBQVB6Cb33llBCeptkzvtHYCQGSAaSnEny/VzXXMmcMuc54aHc/M75HYthGIYAAAAAAGdkNbsAAAAAAPB2BCcAAAAAKAXBCQAAAABKQXACAAAAgFIQnAAAAACgFAQnAAAAACgFwQkAAAAASkFwAgAAAIBSEJwAAAAAoBQEJwCALr/8cl1++eXu97t375bFYtG0adNMqwkAAG9CcAIALzJt2jRZLJYzvpYsWWJ2iRVu+PDhxc45KChIjRs31o033qivvvpKLpfL7BIr3ak/D7vdrtq1a6tjx44aO3asNm7cWGL7k8H35MvHx0cRERG65JJL9Nhjj2nv3r1nPNbevXs1atQoxcXFyeFwKDIyUtddd50WLVpUYtv58+e7j7Fy5coS64cPH66goKDzO3kA8BJ2swsAAJT09NNPq1GjRiWWN23atEKO98svv1TI554rh8OhDz74QJKUk5OjPXv26LvvvtONN96oyy+/XN9++61CQkJMrrJy9erVS0OHDpVhGEpLS9OaNWv04YcfavLkyXrhhRc0bty4Evvccsst6tevn1wul44fP67ly5frtdde03/+8x/997//1eDBg4tt/8cff6hfv36SpDvvvFMtW7ZUUlKSpk2bpu7du+utt97SPffcc9r6nnrqKX333Xflf+IA4CUITgDghfr27atOnTpV2vF8fX0r7VhlYbfbdfvttxdb9q9//UvPP/+8xo8fr5EjR2rGjBkmVWeOCy+8sMTP5Pnnn1f//v314IMPqnnz5u7Qc1KHDh1K7LNnzx717t1bw4YNU4sWLdS2bVtJ0vHjx3XjjTfK399ff/zxh5o0aeLeZ9y4cerTp4/+8Y9/qH379uratWuxz2zXrp2+//57rVq1Sh06dCjP0wYAr8GlegBQBZ28FOvf//63Xn31VTVs2FD+/v667LLLtH79+mLbJiUlacSIEapfv74cDofq1q2ra6+9Vrt373Zv89d7nM7k119/VY8ePRQYGKiwsDBde+212rRpU7FtnnrqKVksFm3fvl3Dhw9XWFiYQkNDNWLECGVnZ5/XeT/66KPq3bu3Zs6cqa1btxZb9+OPP7prCw4O1tVXX60NGzaU+IzNmzfr5ptvVp06deTv769mzZrp8ccfd6/fs2eP7r33XjVr1kz+/v4KDw/XTTfdVOzntXPnTlksFr366qslPn/RokWyWCz6/PPPz+tcyyI8PFzTp0+X3W7Xs88+W6Z9GjZsqGnTpik/P18vvviie/m7776rpKQkvfTSS8VCkyT5+/vrww8/lFQ0GvpX//jHP1SrVi099dRT534yAODlCE4A4IXS0tJ09OjRYq9jx46V2O6jjz7S66+/rtGjR2v8+PFav369rrzySiUnJ7u3ueGGG/T1119rxIgRmjx5su677z5lZGSc9T6X05kzZ4769Omjw4cP66mnntK4ceO0aNEidevWrVioOOnmm29WRkaGJk2apJtvvlnTpk3TxIkTPf5Z/NWQIUNkGIYSEhLcyz7++GNdffXVCgoK0gsvvKAJEyZo48aN6t69e7Ha1q5dqy5duujXX3/VyJEj9Z///EcDBw4sdonZ8uXLtWjRIg0ePFivv/66Ro0apblz5+ryyy93B7/GjRurW7du+vTTT0vU9+mnnyo4OFjXXnvteZ9rWTRo0ECXXXaZlixZovT09DLtEx8fryZNmhT7GX733Xfy8/PTzTfffNp9GjVqpO7du2vOnDnKzc0tti4kJEQPPPCAvvvuO61atercTwYAvJkBAPAaU6dONSSd9uVwONzb7dq1y5Bk+Pv7G/v373cvX7p0qSHJeOCBBwzDMIzjx48bkoyXXnrprMe97LLLjMsuu6zE50+dOtW9rF27dkZkZKRx7Ngx97I1a9YYVqvVGDp0qHvZk08+aUgy7rjjjmLHuO6664zw8PBSfwbDhg0zAgMDz7h+9erVxc4xIyPDCAsLM0aOHFlsu6SkJCM0NLTY8ksvvdQIDg429uzZU2xbl8vl/j47O7vEMRcvXmxIMj766CP3snfffdeQZGzatMm9LD8/34iIiDCGDRtW6nl6QpIxevToM64fO3asIclYs2aNYRh//vqd7df92muvNSQZaWlphmEYRlhYmNG2bduz1nHfffcZkoy1a9cahmEY8+bNMyQZM2fONFJTU41atWoZAwYMcG9f2q8lAFQljDgBgBd66623lJCQUOz1448/lthu4MCBiomJcb/v3LmzunTpotmzZ0squsTK19dX8+fP1/Hjx8+5nkOHDikxMVHDhw9X7dq13cvbtGmjXr16uY93qlGjRhV736NHDx07dqzMoyJncnKWtoyMDElSQkKCUlNTdcsttxQbobPZbOrSpYvmzZsnSTpy5IgWLFigO+64Qw0aNCj2mRaLxf29v7+/+3un06ljx46padOmCgsLKzaacvPNN8vPz6/YqNPPP/+so0ePlrivqKL99WdyLvtkZGQoODj4rPucXH+644SGhur+++/XrFmztHr16jLXAQBVBcEJALxQ586d1bNnz2KvK664osR2F1xwQYllF154ofvyNIfDoRdeeEE//vijoqKidOmll+rFF19UUlKSR/Xs2bNHktSsWbMS61q0aKGjR48qKyur2PK/hpNatWpJ0nkFOEnKzMyU9Oc/4rdt2yZJuvLKK1WnTp1ir19++UWHDx+WVHRfkiS1atXqrJ+fk5OjJ554QrGxsXI4HIqIiFCdOnWUmpqqtLQ093ZhYWHq37+/PvvsM/eyTz/9VDExMbryyivPeoykpKRir5ycHA9/CsX99WdyLvsEBweXGrxOro+MjDzt+rFjxyosLIx7nQBUS8yqBwDV3P3336/+/fvrm2++0c8//6wJEyZo0qRJ+vXXX9W+ffsKO67NZjvtcsMwzutzT05+cXJq9pPPdfr4448VHR1dYnu73bO/6v7xj39o6tSpuv/++xUfH6/Q0FBZLBYNHjy4xDOkhg4dqpkzZ2rRokVq3bq1Zs2apXvvvVdW69n/X7Ju3brF3k+dOlXDhw/3qM5TrV+/Xjab7bRT2J9tn8jISPe07i1bttSqVauUl5cnh8Nx2n3Wrl0rX1/fYqOcpzo56vTUU08x6gSg2iE4AUAVdnK05VRbt25VXFxcsWVNmjTRgw8+qAcffFDbtm1Tu3bt9PLLL+uTTz4p03EaNmwoSdqyZUuJdZs3b1ZERIQCAwM9P4Fz8PHHH8tisahXr16S5J4BLjIyUj179jzjfo0bN5akErMO/tWXX36pYcOG6eWXX3Yvy83NVWpqaolt//a3v6lOnTr69NNP1aVLF2VnZ2vIkCGlnsOpkzJI0kUXXVTqPmeyd+9e/fbbb4qPjy/ziNPixYu1Y8eOYpcU9u/fX4sWLdLMmTNPe6nh7t27tXDhQl177bXFLmf8q/vvv1+vvfaaJk6cqLCwMI/PBwC8FZfqAUAV9s033+jAgQPu98uWLdPSpUvVt29fSVJ2dnaJGdCaNGmi4OBg5eXllfk4devWVbt27fThhx8WCxDr16/XL7/8UuL5QRXl+eef1y+//KJBgwa5L1Ps06ePQkJC9Nxzz8npdJbY58iRI5KkOnXq6NJLL9WUKVNKzCh46iiYzWYrMSr2xhtvqLCwsMRn2+123XLLLfriiy80bdo0tW7dWm3atCn1PP56GeZfR6DKKiUlRbfccosKCwuLTal+Nnv27NHw4cPl6+urhx56yL387rvvVnR0tB566CH3ZY0n5ebmasSIEbJYLHr44YfP+vknR52+/fZbJSYmenxOAOCtGHECAC/0448/avPmzSWWX3LJJe6RE6nocrXu3bvrnnvuUV5enl577TWFh4e7/3G7detWXXXVVbr55pvVsmVL2e12ff3110pOTtbgwYM9qumll15S3759FR8fr7///e/KycnRG2+8odDQ0HK/p6WgoMA9Gpabm6s9e/Zo1qxZWrt2ra644gq999577m1DQkL09ttva8iQIerQoYMGDx6sOnXqaO/evfrhhx/UrVs3vfnmm5Kk119/Xd27d1eHDh101113qVGjRtq9e7d++OEH9z/yr7nmGn388ccKDQ1Vy5YttXjxYs2ZM0fh4eGnrXXo0KF6/fXXNW/ePL3wwgvl+nM41datW/XJJ5/IMAylp6drzZo1mjlzpjIzM/XKK6/ob3/7W4l9Vq1apU8++UQul0upqalavny5vvrqK1ksFn388cfFQl6tWrX05Zdfql+/furQoYPuvPNOtWzZUklJSZo2bZp27typN998U126dCm11rFjx+rVV1/VmjVrKm0kEgAqnLmT+gEATnW26ch1yvTgp043/fLLLxuxsbGGw+EwevTo4Z6S2jAM4+jRo8bo0aON5s2bG4GBgUZoaKjRpUsX44svvih23LJMR24YhjFnzhyjW7duhr+/vxESEmL079/f2LhxY7FtTk5HfuTIkdOe265du876Mxg2bFixcw4ICDDi4uKMG264wfjyyy+NwsLC0+43b948o0+fPkZoaKjh5+dnNGnSxBg+fLixYsWKYtutX7/euO6664ywsDDDz8/PaNasmTFhwgT3+uPHjxsjRowwIiIijKCgIKNPnz7G5s2bjYYNG55xmvGLLrrIsFqtxaaGL0+n/jysVqsRFhZmtG/f3hg7dqyxYcOGEtuf/PU7+bLb7Ubt2rWNLl26GOPHjy8xHfupdu/ebdx1111GgwYNDLvd7v6MOXPmlNj21OnI/+pkHzAdOYDqwmIY53mXLgCg0u3evVuNGjXSSy+9pP/7v/8zu5war3379qpdu7bmzp1rdinlbu7cuerXr5+6d++uH3/8Ub6+vmaXBACm4B4nAADOw4oVK5SYmKihQ4eaXUqFuOqqq/Thhx9q3rx5GjFixHnPiggAVRX3OAEAcA7Wr1+vlStX6uWXX1bdunU1aNAgs0uqMIMHD/b4njgAqG4YcQIA4Bx8+eWXGjFihJxOpz7//HP5+fmZXRIAoAJxjxMAAAAAlIIRJwAAAAAoBcEJAAAAAEpR4yaHcLlcOnjwoIKDg2WxWMwuBwAAAIBJDMNQRkaG6tWrJ6v17GNKNS44HTx4ULGxsWaXAQAAAMBL7Nu3T/Xr1z/rNjUuOAUHB0sq+uGEhISYXI3kdDr1yy+/qHfv3vLx8TG7HFQB9Aw8Rc/AU/QMPEXPwFPe0jPp6emKjY11Z4SzqXHB6eTleSEhIV4TnAICAhQSEsIfNCgTegaeomfgKXoGnqJn4Clv65my3MLD5BAAAAAAUAqCEwAAAACUguAEAAAAAKUgOAEAAABAKQhOAAAAAFAKghMAAAAAlILgBAAAAAClIDgBAAAAQClMDU4LFixQ//79Va9ePVksFn3zzTel7jN//nx16NBBDodDTZs21bRp0yq8TgAAAAA1m6nBKSsrS23bttVbb71Vpu137dqlq6++WldccYUSExN1//33684779TPP/9cwZUCAAAAqMnsZh68b9++6tu3b5m3f+edd9SoUSO9/PLLkqQWLVro999/16uvvqo+ffpUVJkAAAAAajhTg5OnFi9erJ49exZb1qdPH91///1n3CcvL095eXnu9+np6ZIkp9Mpp9NZIXV64mQN3lALqgZ6Bp6iZ+ApegaeomfgKW/pGU+OX6WCU1JSkqKioooti4qKUnp6unJycuTv719in0mTJmnixIkllv/yyy8KCAiosFrLyjAkl6SEhASzS0EVQ8/AU/QMPEXPwFP0DDxlds9kZ2eXedsqFZzOxfjx4zVu3Dj3+/T0dMXGxqp3794KCQkxsTJp2uI9mvrHHl1ZJ0uP3dpTPj4+ptaDqsHpdCohIUG9evWiZ1Am9Aw8Rc/AU/QMPOUtPXPyarSyqFLBKTo6WsnJycWWJScnKyQk5LSjTZLkcDjkcDhKLPfx8TH9N3ZGnksH03K12mrxinpQtdAz8BQ9A0/RM/AUPQNPmd0znhy7Sj3HKT4+XnPnzi22LCEhQfHx8SZVdH76t6krSdqcalFaDtcEAwAAAN7K1OCUmZmpxMREJSYmSiqabjwxMVF79+6VVHSZ3dChQ93bjxo1Sjt37tTDDz+szZs3a/Lkyfriiy/0wAMPmFH+ebsgKlgXRgap0LAoYdNhs8sBAAAAcAamBqcVK1aoffv2at++vSRp3Lhxat++vZ544glJ0qFDh9whSpIaNWqkH374QQkJCWrbtq1efvllffDBB1V6KvJ+raMlSbPXJZlcCQAAAIAzMfUep8svv1yGYZxx/bRp0067z+rVqyuwqsp1desovTZ3uxbtTFFKVr5qB/qaXRIAAACAv6hS9zhVR3HhgaofaKjQZein9Yw6AQAAAN6I4OQF2oe7JEnfrz1ociUAAAAATofg5AXahxddrrhk5zEdycgzuRoAAAAAf0Vw8gLhflKb+iFyGdKP6w+ZXQ4AAACAvyA4eYmrWxXNrvf9GoITAAAA4G0ITl6i74ngtHxPipLSck2uBgAAAMCpCE5eom6onzo1rCXDkH5Yx6gTAAAA4E0ITl7kmjZ1JTG7HgAAAOBtCE5epF/rurJYpNV7U7X/eLbZ5QAAAAA4geDkRSJD/NSlUW1J0g9ruVwPAAAA8BYEJy9zTZt6kqTvCU4AAACA1yA4eZm+raJls1q07kCadh/NMrscAAAAACI4eZ3wIIe6NY2QJH2byCQRAAAAgDcgOHmhge2KLtf7NvGADMMwuRoAAAAABCcv1PuiaPn5WLXzaJbW7k8zuxwAAACgxiM4eaEgh129W0ZLkr5JPGByNQAAAAAITl5qYPuiy/W+W3NIBYUuk6sBAAAAajaCk5fqcUEd1Q701dHMPC3acczscgAAAIAajeDkpXxsVl3Tpq4k6ZvVXK4HAAAAmIng5MWubRcjSfp5Q5Jy8gtNrgYAAACouQhOXqxDgzA1qB2grPxCJWxKNrscAAAAoMYiOHkxi8XifqYTl+sBAAAA5iE4eblr2xddrrdg6xGlZOWbXA0AAABQMxGcvFyTOkFqHROqApehH9YeNLscAAAAoEYiOFUBA0+MOn3N5XoAAACAKQhOVUD/tnVltUir9qZq77Fss8sBAAAAahyCUxUQGeynbk0jJEnfJjLqBAAAAFQ2glMVMbDdn5frGYZhcjUAAABAzUJwqiL6tIqWv49NO49mafW+VLPLAQAAAGoUglMVEeSwq2/raEnSlyv3m1wNAAAAULMQnKqQGzvWlyR9t+agcp2FJlcDAAAA1BwEpyqka6NwxYT5KyO3QAkbk80uBwAAAKgxCE5ViNVq0Q0diiaJ4HI9AAAAoPIQnKqYG05crrdw2xElpeWaXA0AAABQMxCcqpiG4YHqHFdbLqNoanIAAAAAFY/gVAXd0PHk5Xr7eKYTAAAAUAkITlVQv9Z15edj1Y4jWVqzP83scgAAAIBqj+BUBQX7+ahvq7qSikadAAAAAFQsglMVdfKZTrMSeaYTAAAAUNEITlVUfONw1Qv1U3pugeZs4plOAAAAQEUiOFVRVqtF13coGnXimU4AAABAxSI4VWEnn+m0YOsRHU7nmU4AAABARSE4VWGNIgLVqWEtuQzpq1U80wkAAACoKASnKu6mTkWjTl+s4JlOAAAAQEUhOFVx17Spp0Bfm3YdzdLSXSlmlwMAAABUSwSnKi7QYdeAdvUkSdOX7TW5GgAAAKB6IjhVA4MvbiBJmr0+SWnZTpOrAQAAAKofglM10KZ+qJpHByu/wKWvVzM1OQAAAFDeCE7VgMVi0eCLYyVJ05czSQQAAABQ3ghO1cR17evL127V5qQMrd2fZnY5AAAAQLVCcKomQgN81K9VtCRp+nImiQAAAADKE8GpGhncuWiSiFmJB5WVV2ByNQAAAED1QXCqRro0qq1GEYHKyi/U92sPml0OAAAAUG0QnKoRi8WiQadMEgEAAACgfBCcqpkbOtSX3WrR6r2p2pKUYXY5AAAAQLVAcKpm6gQ71LNFlCQmiQAAAADKC8GpGhrUuehyvf+tOqBcZ6HJ1QAAAABVH8GpGrr0gjqKCfNXWo5Ts9cdMrscAAAAoMojOFVDNqtFt5wYdfp4yR6TqwEAAACqPoJTNXXzxbHysRVNErH+QJrZ5QAAAABVGsGpmooM9lOfi6IlSZ8uZdQJAAAAOB8Ep2psSNeGkqRvVh9Ueq7T5GoAAACAqovgVI11blRbF0YFKcdZqP+t3G92OQAAAECVRXCqxiwWi27rUjTq9MnSvTIMw+SKAAAAgKrJ9OD01ltvKS4uTn5+furSpYuWLVt21u1fe+01NWvWTP7+/oqNjdUDDzyg3NzcSqq26rmuQ4wCfG3afjhTS3ammF0OAAAAUCWZGpxmzJihcePG6cknn9SqVavUtm1b9enTR4cPHz7t9p999pkeffRRPfnkk9q0aZP++9//asaMGXrssccqufKqI8TPR9e2i5EkfcIkEQAAAMA5MTU4vfLKKxo5cqRGjBihli1b6p133lFAQICmTJly2u0XLVqkbt266dZbb1VcXJx69+6tW265pdRRqpru9q4NJEk/r0/S4QxG5wAAAABP2c06cH5+vlauXKnx48e7l1mtVvXs2VOLFy8+7T6XXHKJPvnkEy1btkydO3fWzp07NXv2bA0ZMuSMx8nLy1NeXp77fXp6uiTJ6XTK6TR/prmTNVRkLRfWCVD72FCt3pemz5bs0ejLG1fYsVDxKqNnUL3QM/AUPQNP0TPwlLf0jCfHNy04HT16VIWFhYqKiiq2PCoqSps3bz7tPrfeequOHj2q7t27yzAMFRQUaNSoUWe9VG/SpEmaOHFiieW//PKLAgICzu8kylFCQkKFfv5FDotWy6ZpC7epQdZm2SwVejhUgoruGVQ/9Aw8Rc/AU/QMPGV2z2RnZ5d5W9OC07mYP3++nnvuOU2ePFldunTR9u3bNXbsWD3zzDOaMGHCafcZP368xo0b536fnp6u2NhY9e7dWyEhIZVV+hk5nU4lJCSoV69e8vHxqbDjXOUs1A//XqDj2U75N+6kni0iK+xYqFiV1TOoPugZeIqegafoGXjKW3rm5NVoZWFacIqIiJDNZlNycnKx5cnJyYqOjj7tPhMmTNCQIUN05513SpJat26trKws3XXXXXr88cdltZa8ZcvhcMjhcJRY7uPj41W/sSu6Hh8fH93cKVbvLtipz5bvV982MRV2LFQOb+theD96Bp6iZ+ApegaeMrtnPDm2aZND+Pr6qmPHjpo7d657mcvl0ty5cxUfH3/afbKzs0uEI5vNJkk8o6gMbu/aUBaLtHDbUW0/nGF2OQAAAECVYeqseuPGjdP777+vDz/8UJs2bdI999yjrKwsjRgxQpI0dOjQYpNH9O/fX2+//bamT5+uXbt2KSEhQRMmTFD//v3dAQpnFls7QD1bFN1TNm3RbnOLAQAAAKoQU+9xGjRokI4cOaInnnhCSUlJateunX766Sf3hBF79+4tNsL0z3/+UxaLRf/85z914MAB1alTR/3799ezzz5r1ilUOSO6xSlhY7K+WnlAD/VurtAAhtMBAACA0pg+OcSYMWM0ZsyY066bP39+sfd2u11PPvmknnzyyUqorHqKbxyuZlHB2pKcoS9W7NPIS5maHAAAACiNqZfqofJZLBaN6BYnSfpw8W4Vurg3DAAAACgNwakGGtg+RrUCfLT/eI7mbEoufQcAAACghiM41UB+Pjbd0rmBJGnqH7tMrgYAAADwfgSnGur2rg1ls1q0ZGeKNh0q+4O/AAAAgJqI4FRD1Qvz199aFT1oeNofu80tBgAAAPByBKca7I4Tk0R8k3hAKVn55hYDAAAAeDGCUw3WoUEttY4JVV6BS58v22t2OQAAAIDXIjjVYKdOTf7x4j1yFrrMLQgAAADwUgSnGu7qNnUVEeRQUnquflyfZHY5AAAAgFciONVwDrtNQ7o2lCS9v2CnDIMH4gIAAAB/RXCChsQ3lMNu1boDaVq6K8XscgAAAACvQ3CCagf66qZO9SUVjToBAAAAKI7gBEnS37s3lsUizd18WNsPZ5hdDgAAAOBVCE6QJDWKCFTvllGSpA8W7jK5GgAAAMC7EJzgdteljSVJ/1t1QIczck2uBgAAAPAeBCe4dWxYWx0ahCm/0KWPF+8xuxwAAADAaxCcUMzJUaePl+xRdn6BydUAAAAA3oHghGJ6tYxWw/AApWY7NXPFfrPLAQAAALwCwQnF2KwW3dm9kSTpg993qtDFA3EBAAAAghNKuLFjrGoF+GhfSo5+3pBkdjkAAACA6QhOKMHf16YhXRtKkt5dsFOGwagTAAAAajaCE05rSHycfO1WrdmXqiU7U8wuBwAAADAVwQmnVSfYoUGdYiVJk+dvN7kaAAAAwFwEJ5zRXZc2ls1q0cJtR7V2f6rZ5QAAAACmITjhjGJrB+jatvUkSZPn7TC5GgAAAMA8BCec1T2XN5Ek/bQhSdsPZ5hcDQAAAGAOghPO6oKoYPVuGSVJenv+TpOrAQAAAMxBcEKp7r2iqSTpm8QD2peSbXI1AAAAQOUjOKFU7WLD1L1phApdht5fyKgTAAAAah6CE8rk3hP3Os1Yvk9HMvJMrgYAAACoXAQnlEl8k3C1iw1TXoFLU/7YZXY5AAAAQKUiOKFMLBaLRp+41+njxXuUluM0uSIAAACg8hCcUGZXNY/UhVFByswr0EeLdptdDgAAAFBpCE4oM6vVonsvLxp1+u8fu5SZV2ByRQAAAEDlIDjBI9e0qavGEYFKzXbqQ0adAAAAUEMQnOARu82qf1xVNOr0/sKdjDoBAACgRiA4wWP929Rj1AkAAAA1CsEJHjt11OkDRp0AAABQAxCccE76t6mnRhGBOp7t1EeLd5tdDgAAAFChCE44J3abVf+48sS9TgsYdQIAAED1RnDCORvQllEnAAAA1AwEJ5yzv446ZTHqBAAAgGqK4ITzMqBtPcWFB5wYddpjdjkAAABAhSA44bwUjTpdIEl6b8EORp0AAABQLRGccN6ubffnqNM0nusEAACAaojghPNmt1l1f88LJUnv/LZDadlOkysCAAAAyhfBCeWif9t6ahYVrIzcAr27YIfZ5QAAAADliuCEcmGzWvRg76JRp6l/7NbhjFyTKwIAAADKD8EJ5aZXyyi1iw1TjrNQk+cx6gQAAIDqg+CEcmOxWPRwn2aSpE+X7tH+49kmVwQAAACUD4ITytUlTSPUrWm4nIWG/jNnm9nlAAAAAOXinIJTamqqPvjgA40fP14pKSmSpFWrVunAgQPlWhyqpv/rXTTq9NWq/dp+ONPkagAAAIDz53FwWrt2rS688EK98MIL+ve//63U1FRJ0v/+9z+NHz++vOtDFdS+QS31ahkllyG9mrDV7HIAAACA8+ZxcBo3bpyGDx+ubdu2yc/Pz728X79+WrBgQbkWh6rrwd4XymKRflh3SOsPpJldDgAAAHBePA5Oy5cv1913311ieUxMjJKSksqlKFR9zaNDdG3bepKkl37eYnI1AAAAwPnxODg5HA6lp6eXWL5161bVqVOnXIpC9fBArwtlt1r029YjWrTjqNnlAAAAAOfM4+A0YMAAPf3003I6nZKKpqDeu3evHnnkEd1www3lXiCqrobhgbq1SwNJ0vM/bpbLZZhcEQAAAHBuPA5OL7/8sjIzMxUZGamcnBxddtllatq0qYKDg/Xss89WRI2owu676gIF+tq0dn+aflh3yOxyAAAAgHNi93SH0NBQJSQk6Pfff9fatWuVmZmpDh06qGfPnhVRH6q4iCCH7rq0iV6ds1Uv/bxFfS6Klq+dx4cBAACgavE4OJ3UvXt3de/evTxrQTV1Z49G+mTpHu1NydanS/doRLdGZpcEAAAAeMTj4PT000+fdf0TTzxxzsWgegp02HV/zwv0+Nfr9cav23VDx/oK8fMxuywAAACgzDwOTl9//XWx906nU7t27ZLdbleTJk0ITjitQZ1i9d/fd2nnkSxNnrdDj/ZtbnZJAAAAQJl5HJxWr15dYll6erqGDx+u6667rlyKQvVjt1n1WN8WuvOjFZry+y4NvjhWcRGBZpcFAAAAlEm53KUfEhKiiRMnasKECeXxcaimrmoRqcsurKP8Qpee+X6j2eUAAAAAZVZu05ulpaUpLS3N4/3eeustxcXFyc/PT126dNGyZcvOun1qaqpGjx6tunXryuFw6MILL9Ts2bPPtWxUIovFoif6t5TdatHczYe1YOsRs0sCAAAAysTjS/Vef/31Yu8Nw9ChQ4f08ccfq2/fvh591owZMzRu3Di988476tKli1577TX16dNHW7ZsUWRkZInt8/Pz1atXL0VGRurLL79UTEyM9uzZo7CwME9PAyZpUidIQ+PjNOWPXfrXDxs1u0kP2W1MTw4AAADv5nFwevXVV4u9t1qtqlOnjoYNG6bx48d79FmvvPKKRo4cqREjRkiS3nnnHf3www+aMmWKHn300RLbT5kyRSkpKVq0aJF8fIpmZYuLi/P0FGCysVddoK9X79fW5Ex9vmyvhsTHmV0SAAAAcFYeB6ddu3aVy4Hz8/O1cuXKYmHLarWqZ8+eWrx48Wn3mTVrluLj4zV69Gh9++23qlOnjm699VY98sgjstlsp90nLy9PeXl57vfp6emSimYDdDqd5XIu5+NkDd5QS2UJ8JHGXtVUT323Sa8kbFXfiyIV6s/05GVVE3sG54eegafoGXiKnoGnvKVnPDn+OT8A93wdPXpUhYWFioqKKrY8KipKmzdvPu0+O3fu1K+//qrbbrtNs2fP1vbt23XvvffK6XTqySefPO0+kyZN0sSJE0ss/+WXXxQQEHD+J1JOEhISzC6hUoUYUl1/mw5lO/XglLm6vpHL7JKqnJrWMzh/9Aw8Rc/AU/QMPGV2z2RnZ5d52zIFp+uvv77MH/i///2vzNt6yuVyKTIyUu+9955sNps6duyoAwcO6KWXXjpjcBo/frzGjRvnfp+enq7Y2Fj17t1bISEhFVZrWTmdTiUkJKhXr17uyw9ritrNj2n4tJX647BN42/uoSZ1mJ68LGpyz+Dc0DPwFD0DT9Ez8JS39MzJq9HKokzBKTQ09JyLOZOIiAjZbDYlJycXW56cnKzo6OjT7lO3bl35+PgUuyyvRYsWSkpKUn5+vnx9fUvs43A45HA4Siz38fHxqt/Y3lZPZbi8ebR6tojSnE3JeuHnrZo6orPZJVUpNbFncH7oGXiKnoGn6Bl4yuye8eTYZQpOU6dOPedizsTX11cdO3bU3LlzNXDgQElFI0pz587VmDFjTrtPt27d9Nlnn8nlcslqLZqJbevWrapbt+5pQxO83+NXt9BvWw9r3pYjmr/lsC5vVnI2RQAAAMBsps4DPW7cOL3//vv68MMPtWnTJt1zzz3Kyspyz7I3dOjQYpNH3HPPPUpJSdHYsWO1detW/fDDD3ruuec0evRos04B56lRRKCGXxInSfrXD5vkLOReJwAAAHifc5oc4ssvv9QXX3yhvXv3Kj8/v9i6VatWlflzBg0apCNHjuiJJ55QUlKS2rVrp59++sk9YcTevXvdI0uSFBsbq59//lkPPPCA2rRpo5iYGI0dO1aPPPLIuZwGvMSYKy/QV6sOaPvhTH2yZI9GdGtkdkkAAABAMR6POL3++usaMWKEoqKitHr1anXu3Fnh4eHauXOnxw/AlaQxY8Zoz549ysvL09KlS9WlSxf3uvnz52vatGnFto+Pj9eSJUuUm5urHTt26LHHHjvjVOSoGkL9ffR/vZtJkl5N2KqjmXml7AEAAABULo+D0+TJk/Xee+/pjTfekK+vrx5++GElJCTovvvuU1paWkXUiBpg0MWxahUTovTcAr300xazywEAAACK8Tg47d27V5dccokkyd/fXxkZGZKkIUOG6PPPPy/f6lBj2KwWTRzQSpI0Y8U+Je5LNbcgAAAA4BQeB6fo6GilpKRIkho0aKAlS5ZIknbt2iXDMMq3OtQoHRvW0o0d60uSnvh2vQpd9BMAAAC8g8fB6corr9SsWbMkSSNGjNADDzygXr16adCgQbruuuvKvUDULI/8rbmCHXat3Z+msdNXy0V4AgAAgBco86x633//vfr166f33ntPLlfRlNGjR49WeHi4Fi1apAEDBujuu++usEJRM9QJdujZ61tr3IxEfb/2kHpcEKFBFzcwuywAAADUcGUOTgMHDlRUVJSGDx+uO+64Q02aNJEkDR48WIMHD66wAlHzDGhbT0lpOXpu9mZN+nGzerWMVu1AHnAMAAAA85T5Ur1du3bp7rvv1vTp03XhhRfqsssu08cff6ycnJyKrA811IhujdQ8Olip2U5Nmr3J7HIAAABQw5U5OMXGxuqJJ57Qjh07NGfOHMXFxemee+5R3bp1NWrUKC1fvrwi60QN42Oz6tnrimbZm7lyv5btSjG5IgAAANRkHk8OIUlXXHGFPvzwQx06dEgvvfSS1q1bp65du6pt27blXR9qsI4Na+uWzrGSpH9+s07OQpfJFQEAAKCmOqfgdFJwcLCuuuoqXXHFFQoLC9PGjRvLqy5AUtEse7UDfbU1OVP//X2X2eUAAACghjqn4JSTk6OPPvpIl19+uS644AJNnz5d48aN0+7du8u5PNR0YQG+Gt+3uSTpP3O2af/xbJMrAgAAQE3kUXBasmSJ7rrrLvd9TfXr19ecOXO0fft2Pf7444qJiamoOlGD3dixvjo3qq0cZ6Ee/3q9CrhkDwAAAJWszMGpZcuW6tatm1atWqVJkybp0KFD+uSTT3TFFVdUZH2ALBaLnh3YSj42i37bekSPf73e7JIAAABQw5Q5OPXs2VOrVq3SihUrdM899yg0NLQi6wKKuSAqWG/e2kEWizRjxT4t2HrE7JIAAABQg5Q5OL3++uvMmgdT9bkoWsPi4yRJj329Tll5BeYWBAAAgBrjvGbVAyrbQ32aKSbMX/uP5+jfv2wxuxwAAADUEAQnVCmBDrueu761JGnaot1atfe4yRUBAACgJiA4ocq57MI6ur5DjAxDevSrtcovYJY9AAAAVCyCE6qkCVe3VPiJB+NOnr/d7HIAAABQzdnPZae5c+dq7ty5Onz4sFyu4v/bP2XKlHIpDDibWoG+emrARfrH56v11rzt6te6ri6MCja7LAAAAFRTHo84TZw4Ub1799bcuXN19OhRHT9+vNgLqCzXtKmrni0i5Sw09PCXa1XoMswuCQAAANWUxyNO77zzjqZNm6YhQ4ZURD1AmVksFj0zsJWW7lygxH2pmvrHLt3Zo7HZZQEAAKAa8njEKT8/X5dccklF1AJ4rG6ovx67uoUk6aWft2jnkUyTKwIAAEB15HFwuvPOO/XZZ59VRC3AORl8cay6N41QXoFL//h8NQ/GBQAAQLnz+FK93Nxcvffee5ozZ47atGkjHx+fYutfeeWVcisOKAuLxaIXbmyjAW/8rg0H0/XkrA36901tzS4LAAAA1YjHwWnt2rVq166dJGn9+vXF1lkslnIpCvBUTJi/Jt/WQYPfX6IvV+5X75ZR6n1RtNllAQAAoJrwODjNmzevIuoAzluXxuG669LGeve3nRr/v3Xq0LCWIoIcZpcFAACAauC8HoC7f/9+7d+/v7xqAc7buF4XqllUsI5l5Wv8/9bJMJiiHAAAAOfP4+Dkcrn09NNPKzQ0VA0bNlTDhg0VFhamZ555psTDcIHK5rDb9OqgdvKxWZSwMVlfriTYAwAA4Px5HJwef/xxvfnmm3r++ee1evVqrV69Ws8995zeeOMNTZgwoSJqBDzSsl6IHuh1oSRp4ncbtf94tskVAQAAoKrz+B6nDz/8UB988IEGDBjgXtamTRvFxMTo3nvv1bPPPluuBQLn4u5Lm2jupsNauee4/m/mGn12Z1dZrUxeAgAAgHPj8YhTSkqKmjdvXmJ58+bNlZKSUi5FAefLZrXo5Zvayt/HpiU7UzR10W6zSwIAAEAV5nFwatu2rd58880Sy9988021bcuzc+A94iIC9fjVLSRJL/y0WZuT0k2uCAAAAFWVx5fqvfjii7r66qs1Z84cxcfHS5IWL16sffv2afbs2eVeIHA+buvSQHM3JWveliO67/PVmjWmu/x8bGaXBQAAgCrG4xGnyy67TFu3btV1112n1NRUpaam6vrrr9eWLVvUo0ePiqgROGcWi0Uv3dRWEUEObU3O1L9+2Gh2SQAAAKiCPB5xkqR69eoxCQSqjIggh165ua2GTlmmT5bsVY8L6qjPRdFmlwUAAIAqpEzBae3atWX+wDZt2pxzMUBFufTCOhrZo5HeX7hLj3y1Vm3qh6puqL/ZZQEAAKCKKFNwateunSwWiwzDOOt2FotFhYWF5VIYUN4e6tNci3ce0/oD6XpgRqI+vbOrbExRDgAAgDIoU3DatWtXRdcBVDhfu1WvD26va974XUt2puid33Zo9BVNzS4LAAAAVUCZglPDhg0rug6gUjSuE6SJAy7SQ1+u1SsJWxXfJFwdGtQyuywAAAB4uTIFp1mzZqlv377y8fHRrFmzzrrtgAEDyqUwoKLc2LG+Fmw7qu/WHNR9n6/WD/f1UKi/j9llAQAAwIuVKTgNHDhQSUlJioyM1MCBA8+4Hfc4oSqwWCx69rpWStx3XPtScvTwl2v0zu0dZbFwvxMAAABOr0zPcXK5XIqMjHR/f6YXoQlVRYifj966tYN8bBb9vCFZU//YbXZJAAAA8GIePwD3dFJTU8vjY4BK1aZ+mB7r10KS9K8fNurnDUkmVwQAAABv5XFweuGFFzRjxgz3+5tuukm1a9dWTEyM1qxZU67FARVt+CVxuqVzrFyG9OAXa7TjSKbZJQEAAMALeRyc3nnnHcXGxkqSEhISNGfOHP3000/q27evHnrooXIvEKhIFotFz1zbSp0b1VZmXoHu+WSlsvMLzC4LAAAAXsbj4JSUlOQOTt9//71uvvlm9e7dWw8//LCWL19e7gUCFc1us+rNW9qrTrBDW5Mz9ehX60p92DMAAABqFo+DU61atbRv3z5J0k8//aSePXtKkgzDYHIIVFmRIX5669YOslktmrXmoD5avMfskgAAAOBFPA5O119/vW699Vb16tVLx44dU9++fSVJq1evVtOmTcu9QKCydG5UW+P7NpdUNFnEyj3HTa4IAAAA3sLj4PTqq69qzJgxatmypRISEhQUFCRJOnTokO69995yLxCoTH/v3kj9WkfLWWho9KerdCwzz+ySAAAA4AXK9ADcU/n4+Oj//u//Six/4IEHyqUgwEwWi0Uv3thWm5MytPNIlu6bvlofjugsu61cZu4HAABAFXVO/xrcsmWLxowZo6uuukpXXXWVxowZoy1btpR3bYApghx2vXt7RwX42vTH9mN64afNZpcEAAAAk3kcnL766iu1atVKK1euVNu2bdW2bVutWrVKrVq10ldffVURNQKV7oKoYP37praSpPcX7tJXK/ebXBEAAADM5PGleg8//LDGjx+vp59+utjyJ598Ug8//LBuuOGGcisOMFO/1nX1jyub6o1ft2v81+vUJDJI7WLDzC4LAAAAJvB4xOnQoUMaOnRoieW33367Dh06VC5FAd7igZ4XqmeLKOUXuHT3xyt0OD3X7JIAAABgAo+D0+WXX66FCxeWWP7777+rR48e5VIU4C2sVoteHdRWF0QGKTk9T3d/slK5Tp5XBgAAUNN4fKnegAED9Mgjj2jlypXq2rWrJGnJkiWaOXOmJk6cqFmzZhXbFqjqgv189P7QTrr2rT+0em+q/vnNer10YxtZLBazSwMAAEAl8Tg4nXxW0+TJkzV58uTTrpOKpnUuLOR/5lE9xEUE6s1b22vYlGX6cuV+tawboju6NzK7LAAAAFQSjy/Vc7lcZXoRmlDd9Ligjh7r10KS9K8fNmre5sMmVwQAAIDKwlM9AQ/8vXsj3dypvlyGNOazVdp0KN3skgAAAFAJyhyc+vXrp7S0NPf7559/Xqmpqe73x44dU8uWLcu1OMDbWCwW/Wtga8U3DldWfqH+Pm25Dmcw0x4AAEB1V+bg9PPPPysvL8/9/rnnnlNKSor7fUFBgbZs2VK+1QFeyNdu1Tu3d1TjiEAdTMvVyI+YaQ8AAKC6K3NwMgzjrO+BmiQ0wEdThl+ssAAfrdmXqvs+X62MXKfZZQEAAKCCcI8TcI7iIgL17u0d5WOz6JeNybrq5d+0cs9xs8sCAABABShzcLJYLCWeW1Nez7F56623FBcXJz8/P3Xp0kXLli0r037Tp0+XxWLRwIEDy6UOwFNdGofrwzs6Ky48QIcz8jR86jJtOJhW+o4AAACoUsr8HCfDMDR8+HA5HA5JUm5urkaNGqXAwEBJKnb/kydmzJihcePG6Z133lGXLl302muvqU+fPtqyZYsiIyPPuN/u3bv1f//3f+rRo8c5HRcoL5c0idCPYy/VsCnLtGx3im59f6mmDL9YHRvWMrs0AAAAlJMyjzgNGzZMkZGRCg0NVWhoqG6//XbVq1fP/T4yMlJDhw71uIBXXnlFI0eO1IgRI9SyZUu98847CggI0JQpU864T2FhoW677TZNnDhRjRs39viYQHnz97Xpg+Gd1L5BmNJynLpj2nJtS84wuywAAACUkzKPOE2dOrXcD56fn6+VK1dq/Pjx7mVWq1U9e/bU4sWLz7jf008/rcjISP3973/XwoULz3qMvLy8YqNh6elFz91xOp1yOs2/mf9kDd5QC86Pv036cFhHDZ22Qon70jR0yjJ9cVdnRYf4letx6Bl4ip6Bp+gZeIqegae8pWc8OX6Zg1NFOHr0qAoLCxUVFVVseVRUlDZv3nzafX7//Xf997//VWJiYpmOMWnSJE2cOLHE8l9++UUBAQEe11xREhISzC4B5eSmKOngEZsOpeVqwH9+06gWhYqugFajZ+ApegaeomfgKXoGnjK7Z7Kzs8u8ranByVMZGRkaMmSI3n//fUVERJRpn/Hjx2vcuHHu9+np6YqNjVXv3r0VEhJSUaWWmdPpVEJCgnr16iUfHx+zy0E5ib80WyOmrdKelGxN2RWoGSM7KybMv1w+m56Bp+gZeIqegafoGXjKW3rm5NVoZWFqcIqIiJDNZlNycnKx5cnJyYqOji6x/Y4dO7R7927179/fvczlckmS7Ha7tmzZoiZNmhTbx+FwuCe0OJWPj49X/cb2tnpwfhpHhuqb0d1007uLtf1wpu74cJVmjopXeFDJXjxX9Aw8Rc/AU/QMPEXPwFNm94wnxzb1OU6+vr7q2LGj5s6d617mcrk0d+5cxcfHl9i+efPmWrdunRITE92vAQMG6IorrlBiYqJiY2Mrs3zgrGoF+urjvxeNNO08mqXhU5crM6/A7LIAAABwDky/VG/cuHEaNmyYOnXqpM6dO+u1115TVlaWRowYIUkaOnSoYmJiNGnSJPn5+alVq1bF9g8LC5OkEssBb1A31F8f/72zbnxnsdYdSNNdH63QlOEXy8/HZnZpAAAA8ICpI06SNGjQIP373//WE088oXbt2ikxMVE//fSTe8KIvXv36tChQyZXCZy7xnWC9OGIzgr0tWnRjmMa/N4SbT/MVOUAAABViekjTpI0ZswYjRkz5rTr5s+ff9Z9p02bVv4FAeWsdf1QvT+sk+7+aKUS96VqwJt/6KM7OqtTXG2zSwMAAEAZmD7iBNQUlzSJ0C/jLlXXxrWVnV+oEVOXa93+NLPLAgAAQBkQnIBKVDfUX1OHd1bnRrWVkVegIVOWaksSl+0BAAB4O4ITUMn8fW2aMvxitY0NU2q2U7d9sFTrDzDyBAAA4M0IToAJghx2fTSis1rUDdHRzDxd+9Yf+jbxgNllAQAA4AwIToBJQgN89OmdXdSzRZQKXYYemJFIeAIAAPBSBCfARLUDffXekI66uVN9uQwRngAAALyUV0xHDtRkVqtFz1/fRpL0xYr9emBGoiTp2nYxJlYFAACAUxGcAC9AeAIAAPBuXKoHeImT4enUy/a+Xr3f7LIAAAAgghPgVUqGpzV65Mu1ynUWml0aAABAjUZwArzMyfA06rImslikGSv26Zb3l2jToXSzSwMAAKixCE6AF7JaLXq0b3N98vcuCnLYtXpvqq6fvEhzNyWbXRoAAECNRHACvFi3phH6cWwP9bggQjnOQo38aIU+XLxHhYbZlQEAANQsBCfAy8XWDtCU4Rfrxo5F9z39a/YWvb/ZquT0XLNLAwAAqDEITkAV4GOz6sUb2mjCNS3l52PVplSrrn5zkX5cd0iGwfATAABARSM4AVWE1WrR37s30qd3XKyYAENpOQW659NVGvfFGuUVMOseAABARSI4AVVMm/qhGtuqUHd2j5PNatHXqw9oyH+XKS3baXZpAAAA1RbBCaiCHDbpkT4X6sMRnRXssGvZrhTd8M4i7T+ebXZpAAAA1RLBCajCul8QoZn3xCs6xE/bD2fqusmLtP5AmtllAQAAVDsEJ6CKax4doq9HX6JmUcE6kpGnQe8u1nsLdjBpBAAAQDkiOAHVQN1Qf828J17dmoYrK79Qz83erLHTE3UsM8/s0gAAAKoFghNQTYT4+eijO7romYGtZLdaNGvNQXV/YZ6+TTxgdmkAAABVHsEJqEZsVouGdG2oaSM668KoIOU4CzV2eqKem71JLheX7gEAAJwrghNQDXW/IEI/jr1UY65oKkl6b8FOjfpkpbLzC0yuDAAAoGoiOAHVlM1q0f/1aab/DG4nX5tVv2xMVs+Xf9PCbUeYOAIAAMBDBCegmru2XYw+G9lF9UL9dDAtV0P+u0zXTV6kpTuPmV0aAABAlUFwAmqATnG1NffBy3Vzp/rytVuVuC9Vg95botGfrVJmHpfvAQAAlIbgBNQQ/r42vXhjW/3+yBW6vWsD2awW/bD2kG6YvEh7j2WbXR4AAIBXIzgBNUxksJ/+NbC1vhwVr8hgh7YkZ2jAW7/r+7UHVcjMewAAAKdFcAJqqPYNamnWmO5qWz9UqdlOjflstfq8tkDrD6SZXRoAAIDXITgBNVh0qJ9m3B2v+65sqlB/H20/nKnr316kT5bsYeY9AACAUxCcgBrOz8emcb2b6beHLlfPFpHKL3Dpn9+s19jpicpi4ggAAABJBCcAJ4QF+Or9oZ30WL/mslktmrXmoAa+9YdW7z1udmkAAACmIzgBcLNYLLrr0iaacVdXRQY7tO1wpm54e5He/HWbXEwcAQAAajCCE4ASOsXV1g/39dDAdvXkMqR//7JVI6YtV0pWvtmlAQAAmILgBOC06gQ79Nrg9nrxxjby87Hqt61HdPXrC/X16v3KzufeJwAAULMQnACc1c2dYvXN6G5qHBGoQ2m5emDGGl38rzl6bc5WFRS6zC4PAACgUhCcAJSqeXSIZv2jux7oeaEa1A5QVn6hXpuzTbe+v1QHU3PMLg8AAKDCEZwAlEmQw66xPS/Qbw9drtcGtVOQw65lu1PU9z8L9cXyfSpk8ggAAFCNEZwAeMRisWhg+xj9cF93takfqrQcpx7+aq16vPCrpv2xi8v3AABAtURwAnBOGoYH6stRl+jxfi0U4mfXwbRcPfXdRvV+dYFW7uHZTwAAoHohOAE4Z752q0Ze2lhLH+upp/q3VO1AX+08mqWb3lmkl3/ZIiejTwAAoJogOAE4b/6+Ng3v1kjz/u9yXdc+Ri5DeuPX7bpu8h9avZfRJwAAUPURnACUm1B/H706qJ3evLW9Qv19tP5Auq6bvEgD3/pDs9cdMrs8AACAc0ZwAlDurmlTT788cKlu6lhfdqtFiftSde+nqzRi6jL9sf2o2eUBAAB4jOAEoEJEhfjppZvaatGjV2r0FU1ks1o0b8sR3fbBUt398QodSuP5TwAAoOogOAGoUJEhfnqoT3PNvq+Hbu/aQDarRT9vSFavVxbo48W75eL5TwAAoAogOAGoFM2ig/Wvga01+74eat8gTJl5BZrw7QYNnPyH5m0+bHZ5AAAAZ0VwAlCpmkUH68tRl2jigIsU6GvT2v1pGjFtuUZ9vFKrmIEPAAB4KYITgEpns1o07JI4zX/oCt3ZvZGsFumnDUm6fvIiPfrVWm1JyjC7RAAAgGIITgBMUyfYoX9e01Lf/6OHrmsfI0mavnyf+v5ngSZ+t0GZeQUmVwgAAFCE4ATAdC3rhejVQe30xd3x6tkiSi5DmvrHbvV44Ve9/MsWJaXlml0iAACo4QhOALxG50a19cGwTvrojs5qGB6g49lOvfHrdnV74Vc9+MUabTqUbnaJAACghiI4AfA6l15YR3PHXaY3b22vtvVDVegy9NWq/er3+kIN+e9SbTxIgAIAAJWL4ATAK9ltVl3Tpp6+HdNdX90Tr76tomUY0sJtR3XNGwv1+NfrdCwzz+wyAQBADWE3uwAAKE3HhrXVsWFt7T2WrRd+3qwf1h7Sp0v3ataag7rn8iYaFh+nQAd/nAEAgIrDiBOAKqNBeIDeurWDZtzVVRfVC1FGboFe/GmLLn1xnj5YuFO5zkKzSwQAANUUwQlAldOlcbhmjemuV25uq7jwAB3Lyte/ftiky1+ar0+W7FF+gcvsEgEAQDVDcAJQJdmsFl3fob4Sxl2mF25orXqhfkpKz9U/v1mvq16Zr69W7lehyzC7TAAAUE0QnABUaT42qwZd3EDzHrpcEwdcpDrBDu1LydGDM9fomjd+129bj8gwCFAAAOD8EJwAVAsOu03DLonTgoeu0CN/a65gP7s2HUrXsCnL1OvVBfpg4U7tP55tdpkAAKCKIjgBqFb8fW265/ImWvDQFbqzeyP52qzafjjTfQ/U+P+tJUABAACPEZwAVEu1An31z2taavnjPfXENS3VsWEtFbgMfb5sn67493z985t1BCgAAFBmBCcA1VpogI/u6N5IX91zib4cFa9uTcPlLDT0yZK96v7CPA16d7EW7zhmdpkAAMDLeUVweuuttxQXFyc/Pz916dJFy5YtO+O277//vnr06KFatWqpVq1a6tmz51m3B4CTOsXV1qd3dtWMu7rqkibhslikpbtSdMv7SzT4vcVaupMABQAATs/04DRjxgyNGzdOTz75pFatWqW2bduqT58+Onz48Gm3nz9/vm655RbNmzdPixcvVmxsrHr37q0DBw5UcuUAqqoujcP12ciuWvTolRrStaF8bVYt2ZmiQe8t0a3vL9G3iQd4mC4AACjG9OD0yiuvaOTIkRoxYoRatmypd955RwEBAZoyZcppt//000917733ql27dmrevLk++OADuVwuzZ07t5IrB1DV1Q311zMDW2n+Q5frti4N5GOzaNGOYxo7PVGdn52jUR+v1OfL9ionnxAFAEBNZzfz4Pn5+Vq5cqXGjx/vXma1WtWzZ08tXry4TJ+RnZ0tp9Op2rVrn3Z9Xl6e8vLy3O/T09MlSU6nU06n8zyqLx8na/CGWlA10DPlr06gXU9d01x3dW+oT5bu0w/rknQwLVc/bUjSTxuS9OJPmzUsvqEGtqurmDB/s8v1GD0DT9Ez8BQ9A095S894cnyLYeKTIQ8ePKiYmBgtWrRI8fHx7uUPP/ywfvvtNy1durTUz7j33nv1888/a8OGDfLz8yux/qmnntLEiRNLLP/ss88UEBBwficAoFoqNKR9mdKWNIuWHrbqWJ5FkmSRoba1DV1Zz6WGwSYXCQAAzlt2drZuvfVWpaWlKSQk5KzbmjridL6ef/55TZ8+XfPnzz9taJKk8ePHa9y4ce736enp7vuiSvvhVAan06mEhAT16tVLPj4+ZpeDKoCeqVwFhS79sC5JM1Ye0PLdx5WYYlFiilUXx9XSyO5xuuyCCFmtFrPLPCt6Bp6iZ+Apegae8paeOXk1WlmYGpwiIiJks9mUnJxcbHlycrKio6PPuu+///1vPf/885ozZ47atGlzxu0cDoccDkeJ5T4+Pl71G9vb6oH3o2cqh4+PdOPFDXXjxQ21OSld7y3YqVmJB7V893Et331cjSICdW27erqufYwahgeaXe5Z0TPwFD0DT9Ez8JTZPePJsU2dHMLX11cdO3YsNrHDyYkeTr10769efPFFPfPMM/rpp5/UqVOnyigVANQ8OkSv3NxOCx+5Qndf2ljBDrt2Hc3Sa3O26bKX5mvE1GVasPWITLwCGgAAVBDTL9UbN26chg0bpk6dOqlz58567bXXlJWVpREjRkiShg4dqpiYGE2aNEmS9MILL+iJJ57QZ599pri4OCUlJUmSgoKCFBQUZNp5AKg56ob6a3y/Frrvqgv084Ykfb36gBZuO6p5W45o3pYjahoZpOGXxOn6DjEK8DX9j1kAAFAOTP8bfdCgQTpy5IieeOIJJSUlqV27dvrpp58UFRUlSdq7d6+s1j8Hxt5++23l5+frxhtvLPY5Tz75pJ566qnKLB1ADRfosOv6DvV1fYf62nU0Sx8u2q2ZK/Zp++FM/fOb9Xrm+41q3yBMPS6oo36t6youPEAWi3ffDwUAAE7P9OAkSWPGjNGYMWNOu27+/PnF3u/evbviCwIADzWKCNRTAy7SuN4XauaK/fpw0W7tTcnWkp0pWrIzRS/9vEUXRgWpY8PauqJZHV3RPFI+NtMfpQcAAMrIK4ITAFQXIX4++nv3RrqjW5x2HMnSkp3H9P3ag1q1J1VbkzO1NTlTny/bq2A/u65sHqlbOjdQl0a1GYkCAMDLEZwAoAJYLBY1jQxS08gg3d61oVKz8/XH9mNauee4vlt7UEcy8vRt4kF9m3hQjSMCdfPFsereNEIt6obI5uXTmwMAUBMRnACgEoQF+OrqNnV1dZu6evzqFlqzP1UzV+zXrMQD2nk0S8//uFmSFOywq0vj2rqufX31bBkph91mcuUAAEAiOAFApbNZLerQoJY6NKilx69uoVmJB/XThiSt2nNcGXkFmrPpsOZsOqxQfx9d266eru9QX61jQhmJAgDARAQnADBRkMOuW7s00K1dGqjQZWjToXT9uP6Qvlp5QEnpufpo8R59tHiPAnxtuqRJuPq3raeeLaIU6OCPbwAAKhN/8wKAl7BZLWoVE6pWMaEa16uZ/th+VDNX7tevm5KVlV/oHony87GqTUyYOsbV0oC29dQ8OpjJJQAAqGAEJwDwQjarRZdeWEeXXlhHhS5Dm5PS9eO6JM1ac1B7U7K1bHeKlu1O0dvzdyjYYVfXJuFq3yBM7WLD1KFBLfn5cG8UAADlieAEAF7OZrXoonqhuqheqB7sfaG2Jmdq3YE0JWxM0rwtR5SRV6CEjclK2JgsSfKxWRTfJEK9WkapU8NaahLuZ/IZAABQ9RGcAKAKsVgsahYdrGbRwbqxY305C13afChDC7Yd0ZakDP2+/ahSsvK1YOsRLdh6RJIUGexQlN2qPYE71blxhNo3CGO2PgAAPERwAoAqzMdmVev6oWpdP1SSZBiGdhzJ0i8bk7Rw61Gt2ntchzPydFhWrZuzXdJ2OexWdWxYS/GNw9W1Sbja1g+Tr91q7okAAODlCE4AUI38+eDdprr38qbKyS9U4t5jmp6wRPlB9bR8T6qOZuZp0Y5jWrTjmJQg+fvY1Cmulro2DlfXxuFqFRPCiBQAAH9BcAKAaszf16ZODWvpcD1D/fq1ld1u144jmVq845gW7zymJTtTlJKVr4XbjmrhtqOSJItFqhvip+Z1Q3RF80hd2TxSMWH+Jp8JAADmIjgBQA1SNCIVrKaRwRoSHyeXy9C2w5lavOOoFu88pqW7UpSa7dTBtFwdTMvVr5sPa4KkmDB/XRAVpKZ1gnRBVJAuaRKh2NoBZp8OAACVhuAEADWY1frnZBPDuzWSYRhKycrX7mPZWrYrRb9uTtbKPcd1IDVHB1JzNH/LEfe+jSIC1alhLTWvG6ImdQLVKa62gngwLwCgmuJvOACAm8ViUXiQQ+FBDnVsWEv3XN5EaTlObUnK0LbDGdp5JEtr96dq1d5U7TqapV1Hs9z72qwWta0fqs6NwnVRvRBdVC9EceGBslp5OC8AoOojOAEAzirU30edG9VW50a13cvSc51atjNFa/anaseRTK0/kK69KdlatbcoVJ0U4GtT8+hgtawXopZ1Q9WyXoiaRQXL35fJJwAAVQvBCQDgsRA/H/VsGaWeLaPcy/Yfz9ai7ceUuD9VGw+ma3NSurLzC0uEKatFalwnSBfVC1HLuiEnQlWIwoMcJpwJAABlQ3ACAJSL+rUCdPPFAbr54lhJUkGhS7uPZWnDwXRtPJSujQeLXsey8rX9cKa2H87Ut4kH3ftHhTjUsm6IWtQN0UX1QtUqJkT1wvzlY+MZUwAA8xGcAAAVwm6zumfwu7ZdjKSiB/QeycjThpNB6sTX3ceylJyep+T0I5p3ygQUFosUFeynZtHBalM/VC3rhigq1E9RIX6qF+oni4X7pwAAlYPgBACoNBaLRZEhfooM8dMVzSLdyzPzCrQl6WSYytCGg2nafChD+YUuJaXnKik9V79tPVLssyKCHGpZL0QxYX5qFxumjg1rqXFEEJNRAAAqBMEJAGC6IIddHRvWVseGf05A4XIZOpaVr33Hs7XhQJrWHUjTluRMHc3I0+GMXB3NzNOCE2Hq82X7JEnBDruaRgWpdUyo2tYPU5v6oWoYHihfO5f7AQDOD8EJAOCVrFaL6gQ7VCfYoQ4NahVbl+ss1Nr9adpzrGhK9JV7jmvN/lRl5BVo9d5Urd6bKmmPpKJp0mNr+atRRKAuiArWRfWK7qOKI1ABADxAcAIAVDl+PrYSU6TnF7i062iWNiela+3+NK09MbtfVn6hdh/L1u5j2cXun7JZLWpQO0BN6gSqaWTRlOktooNVv1YA06UDAEogOAEAqgVfu1XNooPVLLrkZBQ7j2Zp55EsbTqUrvUH07QtOVOZeQXuh/jO2XS42GfFhPmrxYmp0pvUCVRs7QA1qB2g8EBfJqQAgBqK4AQAqLZOnYyia+Nw93LDMHQ4I087Dmdqx5FMbUnO0IaD6e5AdSA1RwdSczRnU3KxzwvwtalB7QB3kDr5iq0doPq1/OXnw0gVAFRXBCcAQI1jsVgUFVI0rfklTSPcyw3DUFqOU1uSioLU5qR07TmWrX0p2TqUnqvs/EJtTsrQ5qSM035udIifGtQOUP3a/kWBqlaAGoQHqGmdINUK9K2s0wMAVACCEwAAJ1gsFoUF+KpL43B1OWWESpLyCgp14HiO9qYUBam97leO9h7LUlZ+oXvq9GW7S352RJBDF0QGqV6Yv6JDHYoO9VfdED9Fhxa9agf4MpU6AHgxghMAAGXgsNvUuE6QGtcJKrHOMAwdz3Zqb0q29hzL0v7jOe5wtedYtg6k5uhoZp6OZuad8fN9bVbVC/NTw/BANYoIdF8G2KhO0fc+NmYABAAzEZwAADhPFotFtQN9VTvQV+1iw0qsz8wr0LbkDO06mqVDablKTs/VobRcJaUVjVAdzcxTfqHLPfvfXx/2a7NaVL+Wv6JC/BR9YpTqz+8digrxU2SwH9OrA0AFIjgBAFDBghx2tW9QS+3/8jyqk/ILXDqckav9x3O0+2iWdh3L0r6UbO0+mq1dR7OU4yzUnmNFo1dnExHk6w5UUaEnglWIn+oEO9zBrnagrwJ8bcwOCAAeIjgBAGAyX7tV9WsFqH6tgGKz/0mSy2UoKT1X+1KylZReNFqVlJZX9DW9aNTqcEaunIWGjmbm62hmvjYcTD/r8Rx2q6JD/dwzAsbWClB4kK9qB/iqVqCPgn2tynIWHRsAUITgBACAF7NaLaoX5q96Yf5n3MblMpSSna+kE5cBJqfnFYWsUy4FTMnK17GsfOUXuJRX4CrDCJZd/1yZoFoBvqoV6KuoEIfqhxVNux5Ty1+1A32L1gX4KizQR8EOO6NYAKo1ghMAAFWc1WpRRJBDEUEOtYoJPeN2hmEoO79QxzLzdTCtaAKLfSnZ2p+ao+NZ+UrJdhZ9zcpXZl6BXIZ07ETg2n44U9KxM362r82q8CBfhQcVhamTwap2YFHwqn3i+zrBvooIcijEz4dZBAFUKQQnAABqCIvFokCHXYEOuxqEl7ws8CSn06lZ389W18uuUka+SymZ+TqUVnQP1r7j2TqUlqPjWU6lZufreLZTOc5C5Re6dCitaNKLstUiBTvsCg3wUah/8VeIn49C/EsuP/kK9rPLziyDACoZwQkAAJRgt0qRwQ7F+PiUum2us1DHsvJ1NKNoyvXj2UWhKiUrX8dPfs1y6mhWno5m5Ck9t0CGIaXnFig9t0D7lONxfUEOe1HI8vdRqL+9RPA6GchCTr73t7sDmcNu5bJCAB4jOAEAgPPi52NTTJi/Ys5yH9ap8gtcSstxul/pJ7/mOpWW7Sy27q/bZOUXSiqa4j0zr0AHUj0PXb42q0JOhK1aAb4K9fdRkJ9dwX52BTl8Tny1u78G+RWFrmA/u4JPfOW5WkDNQ3ACAACVytduVZ1gh+oEOzze11noUkZuwVnDVVr2iRB2SiBLzylQRq5TLkPKL3S5ZyCUss7pHPx9bArxLwpSIScCVciJywiDHX8GrmA/HwU57O5tgv2Klgc57Ix8AVUMwQkAAFQZPjar+3lUnjIMQ1n5he6AlZrt1PHsfGXkOpWRW6CM3KJRrMzcAmXkOYu/zy0KXidHvHKchcpxFio5Pe+cz8VutbhDVNApYevkaFegb/H3QQ4fBTps7u+D/OwK8rUr0GHjni+gEhCcAABAjWCxWNwB5WzTu59NQaFLmXkFSs8pKBrJOmU0Kz23QOk5TmWduIww40ToSncHM6cycwvc4avAZSg1uyjAnS+H3VoUthwnAteJEBbosCvU364wf1+FnbjvKyyg6Pswfx8FOuwK8LXJ39cmXxsjYMDZEJwAAADKyG6znggeno94neRyGcrK/3M06+T9WkUjXUVf/xq+Tt3G/X1egfILXJKkvAKX8tyXH54bm9WiAJ+iEFUUpuwK9P3zfYBvUcg6GbYCfe0KcBR9ddikLWkW1duXqtBAP/f2/j42+fkQyFA9EJwAAAAqkdVqOXG/k4905sdulUl+gcsdsjLz/gxcWXmFyjoRvIru+8pX6onLE4u+5is126ns/AI5Cw1JUqHLUMaJfc6NTZM3LjvtGn+fovDl52Nzj3D5nxLS/HyKAlig+zLFooAW5LArwGF37+8OdT6MkqHyEZwAAACqKF+7Vb72oocMnytnoUvZ+YXKyS9Udn5B0ffOwhPLit7/ub5om6z8AmXnFSozr2h9Zp5TyUdTZXP4K9vpKjYaJv15T1h5OzlK5udrOzE69ucoWeCJETI/X5scdqv8fIq+Oux/ee9jlZ/dJodP0To/nz+38bVbT/lqk4/NQlCrwQhOAAAANZiPzapQf6tC/Ut/ZteZOJ1OzZ49W/36XSqfE8/+KnQZRYHpROgqCmMFfy47Ec5yT3zNzitQZl5RCMs6Ecoy8wqK7Xty+9ONkh0pl5/G2VksRdPZF4Wpk0HsRLDysclhKwpivie+OuxFo2J+PifWnxLYTg1lvjbbiRBctO/Jde71xZYT4MxCcAIAAEC5s1n/nIyjvJ06SuYOZPmFyjoxSpaVV6hsZ1EYy3W6lFdQqLwCl3KdRV+Lfe/8c13+X9blF7iUX/jnyJlhyL2/dK6XNJ4/q0XFR8dOGTXztVnlY7PKx26Vr81S9P2Jl6/9L+9PrrefXHbqekuxzyr2/rSfZZXPiWV2a/UMdgQnAAAAVCnlMUpWVi6XofxClztInQxhJ0OWe5nTdWK7wmLrTg1rec5C5Tpdyj2xzclglnfK9vkFhUXLTnzeye0KXMafNRmnXv54/rMyVgTfE+HLfvKr1Sr7iWBms1pkt0i3x5pdpWcITgAAAMAZWK0W+VmLJrAwU6HLcIeo3BNBLa+g0D2ilussCmkFLpfyCw05C1xyFha98guNou8L/vL+5PoCQwWuP78vtu4vn+UsLAqSf36eUWxU7qT8QpeKZt4/y71tBCcAAAAA5clmtRTNRuhrU6gqfqTNE4ZhqMBlqODUUFXokrPAUH5hoXuds7Bo5MxZ6FJuvlPHN59+FkZvRXACAAAAcM4sFsuJ+6Mkf5VtZM7pdGr21gourJxZzS4AAAAAALwdwQkAAAAASkFwAgAAAIBSEJwAAAAAoBQEJwAAAAAoBcEJAAAAAEpBcAIAAACAUhCcAAAAAKAUBCcAAAAAKAXBCQAAAABKQXACAAAAgFIQnAAAAACgFAQnAAAAACgFwQkAAAAASmE3u4DKZhiGJCk9Pd3kSoo4nU5lZ2crPT1dPj4+ZpeDKoCegafoGXiKnoGn6Bl4ylt65mQmOJkRzqbGBaeMjAxJUmxsrMmVAAAAAPAGGRkZCg0NPes2FqMs8aoacblcOnjwoIKDg2WxWMwuR+np6YqNjdW+ffsUEhJidjmoAugZeIqegafoGXiKnoGnvKVnDMNQRkaG6tWrJ6v17Hcx1bgRJ6vVqvr165tdRgkhISH8QQOP0DPwFD0DT9Ez8BQ9A095Q8+UNtJ0EpNDAAAAAEApCE4AAAAAUAqCk8kcDoeefPJJORwOs0tBFUHPwFP0DDxFz8BT9Aw8VRV7psZNDgEAAAAAnmLECQAAAABKQXACAAAAgFIQnAAAAACgFAQnAAAAACgFwclEb731luLi4uTn56cuXbpo2bJlZpcEE0yaNEkXX3yxgoODFRkZqYEDB2rLli3FtsnNzdXo0aMVHh6uoKAg3XDDDUpOTi62zd69e3X11VcrICBAkZGReuihh1RQUFCZpwKTPP/887JYLLr//vvdy+gZ/NWBAwd0++23Kzw8XP7+/mrdurVWrFjhXm8Yhp544gnVrVtX/v7+6tmzp7Zt21bsM1JSUnTbbbcpJCREYWFh+vvf/67MzMzKPhVUksLCQk2YMEGNGjWSv7+/mjRpomeeeUanzitG39RsCxYsUP/+/VWvXj1ZLBZ98803xdaXV3+sXbtWPXr0kJ+fn2JjY/Xiiy9W9KmdngFTTJ8+3fD19TWmTJlibNiwwRg5cqQRFhZmJCcnm10aKlmfPn2MqVOnGuvXrzcSExONfv36GQ0aNDAyMzPd24waNcqIjY015s6da6xYscLo2rWrcckll7jXFxQUGK1atTJ69uxprF692pg9e7YRERFhjB8/3oxTQiVatmyZERcXZ7Rp08YYO3asezk9g1OlpKQYDRs2NIYPH24sXbrU2Llzp/Hzzz8b27dvd2/z/PPPG6GhocY333xjrFmzxhgwYIDRqFEjIycnx73N3/72N6Nt27bGkiVLjIULFxpNmzY1brnlFjNOCZXg2WefNcLDw43vv//e2LVrlzFz5kwjKCjI+M9//uPehr6p2WbPnm08/vjjxv/+9z9DkvH1118XW18e/ZGWlmZERUUZt912m7F+/Xrj888/N/z9/Y133323sk7TjeBkks6dOxujR492vy8sLDTq1atnTJo0ycSq4A0OHz5sSDJ+++03wzAMIzU11fDx8TFmzpzp3mbTpk2GJGPx4sWGYRT9wWW1Wo2kpCT3Nm+//bYREhJi5OXlVe4JoNJkZGQYF1xwgZGQkGBcdtll7uBEz+CvHnnkEaN79+5nXO9yuYzo6GjjpZdeci9LTU01HA6H8fnnnxuGYRgbN240JBnLly93b/Pjjz8aFovFOHDgQMUVD9NcffXVxh133FFs2fXXX2/cdttthmHQNyjur8GpvPpj8uTJRq1atYr93fTII48YzZo1q+AzKolL9UyQn5+vlStXqmfPnu5lVqtVPXv21OLFi02sDN4gLS1NklS7dm1J0sqVK+V0Oov1S/PmzdWgQQN3vyxevFitW7dWVFSUe5s+ffooPT1dGzZsqMTqUZlGjx6tq6++ulhvSPQMSpo1a5Y6deqkm266SZGRkWrfvr3ef/999/pdu3YpKSmpWM+EhoaqS5cuxXomLCxMnTp1cm/Ts2dPWa1WLV26tPJOBpXmkksu0dy5c7V161ZJ0po1a/T777+rb9++kugbnF159cfixYt16aWXytfX171Nnz59tGXLFh0/frySzqaIvVKPBknS0aNHVVhYWOwfLJIUFRWlzZs3m1QVvIHL5dL999+vbt26qVWrVpKkpKQk+fr6KiwsrNi2UVFRSkpKcm9zun46uQ7Vz/Tp07Vq1SotX768xDp6Bn+1c+dOvf322xo3bpwee+wxLV++XPfdd598fX01bNgw96/56Xri1J6JjIwstt5ut6t27dr0TDX16KOPKj09Xc2bN5fNZlNhYaGeffZZ3XbbbZJE3+Csyqs/kpKS1KhRoxKfcXJdrVq1KqT+0yE4AV5k9OjRWr9+vX7//XezS4EX27dvn8aOHauEhAT5+fmZXQ6qAJfLpU6dOum5556TJLVv317r16/XO++8o2HDhplcHbzVF198oU8//VSfffaZLrroIiUmJur+++9XvXr16BvUSFyqZ4KIiAjZbLYSM1wlJycrOjrapKpgtjFjxuj777/XvHnzVL9+fffy6Oho5efnKzU1tdj2p/ZLdHT0afvp5DpULytXrtThw4fVoUMH2e122e12/fbbb3r99ddlt9sVFRVFz6CYunXrqmXLlsWWtWjRQnv37pX056/52f5eio6O1uHDh4utLygoUEpKCj1TTT300EN69NFHNXjwYLVu3VpDhgzRAw88oEmTJkmib3B25dUf3vT3FcHJBL6+vurYsaPmzp3rXuZyuTR37lzFx8ebWBnMYBiGxowZo6+//lq//vprieHojh07ysfHp1i/bNmyRXv37nX3S3x8vNatW1fsD5+EhASFhISU+McSqr6rrrpK69atU2JiovvVqVMn3Xbbbe7v6Rmcqlu3biUec7B161Y1bNhQktSoUSNFR0cX65n09HQtXbq0WM+kpqZq5cqV7m1+/fVXuVwudenSpRLOApUtOztbVmvxfyrabDa5XC5J9A3Orrz6Iz4+XgsWLJDT6XRvk5CQoGbNmlXqZXqSmI7cLNOnTzccDocxbdo0Y+PGjcZdd91lhIWFFZvhCjXDPffcY4SGhhrz5883Dh065H5lZ2e7txk1apTRoEED49dffzVWrFhhxMfHG/Hx8e71J6eW7t27t5GYmGj89NNPRp06dZhaugY5dVY9w6BnUNyyZcsMu91uPPvss8a2bduMTz/91AgICDA++eQT9zbPP/+8ERYWZnz77bfG2rVrjWuvvfa00wa3b9/eWLp0qfH7778bF1xwAdNKV2PDhg0zYmJi3NOR/+9//zMiIiKMhx9+2L0NfVOzZWRkGKtXrzZWr15tSDJeeeUVY/Xq1caePXsMwyif/khNTTWioqKMIUOGGOvXrzemT59uBAQEMB15TfPGG28YDRo0MHx9fY3OnTsbS5YsMbskmEDSaV9Tp051b5OTk2Pce++9Rq1atYyAgADjuuuuMw4dOlTsc3bv3m307dvX8Pf3NyIiIowHH3zQcDqdlXw2MMtfgxM9g7/67rvvjFatWhkOh8No3ry58d577xVb73K5jAkTJhhRUVGGw+EwrrrqKmPLli3Ftjl27Jhxyy23GEFBQUZISIgxYsQIIyMjozJPA5UoPT3dGDt2rNGgQQPDz8/PaNy4sfH4448XmxaavqnZ5s2bd9p/wwwbNswwjPLrjzVr1hjdu3c3HA6HERMTYzz//POVdYrFWAzjlMc/AwAAAABK4B4nAAAAACgFwQkAAAAASkFwAgAAAIBSEJwAAAAAoBQEJwAAAAAoBcEJAAAAAEpBcAIAAACAUhCcAAAAAKAUBCcAAAAAKAXBCQBQ5Rw5ckT33HOPGjRoIIfDoejoaPXp00d//PGHJMliseibb74xt0gAQLViN7sAAAA8dcMNNyg/P18ffvihGjdurOTkZM2dO1fHjh0zuzQAQDXFiBMAoEpJTU3VwoUL9cILL+iKK65Qw4YN1blzZ40fP14DBgxQXFycJOm6666TxWJxv5ekb7/9Vh06dJCfn58aN26siRMnqqCgwL3eYrHo7bffVt++feXv76/GjRvryy+/dK/Pz8/XmDFjVLduXfn5+alhw4aaNGlSZZ06AMBEBCcAQJUSFBSkoKAgffPNN8rLyyuxfvny5ZKkqVOn6tChQ+73Cxcu1NChQzV27Fht3LhR7777rqZNm6Znn3222P4TJkzQDTfcoDVr1ui2227T4MGDtWnTJknS66+/rlmzZumLL77Qli1b9OmnnxYLZgCA6stiGIZhdhEAAHjiq6++0siRI5WTk6MOHTrosssu0+DBg9WmTRtJRSNHX3/9tQYOHOjep2fPnrrqqqs0fvx497JPPvlEDz/8sA4ePOjeb9SoUXr77bfd23Tt2lUdOnTQ5MmTdd9992nDhg2aM2eOLBZL5ZwsAMArMOIEAKhybrjhBh08eFCzZs3S3/72N82fP18dOnTQtGnTzrjPmjVr9PTTT7tHrIKCgjRy5EgdOnRI2dnZ7u3i4+OL7RcfH+8ecRo+fLgSExPVrFkz3Xffffrll18q5PwAAN6H4AQAqJL8/PzUq1cvTZgwQYsWLdLw4cP15JNPnnH7zMxMTZw4UYmJie7XunXrtG3bNvn5+ZXpmB06dNCuXbv0zDPPKCcnRzfffLNuvPHG8jolAIAXIzgBAKqFli1bKisrS5Lk4+OjwsLCYus7dOigLVu2qGnTpiVeVuuffx0uWbKk2H5LlixRixYt3O9DQkI0aNAgvf/++5oxY4a++uorpaSkVOCZAQC8AdORAwCqlGPHjummm27SHXfcoTZt2ig4OFgrVqzQiy++qGuvvVaSFBcXp7lz56pbt25yOByqVauWnnjiCV1zzTVq0KCBbrzxRlmtVq1Zs0br16/Xv/71L/fnz5w5U506dVL37t316aefatmyZfrvf/8rSXrllVdUt25dtW/fXlarVTNnzlR0dLTCwsLM+FEAACoRwQkAUKUEBQWpS5cuevXVV7Vjxw45nU7FxsZq5MiReuyxxyRJL7/8ssaNG6f3339fMTEx2r17t/r06aPvv/9eTz/9tF544QX5+PioefPmuvPOO4t9/sSJEzV9+nTde++9qlu3rj7//HO1bNlSkhQcHKwXX3xR27Ztk81m08UXX6zZs2cXG7ECAFRPzKoHAMAJp5uNDwAAiXucAAAAAKBUBCcAAAAAKAX3OAEAcAJXrwMAzoQRJwAAAAAoBcEJAAAAAEpBcAIAAACAUhCcAAAAAKAUBCcAAAAAKAXBCQAAAABKQXACAAAAgFIQnAAAAACgFP8PuyQZ6IK3U+EAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.plot(episode_rwds_ddqn)\n", + "plt.title('Total Rewards per Episode-DDQN')\n", + "plt.xlabel('Episode')\n", + "plt.ylabel('Total Reward')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(10,5))\n", + "plt.plot(epsilon_values_ddqn)\n", + "plt.title('Epsilon Decay-DDQN')\n", + "plt.xlabel('Steps')\n", + "plt.ylabel('Epsilon Value')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Kiyo\\AppData\\Local\\Temp\\ipykernel_8936\\3272690895.py:30: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", + " frames = [imageio.imread(path) for path in frames_paths]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 1 evaluated, GIF saved to eval_gifs_ddqn\\episode_1.gif.\n", + "Episode 2 evaluated, GIF saved to eval_gifs_ddqn\\episode_2.gif.\n", + "Episode 3 evaluated, GIF saved to eval_gifs_ddqn\\episode_3.gif.\n", + "Episode 4 evaluated, GIF saved to eval_gifs_ddqn\\episode_4.gif.\n", + "Episode 5 evaluated, GIF saved to eval_gifs_ddqn\\episode_5.gif.\n", + "Episode 6 evaluated, GIF saved to eval_gifs_ddqn\\episode_6.gif.\n", + "Episode 7 evaluated, GIF saved to eval_gifs_ddqn\\episode_7.gif.\n", + "Episode 8 evaluated, GIF saved to eval_gifs_ddqn\\episode_8.gif.\n", + "Episode 9 evaluated, GIF saved to eval_gifs_ddqn\\episode_9.gif.\n", + "Episode 10 evaluated, GIF saved to eval_gifs_ddqn\\episode_10.gif.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def evaluate_agent(env_ddqn,policy_net_ddqn,num_epis=10,output_dir='eval_gifs_ddqn'):\n", + " if not os.path.exists(output_dir):\n", + " os.makedirs(output_dir)\n", + " \n", + " epi_rwds_eval=[] \n", + " for episode in range(num_epis):\n", + " state=env_ddqn.reset()\n", + " episode_rwds_ddqn=np.zeros((2,))\n", + " frames_paths=[]\n", + " \n", + " done=False\n", + " timestep=0\n", + " while not done:\n", + " with torch.no_grad():\n", + " state_tensor=torch.tensor([state],\n", + " dtype=torch.float)\n", + " action1=policy_net_ddqn(state_tensor).argmax().item()\n", + " action2=policy_net_ddqn(state_tensor).argmax().item()\n", + "\n", + " nxt_stt,rewards,done,_=env_ddqn.step((action1,\n", + " action2))\n", + " episode_rwds_ddqn+=rewards \n", + " state=nxt_stt\n", + " \n", + " frame_path=os.path.join(output_dir,f\"episode_{episode+1}_frame_{timestep}.png\")\n", + " env_ddqn.render(save_path=frame_path) \n", + " frames_paths.append(frame_path) \n", + " timestep+=1\n", + " \n", + " epi_rwds_eval.append(episode_rwds_ddqn) \n", + " \n", + " frames=[imageio.imread(path) for path in frames_paths]\n", + " gif_path=os.path.join(output_dir,\n", + " f\"episode_{episode+1}.gif\")\n", + " imageio.mimsave(gif_path,\n", + " frames,\n", + " fps=10) \n", + " for path in frames_paths:\n", + " os.remove(path)\n", + "\n", + " print(f\"Episode {episode+1} evaluated, GIF saved to {gif_path}.\")\n", + "\n", + " epi_rwds_eval=np.array(epi_rwds_eval) \n", + " plt.figure(figsize=(12,6))\n", + " for agent_index in range(2):\n", + " plt.plot(range(1,num_epis+1),epi_rwds_eval[:,agent_index],marker='o',label=f'Agent {agent_index+1}')\n", + " plt.title('Total Rewards per Episode for Each Agent')\n", + " plt.xlabel('Episode')\n", + " plt.ylabel('Total Reward')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.savefig(os.path.join(output_dir,'rewards_plot.png'))\n", + " plt.show()\n", + "\n", + "evaluate_agent(env_ddqn,policy_net_ddqn,num_epis=10)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}