From dc8d13a13e397b5848f89ebab70403f48bd7e3e9 Mon Sep 17 00:00:00 2001 From: johnjim0816 Date: Sun, 4 Dec 2022 20:54:36 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E8=98=91=E8=8F=87=E4=B9=A6?= =?UTF-8?q?=E9=99=84=E4=B9=A6=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notebooks/A2C.ipynb | 370 ++ notebooks/DDPG.ipynb | 559 +++ notebooks/DQN.ipynb | 541 +++ notebooks/DoubleDQN.ipynb | 490 +++ notebooks/DuelingDQN.ipynb | 482 +++ notebooks/MonteCarlo.ipynb | 748 ++++ notebooks/NoisyDQN.ipynb | 582 +++ notebooks/PER_DQN.ipynb | 644 ++++ notebooks/PPO.ipynb | 522 +++ notebooks/PPO暂存.md | 142 + notebooks/PolicyGradient.ipynb | 202 ++ .../Q-learning/Q-learning探索策略研究.ipynb | 3167 +++++++++++++++++ notebooks/Q-learning/QLearning.ipynb | 459 +++ notebooks/README.md | 23 + notebooks/Sarsa.ipynb | 896 +++++ notebooks/Value Iteration/README.md | 0 .../Value Iteration/value_iteration.ipynb | 232 ++ notebooks/common/multiprocessing_env.py | 153 + notebooks/envs/racetrack.py | 243 ++ notebooks/envs/simple_grid.py | 303 ++ notebooks/envs/track.txt | 15 + notebooks/figs/duelingdqn_model.png | Bin 0 -> 123703 bytes notebooks/requirements.txt | 11 + 23 files changed, 10784 insertions(+) create mode 100644 notebooks/A2C.ipynb create mode 100644 notebooks/DDPG.ipynb create mode 100644 notebooks/DQN.ipynb create mode 100644 notebooks/DoubleDQN.ipynb create mode 100644 notebooks/DuelingDQN.ipynb create mode 100644 notebooks/MonteCarlo.ipynb create mode 100644 notebooks/NoisyDQN.ipynb create mode 100644 notebooks/PER_DQN.ipynb create mode 100644 notebooks/PPO.ipynb create mode 100644 notebooks/PPO暂存.md create mode 100644 notebooks/PolicyGradient.ipynb create mode 100644 notebooks/Q-learning/Q-learning探索策略研究.ipynb create mode 100644 notebooks/Q-learning/QLearning.ipynb create mode 100644 notebooks/README.md create mode 100644 notebooks/Sarsa.ipynb create mode 100644 notebooks/Value Iteration/README.md create mode 100644 notebooks/Value Iteration/value_iteration.ipynb create mode 100644 notebooks/common/multiprocessing_env.py create mode 100644 notebooks/envs/racetrack.py create mode 100644 notebooks/envs/simple_grid.py create mode 100644 notebooks/envs/track.txt create mode 100644 notebooks/figs/duelingdqn_model.png create mode 100644 notebooks/requirements.txt diff --git a/notebooks/A2C.ipynb b/notebooks/A2C.ipynb new file mode 100644 index 0000000..8966eac --- /dev/null +++ b/notebooks/A2C.ipynb @@ -0,0 +1,370 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.distributions import Categorical\n", + "import numpy as np\n", + "from multiprocessing import Process, Pipe\n", + "import argparse\n", + "import gym" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 建立Actor和Critic网络" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class ActorCritic(nn.Module):\n", + " ''' A2C网络模型,包含一个Actor和Critic\n", + " '''\n", + " def __init__(self, input_dim, output_dim, hidden_dim):\n", + " super(ActorCritic, self).__init__()\n", + " self.critic = nn.Sequential(\n", + " nn.Linear(input_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, 1)\n", + " )\n", + " \n", + " self.actor = nn.Sequential(\n", + " nn.Linear(input_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, output_dim),\n", + " nn.Softmax(dim=1),\n", + " )\n", + " \n", + " def forward(self, x):\n", + " value = self.critic(x)\n", + " probs = self.actor(x)\n", + " dist = Categorical(probs)\n", + " return dist, value" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class A2C:\n", + " ''' A2C算法\n", + " '''\n", + " def __init__(self,n_states,n_actions,cfg) -> None:\n", + " self.gamma = cfg.gamma\n", + " self.device = cfg.device\n", + " self.model = ActorCritic(n_states, n_actions, cfg.hidden_size).to(self.device)\n", + " self.optimizer = optim.Adam(self.model.parameters())\n", + "\n", + " def compute_returns(self,next_value, rewards, masks):\n", + " R = next_value\n", + " returns = []\n", + " for step in reversed(range(len(rewards))):\n", + " R = rewards[step] + self.gamma * R * masks[step]\n", + " returns.insert(0, R)\n", + " return returns" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def make_envs(env_name):\n", + " def _thunk():\n", + " env = gym.make(env_name)\n", + " env.seed(2)\n", + " return env\n", + " return _thunk\n", + "def test_env(env,model,vis=False):\n", + " state = env.reset()\n", + " if vis: env.render()\n", + " done = False\n", + " total_reward = 0\n", + " while not done:\n", + " state = torch.FloatTensor(state).unsqueeze(0).to(cfg.device)\n", + " dist, _ = model(state)\n", + " next_state, reward, done, _ = env.step(dist.sample().cpu().numpy()[0])\n", + " state = next_state\n", + " if vis: env.render()\n", + " total_reward += reward\n", + " return total_reward\n", + "\n", + "def compute_returns(next_value, rewards, masks, gamma=0.99):\n", + " R = next_value\n", + " returns = []\n", + " for step in reversed(range(len(rewards))):\n", + " R = rewards[step] + gamma * R * masks[step]\n", + " returns.insert(0, R)\n", + " return returns\n", + "\n", + "\n", + "def train(cfg,envs):\n", + " print('Start training!')\n", + " print(f'Env:{cfg.env_name}, Algorithm:{cfg.algo_name}, Device:{cfg.device}')\n", + " env = gym.make(cfg.env_name) # a single env\n", + " env.seed(10)\n", + " n_states = envs.observation_space.shape[0]\n", + " n_actions = envs.action_space.n\n", + " model = ActorCritic(n_states, n_actions, cfg.hidden_dim).to(cfg.device)\n", + " optimizer = optim.Adam(model.parameters())\n", + " step_idx = 0\n", + " test_rewards = []\n", + " test_ma_rewards = []\n", + " state = envs.reset()\n", + " while step_idx < cfg.max_steps:\n", + " log_probs = []\n", + " values = []\n", + " rewards = []\n", + " masks = []\n", + " entropy = 0\n", + " # rollout trajectory\n", + " for _ in range(cfg.n_steps):\n", + " state = torch.FloatTensor(state).to(cfg.device)\n", + " dist, value = model(state)\n", + " action = dist.sample()\n", + " next_state, reward, done, _ = envs.step(action.cpu().numpy())\n", + " log_prob = dist.log_prob(action)\n", + " entropy += dist.entropy().mean()\n", + " log_probs.append(log_prob)\n", + " values.append(value)\n", + " rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(cfg.device))\n", + " masks.append(torch.FloatTensor(1 - done).unsqueeze(1).to(cfg.device))\n", + " state = next_state\n", + " step_idx += 1\n", + " if step_idx % 200 == 0:\n", + " test_reward = np.mean([test_env(env,model) for _ in range(10)])\n", + " print(f\"step_idx:{step_idx}, test_reward:{test_reward}\")\n", + " test_rewards.append(test_reward)\n", + " if test_ma_rewards:\n", + " test_ma_rewards.append(0.9*test_ma_rewards[-1]+0.1*test_reward)\n", + " else:\n", + " test_ma_rewards.append(test_reward) \n", + " # plot(step_idx, test_rewards) \n", + " next_state = torch.FloatTensor(next_state).to(cfg.device)\n", + " _, next_value = model(next_state)\n", + " returns = compute_returns(next_value, rewards, masks)\n", + " log_probs = torch.cat(log_probs)\n", + " returns = torch.cat(returns).detach()\n", + " values = torch.cat(values)\n", + " advantage = returns - values\n", + " actor_loss = -(log_probs * advantage.detach()).mean()\n", + " critic_loss = advantage.pow(2).mean()\n", + " loss = actor_loss + 0.5 * critic_loss - 0.001 * entropy\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " print('Finish training!')\n", + " return test_rewards, test_ma_rewards" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "def plot_rewards(rewards, ma_rewards, cfg, tag='train'):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(\"learning curve on {} of {} for {}\".format(\n", + " cfg.device, cfg.algo_name, cfg.env_name))\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(ma_rewards, label='ma rewards')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start training!\n", + "Env:CartPole-v0, Algorithm:A2C, Device:cuda\n", + "step_idx:200, test_reward:18.6\n", + "step_idx:400, test_reward:19.7\n", + "step_idx:600, test_reward:24.2\n", + "step_idx:800, test_reward:19.5\n", + "step_idx:1000, test_reward:33.9\n", + "step_idx:1200, test_reward:36.1\n", + "step_idx:1400, test_reward:32.6\n", + "step_idx:1600, test_reward:36.3\n", + "step_idx:1800, test_reward:38.9\n", + "step_idx:2000, test_reward:60.8\n", + "step_idx:2200, test_reward:41.9\n", + "step_idx:2400, test_reward:42.2\n", + "step_idx:2600, test_reward:71.6\n", + "step_idx:2800, test_reward:123.6\n", + "step_idx:3000, test_reward:57.5\n", + "step_idx:3200, test_reward:155.4\n", + "step_idx:3400, test_reward:111.4\n", + "step_idx:3600, test_reward:133.8\n", + "step_idx:3800, test_reward:133.8\n", + "step_idx:4000, test_reward:114.3\n", + "step_idx:4200, test_reward:165.5\n", + "step_idx:4400, test_reward:119.4\n", + "step_idx:4600, test_reward:173.4\n", + "step_idx:4800, test_reward:115.4\n", + "step_idx:5000, test_reward:159.7\n", + "step_idx:5200, test_reward:178.1\n", + "step_idx:5400, test_reward:137.8\n", + "step_idx:5600, test_reward:146.0\n", + "step_idx:5800, test_reward:187.4\n", + "step_idx:6000, test_reward:200.0\n", + "step_idx:6200, test_reward:169.2\n", + "step_idx:6400, test_reward:167.8\n", + "step_idx:6600, test_reward:184.3\n", + "step_idx:6800, test_reward:162.3\n", + "step_idx:7000, test_reward:125.4\n", + "step_idx:7200, test_reward:150.6\n", + "step_idx:7400, test_reward:152.6\n", + "step_idx:7600, test_reward:122.5\n", + "step_idx:7800, test_reward:136.3\n", + "step_idx:8000, test_reward:131.4\n", + "step_idx:8200, test_reward:174.6\n", + "step_idx:8400, test_reward:91.7\n", + "step_idx:8600, test_reward:170.1\n", + "step_idx:8800, test_reward:166.0\n", + "step_idx:9000, test_reward:150.2\n", + "step_idx:9200, test_reward:104.6\n", + "step_idx:9400, test_reward:147.2\n", + "step_idx:9600, test_reward:111.8\n", + "step_idx:9800, test_reward:118.7\n", + "step_idx:10000, test_reward:102.6\n", + "step_idx:10200, test_reward:99.0\n", + "step_idx:10400, test_reward:64.6\n", + "step_idx:10600, test_reward:133.7\n", + "step_idx:10800, test_reward:119.7\n", + "step_idx:11000, test_reward:112.6\n", + "step_idx:11200, test_reward:116.1\n", + "step_idx:11400, test_reward:116.3\n", + "step_idx:11600, test_reward:116.2\n", + "step_idx:11800, test_reward:115.3\n", + "step_idx:12000, test_reward:109.7\n", + "step_idx:12200, test_reward:110.3\n", + "step_idx:12400, test_reward:131.4\n", + "step_idx:12600, test_reward:128.3\n", + "step_idx:12800, test_reward:128.8\n", + "step_idx:13000, test_reward:119.8\n", + "step_idx:13200, test_reward:108.6\n", + "step_idx:13400, test_reward:128.4\n", + "step_idx:13600, test_reward:138.2\n", + "step_idx:13800, test_reward:119.1\n", + "step_idx:14000, test_reward:140.7\n", + "step_idx:14200, test_reward:145.3\n", + "step_idx:14400, test_reward:154.1\n", + "step_idx:14600, test_reward:165.2\n", + "step_idx:14800, test_reward:138.2\n", + "step_idx:15000, test_reward:143.5\n", + "step_idx:15200, test_reward:125.4\n", + "step_idx:15400, test_reward:137.1\n", + "step_idx:15600, test_reward:150.1\n", + "step_idx:15800, test_reward:132.9\n", + "step_idx:16000, test_reward:140.4\n", + "step_idx:16200, test_reward:141.3\n", + "step_idx:16400, test_reward:135.5\n", + "step_idx:16600, test_reward:135.5\n", + "step_idx:16800, test_reward:125.6\n", + "step_idx:17000, test_reward:126.8\n", + "step_idx:17200, test_reward:124.7\n", + "step_idx:17400, test_reward:129.6\n", + "step_idx:17600, test_reward:114.3\n", + "step_idx:17800, test_reward:57.3\n", + "step_idx:18000, test_reward:164.7\n", + "step_idx:18200, test_reward:165.8\n", + "step_idx:18400, test_reward:196.7\n", + "step_idx:18600, test_reward:198.8\n", + "step_idx:18800, test_reward:200.0\n", + "step_idx:19000, test_reward:199.6\n", + "step_idx:19200, test_reward:189.5\n", + "step_idx:19400, test_reward:177.9\n", + "step_idx:19600, test_reward:159.3\n", + "step_idx:19800, test_reward:127.7\n", + "step_idx:20000, test_reward:143.6\n", + "Finish training!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import easydict\n", + "from common.multiprocessing_env import SubprocVecEnv\n", + "cfg = easydict.EasyDict({\n", + " \"algo_name\": 'A2C',\n", + " \"env_name\": 'CartPole-v0',\n", + " \"n_envs\": 8,\n", + " \"max_steps\": 20000,\n", + " \"n_steps\":5,\n", + " \"gamma\":0.99,\n", + " \"lr\": 1e-3,\n", + " \"hidden_dim\": 256,\n", + " \"device\":torch.device(\n", + " \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "})\n", + "envs = [make_envs(cfg.env_name) for i in range(cfg.n_envs)]\n", + "envs = SubprocVecEnv(envs) \n", + "rewards,ma_rewards = train(cfg,envs)\n", + "plot_rewards(rewards, ma_rewards, cfg, tag=\"train\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('rl_tutorials')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "4f613f1ab80ec98dc1b91d6e720de51301598a187317378e53e49b773c1123dd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/DDPG.ipynb b/notebooks/DDPG.ipynb new file mode 100644 index 0000000..5194644 --- /dev/null +++ b/notebooks/DDPG.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1. 定义模型\n", + "\n", + "注意DDGP中critic网络的输入是state加上action。" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class Actor(nn.Module):\n", + " def __init__(self, n_states, n_actions, hidden_dim = 256, init_w=3e-3):\n", + " super(Actor, self).__init__() \n", + " self.linear1 = nn.Linear(n_states, hidden_dim)\n", + " self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.linear3 = nn.Linear(hidden_dim, n_actions)\n", + " \n", + " self.linear3.weight.data.uniform_(-init_w, init_w)\n", + " self.linear3.bias.data.uniform_(-init_w, init_w)\n", + " \n", + " def forward(self, x):\n", + " x = F.relu(self.linear1(x))\n", + " x = F.relu(self.linear2(x))\n", + " x = torch.tanh(self.linear3(x))\n", + " return x\n", + " \n", + "class Critic(nn.Module):\n", + " def __init__(self, n_states, n_actions, hidden_dim=256, init_w=3e-3):\n", + " super(Critic, self).__init__()\n", + " \n", + " self.linear1 = nn.Linear(n_states + n_actions, hidden_dim)\n", + " self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.linear3 = nn.Linear(hidden_dim, 1)\n", + " # 随机初始化为较小的值\n", + " self.linear3.weight.data.uniform_(-init_w, init_w)\n", + " self.linear3.bias.data.uniform_(-init_w, init_w)\n", + " \n", + " def forward(self, state, action):\n", + " # 按维数1拼接\n", + " x = torch.cat([state, action], 1)\n", + " x = F.relu(self.linear1(x))\n", + " x = F.relu(self.linear2(x))\n", + " x = self.linear3(x)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 定义经验回放" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer:\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " '''_summary_\n", + " Args:\n", + " trainsitions (tuple): _description_\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer):\n", + " batch_size = len(self.buffer)\n", + " if sequential: # sequential sampling\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else:\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.optim as optim\n", + "import numpy as np\n", + "class DDPG:\n", + " def __init__(self, models,memories,cfg):\n", + " self.device = torch.device(cfg['device'])\n", + " self.critic = models['critic'].to(self.device)\n", + " self.target_critic = models['critic'].to(self.device)\n", + " self.actor = models['actor'].to(self.device)\n", + " self.target_actor = models['actor'].to(self.device)\n", + " \n", + " # 复制参数到目标网络\n", + " for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n", + " target_param.data.copy_(param.data)\n", + " for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n", + " target_param.data.copy_(param.data)\n", + " self.critic_optimizer = optim.Adam(\n", + " self.critic.parameters(), lr=cfg['critic_lr'])\n", + " self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=cfg['actor_lr'])\n", + " self.memory = memories['memory']\n", + " self.batch_size = cfg['batch_size']\n", + " self.gamma = cfg['gamma']\n", + " self.tau = cfg['tau'] # 软更新参数\n", + " def sample_action(self, state):\n", + " state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n", + " action = self.actor(state)\n", + " return action.detach().cpu().numpy()[0, 0]\n", + " @torch.no_grad()\n", + " def predict_action(self, state):\n", + " ''' 用于预测,不需要计算梯度\n", + " '''\n", + " state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n", + " action = self.actor(state)\n", + " return action.cpu().numpy()[0, 0]\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 当memory中不满足一个批量时,不更新策略\n", + " return\n", + " # 从经验回放中中随机采样一个批量的transition\n", + " state, action, reward, next_state, done = self.memory.sample(self.batch_size)\n", + " # 转变为张量\n", + " state = torch.FloatTensor(np.array(state)).to(self.device)\n", + " next_state = torch.FloatTensor(np.array(next_state)).to(self.device)\n", + " action = torch.FloatTensor(np.array(action)).to(self.device)\n", + " reward = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n", + " done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n", + " # 注意看伪代码,这里的actor损失就是对应策略即actor输出的action下对应critic值的负均值\n", + " actor_loss = self.critic(state, self.actor(state))\n", + " actor_loss = - actor_loss.mean()\n", + "\n", + " next_action = self.target_actor(next_state)\n", + " target_value = self.target_critic(next_state, next_action.detach())\n", + " # 这里的expected_value就是伪代码中间的y_i \n", + " expected_value = reward + (1.0 - done) * self.gamma * target_value\n", + " expected_value = torch.clamp(expected_value, -np.inf, np.inf)\n", + "\n", + " actual_value = self.critic(state, action)\n", + " critic_loss = nn.MSELoss()(actual_value, expected_value.detach())\n", + " \n", + " self.actor_optimizer.zero_grad()\n", + " actor_loss.backward()\n", + " self.actor_optimizer.step()\n", + " self.critic_optimizer.zero_grad()\n", + " critic_loss.backward()\n", + " self.critic_optimizer.step()\n", + " # 各自目标网络的参数软更新\n", + " for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n", + " target_param.data.copy_(\n", + " target_param.data * (1.0 - self.tau) +\n", + " param.data * self.tau\n", + " )\n", + " for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n", + " target_param.data.copy_(\n", + " target_param.data * (1.0 - self.tau) +\n", + " param.data * self.tau\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 定义训练\n", + "\n", + "注意测试函数中不需要动作噪声" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "class OUNoise(object):\n", + " '''Ornstein–Uhlenbeck噪声\n", + " '''\n", + " def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.3, decay_period=100000):\n", + " self.mu = mu # OU噪声的参数\n", + " self.theta = theta # OU噪声的参数\n", + " self.sigma = max_sigma # OU噪声的参数\n", + " self.max_sigma = max_sigma\n", + " self.min_sigma = min_sigma\n", + " self.decay_period = decay_period\n", + " self.n_actions = action_space.shape[0]\n", + " self.low = action_space.low\n", + " self.high = action_space.high\n", + " self.reset()\n", + " def reset(self):\n", + " self.obs = np.ones(self.n_actions) * self.mu\n", + " def evolve_obs(self):\n", + " x = self.obs\n", + " dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(self.n_actions)\n", + " self.obs = x + dx\n", + " return self.obs\n", + " def get_action(self, action, t=0):\n", + " ou_obs = self.evolve_obs()\n", + " self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period) # sigma会逐渐衰减\n", + " return np.clip(action + ou_obs, self.low, self.high) # 动作加上噪声后进行剪切\n", + "\n", + "def train(cfg, env, agent):\n", + " print(\"开始训练!\")\n", + " ou_noise = OUNoise(env.action_space) # 动作噪声\n", + " rewards = [] # 记录所有回合的奖励\n", + " for i_ep in range(cfg['train_eps']):\n", + " state = env.reset()\n", + " ou_noise.reset()\n", + " ep_reward = 0\n", + " for i_step in range(cfg['max_steps']):\n", + " action = agent.sample_action(state)\n", + " action = ou_noise.get_action(action, i_step+1) \n", + " next_state, reward, done, _ = env.step(action)\n", + " ep_reward += reward\n", + " agent.memory.push((state, action, reward, next_state, done))\n", + " agent.update()\n", + " state = next_state\n", + " if done:\n", + " break\n", + " if (i_ep+1)%10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg['train_eps']},奖励:{ep_reward:.2f}\")\n", + " rewards.append(ep_reward)\n", + " print(\"完成训练!\")\n", + " return {'rewards':rewards}\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " for i_ep in range(cfg['test_eps']):\n", + " state = env.reset() \n", + " ep_reward = 0\n", + " for i_step in range(cfg['max_steps']):\n", + " action = agent.predict_action(state)\n", + " next_state, reward, done, _ = env.step(action)\n", + " ep_reward += reward\n", + " state = next_state\n", + " if done:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg['test_eps']},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试!\")\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "import torch\n", + "import numpy as np\n", + "import random\n", + "class NormalizedActions(gym.ActionWrapper):\n", + " ''' 将action范围重定在[0.1]之间\n", + " '''\n", + " def action(self, action):\n", + " low_bound = self.action_space.low\n", + " upper_bound = self.action_space.high\n", + " action = low_bound + (action + 1.0) * 0.5 * (upper_bound - low_bound)\n", + " action = np.clip(action, low_bound, upper_bound)\n", + " return action\n", + "\n", + " def reverse_action(self, action):\n", + " low_bound = self.action_space.low\n", + " upper_bound = self.action_space.high\n", + " action = 2 * (action - low_bound) / (upper_bound - low_bound) - 1\n", + " action = np.clip(action, low_bound, upper_bound)\n", + " return action\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = NormalizedActions(gym.make(cfg['env_name'])) # 装饰action噪声\n", + " if cfg['seed'] !=0:\n", + " all_seed(env,seed=cfg['seed'])\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.shape[0]\n", + " cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # 更新n_states和n_actions到cfg参数中\n", + " models = {\"actor\":Actor(n_states,n_actions,hidden_dim=cfg['actor_hidden_dim']),\"critic\":Critic(n_states,n_actions,hidden_dim=cfg['critic_hidden_dim'])}\n", + " memories = {\"memory\":ReplayBuffer(cfg['memory_capacity'])}\n", + " agent = DDPG(models,memories,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. 设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "def get_args():\n", + " \"\"\" 超参数\n", + " \"\"\"\n", + " parser = argparse.ArgumentParser(description=\"hyperparameters\") \n", + " parser.add_argument('--algo_name',default='DDPG',type=str,help=\"name of algorithm\")\n", + " parser.add_argument('--env_name',default='Pendulum-v1',type=str,help=\"name of environment\")\n", + " parser.add_argument('--train_eps',default=300,type=int,help=\"episodes of training\")\n", + " parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\")\n", + " parser.add_argument('--max_steps',default=100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n", + " parser.add_argument('--gamma',default=0.99,type=float,help=\"discounted factor\")\n", + " parser.add_argument('--critic_lr',default=1e-3,type=float,help=\"learning rate of critic\")\n", + " parser.add_argument('--actor_lr',default=1e-4,type=float,help=\"learning rate of actor\")\n", + " parser.add_argument('--memory_capacity',default=8000,type=int,help=\"memory capacity\")\n", + " parser.add_argument('--batch_size',default=128,type=int)\n", + " parser.add_argument('--target_update',default=2,type=int)\n", + " parser.add_argument('--tau',default=1e-2,type=float)\n", + " parser.add_argument('--critic_hidden_dim',default=256,type=int)\n", + " parser.add_argument('--actor_hidden_dim',default=256,type=int)\n", + " parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\") \n", + " parser.add_argument('--seed',default=1,type=int,help=\"random seed\")\n", + " args = parser.parse_args([]) \n", + " args = {**vars(args)} # 将args转换为字典 \n", + " # 打印参数\n", + " print(\"训练参数如下:\")\n", + " print(''.join(['=']*80))\n", + " tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n", + " print(tplt.format(\"参数名\",\"参数值\",\"参数类型\"))\n", + " for k,v in args.items():\n", + " print(tplt.format(k,v,str(type(v)))) \n", + " print(''.join(['=']*80)) \n", + " return args\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth\n", + "\n", + " Args:\n", + " data (List):输入数据\n", + " weight (Float): 平滑权重,处于0-1之间,数值越高说明越平滑,一般取0.9\n", + "\n", + " Returns:\n", + " smoothed (List): 平滑后的数据\n", + " '''\n", + " last = data[0] # First value in the plot (first timestep)\n", + " smoothed = list()\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg,path=None,tag='train'):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. 我准备好了!" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "训练参数如下:\n", + "================================================================================\n", + " 参数名 \t 参数值 \t 参数类型 \n", + " algo_name \t DDPG \t \n", + " env_name \t Pendulum-v1 \t \n", + " train_eps \t 300 \t \n", + " test_eps \t 20 \t \n", + " max_steps \t 100000 \t \n", + " gamma \t 0.99 \t \n", + " critic_lr \t 0.001 \t \n", + " actor_lr \t 0.0001 \t \n", + " memory_capacity \t 8000 \t \n", + " batch_size \t 128 \t \n", + " target_update \t 2 \t \n", + " tau \t 0.01 \t \n", + " critic_hidden_dim \t 256 \t \n", + " actor_hidden_dim \t 256 \t \n", + " device \t cpu \t \n", + " seed \t 1 \t \n", + "================================================================================\n", + "开始训练!\n", + "回合:10/300,奖励:-1549.57\n", + "回合:20/300,奖励:-1515.84\n", + "回合:30/300,奖励:-1413.30\n", + "回合:40/300,奖励:-972.99\n", + "回合:50/300,奖励:-829.94\n", + "回合:60/300,奖励:-727.91\n", + "回合:70/300,奖励:-954.71\n", + "回合:80/300,奖励:-1318.39\n", + "回合:90/300,奖励:-981.19\n", + "回合:100/300,奖励:-1262.05\n", + "回合:110/300,奖励:-640.49\n", + "回合:120/300,奖励:-1100.00\n", + "回合:130/300,奖励:-764.66\n", + "回合:140/300,奖励:-352.27\n", + "回合:150/300,奖励:-891.03\n", + "回合:160/300,奖励:-1318.07\n", + "回合:170/300,奖励:-124.30\n", + "回合:180/300,奖励:-240.08\n", + "回合:190/300,奖励:-491.77\n", + "回合:200/300,奖励:-1000.77\n", + "回合:210/300,奖励:-128.87\n", + "回合:220/300,奖励:-950.32\n", + "回合:230/300,奖励:-122.48\n", + "回合:240/300,奖励:-246.52\n", + "回合:250/300,奖励:-374.37\n", + "回合:260/300,奖励:-368.25\n", + "回合:270/300,奖励:-364.17\n", + "回合:280/300,奖励:-725.39\n", + "回合:290/300,奖励:-131.21\n", + "回合:300/300,奖励:-610.10\n", + "完成训练!\n", + "开始测试!\n", + "回合:1/20,奖励:-116.05\n", + "回合:2/20,奖励:-126.18\n", + "回合:3/20,奖励:-231.46\n", + "回合:4/20,奖励:-246.40\n", + "回合:5/20,奖励:-304.69\n", + "回合:6/20,奖励:-124.40\n", + "回合:7/20,奖励:-1.06\n", + "回合:8/20,奖励:-114.20\n", + "回合:9/20,奖励:-348.97\n", + "回合:10/20,奖励:-116.11\n", + "回合:11/20,奖励:-117.20\n", + "回合:12/20,奖励:-118.66\n", + "回合:13/20,奖励:-235.18\n", + "回合:14/20,奖励:-356.14\n", + "回合:15/20,奖励:-118.39\n", + "回合:16/20,奖励:-351.94\n", + "回合:17/20,奖励:-114.51\n", + "回合:18/20,奖励:-124.78\n", + "回合:19/20,奖励:-226.47\n", + "回合:20/20,奖励:-121.49\n", + "完成测试!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = get_args() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/DQN.ipynb b/notebooks/DQN.ipynb new file mode 100644 index 0000000..1751130 --- /dev/null +++ b/notebooks/DQN.ipynb @@ -0,0 +1,541 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法\n", + "\n", + "教程中提到相比于Q learning,DQN本质上是为了适应更为复杂的环境,并且经过不断的改良迭代,到了Nature DQN(即Volodymyr Mnih发表的Nature论文)这里才算是基本完善。DQN主要改动的点有三个:\n", + "* 使用深度神经网络替代原来的Q表:这个很容易理解原因\n", + "* 使用了经验回放(Replay Buffer):这个好处有很多,一个是使用一堆历史数据去训练,比之前用一次就扔掉好多了,大大提高样本效率,另外一个是面试常提到的,减少样本之间的相关性,原则上获取经验跟学习阶段是分开的,原来时序的训练数据有可能是不稳定的,打乱之后再学习有助于提高训练的稳定性,跟深度学习中划分训练测试集时打乱样本是一个道理。\n", + "* 使用了两个网络:即策略网络和目标网络,每隔若干步才把每步更新的策略网络参数复制给目标网络,这样做也是为了训练的稳定,避免Q值的估计发散。想象一下,如果当前有个transition(这个Q learning中提过的,一定要记住!!!)样本导致对Q值进行了较差的过估计,如果接下来从经验回放中提取到的样本正好连续几个都这样的,很有可能导致Q值的发散(它的青春小鸟一去不回来了)。再打个比方,我们玩RPG或者闯关类游戏,有些人为了破纪录经常Save和Load,只要我出了错,我不满意我就加载之前的存档,假设不允许加载呢,就像DQN算法一样训练过程中会退不了,这时候是不是搞两个档,一个档每帧都存一下,另外一个档打了不错的结果再存,也就是若干个间隔再存一下,到最后用间隔若干步数再存的档一般都比每帧都存的档好些呢。当然你也可以再搞更多个档,也就是DQN增加多个目标网络,但是对于DQN则没有多大必要,多几个网络效果不见得会好很多。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、定义模型\n", + "\n", + "前面说了DQN的模型不再是Q表,而是一个深度神经网络,这里我只用了一个三层的全连接网络(FCN),这种网络也叫多层感知机(MLP),至于怎么用Torch写网络这里就不多说明了,以下仅供参考。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class MLP(nn.Module):\n", + " def __init__(self, n_states,n_actions,hidden_dim=128):\n", + " \"\"\" 初始化q网络,为全连接网络\n", + " \"\"\"\n", + " super(MLP, self).__init__()\n", + " self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n", + " self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n", + " self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n", + " \n", + " def forward(self, x):\n", + " # 各层对应的激活函数\n", + " x = F.relu(self.fc1(x)) \n", + " x = F.relu(self.fc2(x))\n", + " return self.fc3(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "经验回放首先是具有一定容量的,只有存储一定的transition网络才会更新,否则就退回到了之前的逐步更新了。另外写经验回放的时候一般需要包涵两个功能或方法,一个是push,即将一个transition样本按顺序放到经验回放中,如果满了就把最开始放进去的样本挤掉,因此如果大家学过数据结构的话推荐用队列来写,虽然这里不是。另外一个是sample,很简单就是随机采样出一个或者若干个(具体多少就是batch_size了)样本供DQN网络更新。功能讲清楚了,大家可以按照自己的想法用代码来实现,参考如下。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer(object):\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " ''' 存储transition到经验回放中\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量,则取经验回放的容量\n", + " batch_size = len(self.buffer)\n", + " if sequential: # 顺序采样\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else: # 随机采样\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " ''' 清空经验回放\n", + " '''\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " ''' 返回当前存储的量\n", + " '''\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、真定义算法\n", + "\n", + "到了高级一点的算法,定义算法就比较麻烦,要先定义一些子模块,再定义好子模块之后我们就可以实现我们的算法核心部分。如下,可以看到,其实去掉子模块的话,DQN跟Q learning的算法结构没啥区别,当然因为神经网络一般需要Torch或者Tensorflow来写,因此推荐大家先去学一学这些工具,比如\"eat_pytorch_in_20_days\"。\n", + "\n", + "这里我们主要分析一下DQN的更新过程,也就是update函数。首先我们知道目前所有基于深度神经网络的更新方式都是梯度下降,如下:\n", + "$$\n", + "\\theta_i \\leftarrow \\theta_i - \\lambda \\nabla_{\\theta_{i}} L_{i}\\left(\\theta_{i}\\right)\n", + "$$\n", + "那么这个$\\theta$又是什么呢,注意到前面我们讲的DQN跟Q learning算法的一个主要区别就是使用神经网络替代了Q表,而这个$\\theta$实际上就是神经网络的参数,通常用$Q\\left(s_{i}, a_{i} ; \\theta\\right)$表示。根据强化学习的原理我们需要优化的是对应状态下不同动作的长期价值,然后每次选择价值最大对应的动作就能完成一条最优策略,使用神经网络表示Q表时也是如此,我们将输入的状态数作为神经网络的输入层,动作数作为输出层,这样的神经网络表达的功能就跟在Q learning中的Q表是一样的,只不过具有更强的鲁棒性。\n", + "\n", + "讲完了为什么要优化的是这个参数$\\theta$,接下来我们从代码层面进一步剖析,稍微了解一点Torch知识的同学都知道,上面的公式其实只需要定义一个优化器,然后计算损失之后用优化器迭代即可,如下:\n", + "```python\n", + "optimizer = optim.Adam(Q_net.parameters(), lr=0.01) # 定义优化器,对应的网络是Q_net,学习率为0.01\n", + "loss = ... # 计算损失,这里掠过\n", + "# 然后优化器先zero_grad(),loss再反向传播,然后优化器step() ,这是一个固定的套路\n", + "optimizer.zero_grad() \n", + "loss.backward()\n", + "optimizer.step() \n", + "```\n", + "当然强烈建议同学们了解一下深度学习中的梯度下降,并且使用numpy实现,这样就会更加清楚整个梯度下降过程到底是怎么回事,上述只是在同学们了解了梯度下降的具体实现方式的前提下为了方便学习更多其他的知识形成的套路。这就好比我们玩一个竞技游戏,如果我们之前从来没有接触过该类游戏,那么肯定是从普通攻击,每个技能一步一步地学起打好基础,然后再学习技能连招等等也就是形成固定的套路,但是如果不先打基础,直接学习套路可能会是一脸懵逼的状态,尤其是很多高端玩家会对这些连招套路简化名称比如光速qa和1233321等等,一开始我们是很难听懂的。等当我们先打好基础,然后再学习了很多套路之后会发现这些基础并不能用得上,甚至有的时候可能会忽然忘记了这些基础,但其实我们并没有忘记,再回顾一遍也能很快拣起来。在这点上我想强调的是基础固然重要,但是不要死磕基础,除非是学术研究需要。再比如我们小学学完简单加减乘除之后很快就去背九九乘法表,而不会去过多纠结一加一等于几的问题,上大学后也是如此,只是很多时候我们很可能看起来这个问题值得研究,但意识不到自己就是在纠结一加一等于几的问题,这也是我在和众多读者们学习讨论的过程中在他们身上发现的问题。\n", + "\n", + "回归正题,细心的同学会发现数学公式和代码的对应是有一定的壁垒的,只要通过多加练习跨越了这个壁垒,那么对于往后我们想要复现论文也会轻松许多。我们目前讲了参数的更新过程,但是最关键的是损失是如何计算的,在DQN中损失的计算相对来说比较简单,如下:\n", + "$$\n", + "L(\\theta)=\\left(y_{i}-Q\\left(s_{i}, a_{i} ; \\theta\\right)\\right)^{2}\n", + "$$\n", + "这里的$y_{i}$通常称为期望值,$Q\\left(s_{i}, a_{i} ; \\theta\\right)$称为实际值,这个损失在深度学习中通常称作均方差损失,也就是mseloss,使用这个损失函数通常追溯到数学上的最小二乘法,感兴趣的同学可以了解一下深度学习中的各种损失函数以及各自的使用场景。\n", + "$y_{i}$在DQN中一般表示如下:\n", + "$$\n", + "y_{i}= \\begin{cases}r_{i} & \\text {对于终止状态} s_{i+1} \\\\ r_{i}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{i+1}, a^{\\prime} ; \\theta\\right) & \\text {对于非终止状态} s_{i+1}\\end{cases}\n", + "$$\n", + "该公式的意思就是将下一个状态对应的最大Q值作为实际值(因为实际值通常不能直接求得,只能近似),这种做法实际上只是一种近似,可能会导致过估计等问题,也有一些改善的方法具体可以在后面各种改进的DQN算法比如Double DQN中看到,在这里我们暂时不要深究为什么要用这个来近似实际值。然后注意到这里其实有一个终止状态的判断,因为如果当前状态是终止状态,那么实际上是没有下一个状态的,所以DQN干脆直接使用对应的奖励表示Q的实际值。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "class DQN:\n", + " def __init__(self,model,memory,cfg):\n", + "\n", + " self.n_actions = cfg['n_actions'] \n", + " self.device = torch.device(cfg['device']) \n", + " self.gamma = cfg['gamma'] # 奖励的折扣因子\n", + " # e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg['epsilon_start']\n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg['epsilon_start']\n", + " self.epsilon_end = cfg['epsilon_end']\n", + " self.epsilon_decay = cfg['epsilon_decay']\n", + " self.batch_size = cfg['batch_size']\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " # 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg['lr']) # 优化器\n", + " self.memory = memory # 经验回放\n", + " def sample_action(self, state):\n", + " ''' 采样动作\n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + " @torch.no_grad() # 不计算梯度,该装饰器效果等同于with torch.no_grad():\n", + " def predict_action(self, state):\n", + " ''' 预测动作\n", + " '''\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时,不更新策略\n", + " return\n", + " # 从经验回放中随机采样一个批量的转移(transition)\n", + " state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n", + " self.batch_size)\n", + " # 将数据转换为tensor\n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) \n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float) \n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n", + " done_batch = torch.tensor(np.float32(done_batch), device=self.device)\n", + " q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 计算当前状态(s_t,a)对应的Q(s_t, a)\n", + " next_q_values = self.target_net(next_state_batch).max(1)[0].detach() # 计算下一时刻的状态(s_t_,a)对应的Q值\n", + " # 计算期望的Q值,对于终止状态,此时done_batch[0]=1, 对应的expected_q_value等于reward\n", + " expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)\n", + " loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1)) # 计算均方根损失\n", + " # 优化更新模型\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # clip防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg['train_eps']):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg['ep_max_steps']):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " agent.memory.push((state, action, reward,next_state, done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep + 1) % cfg['target_update'] == 0: # 智能体目标网络更新\n", + " agent.target_net.load_state_dict(agent.policy_net.state_dict())\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg['train_eps']},奖励:{ep_reward:.2f},Epislon:{agent.epsilon:.3f}\")\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg['test_eps']):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg['ep_max_steps']):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg['test_eps']},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg['env_name']) # 创建环境\n", + " if cfg['seed'] !=0:\n", + " all_seed(env,seed=cfg['seed'])\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + " cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # 更新n_states和n_actions到cfg参数中\n", + " model = MLP(n_states, n_actions, hidden_dim = cfg['hidden_dim']) # 创建模型\n", + " memory = ReplayBuffer(cfg['memory_capacity'])\n", + " agent = DQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "def get_args():\n", + " \"\"\" 超参数\n", + " \"\"\"\n", + " parser = argparse.ArgumentParser(description=\"hyperparameters\") \n", + " parser.add_argument('--algo_name',default='DQN',type=str,help=\"name of algorithm\")\n", + " parser.add_argument('--env_name',default='CartPole-v0',type=str,help=\"name of environment\")\n", + " parser.add_argument('--train_eps',default=200,type=int,help=\"episodes of training\")\n", + " parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\")\n", + " parser.add_argument('--ep_max_steps',default = 100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n", + " parser.add_argument('--gamma',default=0.95,type=float,help=\"discounted factor\")\n", + " parser.add_argument('--epsilon_start',default=0.95,type=float,help=\"initial value of epsilon\")\n", + " parser.add_argument('--epsilon_end',default=0.01,type=float,help=\"final value of epsilon\")\n", + " parser.add_argument('--epsilon_decay',default=500,type=int,help=\"decay rate of epsilon, the higher value, the slower decay\")\n", + " parser.add_argument('--lr',default=0.0001,type=float,help=\"learning rate\")\n", + " parser.add_argument('--memory_capacity',default=100000,type=int,help=\"memory capacity\")\n", + " parser.add_argument('--batch_size',default=64,type=int)\n", + " parser.add_argument('--target_update',default=4,type=int)\n", + " parser.add_argument('--hidden_dim',default=256,type=int)\n", + " parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\") \n", + " parser.add_argument('--seed',default=10,type=int,help=\"seed\") \n", + " args = parser.parse_args([])\n", + " args = {**vars(args)} # 转换成字典类型 \n", + " ## 打印超参数\n", + " print(\"超参数\")\n", + " print(''.join(['=']*80))\n", + " tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n", + " print(tplt.format(\"Name\", \"Value\", \"Type\"))\n", + " for k,v in args.items():\n", + " print(tplt.format(k,v,str(type(v)))) \n", + " print(''.join(['=']*80)) \n", + " return args\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "超参数\n", + "================================================================================\n", + " Name \t Value \t Type \n", + " algo_name \t DQN \t \n", + " env_name \t CartPole-v0 \t \n", + " train_eps \t 200 \t \n", + " test_eps \t 20 \t \n", + " ep_max_steps \t 100000 \t \n", + " gamma \t 0.95 \t \n", + " epsilon_start \t 0.95 \t \n", + " epsilon_end \t 0.01 \t \n", + " epsilon_decay \t 500 \t \n", + " lr \t 0.0001 \t \n", + " memory_capacity \t 100000 \t \n", + " batch_size \t 64 \t \n", + " target_update \t 4 \t \n", + " hidden_dim \t 256 \t \n", + " device \t cpu \t \n", + " seed \t 10 \t \n", + "================================================================================\n", + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "回合:10/200,奖励:14.00,Epislon:0.611\n", + "回合:20/200,奖励:10.00,Epislon:0.470\n", + "回合:30/200,奖励:11.00,Epislon:0.372\n", + "回合:40/200,奖励:18.00,Epislon:0.302\n", + "回合:50/200,奖励:15.00,Epislon:0.228\n", + "回合:60/200,奖励:62.00,Epislon:0.121\n", + "回合:70/200,奖励:128.00,Epislon:0.039\n", + "回合:80/200,奖励:200.00,Epislon:0.011\n", + "回合:90/200,奖励:200.00,Epislon:0.010\n", + "回合:100/200,奖励:200.00,Epislon:0.010\n", + "回合:110/200,奖励:200.00,Epislon:0.010\n", + "回合:120/200,奖励:200.00,Epislon:0.010\n", + "回合:130/200,奖励:200.00,Epislon:0.010\n", + "回合:140/200,奖励:200.00,Epislon:0.010\n", + "回合:150/200,奖励:200.00,Epislon:0.010\n", + "回合:160/200,奖励:200.00,Epislon:0.010\n", + "回合:170/200,奖励:200.00,Epislon:0.010\n", + "回合:180/200,奖励:200.00,Epislon:0.010\n", + "回合:190/200,奖励:200.00,Epislon:0.010\n", + "回合:200/200,奖励:200.00,Epislon:0.010\n", + "完成训练!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试!\n", + "回合:1/20,奖励:200.00\n", + "回合:2/20,奖励:200.00\n", + "回合:3/20,奖励:200.00\n", + "回合:4/20,奖励:200.00\n", + "回合:5/20,奖励:200.00\n", + "回合:6/20,奖励:200.00\n", + "回合:7/20,奖励:200.00\n", + "回合:8/20,奖励:200.00\n", + "回合:9/20,奖励:200.00\n", + "回合:10/20,奖励:200.00\n", + "回合:11/20,奖励:200.00\n", + "回合:12/20,奖励:200.00\n", + "回合:13/20,奖励:200.00\n", + "回合:14/20,奖励:200.00\n", + "回合:15/20,奖励:200.00\n", + "回合:16/20,奖励:200.00\n", + "回合:17/20,奖励:200.00\n", + "回合:18/20,奖励:200.00\n", + "回合:19/20,奖励:200.00\n", + "回合:20/20,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = get_args() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.6.9 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/DoubleDQN.ipynb b/notebooks/DoubleDQN.ipynb new file mode 100644 index 0000000..0f78bad --- /dev/null +++ b/notebooks/DoubleDQN.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法\n", + "\n", + "Double DQN除了在更新时对期望Q值的近似方式与DQN不同之外,其他都是相同的\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、定义模型\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class MLP(nn.Module):\n", + " def __init__(self, n_states,n_actions,hidden_dim=128):\n", + " \"\"\" 初始化q网络,为全连接网络\n", + " \"\"\"\n", + " super(MLP, self).__init__()\n", + " self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n", + " self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n", + " self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n", + " \n", + " def forward(self, x):\n", + " # 各层对应的激活函数\n", + " x = F.relu(self.fc1(x)) \n", + " x = F.relu(self.fc2(x))\n", + " return self.fc3(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "经验回放首先是具有一定容量的,只有存储一定的transition网络才会更新,否则就退回到了之前的逐步更新了。另外写经验回放的时候一般需要包涵两个功能或方法,一个是push,即将一个transition样本按顺序放到经验回放中,如果满了就把最开始放进去的样本挤掉,因此如果大家学过数据结构的话推荐用队列来写,虽然这里不是。另外一个是sample,很简单就是随机采样出一个或者若干个(具体多少就是batch_size了)样本供DQN网络更新。功能讲清楚了,大家可以按照自己的想法用代码来实现,参考如下。" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer(object):\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " ''' 存储transition到经验回放中\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量,则取经验回放的容量\n", + " batch_size = len(self.buffer)\n", + " if sequential: # 顺序采样\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else: # 随机采样\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " ''' 清空经验回放\n", + " '''\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " ''' 返回当前存储的量\n", + " '''\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、真定义算法\n", + "\n", + "跟DQN算法几乎一模一样" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "class DoubleDQN(object):\n", + " def __init__(self,cfg):\n", + " self.states = cfg.n_states\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma # 折扣因子\n", + " # e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + " self.policy_net = MLP(cfg.n_states,cfg.n_actions,hidden_dim=cfg.hidden_dim).to(self.device)\n", + " self.target_net = MLP(cfg.n_states,cfg.n_actions,hidden_dim=cfg.hidden_dim).to(self.device)\n", + " # 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " # self.target_net.load_state_dict(self.policy_net.state_dict()) # or use this to copy parameters\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n", + " self.memory = ReplayBuffer(cfg.buffer_size) # 经验回放\n", + " self.update_flag = False \n", + "\n", + " def sample_action(self, state):\n", + " ''' 采样动作\n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + " @torch.no_grad() # 不计算梯度,该装饰器效果等同于with torch.no_grad():\n", + " def predict_action(self, state):\n", + " ''' 预测动作\n", + " '''\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时,不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"开始更新策略!\")\n", + " self.update_flag = True\n", + " # 从经验回放中随机采样一个批量的转移(transition)\n", + " state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n", + " self.batch_size)\n", + " # 将数据转换为tensor\n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) \n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float) \n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n", + " done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1)\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 实际的Q值\n", + " # 计算目标Q值\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) # 最大的Q值\n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch) # 期望的Q值\n", + " # 计算损失\n", + " loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)\n", + " # 优化更新模型\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # clip防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + " if self.sample_count % self.target_update == 0: # 每隔一段时间,将策略网络的参数复制到目标网络\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " agent.memory.push((state, action, reward,next_state, done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},Epislon:{agent.epsilon:.3f}\")\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.test_eps},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + " # 更新n_states和n_actions到cfg参数中\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions) \n", + " agent = DoubleDQN(cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config:\n", + " def __init__(self):\n", + " self.algo_name = 'DoubleDQN' # 算法名称\n", + " self.env_name = 'CartPole-v1' # 环境名称\n", + " self.seed = 1 # 随机种子\n", + " self.train_eps = 100 # 训练回合数\n", + " self.test_eps = 10 # 测试回合数\n", + " self.max_steps = 200 # 每回合最大步数\n", + " self.gamma = 0.99 # 折扣因子\n", + " self.lr = 0.0001 # 学习率\n", + " self.epsilon_start = 0.95 # epsilon初始值\n", + " self.epsilon_end = 0.01 # epsilon最终值\n", + " self.epsilon_decay = 500 # epsilon衰减率\n", + " self.buffer_size = 10000 # ReplayBuffer容量\n", + " self.batch_size = 64 # ReplayBuffer中批次大小\n", + " self.target_update = 4 # 目标网络更新频率\n", + " self.hidden_dim = 256 # 神经网络隐藏层维度\n", + " if torch.cuda.is_available(): # 是否使用GPUs\n", + " self.device = 'cuda'\n", + " else:\n", + " self.device = 'cpu'\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,title=\"learning curve\"):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{title}\")\n", + " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + "\n", + "def print_cfgs(cfg):\n", + " ''' 打印参数\n", + " '''\n", + " cfg_dict = vars(cfg)\n", + " print(\"Hyperparameters:\")\n", + " print(''.join(['=']*80))\n", + " tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n", + " print(tplt.format(\"Name\", \"Value\", \"Type\"))\n", + " for k,v in cfg_dict.items():\n", + " if v.__class__.__name__ == 'list':\n", + " v = str(v)\n", + " print(tplt.format(k,v,str(type(v)))) \n", + " print(''.join(['=']*80))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hyperparameters:\n", + "================================================================================\n", + " Name \t Value \t Type \n", + " algo_name \t DoubleDQN \t \n", + " env_name \t CartPole-v1 \t \n", + " seed \t 1 \t \n", + " train_eps \t 100 \t \n", + " test_eps \t 10 \t \n", + " max_steps \t 200 \t \n", + " gamma \t 0.99 \t \n", + " lr \t 0.0001 \t \n", + " epsilon_start \t 0.95 \t \n", + " epsilon_end \t 0.01 \t \n", + " epsilon_decay \t 500 \t \n", + " buffer_size \t 10000 \t \n", + " batch_size \t 64 \t \n", + " target_update \t 4 \t \n", + " hidden_dim \t 256 \t \n", + " device \t cuda \t \n", + "================================================================================\n", + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "开始更新策略!\n", + "回合:10/100,奖励:24.00,Epislon:0.663\n", + "回合:20/100,奖励:10.00,Epislon:0.508\n", + "回合:30/100,奖励:10.00,Epislon:0.395\n", + "回合:40/100,奖励:10.00,Epislon:0.308\n", + "回合:50/100,奖励:46.00,Epislon:0.222\n", + "回合:60/100,奖励:98.00,Epislon:0.061\n", + "回合:70/100,奖励:61.00,Epislon:0.023\n", + "回合:80/100,奖励:200.00,Epislon:0.011\n", + "回合:90/100,奖励:80.00,Epislon:0.010\n", + "回合:100/100,奖励:171.00,Epislon:0.010\n", + "完成训练!\n", + "开始测试!\n", + "回合:1/10,奖励:200.00\n", + "回合:2/10,奖励:200.00\n", + "回合:3/10,奖励:148.00\n", + "回合:4/10,奖励:200.00\n", + "回合:5/10,奖励:146.00\n", + "回合:6/10,奖励:200.00\n", + "回合:7/10,奖励:200.00\n", + "回合:8/10,奖励:200.00\n", + "回合:9/10,奖励:200.00\n", + "回合:10/10,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "print_cfgs(cfg)\n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/DuelingDQN.ipynb b/notebooks/DuelingDQN.ipynb new file mode 100644 index 0000000..976a680 --- /dev/null +++ b/notebooks/DuelingDQN.ipynb @@ -0,0 +1,482 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法\n", + "\n", + "DQN等算法中使用的是一个简单的三层神经网络:一个输入层,一个隐藏层和一个输出层。如下左图:\n", + "\n", + "\"image-20211112022028670\"\n", + "\n", + "而在Dueling DQN中,我们在后面加了两个子网络结构,分别对应上面上到价格函数网络部分和优势函数网络部分。对应上面右图所示。最终Q网络的输出由价格函数网络的输出和优势函数网络的输出线性组合得到。\n", + "\n", + "我们可以直接使用上一节的价值函数的组合公式得到我们的动作价值,但是这个式子无法辨识最终输出里面$V(S, w, \\alpha)$和$A(S, A, w, \\beta)$各自的作用,为了可以体现这种可辨识性(identifiability),实际使用的组合公式如下:\n", + "\n", + "$$\n", + "Q(S, A, w, \\alpha, \\beta)=V(S, w, \\alpha)+\\left(A(S, A, w, \\beta)-\\frac{1}{\\mathcal{A}} \\sum_{a^{\\prime} \\in \\mathcal{A}} A\\left(S, a^{\\prime}, w, \\beta\\right)\\right)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、定义模型\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class DuelingNet(nn.Module):\n", + " def __init__(self, n_states, n_actions,hidden_dim=128):\n", + " super(DuelingNet, self).__init__()\n", + " \n", + " # hidden layer\n", + " self.hidden_layer = nn.Sequential(\n", + " nn.Linear(n_states, hidden_dim),\n", + " nn.ReLU()\n", + " )\n", + " \n", + " # advantage\n", + " self.advantage_layer = nn.Sequential(\n", + " nn.Linear(hidden_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, n_actions)\n", + " )\n", + " \n", + " # value\n", + " self.value_layer = nn.Sequential(\n", + " nn.Linear(hidden_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, 1)\n", + " )\n", + " \n", + " def forward(self, state):\n", + " x = self.hidden_layer(state)\n", + " advantage = self.advantage_layer(x)\n", + " value = self.value_layer(x)\n", + " return value + advantage - advantage.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "经验回放首先是具有一定容量的,只有存储一定的transition网络才会更新,否则就退回到了之前的逐步更新了。另外写经验回放的时候一般需要包涵两个功能或方法,一个是push,即将一个transition样本按顺序放到经验回放中,如果满了就把最开始放进去的样本挤掉,因此如果大家学过数据结构的话推荐用队列来写,虽然这里不是。另外一个是sample,很简单就是随机采样出一个或者若干个(具体多少就是batch_size了)样本供DQN网络更新。功能讲清楚了,大家可以按照自己的想法用代码来实现,参考如下。" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer(object):\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " ''' 存储transition到经验回放中\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量,则取经验回放的容量\n", + " batch_size = len(self.buffer)\n", + " if sequential: # 顺序采样\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else: # 随机采样\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " ''' 清空经验回放\n", + " '''\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " ''' 返回当前存储的量\n", + " '''\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、真定义算法\n", + "\n", + "跟DQN算法几乎一模一样" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "class DuelingDQN:\n", + " def __init__(self,model,memory,cfg):\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma # 折扣因子\n", + " # e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " # 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " # self.target_net.load_state_dict(self.policy_net.state_dict()) # or use this to copy parameters\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n", + " self.memory = memory # 经验回放\n", + " self.update_flag = False \n", + "\n", + " def sample_action(self, state):\n", + " ''' 采样动作\n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + " @torch.no_grad() # 不计算梯度,该装饰器效果等同于with torch.no_grad():\n", + " def predict_action(self, state):\n", + " ''' 预测动作\n", + " '''\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时,不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"开始更新策略!\")\n", + " self.update_flag = True\n", + " # 从经验回放中随机采样一个批量的转移(transition)\n", + " state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n", + " self.batch_size)\n", + " # 将数据转换为tensor\n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) \n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float) \n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n", + " done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1)\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 实际的Q值\n", + " # 计算目标Q值\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) # 最大的Q值\n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch) # 期望的Q值\n", + " # 计算损失\n", + " loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)\n", + " # 优化更新模型\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # clip防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + " if self.sample_count % self.target_update == 0: # 每隔一段时间,将策略网络的参数复制到目标网络\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " agent.memory.push((state, action, reward,next_state, done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},Epislon:{agent.epsilon:.3f}\")\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.test_eps},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + " # 更新n_states和n_actions到cfg参数中\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions) \n", + " model = DuelingNet(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n", + " memory = ReplayBuffer(cfg.memory_capacity) # 创建经验池\n", + " agent = DuelingDQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config:\n", + " def __init__(self):\n", + " self.algo_name = 'DuelingDQN' # 算法名称\n", + " self.env_name = 'CartPole-v1' # 环境名称\n", + " self.seed = 1 # 随机种子\n", + " self.train_eps = 100 # 训练回合数\n", + " self.test_eps = 10 # 测试回合数\n", + " self.max_steps = 200 # 每回合最大步数\n", + " self.gamma = 0.95 # 折扣因子\n", + " self.lr = 0.0001 # 学习率\n", + " self.epsilon_start = 0.95 # epsilon初始值\n", + " self.epsilon_end = 0.01 # epsilon最终值\n", + " self.epsilon_decay = 500 # epsilon衰减率\n", + " self.memory_capacity = 10000 # ReplayBuffer容量\n", + " self.batch_size = 64 # ReplayBuffer中批次大小\n", + " self.target_update = 800 # 目标网络更新频率\n", + " self.hidden_dim = 256 # 神经网络隐藏层维度\n", + " if torch.cuda.is_available(): # 是否使用GPUs\n", + " self.device = torch.device('cuda')\n", + " else:\n", + " self.device = torch.device('cpu')\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,title=\"learning curve\"):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{title}\")\n", + " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "开始更新策略!\n", + "回合:10/100,奖励:24.00,Epislon:0.663\n", + "回合:20/100,奖励:11.00,Epislon:0.507\n", + "回合:30/100,奖励:10.00,Epislon:0.385\n", + "回合:40/100,奖励:61.00,Epislon:0.187\n", + "回合:50/100,奖励:200.00,Epislon:0.055\n", + "回合:60/100,奖励:200.00,Epislon:0.011\n", + "回合:70/100,奖励:200.00,Epislon:0.010\n", + "回合:80/100,奖励:200.00,Epislon:0.010\n", + "回合:90/100,奖励:200.00,Epislon:0.010\n", + "回合:100/100,奖励:200.00,Epislon:0.010\n", + "完成训练!\n", + "开始测试!\n", + "回合:1/10,奖励:200.00\n", + "回合:2/10,奖励:200.00\n", + "回合:3/10,奖励:200.00\n", + "回合:4/10,奖励:200.00\n", + "回合:5/10,奖励:200.00\n", + "回合:6/10,奖励:200.00\n", + "回合:7/10,奖励:200.00\n", + "回合:8/10,奖励:200.00\n", + "回合:9/10,奖励:200.00\n", + "回合:10/10,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAHJCAYAAABqj1iuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABj/UlEQVR4nO3deXyM5/7/8ddkk4gkEkSoqp3aIiEhqEaqqpZSVE8R1doVtZXaOSlaIvYtRRVVqpYqrbR6WlrHFny72ZfSIBEaS5B9fn/4ZU6nCZI0ZOp+Px+PPB7JvV3XPZ/JzDv3dc0dk9lsNiMiIiJiEHYF3QERERGRh0nhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4ecR86DuWal7YYrIo0Svacam8PMI+eabbxg5cmS+H/fAgQP07t3b8nNMTAxVq1Zlw4YN+d6WFKzQ0FBCQ0MfSluJiYn07dsXX19fAgIC+O2337Jss2HDBqpWrWr1VatWLUJCQhg3bhyxsbEPpG9/fY5n9iMmJibf2/rr+VWvXp369evz+uuv8+2332a7j9lsZvPmzXTr1o0GDRrg5+dH69atmTt3LgkJCdm2ERwcTGJiYpZ1Of19nj59OoGBgdSpU4dNmzbl6VzvJzk5meXLl9OhQwfq1q1LYGAg//rXv9i0aVO+hZXY2Fh69+7N+fPnLctCQ0Oz1KFmzZoEBwczadIkrl27lqs23n77bUJCQvKlv7mRmJhISEiIXptzwKGgOyD5Z/ny5Q/kuOvWrePUqVOWn729vVm7di1ly5Z9IO2JMWzatIlvv/2W8ePHU7lyZcqUKXPXbefNm0eJEiUAuH37NidOnCAyMpLt27c/lOdicHAwa9euxdvb+4Ecv2PHjrz00ksApKamEh8fz/r16+nbty9jxoyhW7dulm1TUlIYPHgwO3bsoEOHDrz22ms4Ozvz888/s2LFCjZs2MCiRYuoWrWqVRsXL17k3Xff5Z133sl1/44fP86SJUvo1KkTbdu2pUKFCn/vhLNx+fJlevbsycWLFwkNDaV27dpkZGTw7bff8vbbbxMdHU1YWBgmk+lvtfPf//6XHTt2ZFlevXp1JkyYYPk5NTWVX3/9lYiICI4cOcLHH3/8t9t+kK5du0b//v2tQp3cncKP5JqTkxN16tQp6G7IP9zVq1cB6Ny5833fVJ588kmrcBQUFERISAjt27dnwoQJfPDBBw+yq3h5eeHl5fXAju/j45Pld6ply5YMHDiQadOmERISYjn/OXPmsGPHDhYvXkzjxo0t2wcFBfHiiy/StWtXBg0axGeffYazs7Nlvbu7O+vWreP555+nUaNGuepfZq1atWpFvXr18naS9zFy5EhiY2NZu3Yt5cqVsywPDg6mdOnSRERE0LRpU5555pkH0n6RIkWy1CAgIICbN28yZ84cfvzxR5t93fvmm2+YPHkyN2/eLOiu/GNo2OsRERoayr59+9i3bx9Vq1Zl7969wJ0XrfHjx9OwYUNq1apFp06d2L17t9W+u3btolOnTvj5+REQEEC/fv0sV3refvttNm7cyPnz5y2XxrMbEqhevTo//vgjL7/8MrVq1aJp06YsXbrUqp1Lly4xZMgQAgMDCQgIYPz48cycOfO+l4cvXbrEyJEjCQoKws/Pj65du3Lo0CHg7pfs/3rZOTQ0lOHDhzNo0CDq1KnDa6+9xnPPPcegQYOytNe2bVv69etn+Xn79u20b9+eWrVq0ahRI9555x1u3bp1zz6np6fz0Ucf0aZNG2rXrk1wcDDh4eEkJydb9bF79+6sX7+e5557jpo1a9K2bVt27tx5z2PDnasmL774Ir6+vgQHBzNjxgxSUlKyPfe7PU4XLlxgwIAB1K1bl0aNGmUbIJKSkpgxYwbNmzenZs2a+Pv789prr3HkyJF79i85OZn58+fTokULatWqRfPmzYmMjCQjIwO4U4+5c+cCUK1aNd5+++37nvNflSlThpdffpn//ve/nDt3LlfnnpPfiz/767BXTmt36NAhunTpQp06dQgODubDDz+ke/fuOT7fIUOGkJqayqeffgrcGdZYsWIFHTp0sAo+mUqUKMGYMWP47bff2LJli9W6l19+mfLlyzN27Nhsh7/uZu7cuZah0FdffdXy+Ob0Of7qq68yYcIE/P39admyJenp6VnaOHLkCD/88AM9evSwCj6ZunfvTpcuXShcuLBl2f79++nRowcBAQHUrFmTkJAQ5s6da3mOZdb9gw8+oEWLFvj6+rJ+/XpGjRoFwDPPPJOjOtSsWRO48/uS6YsvvqB9+/b4+fnRqFEjxo8ff9+hsXXr1tGqVSvLcNrcuXOzfSz+LCevUdevX2fAgAEEBASwZMmS+56P3KHw84iYMGEC1atXp3r16qxdu5YaNWqQnJzMq6++yjfffMOQIUOYN28ePj4+9OzZ0/JC//vvv9O/f39q1qzJwoULmTx5MmfOnKF3795kZGTQv39/nn76aUqUKMHatWsJDg7Otv2MjAwGDx5My5YtiYyMxN/fn2nTpvH9998Ddy7Vv/rqqxw8eJDRo0czdepUjh49yrJly+55Xjdv3uSVV15h7969vPXWW8ybN49ChQrx+uuvZztH5F6+/PJLXF1dWbhwIT179uSFF15gx44dVm8Ep06d4ujRo7Rt2xaAzz//nDfeeIMKFSowf/58BgwYwObNm+nfv/895yCMHz+eqVOn0qxZMxYuXEiXLl1YtWpVlv1++eUXli5dyqBBg5g/fz729vYMHDjwni+kH330ESNHjqRGjRrMmzeP3r17s3LlylwNZ9y6dYuuXbty/PhxwsLCGDduHOvWrbOEykwjRoxg/fr19O7dm2XLljFq1ChOnDjBsGHD7nr+ZrOZvn37smTJEl566SUWLVpEixYtmDVrlmVYYcKECXTs2BGAtWvX0r9//xz3/c8yr2AcOHAgx/vk5PciJ+5Xu1OnTtG9e3cAIiIiGDhwIJGRkbnqa4UKFShdurRln127dpGcnEyzZs3uuk/jxo0pWrQo27dvt1peqFAhpk6dSmxsLNOmTctxH1566SXGjx8P3Hlez5s3z/J9Tp7j0dHRXLx4kfnz5zNs2DDs7e2ztJH5OnG3P4QKFSrE+PHjCQoKAuDo0aN0796dokWLMnPmTBYuXEi9evWYN28eX375pdW+c+fOpVevXkybNo2GDRtaQsO8efNy9Lw7c+YMAI8//jgACxYsYOjQodSpU4c5c+bwxhtvEBUVRWhoKElJSdkeY/HixYwbN46goCAWLVpEly5deP/99xk3btw9287Ja5SzszNbt27lvffew9PT877nI3do2OsRUalSJYoUKQJguTT7ySefcPToUT755BN8fX0BaNKkCaGhoYSHh7N+/Xp++uknkpKS6NOnDyVLlgTuXIL/5ptvuHXrFmXLlsXLy8tqqCu7qx5ms5n+/ftb5i3UrVuXr7/+mu+++46nnnqKzZs3c/r0adavX2/5S6pBgwb3fBEHLFedNm7cyJNPPgmAv78/7dq1Y//+/ZYXw5xwdHRk0qRJODk5AVC2bFnmzp3L9u3badeuHQBbtmzB3d2dkJAQzGYz4eHhPPXUU4SHh1uOU65cObp3786OHTuyDYMnT57k008/ZdiwYZaJ4o0aNcLb25sRI0awc+dOnn76aQBu3LjBhg0bLHNWChcuTNeuXdmzZw/PPfdclmNnZGQwf/58mjVrZhV2bt++zdatW0lNTc3RY7Fx40YuXLjAli1bqFSpEgC+vr48++yzlm1SUlK4efMmY8eOpWXLlgAEBgaSmJjIu+++y+XLly3zcP5s586d/Pe//yUiIoJWrVpZzt/Z2ZnZs2fTrVs3KleujI+PD8DfGkrIbD8+Pj7H+3z22Wf3/b3IifvVbvHixbi5ubFkyRJcXFyAO2HmX//6V25OkeLFi3P58mXgf1cfHnvssbtub2dnx2OPPZbt3A8/Pz9effVVy9WQhg0b3rd9Hx8fy3OkUqVKVK9ePVfP8bS0NP79739b6p2dixcvAtxz3tefHT16lIYNGzJ9+nTs7Ows7f/nP/9h7969lucdwPPPP0+HDh0sP2fW669DqWazmbS0NMvP165dY9++fSxcuBA/Pz9q1qzJtWvXWLhwIZ06dbIEQoAqVarQpUsX1q9fT5cuXaz6euPGDRYsWMDLL7/M2LFjgf8F1LFjx/Laa69RuXLlbM/zhRdeuOdrFNyZhvAg5mA96nTl5xG2e/duSpQoQY0aNUhLSyMtLY309HSaNm3KL7/8wrVr1/D19aVQoUJ07NiRyZMn8/3331OtWjWGDBliCVM55efnZ/neyckJLy8vS1Das2cPjz/+uCX4wJ0x9qZNm97zmAcOHKBMmTKW4APg4uJCVFSUJWjlVIUKFSzBB+78Jefv788XX3xhWbZ161ZatGiBk5MTp0+fJjY2lpCQEMvjl5aWRkBAAEWKFGHXrl3ZtrNv3z4AqxfgzJ/t7e0tQ5JwZy7JnyfrZr5B3L59O9tjnzlzhitXrliFFIAePXqwYcMGHB0dc/JQEB0dTdmyZS1vagClSpWyCiJOTk4sXbqUli1bEhcXx549e1izZo3lE0iZw2x/tW/fPhwcHGjRooXV8hdeeMGyPr9kXmHIzUTUnPxe5MT9ardnzx6aNGliCT5w53fkXsElO2azOdcTbe3s7CzDP381ePBgypUrl+vhrz/LzXO8aNGi9ww+gOVq0P2GgTK1a9eO999/n9TUVI4ePUpUVBRz5swhPT09yx8Af37tuJf9+/dTo0YNy1fDhg0ZOnQoNWvWZMaMGZhMJv7v//6PlJQUWrdubbVvvXr1eOyxx7J9bh86dIikpKQsryOZ4WXXrl2W4PXnL7PZfN/XKMk7Xfl5hF29epX4+Hhq1KiR7fr4+HgqVarEqlWriIyM5NNPP2XFihW4u7vTuXNnBg8enKsX3T9ProQ7L8CZb04JCQkUK1Ysyz7ZLfvrOdxvm5xydXXNsqxt27aEhYWRkJBATEwMZ8+eZcqUKZa2ASZNmsSkSZOy7Hvp0qVs28l88/zrVREHBwc8PT25ceOGZdmf3xjhf2/id3vjyuzT331Mrl27lu0l8hIlSliuMsCd4YgpU6Zw+vRpXF1dqVatmmXexd2GvTKP/dfhjczH48/n/3dlftT9fm+uf5aT34u/Ppezc7/a/fHHH9nWqXjx4jnuK9w5xypVqgBQunRp4M58looVK2a7vdlsJiYmhlq1amW73tnZmSlTptC1a1emTZtmdRuLnMrNczy737u/ygyEFy5csArkfxYXF4e3tzcmk4mkpCTCwsL47LPPSEtLo0yZMvj5+eHg4JDlefnneUL3UqNGDcvvuclkolChQpQqVcrqj8DM886uhsWLF8/2uZ35O3u3x/nSpUvs27fP6hN9ACtWrKB+/fr3fI2SvFP4eYS5ublRrlw5qyGbP8u85Fu7dm3mzZtHSkoKBw4cYO3atSxatIhq1arx/PPP50tfSpYsme0cnStXrtxzPzc3t2zvrXLw4EE8PDwsb1J//YvxfhOSMz3//PO88847bN++ndOnT/PYY49Rt25d4M6nY+DOvJfAwMAs+3p4eGR7zMzl8fHxVn/lp6amkpCQ8LfG5TP79Mcff1gtT0hI4PDhw/j5+WEyme77eHh6enL27Nksx898oQY4d+4cb7zxBs2aNWPx4sU8/vjjmEwmPvroI8scjex4eHiQkJBAenq6VQDKDIv5OS/hv//9LyaTyfIJpJyce05+L/4cAPPKx8cn2+NcuXIlx8MUJ0+eJD4+3jKUkjl8+NVXX1mGleBOrYoWLYq7uzv79+8nISGBJk2a3PW4devWJTQ0lBUrVtw1JN1Lfj/HMydv79ixI9vwk5aWRtu2bfH392fBggVMnjyZqKgoZs2aRcOGDS0BJzfD4H/l6up638ci87wvX76cpYbx8fGWeUF/lvk7Gx4enu1k7uLFi+Pm5maZ1J6pfPnywL1foyTvNOz1CMkc+84UGBjIxYsXKVasGLVq1bJ87dq1iyVLlmBvb8/y5ctp2rQpKSkpODk5ERQURFhYGPC/+QV/PW5eBAYGEhMTY/UpoaSkpHu+icKdy8m///47J06csCxLTk5m4MCBfPrpp5a/yuLi4izrU1NT+emnn3LUL3d3d5o2bco333xDVFQUL7zwguUv+AoVKlCsWDHLX9GZXyVLlmTGjBkcPnz4rucKdy5P/9nWrVtJT0//Wy9cFSpUwNPTM8vN7z777DN69+5Namoqrq6uJCQkWH3q5q+TbBs0aEBMTAw///yzZdkff/zB//3f/1l+/uWXX0hOTqZ3796ULVvW8rhk1uxuV34CAwNJS0tj27ZtVss3b94MkG8v3LGxsaxbt47g4GBKlSoFkKNzz8nvRX4ICAjg+++/t+rL4cOHc3WjxDlz5uDs7MyLL74I3Bkq7t69Oxs3brT6ZNnSpUt56qmnWLRoERMnTsTHx8cyofxuhg4dStmyZXnvvfdyeWb5/xyvXLkyTZo04f333+f333/Psn7x4sUkJCRYhk4PHDhA/fr1adasmSX4/PLLL/zxxx93vWqa6e+8nvn6+uLk5JTlk3TR0dFcuHABf3//bPdxdHQkLi7O6vnm4OBAREQEMTExFClSxGpdrVq1LK9t93qNkrzTlZ9HiLu7O4cOHWL37t1Ur16d9u3bs2rVKl577TX69u1LqVKl+O9//8v7779P165dcXR0pEGDBoSHh/PGG2/QtWtX7O3tWbNmDU5OTpb5OO7u7ly+fJkdO3bkePz8r1q3bk1kZCRvvPEGb775Ju7u7nzwwQdcuXLFcik/O+3bt2flypX069ePQYMG4enpyYoVK0hNTaVz5854eHjg5+fHypUreeKJJ/Dw8GDFihUkJSXl+HL3Cy+8wKBBg0hPT7d8ggLuzEMYMmQI48ePx97enqZNm3L9+nUWLFhAXFzcXYdNKlWqxIsvvsicOXO4ffs2AQEBHDlyhHnz5lG/fn2eeuqp3D14f5L5iaJ///vfFCtWjJCQEM6cOcOcOXPo0qULHh4eNG3alJUrVzJmzBg6duzI8ePH+eCDD6ze1Nu2bcuKFSsYMGCAZX7XwoULrd44atSogYODA9OnT+f1118nJSWFDRs28N133wF3v7rWpEkT6tevz9ixY4mLi6NatWrs27eP999/nxdffPGuwxr3cuTIEctVlNu3b3Ps2DGWL1+Os7Oz1cTTnJx7Tn4v8kPfvn354osv6NmzJ6+//jrXr19n9uzZ2NnZZXnzio2NtQTPtLQ04uLi2LhxIz/88EOWycIDBgzgt99+o1+/fnTs2JGQkBBatmzJuXPnmDlzJgDvvfdelmG5v/rz8FduPYjn+KRJk3j11Vfp1KkT3bp1w9fXl5s3b7Jt2za2bt3Kv/71L8s8stq1a/Pll1/y8ccfU7FiRY4ePcrChQsxmUx3nS+XKfNKzNdff02TJk3uOnyYnaJFi9K7d2/mz5+Po6MjTZs2JSYmhtmzZ1sek7/y9PSkZ8+ezJ49m8TEROrXr09cXByzZ8/GZDJRrVq1+7Z7t9coyTuFn0dIly5d+OWXX+jVqxdTp06lTZs2fPTRR8yYMYPp06dz48YNHnvsMYYNG8brr78O3LnHyqJFi5g/fz5Dhw4lPT2dmjVrsmzZMstl3fbt27Njxw7eeOMNBg0aZPnkT244ODiwdOlSJk+ezMSJE3FwcOCFF16gaNGilo+SZqdIkSKsWrWKadOmERYWRkZGBnXq1GHFihWWS8zvvvsuYWFhjB07liJFitCxY0fq1q3LunXrctS3p59+Gjc3Nx5//HHLpeZML730Eq6urixZsoS1a9dSuHBh/P39CQ8Pz/YSd6bJkyfzxBNPsH79et5//328vb3p1q0b/fv3/9tX0jLvd7J06VLWrl2Lj48PvXr1olevXsCdoZGRI0eycuVKoqKiLB+J//OnjJycnPjwww+ZMmUKkydPxmQy0alTJx5//HHLUOQTTzzBjBkzmDdvHv369cPDw4M6deqwcuVKQkNDiY6OznIXYbgz9LR48WLmzJnD8uXL+eOPPyhTpgxDhw7ltddey9M5DxgwwPK9o6Mjjz32GM8++yy9e/e2mneSk3MvXLjwfX8v8sMTTzzB0qVLmTZtGoMGDaJYsWL06dOHhQsXZpkH8+mnn1qGPezs7ChatCi+vr588MEHWYZyHB0dmT17Nlu2bOGTTz5hxIgRJCcnU6pUKXr06MH169cZM2YMe/fuJSwsDAeHu7/M16tXj65du7Jy5cpcn19+P8dLly7N2rVr+fDDD9myZQuRkZGWTzLNmDHD6nXn7bffJjU1lVmzZpGSkkKZMmXo168fJ0+e5D//+c89J07Xr1+fhg0bMmPGDHbv3k1kZGSu+jlw4ECKFy/OqlWrWLt2LUWLFqVFixYMHjz4rn9wDR48mBIlSrB69WqWLFmCh4cHQUFBDB06FDc3t/u2ea/XKMkbk1n/3U0eghMnTnD69GmaN29u9Vdvx44d8fHxsdw7RORRsXv3bhwdHa3uiHz9+nUaNmzIiBEjskxwzU8//vgj33//vVVoFJH/0ZUfeShu3brFm2++SefOnXn22WdJT0/niy++4JdffmH48OEF3T2RfPfrr78yZ84chg4dSo0aNbh69SoffPABbm5uWT4qnd98fX0t9zASkax05Ucemm3btrF06VJOnTqF2WymevXq9OvXL9vb9Iv802VkZLBo0SI+++wzLl68SOHChQkMDGTYsGE88cQTBd09EUNT+BERERFD0UfdRURExFAUfkRERMRQFH5ERETEUBR+RERExFAM+VF3s9lMRobmedsKOzuT6mEjVAvboVrYDtXCNtjZmfLtX3sYMvyYTCauX79FWtq9/weMPHgODnZ4erqqHjZAtbAdqoXtUC1sh5eXK/b2+RN+NOwlIiIihqLwIyIiIoai8CMiIiKGovAjIiIihmLICc8iIvLPlZGRQXp62kNqy0RSkj0pKcmkp+sTXw+Svb0DdnYP55qMwo+IiPwjmM1mrl//g9u3Ex9qu5cv25GRoU96PQwuLkVwd/fKt4+0343Cj4iI/CNkBp8iRTxxcir0wN8gM9nbm3TV5wEzm82kpCSTmJgAgIdHsQfansKPiIjYvIyMdEvwKVLE/aG27eBgp3v8PAROToUASExMwM3N84EOgWnCs4iI2Lz09HTgf2+Q8mjKrO+DntOl8CMiIv8YD2uoSwrGw6pvrsPP1atXGT9+PE2aNMHf359XXnmF6OjoLNudPXuWOnXqEBMTY7U8OTmZSZMmERQUhJ+fH8OGDeOPP/64Z5sxMTH06dMHf39/GjduzKxZsyx/BYiIiIjkRq7Dz9ChQzl06BARERGsX7+eJ598kh49enD69GnLNqdOneL111/n9u3bWfafOHEiP/zwA3PnzuXDDz/k9OnTDBo06K7tpaam0qNHDwDWrFnDxIkT+fjjj5k/f35uuy4iIiKSu/Bz9uxZdu3axcSJE6lXrx7ly5dn3LhxeHt78/nnnwOwePFiOnbsiIeHR5b94+Li2LRpE2PHjqVevXrUrl2biIgI9u/fz6FDh7JtMyoqigsXLjBt2jSqVKlCs2bNGDp0KB9++CEpKSl5OGURERHJiQEDejN58sSC7ka+y9WnvTw9PYmMjKRWrVqWZSaT6f//l/TrAGzfvp2pU6fi6elJt27drPY/cOAAAA0aNLAsK1++PCVLlmT//v34+fllaTM6OpoaNWpYhakGDRqQmJjIkSNH8PX1zc0pWNjba7qTLcisg+pR8FQL26FaZJWRUTBzfTKnoJhMYNan3R8ae3sTDg7Wz//8nA6Uq/Dj7u7O008/bbUsKiqKs2fPMnr0aADWrVsHwN69e7PsHxcXh6enJ4UKWc/W9/b2JjY2Nts2Y2Nj8fHxybI9wMWLF/McftzdXfK0nzwYqoftUC1sh2rxP0lJ9ly+bJftm+LDYNQgmnmB42E95hkZJuzs7PDwKIyzs/MDa+dv3efn4MGDjBo1iubNmxMcHHzf7W/fvo2Tk1OW5YUKFSI5OTnbfZKSknB3d8+yPXDXfXLi+vXbpKfrvg0Fzd7eDnd3F9XDBqgWtkO1yColJfn//1sLs9U9d8xmMympD+4xMpnu1CM9PSPLlR8nR7s8fTqpceN6vPZaL7744nPS0lKZN+99fHxK8f77C/nqqy+5eTOR8uUr0rNnXwIDG3Dq1EleffVfLF26iqpVqwEwatRwDh7czxdf/Ad7e3syMjJ44YXmDBw4lOeea8nnn2/i00/X8Pvvv2NnZ6JKlWoMGjSUatWqA9CxYxuCg59hz55dJCT8wTvvTKNGjVosWjSXr77aRmpqCm3bdiAjIwOz+X+P+erVK9m06VPi4y9RvHgJWrV6gVdf7ZFvn9JKTzeTkZHBtWu3uH3b+oNNHh4u+XbvnzyHn+3btzN8+HD8/f0JDw/P0T7Ozs7ZztNJTk7GxSX7v3Cy2ycz9BQuXDiXvf6f9PQM3bTKhqgetkO1sB2qxf9kd4dls9nM1FUHOXn+WgH0CCqV8WBUF/88vfFv3LiO8PA5pKWl8/jjZZk4cQxnz55h/PgwSpTwZteunYwYMZgpU8Jp2LAxpUqVZv/+PVStWo309HQOHYrm1q1bHD9+lCefrMHhw79y48YNgoIas2PHt8ycOY2RI8fi6+vH5cuXmTVrOu+++w7Ll6+29GHDhk94772ZuLm5UaFCJWbNms6uXd8zZswESpYsxYoVy/jxx0OULv0YAD/8sJOVKz/g3/+ewuOPl+PXX3/inXcmUKpUaZ57rmW+Pa5AlpAL+TvsmKfws2rVKiZPnkyLFi147733sr2akx0fHx+uXr1KSkqK1T6XLl2iZMmSd93n+PHjVssuXboEcNd9RETEIP6ht/157rmWlqswMTG/s317FB988BGVK1cF4F//6srJkydYvXoFDRs2plGjp9i/fy9du3bnyJFfcXBwpGbNWhw8GM2TT9Zg9+4f8PX1w93dHQ8PD95+exzNmz8PgI9PKVq3foGIiGlWfWjQoBEBAfUBuHXrJl9+uYVhw0YSFNQYgFGjxnPw4P9uZXPhQgxOTo74+JTGx8cHHx8fihf3pmRJ66kp/wS5Dj+rV68mLCyM0NBQxowZk6vEW7duXTIyMjhw4ABBQUEAnDlzhri4OAICArLdJyAggE2bNpGYmEiRIkUA2LNnD66urlSrVi233RcRkUeEyWRiVBf/BzrsBXf/9xZ5HfYCKFOmrOX748ePAdC/f0+rbdLS0ihSxA2ARo2eYvPmjSQnJ7F//17q1q2Hj09pDhyIpkuXV9m9+wdatGgNQJ06/vz22xmWL1/C2bO/ERNzjlOnTmb556xlyjxu+f7cubOkpqZSrVoNy7JChQpRpUpVy8/Nm7dk69bNvPJKe8qVq0BAQH2Cg5/JMi/3nyBX4efMmTNMmTKFZ599lj59+nD58mXLOmdnZ9zc3O65f8mSJWnVqhVjx45lypQpuLi4MGHCBAIDA6lTpw4AKSkpXLt2DQ8PD5ycnGjWrBmzZs1i8ODBDB8+nJiYGCIiInj99ddzfMVJREQeTSaTiUJO9g+0DQcHO+zt8vcS058/+GM23wkl8+e/T+HCrlbbZc5x8fOrh6OjI4cOHSQ6eh/PPdeSUqVKsWHDJ8TGXuTEieNMnnznA0lffbWNyZMn0Lz589SsWZu2bdtz+vQpIiLeu2sfMi+hZfYlk4PD/2JC0aJF+eCD1fzyy0/s37+XvXt3s27dx/To0YfXXuv19x6QhyxXM4eioqJITU3l66+/pnHjxlZfkydPztExwsLCCAoKYsCAAfTo0YMKFSowZ84cy/pDhw7RuHFjy31/ChUqxJIlS8jIyKBTp05MmjSJzp07079//9x0XURExCaVL18RgCtXLlOmzOOWr61bN/PFF3fuoefg4EBgYBA//LCDw4d/oW7dAGrXrkN6ejpLly6mQoVKlCpVGoCPPlpOmzbtGDNmIh06dKJOHX/On7/z3xbMd5k4U7bsEzg5FeKnn360LEtLS+PEif9NO/nqqy/ZuPFTateuQ48efYiMvNPON9989UAelwcpV1d++vbtS9++fXO0bf369Tl27FiW5YULF+add97hnXfeyfF+TzzxBMuWLctNV0VERP4RKlSoSMOGTzF9+lSGDh1J+fIV+O67b1i1ajmjR0+wbNe4cRPee+8dihcvwWOPlQGgZs3aREV9Qbdur1u28/Yuyc8//8ixY0cpUqQIP/ywgw0bPgHujK789XYzcOe9uWPHTixbtpjixYtTrlwFPv54JZcvx1u2SUlJZv782bi6uuLr68elS5c4dOggdepkvUefrftbH3UXERGRv+/f/55KZOR8pk+fwo0b1yldugxvvz2O559vbdkmKKgR6enp+PvXsyyrVy+Qgwejadz4f/fgGzJkBNOmTWbAgN44OTlSqVIVxo6dxIQJozl69DC+vtmHlT59BuDkVIiIiPe4desWISHP0qhRE8v61q3bce3aNZYvX8KlS3G4ubkRHPwM/frd/V9U2SqT+W7XwB5xCQk39RFSG+DgYIenp6vqYQNUC9uhWmSVmprClSsXKVasFI6OD3e+590mPEv+u1edvbxc8+1mk8a8ZaWIiIgYlsKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIgaWlpbF27UeWn5cuXUzHjm3yvZ0Hddy8UPgRERExsK+/3sbcuTMLuhsPlcKPiIiIgRnx/5s7FHQHRERE8spsNkNaygNuww5zdv/V3cEJk8mU6+Pt3r2LJUsW8dtvp3FxKUxQUCMGDhzKyZPHGTLkDf7973dZtGgucXFx1KxZizFjJvLxxyvZtm0rDg6OvPTSv3j11R6W43355RbWrPmI338/h5eXF61btyU09DXs7e0BiIuLZfHi+URH7+PWrZvUrl2H/v3fpFKlynzxxedMmTIJgMaN6zFnziLLcVetWs769Z9w7do1atSoyYgRY3j88bIAJCYmMn/+bL7//ltSU1OpWvVJ+vcfRLVq1S37f/bZBlavXkF8fDwBAYGUKlU614/Vg6LwIyIi/0hms5lbmyeTEXeyQNq3L1kZlxdG5yoAXb16lTFj3mLAgCE0bNiYS5fiCAubwIIFs2ne/HnS09NZsWIZEya8Q1paGm+9NZju3TvTunVbIiM/5KuvvuT99xfSuPHTVKxYiU8+Wc2iRfMYMGAIAQH1OXz4FyIi3uPatWu8+eYwbt26Sb9+PShd+jHefXcGjo5OLFsWyYABvVi+/GOeeeZZEhMTmTNnBp99tg13dw8OHTpAbOxFfv75R6ZPn01qagphYeN5990w5s9/H7PZzFtvDcLJyZn33ptFkSJF2LZtK/369WDx4g+oUqUaX3+9jYiI93jzzeHUqxfIzp3fEhm5AG/vkg+wIjmnYS8REfnHMpH7Ky8FKT4+jpSUFEqW9MHHpxS1a9fhvfci6NDhZcs2PXv2pVq16tSsWZu6dQNwcXGhf/9BlC37BKGh3QE4ffokZrOZVas+pH37TrRv/xKPP16W555rSY8efdm4cR2JiYlERX3JtWtXCQt7j+rVa1K5chUmTnyHQoWc2bDhEwoVcqZIkSIAFCtWHEdHRwAcHBwYPz6MSpUq8+STNWjbtj1Hjx4G4MCB/fzyy8+EhU2lRo2aPPFEOfr0eYMaNWqxbt0aAD79dC3NmjWnffuXKFv2Cbp27U6jRk89xEf63nTlR0RE/pFMJhMuL4x+4MNeDg52pOXTsFflylVp1uw5Ro4cQrFixQkIqE/Dhk/RpEkwP/30fwCUKfO4ZXsXFxdKlSptaadQIWcAUlNTuXo1gT/+uELt2nWs2vDz8yctLY2zZ3/j1KmTPP74E3h6elrWFyrkTPXqNTh16tRd++nlVQxX1yKWn93c3ElOTgbg+PGjmM1mOnRobbVPSkqKZZvTp0/SrNlzVutr1qzNiRPHc/IwPXAKPyIi8o9lMpnAsdCDbcPBDpMpm/CTRxMnTub113uxZ89/2b9/L2Fh46hdu45lHo+Dg/Vb890C1t0mKmdkmP90nLttk4GDg/1d+2hnd/eBoYyMDFxdXVm6dFWWdZlXjsCE2Wz9mP31vAqShr1EREQekl9//YU5c2ZQtmw5OnXqzPTpsxk1ajwHDuwnISEhV8fy8iqGl1cxyxWjTD/+eAhHR0cee6wMFStW5vffz5KQ8IdlfXJyMkePHqFcuQrA3cPV3VSoUImbN2+SmppKmTKPW74++uhDfvhhBwCVK1fhp59+tNrv6NEjuWrnQVL4EREReUhcXV3ZsGEdCxbMISbmd06fPsk333xFmTJlKVq0aK6P98oroWzY8AkbN35KTMzvfPXVNpYti+SFF16kSJEiPPtsCzw8ijJu3NscOfIrJ0+e4N//Hsvt27dp27Y9cGdoDe6Ek+TkpPu2Wb9+EJUrV2HChFEcPBhNTMzvzJ0bwRdffG4JVF27dmfnzm9ZvXoFv/9+jk8/XcN3332T6/N7UGznGpSIiMgjrly58kyePJ0PPnifjRvXYWdnh79/ADNmzCEuLjbXx3vlla44OTmydu1qZs8Ox9u7JF26vErnzqEAFClShLlzFzNv3izefLM/ALVr+7Jw4VJKl34MAH//AKpXr0m/fq8zblzYfdu0t7dn5swFLFgwm/Hj3+b27duUK1eByZOnU7duAAANGzZmwoR3WLYskiVLFlGjRi3+9a+ufP31tlyf44NgMhvx7kZAQsLN7CewyUPl4GCHp6er6mEDVAvboVpklZqawpUrFylWrBSOjk4Pte27TniWfHevOnt5uWJvnz8DVhr2EhEREUNR+BERERFDUfgRERERQ1H4EREREUNR+BERkX8Mg35GxzAeVn0VfkRExOZl/ofylJTkAu6JPEiZ9bW3f7B34snV0a9evUpERATfffcdiYmJVK1alWHDhlGvXj0Adu/ezfTp0zl16hSlSpVi4MCBtGrVCoANGzYwatSobI9bv359VqxYke26zZs389Zbb2VZ/s0331CmTJncdF9ERP6h7OzscXEpQmLinbsgOzkVyvWdifMqI8NEerquOD1IZrOZlJRkEhMTcHEpcs9/r5EfchV+hg4dSnx8PBERERQrVoyVK1fSo0cPNm7ciNlspk+fPrz22mtMnz6d7777jhEjRuDl5UVQUBAtW7bkqaes/6Prtm3bmDp1Kn379r1rm8eOHSMwMJCIiAir5V5eXrnpuoiI/MO5u9953c8MQA+LnZ0dGRm6z8/D4OJSxFLnBynH4efs2bPs2rWL1atXU7duXQDGjRvH999/z+eff86VK1eoWrUqQ4YMAaBixYocPnyYJUuWEBQUhLOzM87OzpbjxcbGMnv2bPr370/Dhg3v2u7x48epWrUqJUqUyOs5iojII8BkMuHhUQw3N0/S09MeSpv29iY8PApz7dotXf15wOztHR74FZ9MOQ4/np6eREZGUqtWLcsyk8mEyWTi+vXrREdH06xZM6t9GjRowOTJkzGbzVkuT06fPh1vb2969+59z3aPHTtGSEhITruZY/l1l0j5ezLroHoUPNXCdqgW92PHw/rvTPb2djg7O5OSYiY9XVd/ClJ+jnLm+Nnj7u7O008/bbUsKiqKs2fPMnr0aDZu3IiPj4/Vem9vb27fvk1CQoLVMNWxY8fYsmUL8+fPx8np7rcpv3btGnFxcURHR7N69WoSEhKoXbs2b731FuXLl89p1+9yPi5/a3/JX6qH7VAtbIdqYTtUi0dLnqPzwYMHGTVqFM2bNyc4OJikpKQsQSbz55SUFKvly5cvp2rVqjzzzDP3bOPEiRPAnYlQU6dOJSkpiYULF9K5c2c+//xzihcvntfuc/36baV4G2Bvb4e7u4vqYQNUC9uhWtgO1cJ2eHi45NuwWJ7Cz/bt2xk+fDj+/v6Eh4cDUKhQoSwhJ/NnF5f/JeakpCS2bdvGW2+9dd+Z+vXq1WP37t14enpatp03bx7BwcFs2LDhvkNm95KenqF/VGdDVA/boVrYDtXCdqgWBS8/bwGU6wi1atUqBg4cSNOmTVm0aBGFChUCoFSpUly6dMlq20uXLlG4cGHc3Nwsy3bt2kVqairPP/98jtrz8vKyCkkuLi6UKVOGuLi43HZdREREJHfhZ/Xq1YSFhdGlSxciIiKshrnq1avHvn37rLbfs2cP/v7+VpepoqOjqVatGp6envdtb+3atdSvX59bt25ZliUmJvLbb79RqVKl3HRdREREBMhF+Dlz5gxTpkzh2WefpU+fPly+fJn4+Hji4+O5ceMGoaGh/PTTT4SHh3Pq1CmWLVvGtm3b6Nmzp9VxDh8+TLVq1bJtIz09nfj4eJKSkgBo0qQJGRkZjBgxghMnTvDzzz8zcOBAvLy8aN++/d84bRERETGqHIefqKgoUlNT+frrr2ncuLHV1+TJk6lcuTILFixgx44dtGvXjnXr1jF9+nSCgoKsjhMfH0/RokWzbePixYs0btyYL774ArgzlLZ8+XJu3brFK6+8Qvfu3XFzc2PFihWW4TYRERGR3DCZDfpf4hISbmrymg1wcLDD09NV9bABqoXtUC1sh2phO7y8XPPt3le6g5aIiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBhKrsPP1atXGT9+PE2aNMHf359XXnmF6Ohoy/rdu3fTvn17fH19adGiBVu3brXa/8CBA1StWjXL1969e+/aZkxMDH369MHf35/GjRsza9Ys0tPTc9t1ERERERxyu8PQoUOJj48nIiKCYsWKsXLlSnr06MHGjRsxm8306dOH1157jenTp/Pdd98xYsQIvLy8CAoKAuDYsWOULVuW1atXWx3Xw8Mj2/ZSU1Pp0aMH5cqVY82aNZw7d44xY8ZgZ2fHoEGD8nDKIiIiYmS5Cj9nz55l165drF69mrp16wIwbtw4vv/+ez7//HOuXLlC1apVGTJkCAAVK1bk8OHDLFmyxBJ+jh8/TqVKlShRokSO2oyKiuLChQt88skneHh4UKVKFa5cucK0adPo27cvTk5OuTkFERERMbhchR9PT08iIyOpVauWZZnJZMJkMnH9+nWio6Np1qyZ1T4NGjRg8uTJmM1mTCYTx44dswSnnIiOjqZGjRpWV4YaNGhAYmIiR44cwdfXNzenYGFvr+lOtiCzDqpHwVMtbIdqYTtUC9thMuXfsXIVftzd3Xn66aetlkVFRXH27FlGjx7Nxo0b8fHxsVrv7e3N7du3SUhIwMvLixMnTuDp6Un79u2Ji4ujSpUqDBkyhNq1a2fbZmxsbLbHBLh48WKew4+7u0ue9pMHQ/WwHaqF7VAtbIdq8WjJ9ZyfPzt48CCjRo2iefPmBAcHk5SUlGUYKvPnlJQULl68yI0bN7h16xZjx47F3t6eVatW0bVrVzZs2EClSpWytJGUlIS7u7vVskKFCgGQnJyc575fv36b9PSMPO8v+cPe3g53dxfVwwaoFrZDtbAdqoXt8PBwwc4uf67A5Tn8bN++neHDh+Pv7094eDhwJ5SkpKRYbZf5s4uLCx4eHuzfvx8XFxccHR0BqFWrFocPH2blypVMmjQpSzvOzs5ZjpkZegoXLpzX7pOenkFamp7ItkL1sB2qhe1QLWyHalHwzOb8O1aeItSqVasYOHAgTZs2ZdGiRZYrMaVKleLSpUtW2166dInChQvj5uYG3Bk6yww+AHZ2dlSsWJG4uLhs2/Lx8cn2mAAlS5bMS/dFRETEwHIdflavXk1YWBhdunQhIiLCapirXr167Nu3z2r7PXv24O/vj52dHTt37sTPz4/ff//dsj4tLY2jR49mO+QFEBAQwOHDh0lMTLQ6pqurK9WqVctt90VERMTgchV+zpw5w5QpU3j22Wfp06cPly9fJj4+nvj4eG7cuEFoaCg//fQT4eHhnDp1imXLlrFt2zZ69uwJgL+/P56enowcOZJffvmFY8eOMXLkSK5evUr37t2BO8Nk8fHxlqGuZs2aUaJECQYPHszRo0fZvn07ERERvP766/qYu4iIiOSayWzO+SjaokWLmDlzZrbrXnzxRd5991127tzJ9OnT+e233yhTpgwDBw6kZcuWlu3OnTtHeHg4e/fuJTk5mbp16zJy5EiqVKkCwN69e+nWrRsrVqygfv36wJ37C02aNIno6Gg8PDzo2LEjAwcO/FsTnxISbmr81gY4ONjh6emqetgA1cJ2qBa2Q7WwHV5ervl2y4FchZ9HiZ7ItkEvLLZDtbAdqoXtUC1sR36GH921SURERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDCXX4efq1auMHz+eJk2a4O/vzyuvvEJ0dLRl/e7du2nfvj2+vr60aNGCrVu3Wu1/8eJFhg4dSqNGjQgICKBHjx6cOHHinm2OHTuWqlWrWn2FhITktusiIiIiOOR2h6FDhxIfH09ERATFihVj5cqV9OjRg40bN2I2m+nTpw+vvfYa06dP57vvvmPEiBF4eXkRFBRESkoKvXv3pmjRoixatAhnZ2fmzp3Lq6++ypYtW/Dy8sq2zWPHjtG3b1+6du1qWWZvb5/3sxYRERHDylX4OXv2LLt27WL16tXUrVsXgHHjxvH999/z+eefc+XKFapWrcqQIUMAqFixIocPH2bJkiUEBQURHR3N8ePH2blzJyVLlgRg+vTp1K9fn//85z907NgxS5tms5mTJ0/Su3dvSpQo8XfPV0RERAwuV+HH09OTyMhIatWqZVlmMpkwmUxcv36d6OhomjVrZrVPgwYNmDx5MmazmcqVKxMZGWkJPgB2dndG3q5fv55tm+fOnePWrVtUqFAhN129L3t7TXeyBZl1UD0KnmphO1QL26Fa2A6TKf+Olavw4+7uztNPP221LCoqirNnzzJ69Gg2btyIj4+P1Xpvb29u375NQkICJUqUyLL/ypUrSUpKolGjRtm2efz4cct2O3fuxM7OjiZNmjBkyBDc3Nxy0/2/nItLnveV/Kd62A7VwnaoFrZDtXi05HrOz58dPHiQUaNG0bx5c4KDg0lKSsLJyclqm8yfU1JSsuz/9ddfM2PGDLp3707VqlWzbeP48ePY2dnh7e3NokWLOHfuHNOmTePEiRN8+OGHlitHuXX9+m3S0zPytK/kH3t7O9zdXVQPG6Ba2A7VwnaoFrbDw8Mlz+/5f5Xn8LN9+3aGDx+Ov78/4eHhABQqVChLyMn82cXFOjV//PHHhIWF8cILLzBixIi7ttOvXz86d+6Mp6cnAFWqVKFEiRJ06tSJn3/+GV9f3zz1Pz09g7Q0PZFthephO1QL26Fa2A7VouCZzfl3rDxFqFWrVjFw4ECaNm3KokWLKFSoEAClSpXi0qVLVtteunSJwoULWw1RTZ8+nYkTJ9KtWzemTp16zyRnZ2dnCT6ZKleuDEBsbGxeui8iIiIGluvws3r1asLCwujSpQsRERFWw1z16tVj3759Vtvv2bMHf39/S8CZPn06S5YsYeTIkbz99tuY7jODacSIEXTv3t1q2c8//wxApUqVctt9ERERMbhchZ8zZ84wZcoUnn32Wfr06cPly5eJj48nPj6eGzduEBoayk8//UR4eDinTp1i2bJlbNu2jZ49ewKwd+9elixZQmhoKG3atLHsGx8fz82bNwFISkoiPj6e9PR0AJ577jl2797NvHnzOHfuHDt27GD06NG0bt2aihUr5vPDISIiIo86k9mc81G0RYsWMXPmzGzXvfjii7z77rvs3LmT6dOn89tvv1GmTBkGDhxIy5YtgTv3BPrkk0+y3X/AgAEMHDiQDRs2MGrUKL755hvKlCkDwJdffklkZCSnT5/Gzc2NNm3aMHjwYMtwW14kJNzU+K0NcHCww9PTVfWwAaqF7VAtbIdqYTu8vFzz7ZYDuQo/jxI9kW2DXlhsh2phO1QL26Fa2I78DD+6a5OIiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBhKrsPP1atXGT9+PE2aNMHf359XXnmF6Ohoy/rdu3fTvn17fH19adGiBVu3brXaPzk5mUmTJhEUFISfnx/Dhg3jjz/+uGebMTEx9OnTB39/fxo3bsysWbNIT0/PbddFREREch9+hg4dyqFDh4iIiGD9+vU8+eST9OjRg9OnT3Pq1Cn69OnDU089xYYNG3jppZcYMWIEu3fvtuw/ceJEfvjhB+bOncuHH37I6dOnGTRo0F3bS01NpUePHgCsWbOGiRMn8vHHHzN//vw8nK6IiIgYnclsNptzuvHZs2dp3rw5q1evpm7dugCYzWaaN29O69atuXLlCkeOHGHdunWWfYYNG8bVq1dZunQpcXFxBAcHs2jRIp5++mkAzpw5Q4sWLVizZg1+fn5Z2tyyZQujRo3ihx9+wMPDA4C1a9cybdo0du/ejZOTU65POiMjg7gLV0hLy8j1vpK/HBzs8PBw4dq126pHAVMtbIdqYTsepVo4uThjZ/fPne3i5eWKvX3+9N8hNxt7enoSGRlJrVq1LMtMJhMmk4nr168THR1Ns2bNrPZp0KABkydPxmw2c+DAAcuyTOXLl6dkyZLs378/2/ATHR1NjRo1LMEnc//ExESOHDmCr69vbk4BgPRr8dz+sH+u95P8lwrcLuhOCKBa2BLVwnY8SrU4a1eKJ3tP/ccGIJMp/46Vq/Dj7u5uuWKTKSoqirNnzzJ69Gg2btyIj4+P1Xpvb29u375NQkICcXFxeHp6UqhQoSzbxMbGZttmbGxstscEuHjxYp7Cj4iIiNGYTCY8PV3/seEnP+Uq/PzVwYMHGTVqFM2bNyc4OJikpKQsw1CZP6ekpHD79u1sh6kKFSpEcnJytm0kJSXh7u6eZXvgrvvcj71HCVxfX0xGeo5H/OQBsbM34VbEmRuJSapHAVMtbIdqYTsepVpUc3Hm2rV/7nUsDw+XfAtueQ4/27dvZ/jw4fj7+xMeHg7cCSUpKSlW22X+7OLigrOzc5b1cCfEuLi4ZNtOdvtkhp7ChQvnqe92dnY4Obv848dvHwUODnYUdnMlOc2kehQw1cJ2qBa241GqRUbGnTmv/1Q5n6F8f3mKUKtWrWLgwIE0bdqURYsWWa7ElCpVikuXLllte+nSJQoXLoybmxs+Pj5cvXo1S5i5dOkSJUuWzLYtHx+fbI8J3HUfERERkbvJdfhZvXo1YWFhdOnShYiICKthrHr16rFv3z6r7ffs2YO/vz92dnbUrVuXjIwMy8RnuPNpr7i4OAICArJtLyAggMOHD5OYmGh1TFdXV6pVq5bb7ouIiIjB5Sr8nDlzhilTpvDss8/Sp08fLl++THx8PPHx8dy4cYPQ0FB++uknwsPDOXXqFMuWLWPbtm307NkTuHOlplWrVowdO5a9e/fy008/MXToUAIDA6lTpw5wZ5gsPj7ecnWoWbNmlChRgsGDB3P06FG2b99OREQEr7/+ep4+5i4iIiLGlqv7/CxatIiZM2dmu+7FF1/k3XffZefOnUyfPp3ffvuNMmXKMHDgQFq2bGnZ7tatW0yZMoWoqCgAmjRpwtixY/H09ARg7969dOvWjRUrVlC/fn3gzv2FJk2aRHR0NB4eHnTs2JGBAwf+rYlPCQk3//Hjt48CBwc7PD1dVQ8boFrYDtXCdqgWtiM/7/OTq/DzKNET2TbohcV2qBa2Q7WwHaqF7cjP8KMP+4uIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKEo/IiIiIihKPyIiIiIoSj8iIiIiKH8rfCzePFiQkNDrZZ9//33dOjQAT8/P9q0acOWLVss6zZs2EDVqlWz/erWrdtd29m8eXO2+8TExPyd7ouIiIgBOeR1x48++ohZs2ZRr149y7IDBw7Qq1cvunTpwrRp0zh69Cjjxo0jLS2Ndu3a0bJlS5566imr42zbto2pU6fSt2/fu7Z17NgxAgMDiYiIsFru5eWV1+6LiIiIQeU6/MTFxTFhwgT27t1LuXLlrNYtXbqU2rVrM27cOAAqVqzIuXPnmDNnDu3atcPZ2RlnZ2fL9rGxscyePZv+/fvTsGHDu7Z5/PhxqlatSokSJXLbXREREREruQ4/v/76K46OjmzevJn58+dz/vx5y7qzZ8/SpEkTq+2rV6/O+fPnuXDhAqVLl7ZaN336dLy9vendu/c92zx27BghISG57eo92dtrupMtyKyD6lHwVAvboVrYDtXCdphM+XesXIefkJCQuwYRb29vLl68aLUsc17OlStXrMLPsWPH2LJlC/Pnz8fJyemu7V27do24uDiio6NZvXo1CQkJ1K5dm7feeovy5cvntvsW7u4ued5X8p/qYTtUC9uhWtgO1eLRkuc5P9lp27Yto0ePZvPmzbRs2ZITJ06wbNkyAFJTU622Xb58OVWrVuWZZ5655zFPnDgBgNlsZurUqSQlJbFw4UI6d+7M559/TvHixfPU1+vXb5OenpGnfSX/2Nvb4e7uonrYANXCdqgWtkO1sB0eHi7Y2eXPFbh8DT/t2rXj/PnzjBs3jpEjR1KqVCl69erFxIkTcXNzs2yXlJTEtm3beOuttzDd5zpWvXr12L17N56enpZt582bR3BwMBs2bLjvkNndpKdnkJamJ7KtUD1sh2phO1QL26FaFDyzOf+Ola/hB+CNN96gb9++XL58mRIlSvD9999jb29vNeS1a9cuUlNTef7553N0zL9+qsvFxYUyZcoQFxeXr30XERGRR1++zuBatWoVYWFh2NvbU7JkSezs7IiKisLPzw9XV1fLdtHR0VSrVg1PT8/7HnPt2rXUr1+fW7duWZYlJiby22+/UalSpfzsvoiIiBhAvoafihUrsmbNGjZt2kRMTAyRkZFs3ryZN99802q7w4cPU61atWyPkZ6eTnx8PElJSQA0adKEjIwMRowYwYkTJ/j5558ZOHAgXl5etG/fPj+7LyIiIgaQr+EnKCiISZMmsWDBAlq1akVUVBQLFy4kMDDQarv4+HiKFi2a7TEuXrxI48aN+eKLLwAoVaoUy5cv59atW7zyyit0794dNzc3VqxYQaFChfKz+yIiImIAJrM5P6cQ/XMkJNzU5DUb4OBgh6enq+phA1QL26Fa2A7VwnZ4ebnm2/2WdNcmERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExFIUfERERMRSFHxERETEUhR8RERExlL8VfhYvXkxoaKjVsu+//54OHTrg5+dHmzZt2LJli9X6AwcOULVq1Sxfe/fuvWs7MTEx9OnTB39/fxo3bsysWbNIT0//O10XERERg3LI644fffQRs2bNol69epZlBw4coFevXnTp0oVp06Zx9OhRxo0bR1paGu3atQPg2LFjlC1bltWrV1sdz8PDI9t2UlNT6dGjB+XKlWPNmjWcO3eOMWPGYGdnx6BBg/LafRERETGoXIefuLg4JkyYwN69eylXrpzVuqVLl1K7dm3GjRsHQMWKFTl37hxz5syxhJ/jx49TqVIlSpQokaP2oqKiuHDhAp988gkeHh5UqVKFK1euMG3aNPr27YuTk1NuT0FEREQMLNfh59dff8XR0ZHNmzczf/58zp8/b1l39uxZmjRpYrV99erVOX/+PBcuXKB06dIcO3aMunXr5ri96OhoatSoYXVlqEGDBiQmJnLkyBF8fX1zewoA2NtrupMtyKyD6lHwVAvboVrYDtXCdphM+XesXIefkJAQQkJCsl3n7e3NxYsXrZbFxMQAcOXKFUqXLs2JEyfw9PSkffv2xMXFUaVKFYYMGULt2rWzPWZsbCw+Pj5Z2gG4ePFinsOPu7tLnvaTB0P1sB2qhe1QLWyHavFoyfOcn+y0bduW0aNHs3nzZlq2bMmJEydYtmwZcGfuzsWLF7lx4wa3bt1i7Nix2Nvbs2rVKrp27cqGDRuoVKlSlmMmJSXh7u5utaxQoUIAJCcn57mv16/fJj09I8/7S/6wt7fD3d1F9bABqoXtUC1sh2phOzw8XLCzy58rcPkaftq1a8f58+cZN24cI0eOpFSpUvTq1YuJEyfi5uZGqVKl2L9/Py4uLjg6OgJQq1YtDh8+zMqVK5k0aVKWYzo7O5OSkmK1LDP0FC5cOM99TU/PIC1NT2RboXrYDtXCdqgWtkO1KHhmc/4dK98HMd944w0OHjzId999x/bt2yldujT29vaULl0aAHd3d0vwAbCzs6NixYrExcVlezwfHx8uXbpktSzz55IlS+Z390VEROQRl6/hZ9WqVYSFhWFvb0/JkiWxs7MjKioKPz8/XF1d2blzJ35+fvz++++WfdLS0jh69Gi2Q14AAQEBHD58mMTERMuyPXv24OrqSrVq1fKz+yIiImIA+Rp+KlasyJo1a9i0aRMxMTFERkayefNm3nzzTQD8/f3x9PRk5MiR/PLLLxw7doyRI0dy9epVunfvDkBKSgrx8fGWoa5mzZpRokQJBg8ezNGjR9m+fTsRERG8/vrr+pi7iIiI5Fq+hp+goCAmTZrEggULaNWqFVFRUSxcuJDAwEAAihQpwvLlyylevDg9evTg5Zdf5urVq6xatYrixYsDcOjQIRo3bsyhQ4eAO5OblyxZQkZGBp06dWLSpEl07tyZ/v3752fXRURExCBMZnN+TiH650hIuKnJazbAwcEOT09X1cMGqBa2Q7WwHaqF7fDycs23+y3prk0iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIofyv8LF68mNDQUKtl33//PR06dMDPz482bdqwZcsWq/UXL15k6NChNGrUiICAAHr06MGJEyfu2c7YsWOpWrWq1VdISMjf6bqIiIgYlENed/zoo4+YNWsW9erVsyw7cOAAvXr1okuXLkybNo2jR48ybtw40tLSaNeuHSkpKfTu3ZuiRYuyaNEinJ2dmTt3Lq+++ipbtmzBy8sr27aOHTtG37596dq1q2WZvb19XrsuIiIiBpbr8BMXF8eECRPYu3cv5cqVs1q3dOlSateuzbhx4wCoWLEi586dY86cObRr147o6GiOHz/Ozp07KVmyJADTp0+nfv36/Oc//6Fjx45Z2jObzZw8eZLevXtTokSJPJyiiIiIyP/kOvz8+uuvODo6snnzZubPn8/58+ct686ePUuTJk2stq9evTrnz5/nwoULVK5cmcjISEvwAbCzuzPydv369WzbO3fuHLdu3aJChQq57eo92dtrupMtyKyD6lHwVAvboVrYDtXCdphM+XesXIefkJCQu8638fb25uLFi1bLYmJiALhy5Qq1atXi6aeftlq/cuVKkpKSaNSoUbbHPH78uGW7nTt3YmdnR5MmTRgyZAhubm657b6Fu7tLnveV/Kd62A7VwnaoFrZDtXi05HnOT3batm3L6NGj2bx5My1btuTEiRMsW7YMgNTU1Czbf/3118yYMYPu3btTtWrVbI95/Phx7Ozs8Pb2ZtGiRZw7d45p06Zx4sQJPvzwQ8uVo9y6fv026ekZedpX8o+9vR3u7i6qhw1QLWyHamE7VAvb4eHhkuf3/L/K1/DTrl07zp8/z7hx4xg5ciSlSpWiV69eTJw4MctVmo8//piwsDBeeOEFRowYcddj9uvXj86dO+Pp6QlAlSpVKFGiBJ06deLnn3/G19c3T31NT88gLU1PZFuhetgO1cJ2qBa2Q7UoeGZz/h0r3wcx33jjDQ4ePMh3333H9u3bKV26NPb29pQuXdqyzfTp05k4cSLdunVj6tSp90xydnZ2luCTqXLlygDExsbmd/dFRETkEZev4WfVqlWEhYVhb29PyZIlsbOzIyoqCj8/P1xdXYE7wWfJkiWMHDmSt99+G9N9ZjCNGDGC7t27Wy37+eefAahUqVJ+dl9EREQMIF/DT8WKFVmzZg2bNm0iJiaGyMhINm/ezJtvvgnA3r17WbJkCaGhobRp04b4+HjL182bNwFISkoiPj6e9PR0AJ577jl2797NvHnzOHfuHDt27GD06NG0bt2aihUr5mf3RURExADydc5PUFAQkyZNYsGCBcTFxVGpUiUWLlxIYGAggOVuzytXrmTlypVW+w4YMICBAwfyxRdfMGrUKL755hvKlCnDM888w6xZs4iMjOT999/Hzc2NNm3aMHjw4PzsuoiIiBiEyWzOzylE/xwJCTc1ec0GODjY4enpqnrYANXCdqgWtkO1sB1eXq75dr8l3bVJREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQMReFHREREDEXhR0RERAxF4UdEREQM5W+Fn8WLFxMaGmq17Pvvv6dDhw74+fnRpk0btmzZYrU+OTmZSZMmERQUhJ+fH8OGDeOPP/64ZzsxMTH06dMHf39/GjduzKxZs0hPT/87XRcRERGDynP4+eijj5g1a5bVsgMHDtCrVy/q1KnDp59+St++fRk/fjybNm2ybDNx4kR++OEH5s6dy4cffsjp06cZNGjQXdtJTU2lR48eAKxZs4aJEyfy8ccfM3/+/Lx2XURERAzMIbc7xMXFMWHCBPbu3Uu5cuWs1i1dupTatWszbtw4ACpWrMi5c+eYM2cO7dq1Iy4ujk2bNrFo0SLq1asHQEREBC1atODQoUP4+fllaS8qKooLFy7wySef4OHhQZUqVbhy5QrTpk2jb9++ODk55eG0RURExKhyHX5+/fVXHB0d2bx5M/Pnz+f8+fOWdWfPnqVJkyZW21evXp3z589z4cIF/u///g+ABg0aWNaXL1+ekiVLsn///mzDT3R0NDVq1MDDw8OyrEGDBiQmJnLkyBF8fX1zewoA2NtrupMtyKyD6lHwVAvboVrYDtXCdphM+XesXIefkJAQQkJCsl3n7e3NxYsXrZbFxMQAcOXKFeLi4vD09KRQoUJZ9ouNjc32mLGxsfj4+GTZHuDixYt5Dj/u7i552k8eDNXDdqgWtkO1sB2qxaMl1+HnXtq2bcvo0aPZvHkzLVu25MSJEyxbtgy4M3fn9u3b2Q5TFSpUiOTk5GyPmZSUhLu7e5btgbvukxPXr98mPT0jz/tL/rC3t8Pd3UX1sAGqhe1QLWyHamE7PDxcsLPLnytw+Rp+2rVrx/nz5xk3bhwjR46kVKlS9OrVi4kTJ+Lm5oazszMpKSlZ9ktOTsbFJftUnd0+maGncOHCee5renoGaWl6ItsK1cN2qBa2Q7WwHapFwTOb8+9Y+T6I+cYbb3Dw4EG+++47tm/fTunSpbG3t6d06dL4+Phw9erVLGHm0qVLlCxZMtvj+fj4cOnSpSzbA3fdR0RERORu8jX8rFq1irCwMOzt7SlZsiR2dnZERUXh5+eHq6srdevWJSMjgwMHDlj2OXPmDHFxcQQEBGR7zICAAA4fPkxiYqJl2Z49e3B1daVatWr52X0RERExgHwNPxUrVmTNmjVs2rSJmJgYIiMj2bx5M2+++SZw50pNq1atGDt2LHv37uWnn35i6NChBAYGUqdOHQBSUlKIj4+3XB1q1qwZJUqUYPDgwRw9epTt27cTERHB66+/ro+5i4iISK7la/gJCgpi0qRJLFiwgFatWhEVFcXChQsJDAy0bBMWFkZQUBADBgygR48eVKhQgTlz5ljWHzp0iMaNG3Po0CHgzuTmJUuWkJGRQadOnZg0aRKdO3emf//++dl1ERERMQiT2ZyfU4j+ORISbmrymg1wcLDD09NV9bABqoXtUC1sh2phO7y8XPPtfku6a5OIiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIrCj4iIiBiKwo+IiIgYisKPiIiIGIphb3KYnq6bVdkKe3s71cNGqBa2Q7WwHaqFbbCzM2EymfLlWIYNPyIiImJMGvYSERERQ1H4EREREUNR+BERERFDUfgRERERQ1H4EREREUNR+BERERFDUfgRERERQ1H4EREREUNR+BERERFDUfgRERERQ1H4EREREUNR+BERERFDUfgRERERQzFU+MnIyGDOnDk89dRT1KlTh169evH7778XdLcM6erVq4wfP54mTZrg7+/PK6+8QnR0dEF3y/DOnDmDn58fGzZsKOiuGNamTZto2bIltWrVolWrVnz55ZcF3SXDSktLY/bs2TRt2hQ/Pz+6dOnC//3f/xV0twxn8eLFhIaGWi07cuQIXbt2pU6dOoSEhLBixYpcHdNQ4WfBggWsXr2asLAw1qxZQ0ZGBj179iQlJaWgu2Y4Q4cO5dChQ0RERLB+/XqefPJJevTowenTpwu6a4aVmprK8OHDuXXrVkF3xbA+++wzxowZQ5cuXdi6dSutW7e2/K7Iw7dw4ULWrVtHWFgYmzZtonz58vTs2ZNLly4VdNcM46OPPmLWrFlWyxISEnjttdcoW7Ys69ev54033iA8PJz169fn+LiGCT8pKSksW7aMQYMGERwcTLVq1Zg5cyaxsbF89dVXBd09Qzl79iy7du1i4sSJ1KtXj/LlyzNu3Di8vb35/PPPC7p7hjV37lyKFClS0N0wLLPZzOzZs+nWrRtdunShbNmy9OvXj4YNG7Jv376C7p4hbd++ndatW9O4cWOeeOIJ3n77bW7cuKGrPw9BXFwcffv2JTw8nHLlylmt++STT3B0dOTf//43FStWpEOHDnTv3p3IyMgcH98w4efo0aPcvHmToKAgyzJ3d3eqV6/O/v37C7BnxuPp6UlkZCS1atWyLDOZTJhMJq5fv16APTOu/fv3s3btWt59992C7ophnTlzhvPnz9OmTRur5UuXLqVPnz4F1CtjK1asGN9++y0xMTGkp6ezdu1anJycqFatWkF37ZH366+/4ujoyObNm/H19bVaFx0dTWBgIA4ODpZlDRo04LfffuPy5cs5Or5hwk9sbCwApUqVslru7e1tWScPh7u7O08//TROTk6WZVFRUZw9e5annnqqAHtmTNevX2fEiBGMHTs2y++HPDxnzpwB4NatW/To0YOgoCBeeukl/vOf/xRwz4xrzJgxODo68swzz1CrVi1mzpzJnDlzKFu2bEF37ZEXEhLC3Llzefzxx7Osi42NxcfHx2qZt7c3ABcvXszR8Q0Tfm7fvg1g9YYLUKhQIZKTkwuiS/L/HTx4kFGjRtG8eXOCg4MLujuGM3HiRPz8/LJccZCHKzExEYCRI0fSunVrli1bRqNGjejfvz+7d+8u4N4Z08mTJ3Fzc2P+/PmsXbuW9u3bM3z4cI4cOVLQXTO0pKSkbN/LgRy/nzvcf5NHg7OzM3Bn7k/m93DngXJxcSmobhne9u3bGT58OP7+/oSHhxd0dwxn06ZNREdHa66VDXB0dASgR48evPjiiwA8+eSTHD58mA8++MBqyF4evIsXLzJs2DCWL19OvXr1AKhVqxYnT55k7ty5LFiwoIB7aFzOzs5ZPqiUGXoKFy6co2MY5spP5uX8v87Sv3TpEiVLliyILhneqlWrGDhwIE2bNmXRokWW5C4Pz/r167ly5QrBwcH4+fnh5+cHwIQJE+jZs2cB985YMl+HqlSpYrW8UqVKxMTEFESXDO3HH38kNTXVam4igK+vL2fPni2gXgmAj49Ptu/lQI7fzw1z5adatWoUKVKEvXv3WsZrr1+/zuHDh+natWsB9854Mm85EBoaypgxYzCZTAXdJUMKDw8nKSnJalnz5s0ZNGgQL7zwQgH1yphq1KiBq6srP/74o+VKA8Dx48c1x6QAZM4pOXbsGLVr17YsP378eJZPH8nDFRAQwJo1a0hPT8fe3h6APXv2UL58eYoVK5ajYxgm/Dg5OdG1a1fCw8Px8vLiscceY/r06fj4+NC8efOC7p6hnDlzhilTpvDss8/Sp08fq9n5zs7OuLm5FWDvjOVufyUVK1ZMV0QfMmdnZ3r27Mn8+fMpWbIktWvXZuvWrezatYvly5cXdPcMp3bt2tStW5eRI0cyYcIEfHx82LRpE7t37+bjjz8u6O4ZWocOHViyZAljxoyhZ8+e/PTTTyxfvpxJkybl+BiGCT8AgwYNIi0tjbFjx5KUlERAQABLly61jLXLwxEVFUVqaipff/01X3/9tdW6F198UR+3FsPq378/Li4uzJw5k7i4OCpWrMjcuXOpX79+QXfNcOzs7Fi4cCGzZs1i1KhRXLt2jSpVqrB8+fIsH72Wh6tYsWIsWbKEyZMn8+KLL1KiRAlGjBhhmSuXEyaz2Wx+gH0UERERsSmGmfAsIiIiAgo/IiIiYjAKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyLyjxQTE0PVqlXZsGHD3z7W22+/TUhISD70SkT+CQz17y1E5NHh7e3N2rVr9U8/RSTXFH5E5B/JycmJOnXqFHQ3ROQfSMNeIvJArFu3jlatWlGzZk2Cg4OZO3cu6enpwJ1hptDQUD799FOaNm2Kn58fr776KkePHrXsn5GRwcyZMwkJCaFmzZqEhIQwY8YMUlNTgeyHvX777TcGDRpEo0aNqFOnDqGhoRw4cMCqX9euXWPUqFEEBgYSEBDA9OnTycjIyNL/7du30759e2rVqkWjRo145513uHXrlmV9UlISEydOpEmTJtSsWZMWLVqwdOnSfH0MReTB0JUfEcl3ixcvZubMmXTt2pVRo0Zx5MgR5s6dy8WLF5kyZQoAR44c4fTp0wwdOhQPDw/mzJlD165d+eKLL/D29ub999/n448/ZuTIkTz++OP8+OOPzJw5E0dHRwYNGpSlzZMnT9KpUyfKlSvH2LFjcXR0ZMWKFbz66qssW7aMwMBAMjIy6NmzJ+fPn2fkyJEULVqUJUuW8PPPP+Pt7W051ueff87w4cNp06YNgwcP5vz588ycOZOTJ0/ywQcfYDKZmDJlCj/88AMjR46kePHi7Ny5k2nTplG0aFE6dOjw0B5rEck9hR8RyVc3btxgwYIFvPzyy4wdOxaAxo0bU7RoUcaOHctrr71m2W7RokXUq1cPgNq1a9OsWTNWrFjB8OHD2bdvHzVr1rQEicDAQFxcXHBzc8u23Xnz5uHk5MSKFSsoUqQIAMHBwbRu3Zpp06bx6aefsnPnTn766Sfef/99mjRpAkBQUJDVZGez2Ux4eDhPPfUU4eHhluXlypWje/fu7Nixg+DgYPbt20ejRo1o1aoVAPXr16dw4cIUK1YsPx9OEXkANOwlIvnq0KFDJCUlERISQlpamuUrM2Ds2rULgDJlyliCD9yZwOzn58f+/fuBO2Fi165ddO7cmSVLlnDy5Em6du1K27Zts2133759NG3a1BJ8ABwcHGjVqhW//PILN2/eJDo6GkdHR5566inLNoULF+bpp5+2/Hz69GliY2Oz9D8gIIAiRYpY+l+/fn0++eQTevXqxapVq/j999954403CA4Ozp8HUkQeGF35EZF8dfXqVQB69+6d7fpLly4BULJkySzrihUrxq+//gpAz549cXV1Zf369YSHhzN9+nQqV67M2LFjadCgQZZ9r127RvHixbMsL168OGazmcTERK5du0bRokUxmUxW25QoUSJL/ydNmsSkSZPu2v8xY8bg4+PD5s2bCQsLIywsDD8/PyZOnEi1atWyPXcRsQ0KPyKSr9zd3QEIDw+nXLlyWdYXL16c2bNnk5CQkGXd5cuXLcNGdnZ2dOnShS5dunDlyhV27NjBokWLGDhwoOXqy595eHhw+fLlLMvj4+MB8PT0xNPTk4SEBNLT07G3t7dskxl4/tz/ESNGEBgYmG07cOfTZv369aNfv35cuHCBb7/9lgULFjBs2DC2bt16t4dHRGyAhr1EJF/5+vri6OhIXFwctWrVsnw5ODgQERFBTEwMcOeTWadOnbLsFxcXx6FDhwgKCgLgX//6F++88w5w54pQ+/bt6dKlC9evXycxMTFLuwEBAXz77bdW69LT09m6dSu1atXCycmJoKAg0tLS2L59u2WblJQUqzBVoUIFihUrRkxMjFX/S5YsyYwZMzh8+DBJSUk899xzLFu2DIDSpUvTpUsXWrVqxYULF/Lx0RSRB0FXfkQkX3l6etKzZ09mz55NYmIi9evXJy4ujtmzZ2MymSxDQmazmb59+zJkyBDs7e2ZN28eHh4ehIaGAnfCzLJlyyhevDh+fn7ExcXxwQcfEBgYiJeXl9XHzgEGDBjAzp076datG71798bR0dEyF2fJkiXAncnNjRs3ZuzYsVy5coXHHnuMFStW8Mcff1iuONnb2zNkyBDGjx+Pvb09TZs25fr16yxYsIC4uDhq1KiBs7MzNWrUYN68eTg6OlK1alXOnDnDxo0bee655x7ioy0ieWEym83mgu6EiDx6PvroI1avXs3Zs2fx8PAgKCiIoUOHUrp0ad5++2327dtHr169mD9/Prdv36Zhw4aMHDmSMmXKAJCWlsbChQvZvHkzsbGxuLm5ERISwrBhw/D09CQmJoZnnnmGqVOn0r59e+DOx+cjIiKIjo7GZDJRu3ZtBgwYYDWx+vbt24SHh7N161aSk5Np2bIlhQsX5ptvvuE///mPZbsvvviCJUuWcOLECQoXLoy/vz+DBw+matWqACQmJjJr1iy++eYb4uPjKVasGC1btuTNN9/E2dn5IT7SIpJbCj8i8tBlhp8/hw0RkYdFc35ERETEUBR+RERExFA07CUiIiKGois/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIoCj8iIiJiKAo/IiIiYigKPyIiImIo/w/xoKfivcOn7AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/MonteCarlo.ipynb b/notebooks/MonteCarlo.ipynb new file mode 100644 index 0000000..9b7a05b --- /dev/null +++ b/notebooks/MonteCarlo.ipynb @@ -0,0 +1,748 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 蒙特卡洛算法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from collections import defaultdict\n", + "class FisrtVisitMC:\n", + " ''' On-Policy First-Visit MC Control\n", + " '''\n", + " def __init__(self,cfg):\n", + " self.n_actions = cfg.n_actions\n", + " self.epsilon = cfg.epsilon\n", + " self.gamma = cfg.gamma \n", + " self.Q_table = defaultdict(lambda: np.zeros(cfg.n_actions))\n", + " self.returns_sum = defaultdict(float) # 保存return之和\n", + " self.returns_count = defaultdict(float)\n", + " \n", + " def sample_action(self,state):\n", + " state = str(state)\n", + " if state in self.Q_table.keys():\n", + " best_action = np.argmax(self.Q_table[state])\n", + " action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions\n", + " action_probs[best_action] += (1.0 - self.epsilon)\n", + " action = np.random.choice(np.arange(len(action_probs)), p=action_probs)\n", + " else:\n", + " action = np.random.randint(0,self.n_actions)\n", + " return action\n", + " def predict_action(self,state):\n", + " state = str(state)\n", + " if state in self.Q_table.keys():\n", + " best_action = np.argmax(self.Q_table[state])\n", + " action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions\n", + " action_probs[best_action] += (1.0 - self.epsilon)\n", + " action = np.argmax(self.Q_table[state])\n", + " else:\n", + " action = np.random.randint(0,self.n_actions)\n", + " return action\n", + " def update(self,one_ep_transition):\n", + " # Find all (state, action) pairs we've visited in this one_ep_transition\n", + " # We convert each state to a tuple so that we can use it as a dict key\n", + " sa_in_episode = set([(str(x[0]), x[1]) for x in one_ep_transition])\n", + " for state, action in sa_in_episode:\n", + " sa_pair = (state, action)\n", + " # Find the first occurence of the (state, action) pair in the one_ep_transition\n", + "\n", + " first_occurence_idx = next(i for i,x in enumerate(one_ep_transition)\n", + " if str(x[0]) == state and x[1] == action)\n", + " # Sum up all rewards since the first occurance\n", + " G = sum([x[2]*(self.gamma**i) for i,x in enumerate(one_ep_transition[first_occurence_idx:])])\n", + " # Calculate average return for this state over all sampled episodes\n", + " self.returns_sum[sa_pair] += G\n", + " self.returns_count[sa_pair] += 1.0\n", + " self.Q_table[state][action] = self.returns_sum[sa_pair] / self.returns_count[sa_pair]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg,env,agent):\n", + " print('开始训练!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录奖励\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录每个回合的奖励\n", + " one_ep_transition = []\n", + " state = env.reset(seed=cfg.seed) # 重置环境,即开始新的回合\n", + " for _ in range(cfg.max_steps):\n", + " action = agent.sample_action(state) # 根据算法采样一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一次动作交互\n", + " one_ep_transition.append((state, action, reward)) # 保存transitions\n", + " agent.update(one_ep_transition) # 更新智能体\n", + " state = next_state # 更新状态\n", + " ep_reward += reward \n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.1f}\")\n", + " print('完成训练!')\n", + " return {\"rewards\":rewards}\n", + "def test(cfg,env,agent):\n", + " print('开始测试!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录所有回合的奖励\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录每个episode的reward\n", + " state = env.reset(seed=cfg.seed) # 重置环境, 重新开一局(即开始新的一个回合)\n", + " for _ in range(cfg.max_steps):\n", + " action = agent.predict_action(state) # 根据算法选择一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一个交互\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合数:{i_ep+1}/{cfg.test_eps}, 奖励:{ep_reward:.1f}\")\n", + " print('完成测试!')\n", + " return {\"rewards\":rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3、定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys,os\n", + "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), \"../..\")))\n", + "import torch\n", + "import numpy as np\n", + "import random\n", + "from envs.racetrack import RacetrackEnv\n", + "\n", + "def all_seed(env,seed = 1):\n", + " ''' omnipotent seed for RL, attention the position of seed function, you'd better put it just following the env create function\n", + " '''\n", + " if seed == 0:\n", + " return\n", + " # print(f\"seed = {seed}\")\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + " \n", + "def env_agent_config(cfg):\n", + " '''创建环境和智能体\n", + " ''' \n", + " env = RacetrackEnv() # 创建环境\n", + " all_seed(env,seed=cfg.seed) \n", + " n_states = env.observation_space.shape[0] # 状态空间维度\n", + " n_actions = env.action_space.n # 动作空间维度\n", + " setattr(cfg, 'n_states', n_states) # 将状态维度添加到配置参数中\n", + " setattr(cfg, 'n_actions', n_actions) # 将动作维度添加到配置参数中\n", + " agent = FisrtVisitMC(cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config:\n", + " '''配置参数\n", + " '''\n", + " def __init__(self):\n", + " self.env_name = 'Racetrack-v0' # 环境名称\n", + " self.algo_name = \"FirstVisitMC\" # 算法名称\n", + " self.train_eps = 400 # 训练回合数\n", + " self.test_eps = 20 # 测试回合数\n", + " self.max_steps = 200 # 每个回合最大步数\n", + " self.epsilon = 0.1 # 贪婪度\n", + " self.gamma = 0.9 # 折扣因子\n", + " self.lr = 0.5 # 学习率\n", + " self.seed = 1 # 随机种子\n", + " # if torch.cuda.is_available(): # 是否使用GPUs\n", + " # self.device = torch.device('cuda')\n", + " # else:\n", + " # self.device = torch.device('cpu')\n", + " self.device = torch.device('cpu')\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线\n", + " '''\n", + " last = data[0] # First value in the plot (first timestep)\n", + " smoothed = list()\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,title=\"learning curve\"):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{title}\")\n", + " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\core.py:257: DeprecationWarning: \u001b[33mWARN: Function `env.seed(seed)` is marked as deprecated and will be removed in the future. Please use `env.reset(seed=seed)` instead.\u001b[0m\n", + " \"Function `env.seed(seed)` is marked as deprecated and will be removed in the future. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始训练!\n", + "环境:Racetrack-v0, 算法:FirstVisitMC, 设备:cpu\n", + "回合:1/400,奖励:-680.0\n", + "回合:2/400,奖励:-510.0\n", + "回合:3/400,奖励:-360.0\n", + "回合:4/400,奖励:-440.0\n", + "回合:5/400,奖励:-410.0\n", + "回合:6/400,奖励:-380.0\n", + "回合:7/400,奖励:-400.0\n", + "回合:8/400,奖励:-360.0\n", + "回合:9/400,奖励:-360.0\n", + "回合:10/400,奖励:-350.0\n", + "回合:11/400,奖励:-320.0\n", + "回合:12/400,奖励:-380.0\n", + "回合:13/400,奖励:-360.0\n", + "回合:14/400,奖励:-350.0\n", + "回合:15/400,奖励:-310.0\n", + "回合:16/400,奖励:-310.0\n", + "回合:17/400,奖励:-340.0\n", + "回合:18/400,奖励:-84.0\n", + "回合:19/400,奖励:-310.0\n", + "回合:20/400,奖励:-104.0\n", + "回合:21/400,奖励:-370.0\n", + "回合:22/400,奖励:-330.0\n", + "回合:23/400,奖励:-350.0\n", + "回合:24/400,奖励:-350.0\n", + "回合:25/400,奖励:-380.0\n", + "回合:26/400,奖励:-410.0\n", + "回合:27/400,奖励:-310.0\n", + "回合:28/400,奖励:-260.0\n", + "回合:29/400,奖励:-21.0\n", + "回合:30/400,奖励:-310.0\n", + "回合:31/400,奖励:-350.0\n", + "回合:32/400,奖励:-400.0\n", + "回合:33/400,奖励:-290.0\n", + "回合:34/400,奖励:-340.0\n", + "回合:35/400,奖励:-320.0\n", + "回合:36/400,奖励:-360.0\n", + "回合:37/400,奖励:-262.0\n", + "回合:38/400,奖励:-370.0\n", + "回合:39/400,奖励:-69.0\n", + "回合:40/400,奖励:-170.0\n", + "回合:41/400,奖励:-310.0\n", + "回合:42/400,奖励:-300.0\n", + "回合:43/400,奖励:-280.0\n", + "回合:44/400,奖励:-310.0\n", + "回合:45/400,奖励:-320.0\n", + "回合:46/400,奖励:-320.0\n", + "回合:47/400,奖励:-330.0\n", + "回合:48/400,奖励:-330.0\n", + "回合:49/400,奖励:-360.0\n", + "回合:50/400,奖励:-350.0\n", + "回合:51/400,奖励:-320.0\n", + "回合:52/400,奖励:-400.0\n", + "回合:53/400,奖励:-330.0\n", + "回合:54/400,奖励:-250.0\n", + "回合:55/400,奖励:-340.0\n", + "回合:56/400,奖励:-310.0\n", + "回合:57/400,奖励:-300.0\n", + "回合:58/400,奖励:-320.0\n", + "回合:59/400,奖励:-280.0\n", + "回合:60/400,奖励:-290.0\n", + "回合:61/400,奖励:-360.0\n", + "回合:62/400,奖励:-270.0\n", + "回合:63/400,奖励:-310.0\n", + "回合:64/400,奖励:-370.0\n", + "回合:65/400,奖励:-330.0\n", + "回合:66/400,奖励:-290.0\n", + "回合:67/400,奖励:-330.0\n", + "回合:68/400,奖励:-400.0\n", + "回合:69/400,奖励:-360.0\n", + "回合:70/400,奖励:-310.0\n", + "回合:71/400,奖励:-250.0\n", + "回合:72/400,奖励:-280.0\n", + "回合:73/400,奖励:-98.0\n", + "回合:74/400,奖励:-270.0\n", + "回合:75/400,奖励:-360.0\n", + "回合:76/400,奖励:-270.0\n", + "回合:77/400,奖励:-310.0\n", + "回合:78/400,奖励:-290.0\n", + "回合:79/400,奖励:-300.0\n", + "回合:80/400,奖励:-320.0\n", + "回合:81/400,奖励:-280.0\n", + "回合:82/400,奖励:-300.0\n", + "回合:83/400,奖励:-260.0\n", + "回合:84/400,奖励:-290.0\n", + "回合:85/400,奖励:-249.0\n", + "回合:86/400,奖励:-320.0\n", + "回合:87/400,奖励:-300.0\n", + "回合:88/400,奖励:-300.0\n", + "回合:89/400,奖励:-300.0\n", + "回合:90/400,奖励:-300.0\n", + "回合:91/400,奖励:-70.0\n", + "回合:92/400,奖励:-310.0\n", + "回合:93/400,奖励:-114.0\n", + "回合:94/400,奖励:-280.0\n", + "回合:95/400,奖励:-180.0\n", + "回合:96/400,奖励:-310.0\n", + "回合:97/400,奖励:-320.0\n", + "回合:98/400,奖励:-340.0\n", + "回合:99/400,奖励:-210.0\n", + "回合:100/400,奖励:-4.0\n", + "回合:101/400,奖励:-300.0\n", + "回合:102/400,奖励:-290.0\n", + "回合:103/400,奖励:-270.0\n", + "回合:104/400,奖励:-370.0\n", + "回合:105/400,奖励:-241.0\n", + "回合:106/400,奖励:-300.0\n", + "回合:107/400,奖励:-280.0\n", + "回合:108/400,奖励:-320.0\n", + "回合:109/400,奖励:-330.0\n", + "回合:110/400,奖励:-290.0\n", + "回合:111/400,奖励:-300.0\n", + "回合:112/400,奖励:-270.0\n", + "回合:113/400,奖励:-260.0\n", + "回合:114/400,奖励:-320.0\n", + "回合:115/400,奖励:-260.0\n", + "回合:116/400,奖励:-310.0\n", + "回合:117/400,奖励:-250.0\n", + "回合:118/400,奖励:-330.0\n", + "回合:119/400,奖励:-108.0\n", + "回合:120/400,奖励:-270.0\n", + "回合:121/400,奖励:-340.0\n", + "回合:122/400,奖励:-290.0\n", + "回合:123/400,奖励:-310.0\n", + "回合:124/400,奖励:-4.0\n", + "回合:125/400,奖励:-290.0\n", + "回合:126/400,奖励:-280.0\n", + "回合:127/400,奖励:-250.0\n", + "回合:128/400,奖励:-36.0\n", + "回合:129/400,奖励:-290.0\n", + "回合:130/400,奖励:-300.0\n", + "回合:131/400,奖励:-290.0\n", + "回合:132/400,奖励:-310.0\n", + "回合:133/400,奖励:-320.0\n", + "回合:134/400,奖励:-290.0\n", + "回合:135/400,奖励:-260.0\n", + "回合:136/400,奖励:-270.0\n", + "回合:137/400,奖励:-290.0\n", + "回合:138/400,奖励:-230.0\n", + "回合:139/400,奖励:-95.0\n", + "回合:140/400,奖励:-260.0\n", + "回合:141/400,奖励:-105.0\n", + "回合:142/400,奖励:-237.0\n", + "回合:143/400,奖励:-270.0\n", + "回合:144/400,奖励:-280.0\n", + "回合:145/400,奖励:-166.0\n", + "回合:146/400,奖励:-259.0\n", + "回合:147/400,奖励:-16.0\n", + "回合:148/400,奖励:-300.0\n", + "回合:149/400,奖励:-260.0\n", + "回合:150/400,奖励:-227.0\n", + "回合:151/400,奖励:-260.0\n", + "回合:152/400,奖励:-240.0\n", + "回合:153/400,奖励:-300.0\n", + "回合:154/400,奖励:-240.0\n", + "回合:155/400,奖励:-320.0\n", + "回合:156/400,奖励:-65.0\n", + "回合:157/400,奖励:-310.0\n", + "回合:158/400,奖励:-340.0\n", + "回合:159/400,奖励:-300.0\n", + "回合:160/400,奖励:-52.0\n", + "回合:161/400,奖励:-232.0\n", + "回合:162/400,奖励:-179.0\n", + "回合:163/400,奖励:-260.0\n", + "回合:164/400,奖励:-98.0\n", + "回合:165/400,奖励:-310.0\n", + "回合:166/400,奖励:-246.0\n", + "回合:167/400,奖励:-1.0\n", + "回合:168/400,奖励:-340.0\n", + "回合:169/400,奖励:-182.0\n", + "回合:170/400,奖励:-240.0\n", + "回合:171/400,奖励:-290.0\n", + "回合:172/400,奖励:-133.0\n", + "回合:173/400,奖励:-260.0\n", + "回合:174/400,奖励:-58.0\n", + "回合:175/400,奖励:-100.0\n", + "回合:176/400,奖励:-287.0\n", + "回合:177/400,奖励:-280.0\n", + "回合:178/400,奖励:-166.0\n", + "回合:179/400,奖励:-310.0\n", + "回合:180/400,奖励:-2.0\n", + "回合:181/400,奖励:-250.0\n", + "回合:182/400,奖励:-310.0\n", + "回合:183/400,奖励:-106.0\n", + "回合:184/400,奖励:-300.0\n", + "回合:185/400,奖励:1.0\n", + "回合:186/400,奖励:-54.0\n", + "回合:187/400,奖励:-270.0\n", + "回合:188/400,奖励:-260.0\n", + "回合:189/400,奖励:-250.0\n", + "回合:190/400,奖励:-184.0\n", + "回合:191/400,奖励:-290.0\n", + "回合:192/400,奖励:-310.0\n", + "回合:193/400,奖励:1.0\n", + "回合:194/400,奖励:-96.0\n", + "回合:195/400,奖励:-180.0\n", + "回合:196/400,奖励:-280.0\n", + "回合:197/400,奖励:-310.0\n", + "回合:198/400,奖励:-310.0\n", + "回合:199/400,奖励:-240.0\n", + "回合:200/400,奖励:-230.0\n", + "回合:201/400,奖励:-108.0\n", + "回合:202/400,奖励:-72.0\n", + "回合:203/400,奖励:-260.0\n", + "回合:204/400,奖励:-270.0\n", + "回合:205/400,奖励:-12.0\n", + "回合:206/400,奖励:-9.0\n", + "回合:207/400,奖励:-103.0\n", + "回合:208/400,奖励:0.0\n", + "回合:209/400,奖励:-67.0\n", + "回合:210/400,奖励:-167.0\n", + "回合:211/400,奖励:-290.0\n", + "回合:212/400,奖励:-280.0\n", + "回合:213/400,奖励:-192.0\n", + "回合:214/400,奖励:-184.0\n", + "回合:215/400,奖励:-30.0\n", + "回合:216/400,奖励:-300.0\n", + "回合:217/400,奖励:-58.0\n", + "回合:218/400,奖励:-290.0\n", + "回合:219/400,奖励:-185.0\n", + "回合:220/400,奖励:-270.0\n", + "回合:221/400,奖励:-231.0\n", + "回合:222/400,奖励:-178.0\n", + "回合:223/400,奖励:-48.0\n", + "回合:224/400,奖励:-260.0\n", + "回合:225/400,奖励:-240.0\n", + "回合:226/400,奖励:-160.0\n", + "回合:227/400,奖励:-250.0\n", + "回合:228/400,奖励:1.0\n", + "回合:229/400,奖励:-75.0\n", + "回合:230/400,奖励:-249.0\n", + "回合:231/400,奖励:-10.0\n", + "回合:232/400,奖励:-60.0\n", + "回合:233/400,奖励:-290.0\n", + "回合:234/400,奖励:1.0\n", + "回合:235/400,奖励:-250.0\n", + "回合:236/400,奖励:-320.0\n", + "回合:237/400,奖励:-97.0\n", + "回合:238/400,奖励:-225.0\n", + "回合:239/400,奖励:-320.0\n", + "回合:240/400,奖励:-250.0\n", + "回合:241/400,奖励:-127.0\n", + "回合:242/400,奖励:-270.0\n", + "回合:243/400,奖励:-230.0\n", + "回合:244/400,奖励:-50.0\n", + "回合:245/400,奖励:-171.0\n", + "回合:246/400,奖励:-270.0\n", + "回合:247/400,奖励:-19.0\n", + "回合:248/400,奖励:-119.0\n", + "回合:249/400,奖励:-18.0\n", + "回合:250/400,奖励:-41.0\n", + "回合:251/400,奖励:-290.0\n", + "回合:252/400,奖励:-88.0\n", + "回合:253/400,奖励:-270.0\n", + "回合:254/400,奖励:-280.0\n", + "回合:255/400,奖励:-300.0\n", + "回合:256/400,奖励:-250.0\n", + "回合:257/400,奖励:-91.0\n", + "回合:258/400,奖励:-270.0\n", + "回合:259/400,奖励:-109.0\n", + "回合:260/400,奖励:-330.0\n", + "回合:261/400,奖励:-320.0\n", + "回合:262/400,奖励:-280.0\n", + "回合:263/400,奖励:-240.0\n", + "回合:264/400,奖励:-250.0\n", + "回合:265/400,奖励:-240.0\n", + "回合:266/400,奖励:1.0\n", + "回合:267/400,奖励:-310.0\n", + "回合:268/400,奖励:-290.0\n", + "回合:269/400,奖励:-170.0\n", + "回合:270/400,奖励:-104.0\n", + "回合:271/400,奖励:-166.0\n", + "回合:272/400,奖励:-290.0\n", + "回合:273/400,奖励:-11.0\n", + "回合:274/400,奖励:-290.0\n", + "回合:275/400,奖励:-107.0\n", + "回合:276/400,奖励:-156.0\n", + "回合:277/400,奖励:-280.0\n", + "回合:278/400,奖励:-242.0\n", + "回合:279/400,奖励:-260.0\n", + "回合:280/400,奖励:-31.0\n", + "回合:281/400,奖励:-165.0\n", + "回合:282/400,奖励:1.0\n", + "回合:283/400,奖励:-139.0\n", + "回合:284/400,奖励:-129.0\n", + "回合:285/400,奖励:-87.0\n", + "回合:286/400,奖励:-109.0\n", + "回合:287/400,奖励:-89.0\n", + "回合:288/400,奖励:-240.0\n", + "回合:289/400,奖励:-95.0\n", + "回合:290/400,奖励:-152.0\n", + "回合:291/400,奖励:-43.0\n", + "回合:292/400,奖励:-42.0\n", + "回合:293/400,奖励:-270.0\n", + "回合:294/400,奖励:-84.0\n", + "回合:295/400,奖励:-300.0\n", + "回合:296/400,奖励:-260.0\n", + "回合:297/400,奖励:-260.0\n", + "回合:298/400,奖励:-83.0\n", + "回合:299/400,奖励:-56.0\n", + "回合:300/400,奖励:-77.0\n", + "回合:301/400,奖励:-176.0\n", + "回合:302/400,奖励:-103.0\n", + "回合:303/400,奖励:-215.0\n", + "回合:304/400,奖励:-182.0\n", + "回合:305/400,奖励:2.0\n", + "回合:306/400,奖励:-182.0\n", + "回合:307/400,奖励:-33.0\n", + "回合:308/400,奖励:-36.0\n", + "回合:309/400,奖励:-142.0\n", + "回合:310/400,奖励:-26.0\n", + "回合:311/400,奖励:-185.0\n", + "回合:312/400,奖励:-250.0\n", + "回合:313/400,奖励:1.0\n", + "回合:314/400,奖励:-73.0\n", + "回合:315/400,奖励:-152.0\n", + "回合:316/400,奖励:-133.0\n", + "回合:317/400,奖励:-270.0\n", + "回合:318/400,奖励:-46.0\n", + "回合:319/400,奖励:-270.0\n", + "回合:320/400,奖励:2.0\n", + "回合:321/400,奖励:-280.0\n", + "回合:322/400,奖励:-330.0\n", + "回合:323/400,奖励:-300.0\n", + "回合:324/400,奖励:-29.0\n", + "回合:325/400,奖励:-246.0\n", + "回合:326/400,奖励:-300.0\n", + "回合:327/400,奖励:-124.0\n", + "回合:328/400,奖励:-81.0\n", + "回合:329/400,奖励:-280.0\n", + "回合:330/400,奖励:-127.0\n", + "回合:331/400,奖励:-270.0\n", + "回合:332/400,奖励:-310.0\n", + "回合:333/400,奖励:-270.0\n", + "回合:334/400,奖励:-270.0\n", + "回合:335/400,奖励:-76.0\n", + "回合:336/400,奖励:-260.0\n", + "回合:337/400,奖励:-160.0\n", + "回合:338/400,奖励:-135.0\n", + "回合:339/400,奖励:-214.0\n", + "回合:340/400,奖励:-176.0\n", + "回合:341/400,奖励:-28.0\n", + "回合:342/400,奖励:-280.0\n", + "回合:343/400,奖励:-75.0\n", + "回合:344/400,奖励:-65.0\n", + "回合:345/400,奖励:-17.0\n", + "回合:346/400,奖励:-162.0\n", + "回合:347/400,奖励:-250.0\n", + "回合:348/400,奖励:-134.0\n", + "回合:349/400,奖励:-165.0\n", + "回合:350/400,奖励:-128.0\n", + "回合:351/400,奖励:-250.0\n", + "回合:352/400,奖励:-186.0\n", + "回合:353/400,奖励:-250.0\n", + "回合:354/400,奖励:-9.0\n", + "回合:355/400,奖励:-12.0\n", + "回合:356/400,奖励:-127.0\n", + "回合:357/400,奖励:-155.0\n", + "回合:358/400,奖励:-15.0\n", + "回合:359/400,奖励:-290.0\n", + "回合:360/400,奖励:-260.0\n", + "回合:361/400,奖励:-250.0\n", + "回合:362/400,奖励:-260.0\n", + "回合:363/400,奖励:-180.0\n", + "回合:364/400,奖励:-19.0\n", + "回合:365/400,奖励:-300.0\n", + "回合:366/400,奖励:-157.0\n", + "回合:367/400,奖励:-11.0\n", + "回合:368/400,奖励:-58.0\n", + "回合:369/400,奖励:-46.0\n", + "回合:370/400,奖励:-212.0\n", + "回合:371/400,奖励:-134.0\n", + "回合:372/400,奖励:-220.0\n", + "回合:373/400,奖励:-243.0\n", + "回合:374/400,奖励:-28.0\n", + "回合:375/400,奖励:-3.0\n", + "回合:376/400,奖励:-240.0\n", + "回合:377/400,奖励:-54.0\n", + "回合:378/400,奖励:-230.0\n", + "回合:379/400,奖励:-98.0\n", + "回合:380/400,奖励:-83.0\n", + "回合:381/400,奖励:-81.0\n", + "回合:382/400,奖励:-290.0\n", + "回合:383/400,奖励:-270.0\n", + "回合:384/400,奖励:-53.0\n", + "回合:385/400,奖励:-38.0\n", + "回合:386/400,奖励:-97.0\n", + "回合:387/400,奖励:-69.0\n", + "回合:388/400,奖励:-270.0\n", + "回合:389/400,奖励:-240.0\n", + "回合:390/400,奖励:-56.0\n", + "回合:391/400,奖励:-8.0\n", + "回合:392/400,奖励:-19.0\n", + "回合:393/400,奖励:-191.0\n", + "回合:394/400,奖励:-230.0\n", + "回合:395/400,奖励:-57.0\n", + "回合:396/400,奖励:-142.0\n", + "回合:397/400,奖励:-41.0\n", + "回合:398/400,奖励:-247.0\n", + "回合:399/400,奖励:-240.0\n", + "回合:400/400,奖励:2.0\n", + "完成训练!\n", + "开始测试!\n", + "环境:Racetrack-v0, 算法:FirstVisitMC, 设备:cpu\n", + "回合数:1/20, 奖励:-200.0\n", + "回合数:2/20, 奖励:-210.0\n", + "回合数:3/20, 奖励:-200.0\n", + "回合数:4/20, 奖励:-200.0\n", + "回合数:5/20, 奖励:-200.0\n", + "回合数:6/20, 奖励:-200.0\n", + "回合数:7/20, 奖励:-200.0\n", + "回合数:8/20, 奖励:-200.0\n", + "回合数:9/20, 奖励:-200.0\n", + "回合数:10/20, 奖励:2.0\n", + "回合数:11/20, 奖励:-200.0\n", + "回合数:12/20, 奖励:-200.0\n", + "回合数:13/20, 奖励:-200.0\n", + "回合数:14/20, 奖励:-200.0\n", + "回合数:15/20, 奖励:-200.0\n", + "回合数:16/20, 奖励:-200.0\n", + "回合数:17/20, 奖励:-200.0\n", + "回合数:18/20, 奖励:-200.0\n", + "回合数:19/20, 奖励:-200.0\n", + "回合数:20/20, 奖励:-200.0\n", + "完成测试!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHJCAYAAABpOFaGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1yklEQVR4nO3dd3zM9+MH8NfN5DIlIYlRtSKKBCGxZxVFS3VobaXUrqrV+ipFByk1itq1+tMqXVHVSas2LWrGqpREkETmXe7u8/vj8vkk5y6RcUvu9Xw8PCR3n7vP+32f5O6V95QJgiCAiIiIyA3JnV0AIiIiImdhECIiIiK3xSBEREREbotBiIiIiNwWgxARERG5LQYhIiIiclsMQkREROS2GISIiIjIbTEIlRP2WheT621SeeDMn2P+DrkGXgcqDINQOfDzzz9j6tSpNn/eY8eOYcSIEdL3CQkJCA8Px44dO2x+LiofDh48iK5du6Jhw4YYPny41WOmTZuG8PDwQv/t3r0bADBw4EAMHDiwzGVavnw51q5dCwD45ptvEB4eju+//77Q49etW4d69erh33//xbRp09CpU6din+v+4+//3RR/h8LDw7Ft2zarz5Geno6IiAiEh4fj0KFDZvdptVps2LABzz77LJo2bYqYmBi8+OKL+Oqrrx74QZ+RkYFXX30VjRo1QnR0NK5evVrsehXH0qVLrV7Pxo0bo2vXrli0aBH0er1Nz1lcX3zxBT744AOHnOvQoUNWr52tfPfdd+jRowciIyPx5JNPYufOnXY5jztROrsAVHYbNmywy/N+8cUXuHTpkvR9cHAwtm3bhurVq9vlfPTwmz9/PoxGI1atWoWgoKBCj6tUqRKWLVtm9b4aNWoAAN5++22blGnx4sUYO3YsAKBLly5455138O233+LJJ5+0evzOnTsRExOD6tWrY/To0Rg0aFCxz3X/8YX9bsrlcuzevRt9+/a1uO/HH3+ETqezuP327dsYPnw4bt68iYEDByIyMhJGoxG//vorpk2bhqNHj2LOnDmQyWRWz/nVV1/h119/xcyZMxEWFoZq1aoVu14lcX/AS0lJwXfffYeVK1dCr9dj8uTJdjlvUVasWIGYmBiHn9fWfvjhB7zxxhsYNGgQ2rZti59++gnTpk2DWq1Gjx49nF28hxaDEBWbWq1G48aNnV0McmGpqamIjo5Gq1atijyuOD9LderUsWHJTDw9PdGzZ09s374daWlp8Pf3N7v/zJkzuHDhAhYsWAAAJQ79xT0+KioKhw4dwt27dxEYGGh2X1xcHB577DGcPXvW7PapU6ciMTER27Ztk8IiAHTo0AFVqlTBwoUL0bFjRzz++ONWz5mamgoA6NevX6FhyRasXdeOHTsiISEBO3bscEoQKi8WLlyIbt264c033wQAtG3bFmlpaVi8eDGDUBmwa+whN3DgQBw+fBiHDx82a45NTU3FzJkz0apVK0REROCFF17AgQMHzB67f/9+vPDCC2jSpAmio6MxatQoqQVo2rRp2LlzJ/777z+pO+z+rrEdO3agfv36+Pvvv9G3b19ERESgY8eOUjeE6NatW5g4cSJiYmIQHR2NmTNnYtGiRQ/scrh16xamTp2Kli1bokmTJhgwYABOnDgBoPBuuvu7JgYOHIg33ngD48ePR+PGjTF06FB07doV48ePtzhfr169MGrUKOn7n376CX369EFERARat26NuXPnIisrq8gyGwwGbNmyBU899RQiIyPRoUMHxMbGQqvVmpVxyJAh+PLLL6VupF69emHfvn1FPjdg+qv+mWeeQaNGjdChQwd8+OGHUuvB0qVL0alTJ/z666/o1q0bGjVqhBdeeMGsiX7Hjh0IDw9HQkKC2fN26tQJ06ZNK/LcV69exfjx49G6dWs0btwYAwcOxLFjxwDkX4///vsPX331lU26Bu7vGgsPD8eyZcvQp08fREZGYtmyZTAajdLPUsOGDdGpUyd8+OGHyM3NlR4DAMuWLZO+fvbZZ5Gbmyt1wRW0c+dO+Pn5oWvXrgAsf55Onz6NwYMHo2nTpmjSpAmGDBmCv/76S7q/4PGF/W4CwBNPPAG5XI4ff/zR7PwpKSk4ePCgxYfa2bNn8ccff2DYsGFmIUg0ZMgQ9O/fH15eXoW+lkuXLgUA1KtXT7rW6enpeO+999C5c2dERERIIbGgTp064d1338XgwYMRGRmJt956y+o5HsTHx8csgBkMBqxatQo9e/ZEZGQkGjdujBdffBEHDx40e9xff/2Fl19+GVFRUWjRogVef/11JCUlSfc/6L2uU6dO+O+//7Bz507pZ1987/riiy/QunVrxMTEID4+3mZlKkin0+Hll19G8+bNLcKtKDExEY899hg2b95sdvvdu3fRoEEDbNiwAQkJCbh69SqeeOIJs2O6du2Ka9eu2byr050wCD3k3n77bdSvXx/169fHtm3b0KBBA2i1WgwePBg///wzJk6ciGXLliE0NBTDhw+X3iCuX7+O0aNHo2HDhlixYgXmzZuHK1euYMSIETAajRg9ejTat2+PSpUqYdu2bejQoYPV8xuNRrz22mvo3r07Vq1ahaioKMyfPx+///47ANObwODBg3H8+HG8+eabeO+993Du3DmsW7euyHplZmbipZdewqFDhzB58mQsW7YMHh4eePnll0v8C//999/D29sbK1aswPDhw/H0009j7969yMjIkI65dOkSzp07h169egEAvv32W4wZMwa1atXCxx9/jLFjx+Kbb77B6NGjixyLMXPmTOmDZcWKFejfvz82b95s8bjTp09j7dq1GD9+PD7++GMoFAqMGzcOaWlphT73li1bMHXqVDRo0ADLli3DiBEjsGnTJsydO1c65u7du5g6dSr69euHxYsXw9PTE8OGDSv0Dbi44uPj0adPHyQkJGDGjBmIjY2FTCbD4MGDcfjwYanbtFKlSmjfvr30s1gUvV5v8e9B41xWrlyJp556CkuWLEHXrl2xevVqfPbZZxgzZgzWrVuHl156CWvXrsWKFSsA5HfTPPfcc9LX4vibb7/91qI8cXFxeOqpp+Dh4WFx7oyMDAwfPhwBAQFYunQpFi1ahOzsbAwbNgzp6ekWx1v73RT5+fmhdevWFmHshx9+QJUqVRAZGWl2u/j7VNgfDx4eHpg5cyZatmxp9f63334bzz33nPSajB49Gjk5OejXrx++/fZbDB8+HMuXL0fTpk3x1ltvYeXKlWaP37JlCyIiIrB8+XLpeQpT8HrqdDokJSVh9erV2L9/v/T7BQCxsbFYvnw5+vbtizVr1mDOnDlITU3FhAkTkJ2dDcDUQjdgwABotVrMnz8fs2fPxunTpzFs2DDo9fpivdctW7bM7OcyODgYgCmIrVu3DvPmzcP06dNRu3Ztm5Tp/tdi4sSJOH36NNatW4fHHnvM6msWGhqKmJgYxMXFmd2+e/duCIKAHj16SH+k3h+EH330UQDAlStXirwuVDh2jT3k6tSpAx8fHwD5TdKff/45zp07h88//xyNGjUCALRr1w4DBw5EbGwsvvzyS5w8eRI5OTkYOXIkQkJCAJh+GX/++WdkZWWhevXqCAwMNOvCsNYaIggCRo8ejeeffx4A0LRpU/z444/47bff0LZtW3zzzTe4fPkyvvzySzRs2BAA0KJFC3Tu3LnIeomtUTt37pTePKKiotC7d28cOXKk0Dd8a1QqFWbPng21Wg3A1H2xdOlS/PTTT+jduzcA0wBEPz8/dOrUCYIgIDY2Fm3btkVsbKz0PDVq1MCQIUOwd+9eq8EwPj4e27dvx6RJk6RB5q1bt0ZwcDCmTJmCffv2oX379gBMf4nv2LFD6krx8vLCgAEDpMHG9zMajfj444/RuXNns+CTnZ2NuLg4qQUkOzsbs2bNkuolvtarVq3CokWLiv2a3W/ZsmVQq9XYuHGj9PPWoUMH9OzZE/Pnz8f27dvRuHFjqNVqBAYGPrDb67///rMalAq+dtY0a9YMQ4cOlb5///330bBhQzz77LMAgJiYGGg0Gvj6+gLI/50IDQ01K9Ozzz6L9957Dzdu3ECVKlUAAPv27cOdO3cK/aCPj49HSkoKBg0ahKioKABArVq1sG3bNmRmZkrnFFn73RS7pwDgySefxJtvvmnWPRYXF4fu3btbnPvmzZsAUOpxPXXq1EFoaKhZWbZu3YoLFy7g//7v/9CkSRMApq4WvV6P5cuX48UXX0SFChUAAFWqVMEbb7xRrHNZu65VqlTBuHHjzK6t2FJcsNXPw8MD48aNw/nz59G4cWOsXLkSFSpUwLp166RwGhwcjEmTJuHixYs4derUA9/r6tevX+jP5auvvmr2u2yLMomMRiOmTZuGQ4cOYf369Q/8w6BXr1548803zX4m4+Li0KpVK1SqVEn6w038mRJ5e3sDgNkfdlQybBEqhw4cOIBKlSqhQYMG0l9mBoMBHTt2xOnTp5GWloZGjRrBw8MDzz33HObNm4fff/8d9erVw8SJEy1+0R5EfBMFIL3hiKHp4MGDeOSRR6QQBJh+kTt27Fjkcx47dgzVqlUz+wtKo9Hghx9+kEJXcdWqVUsKQQDwyCOPICoqCrt27ZJui4uLQ7du3aBWq3H58mUkJiaiU6dOZn/dRkdHw8fHB/v377d6nsOHDwOARbdGjx49oFAozLpGAgMDzcaTiB9S4l+d97ty5Qru3Llj0Sw+bNgw7NixAyqVCgCgVCrRs2dP6X5PT0+0a9cOR44cKfwFKobDhw+jY8eOZj8bSqUSPXr0wOnTp5GZmVmi56tUqRK2b99u8e+ZZ54p8nH3/0XdvHlz7N+/H/369cOaNWsQHx+PAQMGmLU8WPP0009DqVTiu+++k2776quvpBYca8LCwhAYGIhXX30VM2fOxI8//oiKFSti8uTJ0vUric6dO0OhUEjdY7du3cLRo0fNrp9IoVAAMLVi2Mrhw4dRtWpVs99fwPTaaLVa/P3339JthbVkWCNey02bNuHxxx+Hj48PZsyYgTFjxkg/pwDw4YcfYvDgwbh79y6OHj2KL7/8Et988w0ASN29x44dQ7t27cxa6Jo0aYJffvkFjz32WLHe64pyf71sUSZRbGwsvv32WwwaNAgRERHS7Uaj0aIlFDAN5Pfw8JDel27evIljx45JP8tGo7HIusjl/DgvLbYIlUOpqalITk4u9C+Q5ORk1KlTB5s3b8aqVauwfft2bNy4EX5+fujXrx9ee+21Eg2m9PT0NPteLpdLXRwpKSlWZw8VNaNIrMODjiku8S+mgnr16oU5c+YgJSUFCQkJuHbtGt59913p3AAwe/ZszJ492+Kxt27dsnoe8U23UqVKZrcrlUoEBASYdZ9oNBqzY8TXu7A3O7FMD3pNKlasCKXS/Nc6KCjIrCWiNNLS0lCxYkWr5xMEARkZGVZf58Ko1WqzD4fiun8MzPDhw+Ht7Y0vv/wSsbGxWLBgAcLCwjBjxgy0aNGi0OcJCAhAp06d8O2332LEiBFIS0uTZl8VxtvbG1u2bMGKFSvw/fffY9u2bfD09ESvXr0wY8YMs7BdHD4+PmjXrp00e2z37t2oU6cOwsLCLMZXVa1aFQBw48aNQgeRJyUlITg4uNi/u2lpaRY/qwCk63zv3j3ptsLGHllT8Lo2a9YMQ4YMwYQJE7BhwwY0a9ZMuu/UqVOYPXs2Tp06BY1Ggzp16kgtIeL7x4PeB4rzXnf/gPiC7q+XLcokunLlCqKjo/Hpp5+ib9++Usv7xx9/bDFj8vz58/Dx8UHnzp0RFxeH4cOHY9euXdBoNFLrudjieP8fHYW1FFHxMQiVQ76+vqhRo4ZZt05BYvO6OOBUp9Ph2LFj2LZtG1auXIl69eoVOrW4pEJCQqyO6blz506Rj/P19bUY0AsAx48fh7+/vxS+7v8L+UGDmUVPPvkk5s6di59++gmXL19G1apV0bRpUwCm8RsAMGXKFKtTbgt7YxVvT05Olj64ACA3NxcpKSkICAgoVtmsEct09+5ds9tTUlJw5swZ6a96a4Hn9u3b0ht3YYHrQS06/v7+uH37tsXtycnJAFCmupWFXC5H//790b9/f9y5cwd79+7FypUrMW7cOOzfv7/IcPLcc8/hlVdewYULF3Ds2DHIZDI89dRTRZ6vVq1aWLBgAQwGA06ePImvv/4an332GapXr17ouklF6d69OyZPnoy7d+9i165dhc78adOmDQBg7969VoOQXq9Hr169EBUVheXLlxfr3P7+/rh27ZrF7ba8pnK5HO+99x569OiBadOmIS4uDh4eHtJ4q/DwcMTFxaFWrVqQy+XYu3cvfvjhB+nxvr6+Fj/zgOl1eOyxx4r9XlcctiqTaM6cOYiJicGTTz6J2bNnS9flhRdeKHTM5dNPP40RI0bg2rVriIuLQ9euXaU/mmrWrAkAuHbtmlmrpXgNa9euXey6kjm2pZUD9zeJxsTE4ObNmwgKCkJERIT0b//+/VizZg0UCgU2bNiAjh07QqfTQa1Wo2XLlpgzZw4A01+d1p63NGJiYpCQkGA2WDcnJ0ca/FmYZs2a4fr162Z97lqtFuPGjcP27dulv34KztTIzc3FyZMni1UuPz8/dOzYET///DN++OEHPP3001JIqFWrFoKCgpCQkGD2+oWEhODDDz/EmTNnCq0rAIsBj3FxcTAYDFLQKo1atWohICAAv/76q9ntX3/9NUaMGCGNEbr/tc3JycG+ffukMVXi65aYmCgdc+nSpQe2GEVHR+PXX381G4dgMBgQFxeHiIiIEreG2MqLL74ojZkKCgpCnz590L9/f9y7d08qa2E/x23atEFoaCj27NmD77//Hl26dJECpzW7d+9GixYtkJycDIVCgSZNmmDWrFnw8/OTfmfu96DfoY4dO0KtVmPz5s3466+/Cg1CYWFhaNeuHVavXo3r169b3P/JJ58gJSUFTz/9dJHnKyg6Ohr//fefNBNT9M0330ClUlkM2C6tqlWrYvTo0bh+/TpWr14NALh8+TJSU1MxaNAg1KlTR3qdxJmTYlBv1qwZ9u/fb7au0pkzZzBixAj8888/xXqvA4r3XmarMokqVqyISpUq4fXXX8fPP/8sLeIZEhJiVtaCLWht2rRBxYoVsXHjRvzzzz9mXbyPPvooqlWrZhbKAGDPnj2oUaOG3daFcgdsESoH/Pz8cOLECRw4cAD169dHnz59sHnzZgwdOhSvvvoqKleujD///BOrV6/GgAEDoFKp0KJFC8TGxmLMmDEYMGAAFAoF/u///g9qtVoav+Pn54fbt29b/KVTEj179sSqVaswZswYTJgwAX5+fli/fj3u3LkjNTlb06dPH2zatAmjRo3C+PHjERAQgI0bNyI3Nxf9+vWDv78/mjRpgk2bNuHRRx+Fv78/Nm7ciJycnGI34z/99NMYP348DAaD2RuOQqHAxIkTMXPmTCgUCnTs2BH37t3D8uXLkZSUVGgzfJ06dfDMM89gyZIlyM7ORnR0NM6ePYtly5ahefPmaNu2bclevALEWWXvvPMOgoKC0KlTJ1y5cgVLlixB//79zVqppk+fjtdeew1BQUFYu3YtsrKypGUBmjdvDk9PT7z//vuYMGECMjMzsWTJEmlQbGHGjh2Lffv2YdCgQRgxYgRUKhU2b96M69evY82aNaWuV1lFR0dj3bp1qFixIpo0aYKkpCSsX78eMTEx0gBkPz8/HD9+HEeOHEGzZs2kwCuXy9G7d2989dVXuHHjBtavX1/kuaKiomA0GjFmzBiMGDEC3t7e+P7775Geno4uXbpYfcz9v5v38/LyQvv27bFq1SpERkbikUceKfT8s2fPxuDBg/HCCy9g0KBBaNSoETIzM7F7927ExcXhxRdfRLdu3Yr70qFPnz7YunUrxowZg/Hjx6NatWr45Zdf8OWXX2Ls2LFFhsKSGjJkCLZv347Vq1fjmWeeQc2aNeHj44OVK1dCqVRCqVTihx9+kKbui2PlRo8ejb59+2LkyJEYNGgQcnJy8NFHHyEyMhKtW7eGXq9/4HsdYLoOZ86cweHDhwsNeLYq0/3BUlz5e968eWjVqlWRXXUKhQI9evTA5s2bERISgubNm5vdP2bMGEyfPh0VKlRAp06dpIBVlokQxBahcqF///5QqVR45ZVXsG/fPnh5eWHLli1o2rQpFixYgFdeeQV79uzBpEmTMH36dACmtURWrlyJjIwMvP766xg7dixSU1Oxbt061KpVC4DpjbJq1aoYM2YMvvrqq1KVTalUYu3atahfvz5mzZqFKVOmICwsDE888USRgcXHxwebN29Go0aNMGfOHLz22mswGo3YuHGj9GEhzhiaMWMGpk+fjgYNGmDw4MHFLlv79u3h6+uLiIgIqdlZ9Pzzz+PDDz/E8ePH8eqrr2LWrFmoVq0aNm3aVOSH1bx58zBmzBhp7MmWLVswaNAgrF69uswtbP3798f777+PQ4cOYeTIkdiwYQNeeeUVTJkyxey4WbNmYfny5Zg4cSLUajU+++wzaYqtn58fli5dCoPBgDFjxmDx4sUYM2aM2WB2a8LCwrB161YEBQVh+vTpmDx5MgRBwMaNGx+4eKI9TZgwAa+++iq+/PJLDB8+HO+//z7atGmDJUuWSMe8+uqrOH36NF555RVp9pXoueeeQ0JCAqpWrfrAlYeDg4OxZs0a+Pr64q233sLIkSPxzz//YOnSpYWOR7r/d9Oa7t27Izc31+pssYKqVKmCbdu24YUXXsB3332HMWPGYMaMGbhx4wY+/PBDzJo1q8jH30+j0WDTpk3o2LEjFi9ejFGjRuHYsWOYN28exo0bV6LnehC1Wo0333wTOTk5+OCDD+Dr64vly5dDEARMmDABU6ZMwY0bN7B582Z4e3vj6NGjAID69etj06ZN0Ov1eO211zB37lw0bdoUn3zyCdRqdbHe6wDg5Zdfxu3btzFs2DCcPn3aahltVab7yeVyvPPOO0hJSSnWNh+9evWCwWBAz549Ld4z+vTpg9mzZ+PPP//EmDFjcOTIEXzwwQcP/NmhoskE7kRHdnTx4kVcvnwZXbp0MRvE+dxzzyE0NLTQbRao5JYuXYply5bh/Pnzzi4KEdFDg11jZFdZWVmYMGEC+vXrhyeeeAIGgwG7du3C6dOni70uCRERkb0wCJFdNWrUCB999BHWrl0r7ZBdv359rFmzpsjpzURERI7ArjEiIiJyWxwsTURERG6LQYiIiIjcFoMQERERuS0GISIiInJbbjNrTBAEGI3uNy5cLpex3m6E9XYvrLd7ccd6y+WyEm0CXhpuE4RkMhnu3cuCXm99d+/ySKmUIyDAm/V2E6w36+0OWG/3qndgoDcUCvsGIXaNERERkdtiECIiIiK3xSBEREREbotBiIiIiNyW2wyWJiKih5PRaITBoM/7WoacHAV0Oi0MBveZQVUe661QKCGXO789hkGIiIhckiAIuHfvLrKzM8xuv31bDqPRfWZOicpjvTUaH/j5Bdp9inxRGISIiMgliSHIxycAarWH9GGpUMjKTatISZSneguCAJ1Oi4yMFACAv3+Q08rCIERERC7HaDRIIcjHx8/sPqVS7lZr6YjKW73Vag8AQEZGCnx9A5zWTeb8zjkiIqL7GAwGAPkfllQ+iddXHAPmDAxCRETkspw5doTszxWuL4MQERERuS0GISIiInJbDEJEREQEABg7dgTmzZvl7GI4lEsGIaPRiCVLlqBt27Zo3LgxXnnlFVy/ft3ZxSKiEjAaBew6eA3x/6U5uyhERIVyySC0fPlybN26FXPmzMH//d//wWg0Yvjw4dDpdM4uGhEV0/nrqdj+2yVs/fGCs4tCRFQolwtCOp0O69atw/jx49GhQwfUq1cPixYtQmJiIvbs2ePs4hFRMaWma03/Z2idXBIqTwRBgFZncNo/QSj5goZt2jTD2rWf4Nlne6JXr664fv1f5ObmYvnyJejd+0k88URbjBgxBIcPHwQAXLoUjzZtmuH8+XPSc0yf/gYef7ydtKyA0WhEz56d8cMPuwAA3377FQYPfhGdOrVG585tMHr0cJw7d0Z6/HPPPYVlyz7CgAHPo0ePx3HixDHodDosWfIhevZ8Al27tsfy5Uss6rd16ya88EIvdOzYEs8//zQ2bFhTqtfAlbncgornzp1DZmYmWrZsKd3m5+eH+vXr48iRI+jZs6cTS0dExZWenQsAyMjOhSAILjFNlh5ugiDgvc3HndrdWqeaP6b3jyrxz/POnV8gNnYJ9HoDHnmkOmbNegvXrl3BzJlzUKlSMPbv34cpU17Du+/GolWrNqhcuQqOHDmI8PB6MBgMOHHiKLKyMnHhwjk89lgDnDnzD9LT09GyZRvs3fsrFi2aj6lTZ6BRoya4ffs2PvpoAd5/fy42bNgqlWHHjs/xwQeL4Ovri1q16uCjjxZg//7f8dZbbyMkpDI2blyHv/8+gSpVqgIA/vhjHzZtWo933nkXjzxSA//8cxJz576NypWroGvX7jZ9XZ3J5YJQYmIiAKBy5cpmtwcHB0v3lZZC4XINYHYl1pf1dg+uVu+sHFMQ0hsE6I0CNB4Ku5zH1ertKOW93kaj9aDxsObprl27o169+gCAhITr+OmnH7B+/RaEhYUDAF58cQDi4y9i69aNaNWqDVq3bosjRw5hwIAhOHv2HyiVKjRsGIkTJ47iscca4MCBP9CoURP4+fnB398f06b9D126PAkACA2tjJ49n8bChfPNytCiRWtERzcHAGRlZeL777/DpElT0bJlGwDA9Okzcfz4Uen4GzcSoFarEBpaBaGhoQgNDUXFisEICQm1+eujUMigVFr+LDviertcEMrOzgYAqNVqs9s9PDyQlla2vwL8/DRlevzDivV2L65S79wCOwEo1CoEBHjZ9XyuUm9HK6/1zslR4PZtucUH5IzBzaDLdd42E2qVvFStm9WrPyrV49Il07i50aOHmx2j1+vh4+MLpVKOtm3b45tvdkKv1+HYscNo1iwalStXwfHjRzFo0FAcOLAfPXr0hFIpR7NmzXDlymVs3LgWV69eRULCv4iPvwij0Wj22lWvXl36/r//riM3NxcNGjSUblMqNQgPrweZzPSad+/eA3Fx3+Cll/qgZs1aiIlpjo4dO6NatSqleu2sMRplkMvl8Pf3gqenp82etyRcLgiJL4ROpzN7UbRaLTSasv3C37uXDYOh/OzT8iAKhRx+fhrW2024Wr1vp2ZJXyfcTINaZp9xBa5Wb0cp7/XW6bQwGo0wGASz/bVkMsBDrYDBYIQzhqqYNj0t+YlVKrVUD73eNM7n449Xw8vL2+w4udy0n1ijRlFQqVQ4evQoDh8+hG7duqNKlarYvn0bEhL+w8WL59Gq1Xzo9Ubs2bMb8+a9jS5dnkSDBhF4+ulncPnyJSxc+IHZa1ewDOLmrXq9wewYhUIBQTC95j4+/li/fitOnz6JI0cO4dChA9i27TMMGzYSQ4e+UuLXwBqDQYDRaERaWhaysw0W9/v7a+y+B5nLBSGxS+zWrVuoXr26dPutW7cQHh5epuc2GIzlasO64mK93Yur1Ds9M3+WZ1qG1u5lcpV6O1p5rXdhu6yL4edhHq9bs2ZtAMCdO7dRt2496fZPPvkYCoUCw4e/CqVSiZiYlvjjj704c+Y03nzzbYSEBMNgMGDt2k9Qq1YdVK5sapnZsmUDnnqqN954Y7r0XL//vhcACh2fV736o1CrPXDy5N9S95xer8fFixcQFdUMALBnz/dIT0/Hs8++gMjIxhg2bCQ++GAufv55j82CkOj+wCtyxHV2uc7levXqwcfHB4cOHZJuu3fvHs6cOYPo6GgnloyISkIcLA0AGVm5RRxJ5F5q1aqNVq3aYsGC9/DHH/vw338J2LLlU2zevAFVq1aTjmvTph127foWFStWQtWq1eDp6YmGDSPxww+70LZte+m44OAQnDr1N86fP4f//kvAtm1bsGPH5wBQ6LIzXl5eeO65F7Bu3SfYu/cXXLt2FbGx7+H27WTpGJ1Oi48/Xozdu+Nw8+YN/P33Xzhx4jgaNoy00yvjHC7XIqRWqzFgwADExsYiMDAQVatWxYIFCxAaGoouXbo4u3hEVEwFw0/BUEREwDvvvIdVqz7GggXvIj39HqpUqYZp0/6HJ5/MnxndsmVrGAwGqYUGAJo1i8Hx40fRpk1+EJo4cQrmz5+HsWNHQK1WoU6dupgxYzbefvtNnDt3Bo0aNbFahpEjx0Kt9sDChR8gKysLnTo9gdat20n39+zZG2lpadiwYQ1u3UqCr68vOnR4HKNGjbfDK+I8MsEFFwQwGAxYuHAhduzYgZycHERHR2PmzJmoVq3agx9chJSUzHLZhFwYpVKOgABv1ttNuFK9BUHAiAW/wWA0vb30bPUo+rSrbZdzuVK9Ham81zs3V4c7d24iKKgyVCrzyTNKpbxc1vlBymO9i7rOABAY6G33mZEu1yIEmAZrTZ48GZMnT3Z2UYioFHJ0BikEAUBGtt6JpSEiKpzLjREiooff/V1hGVncHoeIXBODEBHZ3P2DozM4RoiIXBSDEBHZXEa2eQsQB0sTkatiECIim0vPaxHy81IB4PR5InJdDEJEZHNiV1hooJf0vQtOUCUiYhAiItsTg1BIXhAyGAXk6CyXzycicjYGISKyOTEIBfl5Qq0yvc1wnBARuSIGISKyOXFMkI+XCr4ajhMiItfFIERENie2/vhoVPDRmFaLvX8mGRGRK2AQIiKbE7vGfDUq+OTNHEtnixCRS9Dr9di2bYv0/dq1n+C5556y+Xns9by2xiBERDYnriTtrVHBR+wa4xghIpfw44+7sXTpImcXw2UwCBGRTQmCIO0t5uulZhAicjFcysKcS266SkQPr2ytHsa8N1ofjTJ/sDSDENmAIAgQcrUQnLULu1INmUxWooccOLAfa9asxNWrl6HReKFly9YYN+51xMdfwMSJY/DOO+9j5cqlSEpKQsOGEXjrrVn47LNN2L07DkqlCs8//yIGDx4mPd/333+H//u/Lbh+/V8EBgaiZ89eGDhwKBQKBQAgKSkRn3zyMY4ePYysrExERjbG6NETUKdOGHbt+hbvvjsbANCmTTMsWbJSet7Nmzfgyy8/R1paGho0aIgpU97CI49UBwBkZGTg448X4/fff0Vubi7Cwx/D6NHjUa9efenxX3+9A1u3bkRycjKio2NQuXKVUr/MjsQgREQ2JQ6U9lAroFIqpDFCnDVGZSUIArK+mQdjUrzTyqAICYPm6TeLHYZSU1Px1luTMXbsRLRq1Qa3biVhzpy3sXz5YnTp8iQMBgM2blyHt9+eC71ej8mTX8OQIf3Qs2cvrFr1Kfbs+R6rV69AmzbtER5eF59/vhUrVy7D2LETER3dHGfOnMbChR8gLS0NEyZMQlZWJkaNGoYqVari/fc/hEqlxrp1qzB27CvYsOEzPP74E8jIyMCSJR/i6693w8/PHydOHENi4k2cOvU3FixYjNxcHebMmYn335+Djz9eDUEQMHnyeKjVnvjgg4/g4+OD3bvjMGrUMHzyyXrUrVsPP/64GwsXfoAJE95As2Yx2LfvV6xatRzBwSF2viJlx64xIrIpMfCILUFi1xjXESJbkKFkrTHOlpycBJ1Oh5CQUISGVkZkZGN88MFCPPtsX+mY4cNfRb169dGwYSSaNo2GRqPB6NHjUb36oxg4cAgA4PLleAiCgM2bP0WfPi+gT5/n8cgj1dG1a3cMG/Yqdu78AhkZGfjhh++RlpaKOXM+QP36DREWVhezZs2Fh4cnduz4HB4envDx8QEABAVVhEpl+v1UKpWYOXMO6tQJw2OPNUCvXn1w7twZAMCxY0dw+vQpzJnzHho0aIhHH62BkSPHoEGDCHzxxf8BALZv34bOnbugT5/nUb36oxgwYAhat27rwFe69NgiREQ2VXDqPAB2jZHNyGQyaJ5+E0rooX9IusbCwsLRuXNXTJ06EUFBFREd3RytWrVFu3YdcPLkXwCAatUekY7XaDSoXLmKdA4PD08AQG5uLlJSUnD37h1ERjY2O0eTJlHQ6/W4du0qLl2KxyOPPIqAgADpfg8PT9Sv3wCXLl0qtJyBgUHw9vaRvvf19YNWqwUAXLhwDoIg4Nlne5o9RqfTScdcvhyPzp27mt3fsGEkLl68UJyXyakYhIjIpqTFFPMCkLe0oCLXEaKyk8lkkCk9IJM5KQiVwqxZ8/Dyy6/g4ME/ceTIIcyZ8z9ERjaWxv0oleYfxYUFrcIGORuNQoHnKewYI5RKRaFllMsL7yAyGo3w9vbG2rWbLe4TW5QAGQTB/JrcXy9Xxa4xIrIpseVHHBvk6yUuqKjnbBVyO//8cxpLlnyI6tVr4IUX+mHBgsWYPn0mjh07gpSUlBI9V1BQEAIDg6SWJNHff5+ASqVC1arVULt2GK5fv4aUlLvS/VqtFufOnUWNGrUAFB60ClOrVh1kZmYiNzcX1ao9Iv3bsuVT/PHHXgBAWFhdnDz5t9njzp07W6LzOAuDEBHZVMZ9XWM+GtNfhUZBQLZW77RyETmDt7c3duz4AsuXL0FCwnVcvhyPn3/eg2rVqqNChQolfr6XXhqIHTs+x86d25GQcB179uzGunWr8PTTz8DHxwdPPNEN/v4V8L//TcPZs/8gPv4i3nlnBrKzs9GrVx8Apu43wBRUtNqcB56zefOWCAuri7ffno7jx48iIeE6li5diF27vpXC1YABQ7Bv36/YunUjrl//F9u3/x9+++3nEtfPGR6OdisiemiIW2mIY4NUSgU81ApodQakZ+fCy1NV1MOJypUaNWpi3rwFWL9+NXbu/AJyuRxRUdH48MMlSEpKLPHzvfTSAKjVKmzbthWLF8ciODgE/fsPRr9+AwEAPj4+WLr0Eyxb9hEmTBgNAIiMbIQVK9aiSpWqAICoqGjUr98Qo0a9jP/9b84Dz6lQKLBo0XIsX74YM2dOQ3Z2NmrUqIV58xagadNoAECrVm3w9ttzsW7dKqxZsxINGkTgxRcH4Mcfd5e4jo4mE9yorTolJdN5A+ycQKmUIyDAm/V2E65S76VfnsSJi7cxsGs4OjYxvfFOWfEnbqfl4K2BTVG7qr9Nz+cq9Xa08l7v3Fwd7ty5iaCgylCp1Gb3KZXyclnnBymP9S7qOgNAYKA3FAr7dl6xa4yIbKrgPmMiTqEnIlfFIERENiUGIW8rQYiLKhKRq2EQIiKbstoi5MW1hIjINTEIEZHNGAXBYvo8AG68SkQui0GIiGwmK0cPcfqFT4EWofzVpbmoIpWMG83ncUuucH0ZhIjIZsQWH42HAsoCMz188hZVTOcYISomcSd1nU7r5JKQPYnXV6Fw3mo+XEeIiGzm/u01RNxvjEpKLldAo/FBRoZp9WW12kNaEdlolMFgcH5LgqOVp3oLggCdTouMjBRoND5FbvFhbwxCRGQz6XldX/cHIW8GISoFP79AAJDCkEgul8NoLF/r6RRHeay3RuMjXWdnYRAiIpvJ317DfGE0tghRachkMvj7B8HXNwAGg2l7FoVCBn9/L6SlZZWb1pHiKI/1ViiUTm0JEjEIEZHN3L/PmKjg9HmjIEBewk0fyb3J5XLI5aZwrVTK4enpiexsQ7lbZbko7lpvR3B+FCOickMcI+TrdV8QygtGgmCaWUZE5CoYhIjIZtILaRFSKuTQeJhmAbF7jIhcCYMQEdlMYbPGCt7GbTaIyJUwCBGRzRQ2RqjgbelcVJGIXAiDEBHZjLTPmJe1IKQ2O4aIyBUwCBGRzRSnRYhBiIhcCYMQEdmE0SggU9pwVW1xv9hKxDFCRORKGISIyCYyc3IhLvPm7Wm5RFn+GCEGISJyHQxCRGQT+RuuKs02XBVx1hgRuSIGISKyCXFneV8r44MAjhEiItfEIERENpE/Psh6EPL1YhAiItfDIERENlHYqtIitggRkStiECIim5DWECosCOXNJMvMzoXRWD52zyaihx+DEBHZhLS9RiFdY+JMMgGmGWZERK6AQYiIbELcOqOwrjHTxqumMMTuMSJyFQxCRGQTRW24KhK7zdI5hZ6IXASDEBHZREaOGIQsV5UWid1mmWwRIiIXwSBERDYhtghZ23BVxNWlicjVMAgRkU0UteGqyJdT6InIxTAIEVGZGYxGZOboARQ+a6zgfdxmg4hcBYMQEZVZZrZe+trahqui/K4xnd3LRERUHAxCRFRm4pgfb08lFPLC31a48SoRuRoGISIqs8xijA8y3W+aUZbBBRWJyEUwCBFRmaU/YFVpkS/HCBGRi2EQIqIyy8gb8+NbxBpCADdeJSLXwyBERGVWnKnzQIEFFXP0MBiNdi8XEdGDMAgRUZmlF2N7DcB8RlnBmWZERM7CIEREZSa1CD1gjJBCLpfCEFeXJiJXwCBERGVW3K6xgsdwvzEicgUMQkRUZmIQ8i1OEPLiDvRE5DoYhIiozDKKOX0eyJ9ZlsHVpYnIBTAIEVGZpZeia4xT6InIFTAIEVGZ6A1GZGvzNlwtQRBi1xgRuQIGISIqE3HQswyAt2fxxwixRYiIXAGDEBGViRhovDUqyOWyBx7PrjEiciUMQkRUJiWZOg/kzyxjECIiV+DwIHTs2DGEh4db/Dt06JB0zIEDB9CnTx80atQI3bp1Q1xcnKOLSUTFVNwNV0U+3HiViFyI8sGH2Nb58+dRvXp1bN261ex2f39/AMClS5cwcuRIDB06FAsWLMBvv/2GKVOmIDAwEC1btnR0cYnoAUqyhhBQYLA0W4SIyAU4PAhduHABderUQaVKlaze/+mnnyI8PBwTJ04EANSuXRtnzpzBmjVrGISIXFB6gTFCxSEGoWytHnqDEUoFe+iJyHkc/g50/vx51K5du9D7jx49ahF4WrRogWPHjkEQBHsXj4hKSOziKm6LkLenCuKQam6zQUTO5vAWoYsXLyIgIAB9+vRBUlIS6tati4kTJyIyMhIAkJiYiNDQULPHBAcHIzs7GykpKQgMDCz1uRVu9penWF/W2z04q95ZWlOY8fNRQ6ks3rm9NSpkZOciO9eAoGI+pjC83qy3O3DXessePBG1zGwahBISEvD4448Xev9vv/2G9PR0ZGVlYcaMGVAoFNi8eTMGDBiAHTt2oE6dOsjJyYFarTZ7nPi9Tle2Jfn9/DRlevzDivV2L46ud06uEQAQWtEHAQHexXqMv4+HaWyRQlHsxzwIr7d7Yb3JVmwahEJCQrBr165C7w8ODsaRI0eg0WigUpma0SMiInDmzBls2rQJs2fPhoeHh0XgEb/XaMr2A3DvXjYMBmOZnuNholDI4eenYb3dhLPqnXIvBwAgFwSkpGQW6zFeHgoAwM2ke6gWWLbfa15v1tsduGu9/f01kMvt2wpm0yCkUqmKHP8DAH5+fmbfy+Vy1K5dG0lJSQCAypUr49atW2bH3Lp1C15eXvD19S1T+QwGI/R69/kBErHe7sXR9b6XmfeHioey2OcVB0ynZehsVlZeb/fCersHRwwNdmhn4759+9CkSRNcv35duk2v1+PcuXOoU6cOAKBZs2Y4fPiw2eMOHjyIqKgou6dCIiq5ki6oCOTPMOMUeiJyNocmi6ioKAQEBGDq1Kk4ffo0zp8/j6lTpyI1NRVDhgwBAAwcOBAnT55EbGwsLl26hHXr1mH37t0YPny4I4tKRMWgNxiRozMAKFkQEmeYcdYYETmbQ4OQj48PNmzYgIoVK2LYsGHo27cvUlNTsXnzZlSsWBEAEBYWhuXLl2Pv3r3o3bs3vvjiCyxYsIBrCBG5ILE1SCYDvDyL39Muri7NHeiJyNkcPn2+evXqWLJkSZHHtGvXDu3atXNQiYiotMQ1hHw0KshLMM+VG68SkavgoBsiKrX0UowPAgBfjWlJjIzssi2JQURUVgxCRFRqJd1nTMSuMSJyFQxCRFRqGVmmFp3i7jMmYtcYEbkKBiEiKjWpRcirdEEoR2eA3o0WhyMi18MgRESllj9GSP2AI815eSqlPYTYKkREzsQgRESlVprFFAFALpPld49xnBARORGDEBGVmhhiSto1BuSHJ64uTUTOxCBERKVW2unzQP5MM3aNEZEzMQgRUakVXFCxpLylrjGuJUREzsMgRESllpGTF4RK0TUmdqexRYiInIlBiIhKJVdvgDZvw9WSLqgI5M804xghInImBiEiKpWMbD0A0wwwjUfJty3koopE5AoYhIioVNLzxvb4eKkgK8GGqyKpa4zT54nIiRiEiKhUSrvPmIjT54nIFTAIEVGpiEGopPuMibigIhG5AgYhIiqVMrcIiV1jOQxCROQ8DEJEVCrSGkKlmDoP5Acorc6AXL3BZuUiIioJBiEiKpWyrCoNABoPJeR5g6zFGWhERI7GIEREpVLWrjGZTCa1JqVzdWkichIGISIqlYwC0+dLi/uNEZGzMQgRUamUtWsMKLDfGIMQETkJgxARlUqmFITUpX4OtggRkbMxCBFRqUgtQmXoGvPh6tJE5GQMQkRUYtpcA3S5RgClHywNcHVpInI+BiEiKjGxW0whl8FTrSj187BrjIicjUGIiEosPSt/oHRpNlwV5XeNcfo8ETkHgxARlViGDcYHAewaIyLnYxAiohIr62KKInHGWSaDEBE5CYMQEZVYhg3WEALyW5TYIkREzsIgREQlli6tKl36NYSA/BYlXa4R2lxuvEpEjscgREQlZqsWIU+1Agq5abA1u8eIyBkYhIioxGwVhGQyWf6AaS6qSEROwCBERCUmhpayDpYGCkyhZ4sQETkBgxARlVimjabPA1xUkYici0GIiErMFjvPi3wYhIjIiRiEiKhEBEGw2TpCQP7Ms3SuLk1ETsAgREQloss1Ildv2nDVFl1jbBEiImdiECKiEknPNrXcKBUyeKhKv+GqiEGIiJyJQYiISqTg1PmybLgq8uX0eSJyIgYhIiqR/CBUtlWlRWL3GhdUJCJnYBAiohLJENcQssH4IIA70BORczEIEVGJ2HLqPGC+jpAgCDZ5TiKi4mIQIqISEVuEbDFjrODz5OqN0OUabfKcRETFxSBERCUijRHytE0Q8lApoFSYBl2LM9KIiByFQYiISiTdhttrAOYbr3IKPRE5GoMQEZVIpg1XlRaJM9AYhIjI0RiEiKhE0m08RgjIn4GWwbWEiMjBGISIqEQy8sbx+NpoHSGAU+iJyHkYhIio2ApuuGqr6fNAfusSW4SIyNEYhIio2HJ0BugNprV+bBqEPDlYmoicg0GIiIpNDCoqpRxqle3ePsQWIXaNEZGjMQgRUbHZesNVkTgDjfuNEZGjMQgRUbFl2GHqPFCgRYhjhIjIwRiEiKjYbL29hshXWkeIK0sTkWMxCBFRsdl6w1WRDzdeJSInYRAiomITW2zsFYT0BgE5OoNNn5uIqCgMQkRUbFLXmI2DkFolh0ppejviFHoiciQGISIqNmmwtJftVpUGuPEqETkPgxARFZs9VpUW+TIIEZETMAgRUbFJg6VtPGus4HNymw0iciQGISIqNjGk2HodIYAbrxKRczAIEVGx2GvDVVH+GCGuJUREjsMgRETFkq01wGA0rfHjbc8gxK4xInIgBiEiKpaMHFNAUavk8FApbP784kw0DpYmIkdiECKiYrHn+CAAnD5PRE7BIERExZK/qrRt1xASSRuvMggRkQMxCBFRsaTbacNVkS/HCBGRE9g1CM2cORPTpk2zuP3AgQPo06cPGjVqhG7duiEuLs7sfq1Wi9mzZ6Nly5Zo0qQJJk2ahLt379qzqET0APacMVbwebnxKhE5kl2CkNFoxMKFC7Ft2zaL+y5duoSRI0eibdu22LFjB55//nlMmTIFBw4ckI6ZNWsW/vjjDyxduhSffvopLl++jPHjx9ujqERUTPYOQuJMNINRQLaWG68SkWMobf2Ely5dwltvvYVr166hSpUqFvd/+umnCA8Px8SJEwEAtWvXxpkzZ7BmzRq0bNkSSUlJ+Oqrr7By5Uo0a9YMALBw4UJ069YNJ06cQJMmTWxdZCIqBmmfMTsFIQ+VAmqVHLpcIzJycuHlafO3JyIiCzZvETp48CBq166N7777DtWqVbO4/+jRo2jZsqXZbS1atMCxY8cgCAKOHTsm3SaqWbMmQkJCcOTIEVsXl4iKKcPOY4QAjhMiIsez+Z9c/fv3L/L+xMREhIaGmt0WHByM7OxspKSkICkpCQEBAfDw8LA4JjExsUxlUyjca2y4WF/W2z3Yu97iOkL+Ph5QKu1zDl8vNe7c0yJbpy/2OXi9WW934K71lsnsf44SBaGEhAQ8/vjjhd5/4MABBAYGFvkcOTk5UKvNp9+K3+t0OmRnZ1vcDwAeHh7QarUlKa4FPz9NmR7/sGK93Yu96p2VN26ncrAvAgK87XKOAD9PXE1Mh1EmK/E5eL3dC+tNtlKiIBQSEoJdu3YVer+/v/8Dn8PDwwM6nfleQuL3Go0Gnp6eFvcDpplkGk3ZfgDu3cuGwWAs03M8TBQKOfz8NKy3m7B3vdMy8v4QMRiQkpJp8+cHAA+V6a/dxOSMYp+D15v1dgfuWm9/fw3kcvu2gpUoCKlUKtSuXbtMJ6xcuTJu3bpldtutW7fg5eUFX19fhIaGIjU1FTqdzqxl6NatWwgJCSnTuQ0GI/R69/kBErHe7sUe9RYEQRq3o1Er7fa6enuaxgjdy9SV+By83u6F9XYPjlhJw+Gdjc2aNcPhw4fNbjt48CCioqIgl8vRtGlTGI1GadA0AFy5cgVJSUmIjo52dHGJCEC2Vg9j3juSj8Z+s7l8uc0GETmYw4PQwIEDcfLkScTGxuLSpUtYt24ddu/ejeHDhwMwdb/16NEDM2bMwKFDh3Dy5Em8/vrriImJQePGjR1dXCJC/rYXHmoFVErbb7gqEmekcdYYETmKw4NQWFgYli9fjr1796J379744osvsGDBArMp9XPmzEHLli0xduxYDBs2DLVq1cKSJUscXVQiymPvDVdF4mKN3G+MiBzFriuWbdq0yert7dq1Q7t27Qp9nJeXF+bOnYu5c+faq2hEVALpdl5VWsSuMSJyNPdakICISkVaTNHOQchbWlDRcuYoEZE9MAgR0QNJ+4zZcVVpwLSgoul8em68SkQOwSBERA9k7w1XReKMNKMgIFurt+u5iIgABiEiKoaMbFNXlb0HS6uUCnioTbPSOGCaiByBQYiIHihd2nDVcvsbW+PGq0TkSAxCRPRAYteYvVuEAE6hJyLHYhAiogcSg5C3A4MQW4SIyBEYhIjogdIdtKAiUGB1abYIEZEDMAgRUZGMgoDMHMdMnwcKtAgxCBGRAzAIEVGRsnL00g7Q9p4+DxRcXZqLKhKR/TEIEVGRxJYZjYcCSoX93zLEmWnpHCNERA7AIERERXLU9hoi7jdGRI7EIERERUrP66JyVBDyZhAiIgdiECKiIuVvr2H/xRQBtggRkWMxCBFRkRy1z5io4PR5IzdeJSI7YxAioiKJY4R8HTB1HsgPXIJgmrFGRGRPDEJEVKR0B7cIKRVyaDxMG6+ye4yI7I1BiIiK5OhZYwXPxW02iMjeGISIqEiOHiNU8FzpXFSRiOyMQYiIiiTtPO+gMUJA/gw1do0Rkb0xCBFRkZzZIsQgRET2xiBERIUyGgVkikHIyzHrCAH5rU8cI0RE9sYgRESFyszJhbiSj7en0mHnzR8jxCBERPbFIEREhcrfcFXpkA1XRZw1RkSOwiBERIUSd4D3deD4IIBjhIjIcRiEiKhQ+eODHBuEfL0YhIjIMRiEiKhQjl5VWsQWISJyFAYhIiqUtIaQo4NQ3gy1zOxcGI3ceJWI7IdBiIgKJW2v4eCuMXGGmgDTzDUiInthECKiQolbXDi6a8y08aopDLF7jIjsiUGIiArljA1XRWJ3XDqn0BORHTEIEVGhMnLEIOS4VaVFYndcJluEiMiOGISIqFBii5AjN1wVcXVpInIEBiEiKpQzNlwV+XIKPRE5AIMQEVllMBqRmaMH4PhZYwXPyW02iMieGISIyKrMbL30tSM3XBXld43pHH5uInIfDEJEZJU4NsfbUwmF3PFvFdx4lYgcgUGIiKzKdOL4INN5TTPVMrigIhHZEYMQEVmV7qRVpUW+HCNERA7AIEREVmXkjc3xdcIaQgA3XiUix2AQIiKrnDl1HiiwoGKOHgaj0SllIKLyj0GIiKxKd+L2GoD5TLWCM9iIiGyJQYiIrJJahJw0Rkghl0thiKtLE5G9MAgRkVXO7horeG7uN0ZE9sIgRERWiUHI15lByIs70BORfTEIEZFVGU6ePg/kz1jL4OrSRGQnDEJEZFW6C3WNcQo9EdkLgxARWdAbjMjW5m246gJBiF1jRGQvDEJEZEEcnCwD4O3p/DFCbBEiInthECIiC2Lw8NaoIJfLnFYOdo0Rkb0xCBGRBVeYOg/kz1hjECIie2EQIiILzt5wVeTDjVeJyM4YhIjIgiusIQQUGCzNFiEishMGISKykF5gjJAziUEoW6uH3sCNV4nI9hiEiMiC2BXl7BYhb08VxKHa3GaDiOyBQYiILDh7w1WRXC6TWqU4YJqI7IFBiIgsuMqssYJlYBAiIntgECIiC+LeXuJeX87EjVeJyJ4YhIjIgqtMnwe4lhAR2ReDEBFZcKWuMW9OoSciO2IQIiIzeoMROToDANcIQlKLELvGiMgOGISIyIzYGiSTAV6eSieXhhuvEpF9MQgRkRmx5cVHo4Jc5rwNV0WcNUZE9sQgRERm0l1ofBCQP3NNnMlGRGRLDEJEZMZV9hkTcfo8EdkTgxARmcnIMrW8OHufMRG7xojInhiEiMiM2DXm6wJrCAH5QShHZ+DGq0RkcwxCRGQmfw0h568qDZhmroljttkqRES2ZtcgNHPmTEybNs3i9qFDhyI8PNzs38CBA6X7tVotZs+ejZYtW6JJkyaYNGkS7t69a8+iElEeV1pMEQDkMll+9xjHCRGRjdllkRCj0YiPPvoI27ZtwzPPPGNx//nz5zFr1ix07txZuk2lyn/TnTVrFo4ePYqlS5dCrVbj7bffxvjx47F582Z7FJeIChDDhqt0jQGmUJaelcvVpYnI5mwehC5duoS33noL165dQ5UqVSzuv3PnDu7cuYNGjRqhUqVKFvcnJSXhq6++wsqVK9GsWTMAwMKFC9GtWzecOHECTZo0sXWRiagAV5s+D5hmsN0Eu8aIyPZsHoQOHjyI2rVr4+OPP8Zrr71mcf/58+chk8lQs2ZNq48/duwYAKBFixbSbTVr1kRISAiOHDlSpiCkULjXkCixvqy3e7BVvTPzwoa/jweUStd4DX29TeOVsrR6izLxerPe7sBd6+2INV1tHoT69+9f5P0XLlyAr68v3nnnHezfvx9eXl7o1q0bRo8eDbVajaSkJAQEBMDDw8PsccHBwUhMTCxT2fz8NGV6/MOK9XYvZa232OpStbIfAgK8bVGkMguq4AUA0AsotEy83u6F9SZbKVEQSkhIwOOPP17o/QcOHEBgYGCRz3HhwgVotVpERkZi6NChOHv2LObPn48bN25g/vz5yM7OhlptOVvFw8MDWq22JMW1cO9eNgxuNP1WoZDDz0/DersJW9RbpzdIG64ac/VIScm0ZRFLTa0w/VmYfDfToky83qy3O3DXevv7ayCX27cVrERBKCQkBLt27Sr0fn9//wc+xzvvvIOpU6dKx9atWxcqlQoTJ07ElClT4OnpCZ3Ocil9rVYLjaZsSdhgMEKvd58fIBHr7V7KUu+0dNPvnlwmg1ohd5nXz8vD9FZ1L1NXaJl4vd0L6+0eBMH+5yhREFKpVKhdu3bZTqhUWgSmsLAwAEBiYiJCQ0ORmpoKnU5n1jJ069YthISElOncRFS09LxVpX28VJC5wIarInEGG6fPE5GtOXzU1cCBAzF9+nSz206dOgWVSoUaNWqgadOmMBqN0qBpALhy5QqSkpIQHR3t6OISuRVX22dMJM5g4/R5IrI1hwehrl274uuvv8Znn32G69evY9euXZg/fz6GDRsGHx8fhISEoEePHpgxYwYOHTqEkydP4vXXX0dMTAwaN27s6OISuRUxCLnKPmMiLqhIRPZilwUVizJgwADIZDJs2rQJ7777LipVqoQhQ4ZgxIgR0jFz5szBu+++i7FjxwIA2rVrhxkzZji6qERuR9zh3eVahLy48SoR2Yddg9CmTZus3t6/f/8ip9l7eXlh7ty5mDt3rr2KRkRWiGsI+bjQqtJAfjDT5hqQqzdApVQ4uUREVF6418pMRFQkV1xVGgA0HkrI8wZvZ2TrnVwaIipPGISISOKqg6VlMpnUSiXObCMisgUGISKSZBSYPu9qxHDGcUJEZEsMQkQkcdWuMSB/JhuDEBHZEoMQEUkypCBkuc2Ns4ktQumcQk9ENsQgRESSDBedNQbklymTLUJEZEMMQkQEwDQ1XZdr2sPI1QZLA1xdmojsg0GIiADkt7Qo5DJ4ql1vnR4OliYie2AQIiIA+WNvfDSuteGqSFpdmtPniciGGISICIBrjw8C2DVGRPbBIEREAID0bFNLiyuODwLyZ7Kxa4yIbIlBiIgAAJl5W1e44hpCADdeJSL7YBAiIgD5W1f4eLneGkJAfkuVLtcIba7ByaUhovKCQYiIABRcTNE1W4Q81Qoo5KZB3FxLiIhshUGIiAC4fhCSyWT5A6a5ujQR2QiDEBEByA8XrjpYGuA4ISKyPQYhIgLg+tPngQL7jWVzLSEisg0GISIC4PpdY0B+2cQZbkREZcUgREQQBEEKQq7dNWaa0ZbO1aWJyEYYhIgIulwjcvWmDVdduWvMh/uNEZGNMQgRkTTmRqmQwUPlehuuihiEiMjWGISIyGx8kCtuuCry5fR5IrIxBiEiQoa087xrriot4vR5IrI1BiEiyh8o7cLjgwB2jRGR7TEIERHSH4Kp80B+11hGdi4EQXByaYioPGAQIqL8rjFXbxHKK1+u3ghdrtHJpSGi8oBBiIjyB0t7unYQ8lApoFSYBnNzdWkisgUGISLK7xpz8RahghuvcpwQEdkCgxARIfMhWFVaJM5sYxAiIltgECIiaV0eV28RAvJntmVwLSEisgEGISJCRt54G18XX0cIyJ/Zls4WISKyAQYhIjdXcMNVV58+DxRYVJEtQkRkAwxCRG4uR2eA3mBak+ehCEKeHCxNRLbDIETk5sRAoVLKoVa5/luC2CLErjEisgXXf9cjIrt6WDZcFYkz2zIZhIjIBhiEiNxcxkM0dR4o0CLEMUJEZAMMQkRu7mHZXkPkK60jxJWliajsGISI3NzDsuGqyIcbrxKRDTEIEbk5sWXlYQtCeoOAHJ3ByaUhooed0tkFICLnkrrGbByEhJwM5Py+ATAaIPOtCLlPRcj8TP/L/SpBpvYq1fOqVXKolHLk6o3IyM6Fr7frLwJJRK6LQYjIzUmDpb1sFygEoxHZv6yEIeF04QepvSD3rQi5byVTUMr7J4Umtcbqw8SNV1PStVxLiIjKjEGIyM3ZY1Vp3fGvTSFIoYZHdB8I2fdgTL8NY3oyhPTbEHLSAV0WjHf+hfHOv1afQ+bhIwUk86BUCQGeQEo6F1UkorJjECJyc9JgaRvNGtP/exK6498AADzbDYEqrJXFMUKuFsb02xAykvMC0m0IeUHJmH4b0GZC0GZA0GbAePuqxeMnAEiv4AnFwV+RcaUyjJVCoVP6QdAEQO4TCJl3IGQaX8hkHAZJREVjECJyc+IYIVusI2RMv43sXz8BIEBVv5PVEAQAMpUHFIFVgcCqVu8XdNn54SjjNoz3kiFk5AWle7eB3Gz4ynOAjOvIzbiOtEtWnkSuhMw7Lxj5BEHuHQiZT2BeUAqC3CcQUHs9FItIEpH9MAgRuTFbbrgqGHKR/dPHgDYT8ko14dHypVI/l0ytgSLoESDoEav3/9/3f+Of0xfQpb4XWj6qhEqfjuzbSTCk34GQeRdCVhpg1ENIT4YhPbnwEyk9IPcJMgUkMSjl/W/6OggylUep60FEro9BiMiNZWsNMBhNa/F4lzEIaf/cCmPyFcg8fKB5YixkCvtNx/f08cV/hiBcUVRBx8b1ERDgjZSUTOj1RgCAYNBDyEqBMeMuhMy7pv8z7kjfCxl3IWgzAL0WxtQbQOoNFDoR38Pb1IrkFQC5VwXIvCuYvs77X+ZdATJPP8jk7IYjehgxCBG5sYwcU2uQWiWHh0pR6ufJvbAfuWd/BSCDZ6eRkPsE2aiE1okz3AobLC1TKCHzrQS5b6VCn0PQayFkpMCYmReS8gKSMeOOFJ6QmwNoM2HUZgJ3rhcelmRyyLz8IfOqkBeWAsy/9q4AuVcA4OHNrjgiF8MgROTGbDE+yHDnOnJ+/xQAoG7aC8pHImxStqIUXF26tGRKD8gqhEJeIbTQYwRdVl5r0l0IWakwZqVCyEwx/zo7DRCMpq8zU2As6qRypRSKTC1LBVuXKkCm8Yfcy5+BiciBGISI3Fj+qtKlW0NI0GUh+8dlgEEHxSMRUEc9bcviFUraeNXO0+dlai8oAr2AwGqFHiMYjRCy0yBkpULITIUxKyXv65S8sJRq+j4nPW/c0m0Y0m8/4MQKyLz8INP4Q6bxg9zL3/S1l+l7mcYfMt8KMGiqcJsRojJiECJyY+ll2HBVEATk/LYGwr0kyHyCoOk40mHT1cUWrAwX2IFeJpdD5h0AeAcAhffEQTDkFghLqfeFpRQIWWkwZqcB2kxAMEgtTACsdsllA7gHAApVfjiSQpNfXmgyhSd53n1QebKlieg+DEJEbqwsM8ZyT34P/dXjgFwJTecxkHn62Lp4hXoYN16VKVSQ+VYCfCuhqNFYgiEXQvY907+8cCRkpZlanaTb7pm65HTZgCEXQsYdCBl3AFgPTRKF2rS+kqdv3v9+0vdyT9+8QJV3v6cvgxO5BQYhIjdW2iCkv3EO2sPbAQAerfpDEVzL5mUrijjDzWAUkK0tXxuvyhQqyHyCgAcMOFcq5fD3UeLujZvQp6eYwlFWXljKC08FQxT0OsCgMwtND6RQFQhNeUGpwPdy6Xs/Bid6aDEIEbkxaZ+xEgQhY1Yqcn5eDghGKMNaQfVYBzuVrnAeKgXUKjl0uUZpnJM7kqs8oPCrBMErqMhWJgAQcnNMISknHUJ2umnbk5z0/O9z7uX9b/oeBp2ptSnTtORAsSiUpq1RPH1MAcnD2/S1dFuBr/P+h4cXVwAnp2IQInJjGSUcIyQY9cj5aTmE7HuQB1aDZ9vBTmsB8NWocCdXK41zoqLJVJ6QqTwBv+BiHS/kavODU4GQZCwYpqQgdS+vxUlvGvuUlVqSkpnCkKdvXkDythqYxK/l3r4w+vCji2yHP01Ebiy9hF1j2sPbYUi8AKg0pkUTlc5bddlHo8ade9yB3l5kKg/IVJUAvyJGgBcg6LWmcKTNgJBT4J/2/v8z8+5LN63TBCFvb7lMCGnFK1saYOq2U3uZgpOHtylM5X1d8HbTfd6QifervSBTlm6WJJVPDEJEbqwkXWO5l48g9+RuAIBnh+GQ+xe+/o4jSFPos9y3a8yVyJQekPl6AL4Vi/0YwaDPC0iZloEpJwPQWgtUmYBgNHXbZeeNfyophTo/GHl4m/ac8/SGTC2GJy9TYFJ7mQKWWpP3vQZQa9iVV84wCBG5sYy8EPGg7TWMqYnI2bsWAKCKfBKqmk3tXrYHEVux2DX28JIplJB5VQC8KhT7MQqFDBW85biblAx9ZrqpJUmbCUGXldeylGUKTdos6XbxGGizAAimQeNZuhJ24UmlNg0KLxCQIAUlL+l23Pe92XFskXIpDEJEbsq04aoeQP6WFVaPy9WaFk3MzYGicjg8Yp5zVBGL5ONCawmR48hkMsg9vKDwrQhBE1iixwqCEdBlm0KSLjM/LElBKTP/vrzjoMsyham8pQoAAcjNhpCbjVIv3CBX5rcuqTSQqT0BlSYvMGlMY7ny/pepNYBKA0HjhZzsQBhyAKPCAzKVBlCqOUvPBhiEiNxUtlYPY94aPD4a628FgiAg5/cNMKYkQKbxh+fjoyCTl35PMlvytcE2G+ReZDJ53nghbxS5+mUhBEOuKRBpxXBkCkiCLi8wacXvswsEqKwCoSobgGBaYTwnHchJL1GYyrCsUH6AUmkAtacUnmQqjanlSu0JKE3/y5QepmPyvkfeAHqZyhNQeUAmd89I4J61JiJpoLSHWgGV0nq4yT37K/TxBwCZHJ6dR0Negi4Me8vfZoNjhMgxZAoVZBoVoPEr1eMFwQjkaqWABF2OqWUp73/khSghN8f0da7pa0GXDeTmQK7PgSEvbEEQTP/EsGWLCiqUkCk9pbCEvPBkaqEqEKCUHlLLlaJ6I8hL+Xq4CgYhIjf1oA1XDbcuQ/vnFgCAR/Pnoawc7rCyFQfHCNHDRiaT540T0gAoesHM+ymVcgQEeCMlJRO5uQZAr7MIT6bAlJ3fKpWbY7o9V1vg6xxTGMvNzvs/BzCaushh0EMw5A1SL2a5FNUbwavbxBLVxdUwCBG5qaKmzhtz0k3jgowGKGs0hSqim6OL90CutN8YkSPJZDJTV5bKo0QDzQsjGPSmoKTXQtDlAPocUyuVPsfUanXf7dL/hlyo6rUve4WcjEGIyE1JiyneF4QEoxE5v3wCIfMuZP4h8Oww3CUHZIoz3ey9Az1ReSdTKAGFD2Rw3H6BroSLIRC5KWmfsftWldYd/xqGhNOAUg3NE+PymvFdjzjTLSPr4dl4lYhcD4MQkZuytuGq/t+T0B3/BgDg2XYIFIHVnFK24hBnuhkFAZk5eieXhogeVgxCRG5K3KxUHGtjTE9G9q+fABCgqt8JqrBWTizdg6mUCnioTbPd7mVqnVwaInpYMQgRual0acNVNQS9Dtk/fgxoMyGvVBMeLV9ycumKRwxx9zI5hZ6ISsfmQejmzZt4/fXX0bp1a0RHR2PYsGG4ePGi2THff/89unfvjsjISPTu3RsHDhwwuz8lJQWTJk1CdHQ0YmJiMHv2bGRnZ9u6qERureA+Y9oDW2G8fRUyDx/TZqqK4m3C6mw+DEJEVEY2DUI6nQ4jRoxAcnIyVq5cia1bt8Lb2xuDBw/G3bt3AQAHDx7E5MmT8eKLL2Lnzp1o2bIlRowYgUuXLknPM378eFy7dg0bNmzA4sWLsXfvXsyaNcuWRSVye2IQqnT3L+Se/Q2ADJ6dRkLuU7L1TZxJCkIZDEJEVDo2DUJHjx7FhQsXEBsbi4iICISFhWHBggXIysrCL7/8AgBYvXo1OnfujEGDBqF27dqYOnUqGjRogE8//RQAcOLECRw+fBgffPABGjRogJYtW+Kdd97B119/jaSkJFsWl8itpWfloooiBQFnvwAAqJv2hvKRCCeXqmTEGW9sESKi0rLpOkJhYWFYtWoVQkJCpNvkclPWunfvHoxGI44fP45p06aZPa558+bYs2cPAFOYqlSpEmrXri3dHxMTA5lMhmPHjqF79+6lKps+Jwu6S0dgVGog8/CWdgWGWmNa7dPFXUtMx/nrqaYl1YtJrpBBo/FAdrYWRoP7TC9mvYtXb0NOJl72+w0yQy4Uj0RCHfWUA0ppW2KL0Inzt6DV6ni93QDr7Tr1lslkaBxWEZUquOYSG8Vl0yBUqVIltG9vvsrkpk2bkJOTg9atW+PevXvIyspCaGio2THBwcFITEwEACQlJaFy5cpm96vValSoUAE3b94sddmE7HRk/rDUyj0y054pHqZgJFN7539t9r3pf/l9t9l799+snFx8+dsl/HL0XwgAZBAgk/43fQ0IkMnM7wMAed7/BY+Ty8xvu/8xsvueC9buL/i9zPx5IP0vnj/vfum81p/7/seanrfwx9z//LBS/4KPzz8XLB5jtV73l0d6jPltBctX5DmtPq7gsYWdW3z9zMtT2Pl1AJTWnkdmeb5xvumopEiHzCcIPk+MhFz18K2vGujnCQD462Iy/rqY7OTSELmfM9fuYtKLTez2/I5Yy7VE73wJCQl4/PHHC73/wIEDCAwMlL7/8ccf8eGHH2LIkCEIDw+Xwo5arTZ7nIeHB7Ra0/TX7Oxsi/vvP6Y0dIICl3MroYKHAYGeRshys037r0DI3wAvvRRPLFdC7ukFubjonCAAgtH0kSMY8zfGg2Ba9E36Z+UYIe8Y5B8DAD0B9Ay0dnKishFkClR5fgo8K4c++GAX1LNdbWTk6JGZzXWEiBxNJge6xDyKgABvZxelTEoUhEJCQrBr165C7/f395e+/uyzzzBnzhw8/fTTmDJlCgBTmAFMg6oL0mq10GhMQcLT09PifvEYLy+vkhTXnMYfK3N6QptugFIhQ682NdG9eVUo9FoIukwI2iwIWvH/LAi6TBjFr8XbdeZfw2gAjHoYs+7BmHWv9GWzK5kpUstk930N008x8jYClBU41uz//OMAman1677HW/0+7/Ey6ZzWnh8W38sKnhcFy5X3//11gCzvy/zbZTIZlCol9HqjKYNKj80ro8xUMrPnNSufldctr6wyszIXLJO1cpo/p6zg899ff+lyFf7cUj0LPr7Ac8rlcnh4qqDV6mE0CpbnynuugnVXVnkM2ZrKyE7JxMOq/xN14eenwb172TAYjM4ujsMoFHLWm/V2CSl2fP/w99dIQ2zspURBSKVSmY3dKcyCBQuwZs0aDB06FFOnTpW6jipUqAAvLy/cunXL7Phbt25J44pCQ0Px008/md2v0+mQmpqK4ODgkhTXjLdGhfdGtsD6Xedw6vIdfLn3Mg6eScKQbvVQu2oI4CN97BSLIAim3X+1maZQlJtjukMKA3LzgCB9sIsfRuLX+R9KAmQ4ci4Z3/55FZk5BkAmQ4cm1dCtxaPwELstZLL7zgFYDTuQQaVSSLsV6/Wu9YtjTwV3aXa3elcoYb0FoNy8RgaDsdzUpSRYb/fibvV2xO45Nh8UIIagqVOn4uWXXza7TyaTISoqCocPH8bzzz8v3X7o0CE0a9YMABAdHY3Y2Fhcu3YNjz76KADg8OHDAICmTZuWqWwVK2jw2vOROHQmCVt/uoj/kjPx7qZj6NS0Gvq0qwWNR/FfDrPdf1H2fqtbKVn4dPd5nL2WAsAD1UN8MOTJeqgR6lfm5yYiIiLrbBqEDh06hDVr1mDgwIF46qmnkJycP3jRy8sL3t7eGDp0KEaMGIH69eujXbt2+PLLL3H27FnMmzcPANCoUSNERUVh4sSJmDVrFrKysjBz5kz07t3bbDZaaclkMrRoEIoGNQOx7Zd4/Hk6ET8fS8CJi8kY2CUcjepULPM5SsJgNGLP4ev4+o8r0OmNUCnl6N22JrpEPwKFnZsDiYiI3J1MsOG2zf/73//w+eefW71v7NixGDduHADgq6++wvLly5GYmIg6depg8uTJaNmypXTsnTt3MHv2bPz+++/w8PBAt27dMH36dGmMUWlZ6zL458pdfLr7HG6nmbq2Yh4LRr/OdeHnbTlg29auJaZj/fdn8W9SBgDgsUcDMKhbOEICyjAWqgB37iJivVnv8o71Zr3dQWCgNxQK+zYK2DQIubrCfoC0OgO++uMy9hy5DkEAvD2VePHxMLRqGGqXqfHaXAO+/v0K9hy5DqMgwNtTib6dwtA6wrbnc9dfHNab9XYHrDfr7Q4cEYQevoVD7MBDrUDfTmFoXj8EG3adw7+3MrA27iwO/JOIQV3DEWyjFhoA+OfqXWzcfQ7JqfktUC91rgt/B7RAERERkTkGoQJqhPphxuBm2HPENGbnzNUUzFx7GL3b1sIT0dXKNGYnIzsX236+iP2nTWspBfh6YGDXcDR28JgkIiIiyscgdB+lQo7uLR5F0/BK+PT7czj3byo+/zUeh84kYciT9fBoqG+Jnk8QBBw+ewtbf7qA9KxcyIBSzVIjIiIi2+MncSFCArww+aUm+OPUTXz+SzyuJaVjzqdH0SXmEfRqUxMeKsUDn+NOWg427TmPk5fuAACqVvTG4CfroU5V/wc8koiIiByBQagIMpkMbSOrILJ2RXz20wUcPnsLuw/9i2Pnb2Fwt3qoX8P6+kFGo4Bfjifgy72Xoc01rWTds1UNdG/xKJR2HvRFRERExccgVAz+3mq82qshWtS/jU17ziM5NQex//cXWkeEom+nMGkHbABISM7Ahu/P4fIN05YbYdX8MeTJeqgc9HDvxUJERFQeMQiVQOOwigivXgE79l7GL8cTsP9UIk5duoOXOtdFVN2K+O7Pa9h18BoMRgEaDwWe61AH7RtXgdwR2+cSERFRiTEIlZDGQ4n+XeqieYMQbPj+HG7czsQn3/wDb08lMnNMO2A3CauIAV3CEeBbtgUgiYiIyL4YhEqpTlV/vD0kGt8fvIbvDlxFZo4e/t5q9H+iLpqGV7LLQoxERERkWwxCZaBSyvF0m5qIfiwYZ6+loEX9EHh5qh78QCIiInIJDEI2UDnIm4OhiYiIHkKcy01ERERui0GIiIiI3BaDEBEREbktBiEiIiJyWwxCRERE5LYYhIiIiMhtMQgRERGR22IQIiIiIrfFIERERERui0GIiIiI3BaDEBEREbktBiEiIiJyWwxCRERE5LZkgiAIzi6EoxgMRmcXweEUCjnr7UZYb/fCersXd6y3XC6DTCaz6zncKggRERERFcSuMSIiInJbDEJERETkthiEiIiIyG0xCBEREZHbYhAiIiIit8UgRERERG6LQYiIiIjcFoMQERERuS0GISIiInJbDEJERETkthiEiIiIyG0xCBEREZHbYhAiIiIit1UugpDRaMSSJUvQtm1bNG7cGK+88gquX79e6PEpKSmYNGkSoqOjERMTg9mzZyM7O9uBJS671NRUzJw5E+3atUNUVBReeuklHD16tNDjV6xYgfDwcIt/D6OkpCSrddmxY4fV48vD9T506JDVOoeHh+Pxxx+3+phjx45ZPf7QoUMOLn3pfPLJJxg4cKDZbWfPnsWAAQPQuHFjdOrUCRs3bnzg83z//ffo3r07IiMj0bt3bxw4cMBeRbYJa/X+5Zdf8Oyzz6JJkybo1KkTPvjgA+Tk5BT6HAaDAZGRkRbXfunSpfYufqlZq/eMGTMs6tCpU6cin+dhv94DBw4s9Hf9q6++KvR5hg4danH8/a+nsz3oc+vAgQPo06cPGjVqhG7duiEuLu6Bz7llyxY8/vjjiIyMRL9+/XDmzJmSF0woB5YuXSo0b95c+PXXX4WzZ88KL7/8stClSxdBq9VaPX7AgAHCs88+K5w+fVr4888/hY4dOwpTpkxxcKnLZujQoULPnj2FI0eOCJcvXxZmz54tREZGCpcuXbJ6/IQJE4TJkycLt27dMvv3MPrtt9+EiIgIISkpyawu2dnZVo8vD9dbq9VaXLs9e/YI4eHhwvbt260+ZsuWLULnzp0tHlfY74Ur2bx5s1CvXj1hwIAB0m13794VmjdvLkyfPl2Ij48Xtm/fLkRERBRaf0EQhAMHDggNGjQQPv30UyE+Pl54//33hYYNGwrx8fGOqEaJWav3kSNHhMcee0xYsWKFcOXKFeG3334T2rVrJ0ybNq3Q54mPjxfq1q0rnD171uzaZ2RkOKIaJWat3oIgCM8995ywcOFCszrcuXOn0OcpD9c7JSXFrL5JSUlCv379hB49ehR5/Vq2bCls3brV7LEpKSkOqEXxFfW5FR8fL0RERAgLFy4U4uPjhTVr1gj169cX/vzzz0Kfb8eOHUJkZKTw9ddfCxcvXhQmT54sxMTEFPkzYs1DH4S0Wq3QpEkTYcuWLdJtaWlpQmRkpPDtt99aHH/8+HGhbt26Zr8Yv//+uxAeHi4kJiY6pMxldfXqVaFu3brC0aNHpduMRqPQuXNn4aOPPrL6mCeffFJYv369g0poX6tWrRKeeuqpYh1bHq63NZmZmULHjh2L/DB8++23hVdffdWBpSq7xMREYeTIkULjxo2Fbt26mX1ArFy5UmjTpo2Qm5sr3fbhhx8KXbp0KfT5Xn75ZWHChAlmt/Xt21f43//+Z/Oyl0VR9Z40aZIwZMgQs+N37twpNGjQoNBQGxcXJ0RFRdm1zLZQVL2NRqPQuHFjYc+ePcV+vvJwve+3adMmoWHDhoX+kSsIgnD79m2hbt26wj///GOP4trEgz63/ve//wnPPfec2WNef/114eWXXy70Obt06SLMnz9f+j43N1do3769sHLlyhKV7aHvGjt37hwyMzPRsmVL6TY/Pz/Ur18fR44csTj+6NGjqFSpEmrXri3dFhMTA5lMhmPHjjmkzGUVEBCAVatWISIiQrpNJpNBJpPh3r17FsfrdDpcvXoVtWrVcmQx7eb8+fNm168o5eF6W7Ny5UpkZ2dj6tSphR5TktfJVfzzzz9QqVT45ptv0KhRI7P7jh49ipiYGCiVSum2Fi1a4OrVq7h9+7bFcxmNRhw/ftzsvQEAmjdvbvW9wZmKqvfLL79scZ3lcjlyc3ORkZFh9fkelmtfVL3//fdfZGVlFft9q7xc74Lu3r2Ljz76CKNGjSrydTh//jxkMhlq1qxpj+LaxIM+t44ePWpx7Vq0aIFjx45BEASL57tz5w6uXr1q9hilUolmzZqV+HorH3yIa0tMTAQAVK5c2ez24OBg6b6CkpKSLI5Vq9WoUKECbt68ab+C2pCfnx/at29vdtsPP/yAa9eu4c0337Q4Pj4+HgaDAT/88APmzZsHrVaL6OhoTJ48GcHBwY4qts1cuHABAQEB6N+/P65cuYJHH30Uo0aNQrt27SyOLQ/X+353797Fhg0bMGnSJFSoUKHQ4y5evIiAgAD06dMHSUlJqFu3LiZOnIjIyEjHFbaEOnXqVOgYkMTERNStW9fsNvHn9+bNm6hYsaLZfffu3UNWVhZCQ0MtHmPtvcGZiqp3/fr1zb7Pzc3Fhg0b0LBhQwQGBlp9zIULF6DX6zFs2DCcO3cOISEhGDx4MHr16mXzspdFUfW+cOECAGDTpk3Yt28f5HI52rVrh4kTJ8LX19fi+PJyvQtavXo1PD09MWzYsCKPu3DhAnx9ffHOO+9g//798PLyQrdu3TB69Gio1WpbFbtMHvS5tXPnTqvXLjs7GykpKRY/60V99p87d65EZXvoW4TEQa/3X2wPDw9otVqrx1v7wSjs+IfB8ePHMX36dHTp0gUdOnSwuF98Q9FoNFi8eDHmzZuHy5cvY9CgQUUOuHRFer0ely9fRlpaGsaNG4dVq1ahcePGGDFihNVBkeXxem/duhW+vr7o27dvocfcvHkT6enpyMrKwowZM7B8+XJUrFgRAwYMQHx8vANLazs5OTlWf88BWL2W4s92cd8bHgZ6vR5TpkzBxYsX8fbbbxd63MWLF5GamoqBAwdi7dq16Nq1K6ZPn47t27c7sLRlc+HCBcjlcgQHB2PlypWYNm0a/vjjD4wePRpGo9Hi+PJ2vTMyMvD5559j2LBh0s95YS5cuACtVovIyEisWbMGo0aNwhdffIEZM2Y4qLQld//nlrXfb/F7nU5n8fiSfvYX5aFvEfL09ARgeqHErwHTG6NGo7F6vLUXVavVwsvLy34FtZOffvoJb7zxBqKiohAbG2v1mN69e6Ndu3ZmiTosLAzt2rXDL7/8gu7duzuquGWmVCpx6NAhKBQK6Xo3bNgQFy9exNq1ay2aVsvb9QaAr776Cr179zb7eb9f5cqVceTIEWg0GqhUKgBAREQEzpw5g02bNmH27NmOKq7NWLuW4huetWspfnhYe4y19wZXl5GRgddeew2HDx/GsmXLimzZ++6772AwGODt7Q0AqFevHm7cuIG1a9fiueeec1SRy2TUqFHo168fAgICAAB169ZFpUqV8MILL+DUqVMWXUrl7Xr/9NNP0Ol0ePbZZx947DvvvIOpU6fC398fgOm1UqlUmDhxIqZMmWLRWups1j63PDw8LK6d+H1hn+UFjxGV5no/9C1CYrPYrVu3zG6/desWQkJCLI4PDQ21OFan0yE1NfWh6ybavHkzxo0bh44dO2LlypVF/tVwf7NicHAwKlSo4HJNxsXh7e1tEQLCwsKQlJRkcWx5ut6AaUzc9evX8dRTTz3wWD8/PykEAaZxJbVr17b6Oj0MrF1L8Xtrv+sVKlSAl5dXsd8bXNmtW7fQv39//PXXX1i7dq1FF8P9PD09pRAkqlu37kP1+y6Xy6UQJAoLCwMAq/UoT9cbMIWF9u3bw8/P74HHKpVKKQSJinqtnKmwz63KlStbvXZeXl5Wu0JL+tlflIc+CNWrVw8+Pj5ma6Pcu3cPZ86cQXR0tMXx0dHRSExMxLVr16TbDh8+DABo2rSp/QtsI1u3bsWcOXPQv39/LFy4sMh+4EWLFqFr165mA84SEhKQkpKCOnXqOKK4NnPx4kVERUVZrIVz+vRpq3UpL9dbdPToUQQFBaFevXpFHrdv3z40adLEbD0tvV6Pc+fOPXTXXBQdHY1jx47BYDBItx08eBA1a9ZEUFCQxfEymQxRUVHS9RYdOnQIzZo1s3t5bSUtLQ2DBw/G3bt3sWXLFqvvawXdu3cPMTExFutqnTp1SvpwfBhMmTIFQ4YMMbvt1KlTAGD1Z7i8XG+RtcHDhRk4cCCmT59udtupU6egUqlQo0YNO5SudIr63GrWrJnFtTt48CCioqIgl1tGlaCgINSsWdPss0Cv1+Po0aMP/B2530MfhNRqNQYMGIDY2Fj8/PPPOHfuHCZOnIjQ0FB06dIFBoMBycnJUv9xo0aNEBUVhYkTJ+LkyZM4ePAgZs6cid69ez80fzVcuXIF7777Lp544gmMHDkSt2/fRnJyMpKTk5Geng6dTofk5GSpyfCJJ57Af//9h1mzZuHKlSs4cuQIxo0bh6ioKLRt29bJtSmZ2rVro1atWnjnnXdw9OhRXLp0Ce+99x7++usvjBo1qlxe74LOnDlT6EKYycnJyMzMBABERUUhICAAU6dOxenTp3H+/HlMnToVqampFh8uD4tnn30WGRkZeOuttxAfH48dO3Zgw4YNGDlypHRMeno67t69K30/dOhQxMXFYf369bh06RLmz5+Ps2fPYvDgwc6oQqm89957uH79OhYsWIDAwEDpdz05OVkKhampqUhNTQVgagls0aIFFi1ahL179+Lq1atYtWoVvvnmG4wbN86JNSmZrl274sCBA1i2bBn+/fdf7N27F2+++SZ69uwpzYgrj9cbMI3xS0lJKfQPnszMTCQnJ0vfd+3aFV9//TU+++wzXL9+Hbt27cL8+fMxbNgw+Pj4OKrYRXrQ59bAgQNx8uRJxMbG4tKlS1i3bh12796N4cOHS89R8OccMM2oXL9+PXbu3In4+Hi8+eabyMnJKXn3b4km27sovV4vzJ8/X2jRooXQuHFj4ZVXXhGuX78uCIIgXL9+Xahbt67w5ZdfSsffvn1bGDdunNC4cWOhefPmwttvvy3k5OQ4q/gltmLFCqFu3bpW/02dOlU4ePCgULduXeHgwYPSY/7880+hb9++QuPGjYWYmBhh+vTpQmpqqhNrUXrJycnCtGnThNatWwsRERFC3759hSNHjgiCUD6vd0HDhw8XXnvtNav31a1bV1iyZIn0/bVr14Rx48YJMTExQqNGjYSXX35ZOH/+vKOKWmZTp061WF/l77//Fl544QWhYcOGQseOHYVNmzZZPKZjx45mt+3cuVN44oknhIiICOGZZ54pcoE2V1Cw3nq9XoiIiCj09118nxswYIDZa5Weni68++67Qvv27YWGDRsKvXr1En788Uen1Ke4rF3vXbt2Cb179xYiIyOF1q1bC++//77Z7255u96iv//+22L9s4KWLFki1K1b1+y2zZs3C08++aT0u7FixQrBYDDYrdwl9aDPLUEQhL179wo9e/YUGjZsKHTr1k2Ii4sze477f84FQRDWrFkjtGvXToiMjBT69esnnDlzpsRlkwmClQn6RERERG7goe8aIyIiIiotBiEiIiJyWwxCRERE5LYYhIiIiMhtMQgRERGR22IQIiIiIrfFIERERERui0GIiIiI3BaDEBE9FBISEhAeHm6xh1ZpTJs2DZ06dbJBqYjoYad0dgGIiIojODgY27ZtQ/Xq1Z1dFCIqRxiEiOihoFar0bhxY2cXg4jKGXaNEZFNfPHFF+jRowcaNmyIDh06YOnSpdLu6NOmTcPAgQOxfft2dOzYEU2aNMHgwYNx7tw56fFGoxGLFi1Cp06d0LBhQ3Tq1AkffvghcnNzAVjvGrt69SrGjx+P1q1bo3Hjxhg4cCCOHTtmVq60tDRMnz4dMTExiI6OxoIFC2A0Gi3K/9NPP6FPnz6IiIhA69atMXfuXGRlZUn35+TkYNasWWjXrh0aNmyIbt26Ye3atTZ9DYnI8dgiRERl9sknn2DRokUYMGAApk+fjrNnz2Lp0qW4efMm3n33XQDA2bNncfnyZbz++uvw9/fHkiVLMGDAAOzatQvBwcFYvXo1PvvsM0ydOhWPPPII/v77byxatAgqlQrjx4+3OGd8fDxeeOEF1KhRAzNmzIBKpcLGjRsxePBgrFu3DjExMTAajRg+fDj+++8/TJ06FRUqVMCaNWtw6tQpBAcHS8/17bff4o033sBTTz2F1157Df/99x8WLVqE+Ph4rF+/HjKZDO+++y7++OMPTJ06FRUrVsS+ffswf/58VKhQAc8++6zDXmsisi0GISIqk/T0dCxfvhx9+/bFjBkzAABt2rRBhQoVMGPGDAwdOlQ6buXKlWjWrBkAIDIyEp07d8bGjRvxxhtv4PDhw2jYsKEUKmJiYqDRaODr62v1vMuWLYNarcbGjRvh4+MDAOjQoQN69uyJ+fPnY/v27di3bx9OnjyJ1atXo127dgCAli1bmg2UFgQBsbGxaNu2LWJjY6Xba9SogSFDhmDv3r3o0KEDDh8+jNatW6NHjx4AgObNm8PLywtBQUG2fDmJyMHYNUZEZXLixAnk5OSgU6dO0Ov10j8xbOzfvx8AUK1aNSkEAabBz02aNMGRI0cAmILF/v370a9fP6xZswbx8fEYMGAAevXqZfW8hw8fRseOHaUQBABKpRI9evTA6dOnkZmZiaNHj0KlUqFt27bSMV5eXmjfvr30/eXLl5GYmGhR/ujoaPj4+Ejlb968OT7//HO88sor2Lx5M65fv44xY8agQ4cOtnkhicgp2CJERGWSmpoKABgxYoTV+2/dugUACAkJsbgvKCgI//zzDwBg+PDh8Pb2xpdffonY2FgsWLAAYWFhmDFjBlq0aGHx2LS0NFSsWNHi9ooVK0IQBGRkZCAtLQ0VKlSATCYzO6ZSpUoW5Z89ezZmz55daPnfeusthIaG4ptvvsGcOXMwZ84cNGnSBLNmzUK9evWs1p2IXB+DEBGViZ+fHwAgNjYWNWrUsLi/YsWKWLx4MVJSUizuu337ttS1JJfL0b9/f/Tv3x937tzB3r17sXLlSowbN05qlSnI398ft2/ftrg9OTkZABAQEICAgACkpKTAYDBAoVBIx4jhp2D5p0yZgpiYGKvnAUyz1kaNGoVRo0bhxo0b+PXXX7F8+XJMmjQJcXFxhb08ROTi2DVGRGXSqFEjqFQqJCUlISIiQvqnVCqxcOFCJCQkADDN8Lp06ZL0uKSkJJw4cQItW7YEALz44ouYO3cuAFNLUZ8+fdC/f3/cu3cPGRkZFueNjo7Gr7/+anafwWBAXFwcIiIioFar0bJlS+j1evz000/SMTqdzixY1apVC0FBQUhISDArf0hICD788EOcOXMGOTk56Nq1K9atWwcAqFKlCvr3748ePXrgxo0bNnw1icjR2CJERGUSEBCA4cOHY/HixcjIyEDz5s2RlJSExYsXQyaTSd1GgiDg1VdfxcSJE6FQKLBs2TL4+/tj4MCBAEzBZt26dahYsSKaNGmCpKQkrF+/HjExMQgMDDSbyg4AY8eOxb59+zBo0CCMGDECKpVKGruzZs0aAKaB0W3atMGMGTNw584dVK1aFRs3bsTdu3elliiFQoGJEydi5syZUCgU6NixI+7du4fly5cjKSkJDRo0gKenJxo0aIBly5ZBpVIhPDwcV65cwc6dO9G1a1cHvtpEZGsyQRAEZxeCiB5+W7ZswdatW3Ht2jX4+/ujZcuWeP3111GlShVMmzYNhw8fxiuvvIKPP/4Y2dnZaNWqFaZOnYpq1aoBAPR6PVasWIFvvvkGiYmJ8PX1RadOnTBp0iQEBAQgISEBjz/+ON577z306dMHgGlK/sKFC3H06FHIZDJERkZi7NixZoOys7OzERsbi7i4OGi1WnTv3h1eXl74+eef8csvv0jH7dq1C2vWrMHFixfh5eWFqKgovPbaawgPDwcAZGRk4KOPPsLPP/+M5ORkBAUFoXv37pgwYQI8PT0d+EoTkS0xCBGR3YlBqGDwICJyBRwjRERERG6LQYiIiIjcFrvGiIiIyG2xRYiIiIjcFoMQERERuS0GISIiInJbDEJERETkthiEiIiIyG0xCBEREZHbYhAiIiIit8UgRERERG7r/wGcqEkE1iZKsQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/NoisyDQN.ipynb b/notebooks/NoisyDQN.ipynb new file mode 100644 index 0000000..69c32f5 --- /dev/null +++ b/notebooks/NoisyDQN.ipynb @@ -0,0 +1,582 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法\n", + "\n", + "NoisyDQN 是在 DQN 的基础上进行改进,主要就是通过在训练网络的时候加上一些噪声参数,可以用较小的额外计算成本,在强化学习算法上获得更优的结果。\n", + "配置和 DQN 基本一致,只是在模型定义的时候,在模型中加入了一些噪声参数。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、 定义模型\n", + "这里使用了一个三层的MLP,不同的是其中加入了一些噪声参数,就是每个权值weight和偏置bias中都有额外的参数mu和sigma,这里仅供参考。" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class NoisyLinear(nn.Module):\n", + " def __init__(self, input_dim, output_dim, std_init=0.4):\n", + " super(NoisyLinear, self).__init__()\n", + " \n", + " self.input_dim = input_dim\n", + " self.output_dim = output_dim\n", + " self.std_init = std_init\n", + " \n", + " self.weight_mu = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n", + " self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n", + " self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n", + " \n", + " self.bias_mu = nn.Parameter(torch.FloatTensor(output_dim))\n", + " self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n", + " self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n", + " \n", + " self.reset_parameters()\n", + " self.reset_noise()\n", + " \n", + " def forward(self, x):\n", + " if self.training: \n", + " weight = self.weight_mu + self.weight_sigma.mul(torch.tensor(self.weight_epsilon))\n", + " bias = self.bias_mu + self.bias_sigma.mul(torch.tensor(self.bias_epsilon))\n", + " else:\n", + " weight = self.weight_mu\n", + " bias = self.bias_mu\n", + " \n", + " return F.linear(x, weight, bias)\n", + " \n", + " def reset_parameters(self):\n", + " mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n", + " \n", + " self.weight_mu.data.uniform_(-mu_range, mu_range)\n", + " self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n", + " \n", + " self.bias_mu.data.uniform_(-mu_range, mu_range)\n", + " self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n", + " \n", + " def reset_noise(self):\n", + " epsilon_in = self._scale_noise(self.input_dim)\n", + " epsilon_out = self._scale_noise(self.output_dim)\n", + " \n", + " self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n", + " self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n", + " \n", + " def _scale_noise(self, size):\n", + " x = torch.randn(size)\n", + " x = x.sign().mul(x.abs().sqrt())\n", + " return x\n", + "\n", + "class NoisyMLP(nn.Module):\n", + " def __init__(self, input_dim,output_dim,hidden_dim=128):\n", + " super(NoisyMLP, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.noisy_fc2 = NoisyLinear(hidden_dim, hidden_dim)\n", + " self.noisy_fc3 = NoisyLinear(hidden_dim, output_dim)\n", + " \n", + " def forward(self, x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.noisy_fc2(x))\n", + " x = self.noisy_fc3(x)\n", + " return x\n", + "\n", + " def reset_noise(self):\n", + " self.noisy_fc2.reset_noise()\n", + " self.noisy_fc3.reset_noise()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "这里的经验回放和DQN中保持一致,也是具有一定容量,只有存储到一定的transition网络才会更新。经验回放的时候一般包涵两个功能或方法,一个是push,即将一个transition样本按顺序放到经验回放中,如果满了就把最开始放进去的样本挤掉;另外一个是sample,就是随机采样出一个或者若干个(具体多少就是batch_size了)样本供DQN网络更新。" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer(object):\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " ''' 存储transition到经验回放中\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量,则取经验回放的容量\n", + " batch_size = len(self.buffer)\n", + " if sequential: # 顺序采样\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else: # 随机采样\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " ''' 清空经验回放\n", + " '''\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " ''' 返回当前存储的量\n", + " '''\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、模型算法定义\n", + "\n", + "这里根据前面的噪声MLP搭建智能体agent,其中的动作采样和模型更新和DQN基本一致,这里不再赘述。" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "\n", + "class NoisyDQN:\n", + " def __init__(self, model, memory, cfg) -> None:\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma \n", + " ## e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + "\n", + " self.device = torch.device(cfg.device) \n", + "\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " ## 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)\n", + " self.memory = memory ## 经验回放\n", + " self.update_flag = False\n", + " \n", + " def sample_action(self, state):\n", + " ''' sample action with e-greedy policy \n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon 指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # 根据Q值选择动作\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + "\n", + " @torch.no_grad()\n", + " def predict_action(self, state):\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_value = self.policy_net(state)\n", + " action = q_value.max(1)[1].item()\n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 不满足一个批量时,不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"Begin to update!\")\n", + " self.update_flag = True\n", + " # beta = min(1.0, self.beta_start + self.sample_count * (1.0 - self.beta_start) / self.beta_frames)\n", + " state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n", + " self.batch_size)\n", + " # state_batch, action_batch, reward_batch, next_state_batch, done_batch, weights_batch, indices = self.memory.sample(self.batch_size, beta) \n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) \n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)\n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " done_batch = torch.tensor(done_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n", + " # weights_batch = torch.tensor(weights_batch, device=self.device, dtype=torch.float)\n", + "\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) \n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)\n", + "\n", + " loss = nn.MSELoss()(q_value_batch, expected_q_value_batch) # shape same to \n", + " # 反向传播\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # 梯度截断,防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + "\n", + " if self.sample_count % self.target_update == 0: # 更新 target_net\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n", + "\n", + " ## 噪声参数重置\n", + " self.policy_net.reset_noise()\n", + " self.target_net.reset_noise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、 定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " agent.memory.push((state, action, reward,next_state, done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep + 1) % cfg.target_update == 0: # 智能体目标网络更新\n", + " agent.target_net.load_state_dict(agent.policy_net.state_dict())\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},Epislon:{agent.epsilon:.3f}\")\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.test_eps},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " if cfg.seed !=0:\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + "\n", + " cfg.n_actions = env.action_space.n ## set the env action space\n", + " model = NoisyMLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n", + " memory = ReplayBuffer(cfg.buffer_size)\n", + " agent = NoisyDQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config():\n", + " def __init__(self) -> None:\n", + " self.env_name = \"CartPole-v1\" # 环境名字\n", + " self.new_step_api = True # 是否用gym的新api\n", + " self.wrapper = None \n", + " self.render = False \n", + " self.algo_name = \"NoisyDQN\" # 算法名字\n", + " self.mode = \"train\" # train or test\n", + " self.seed = 0 # 随机种子\n", + " self.device = \"cpu\" # device to use\n", + " self.train_eps = 100 # 训练的回合数\n", + " self.test_eps = 20 # 测试的回合数\n", + " self.eval_eps = 10 # 评估的回合数\n", + " self.eval_per_episode = 5 # 每个回合的评估次数\n", + " self.max_steps = 200 # 每个回合的最大步数\n", + " self.load_checkpoint = False\n", + " self.load_path = \"tasks\" # 加载模型的路径\n", + " self.show_fig = False # 是否展示图片\n", + " self.save_fig = True # 是否存储图片\n", + "\n", + "\n", + " # 设置epsilon值\n", + " self.epsilon_start = 0.95 # 起始的epsilon值\n", + " self.epsilon_end = 0.01 # 终止的epsilon值\n", + " self.epsilon_decay = 500 # 衰减率\n", + " self.hidden_dim = 256 \n", + " self.gamma = 0.95 \n", + " self.lr = 0.0001 \n", + " self.buffer_size = 100000 # 经验回放的buffer大小\n", + " self.batch_size = 64 # batch size\n", + " self.target_update = 4 # 目标网络更新频率\n", + " self.value_layers = [\n", + " {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n", + " 'activation': 'none'}]\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "Begin to update!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:27: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "回合:10/100,奖励:11.00,Epislon:0.711\n", + "回合:20/100,奖励:18.00,Epislon:0.498\n", + "回合:30/100,奖励:20.00,Epislon:0.359\n", + "回合:40/100,奖励:20.00,Epislon:0.214\n", + "回合:50/100,奖励:94.00,Epislon:0.049\n", + "回合:60/100,奖励:200.00,Epislon:0.011\n", + "回合:70/100,奖励:200.00,Epislon:0.010\n", + "回合:80/100,奖励:200.00,Epislon:0.010\n", + "回合:90/100,奖励:200.00,Epislon:0.010\n", + "回合:100/100,奖励:200.00,Epislon:0.010\n", + "完成训练!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试!\n", + "回合:1/20,奖励:200.00\n", + "回合:2/20,奖励:200.00\n", + "回合:3/20,奖励:200.00\n", + "回合:4/20,奖励:200.00\n", + "回合:5/20,奖励:200.00\n", + "回合:6/20,奖励:200.00\n", + "回合:7/20,奖励:200.00\n", + "回合:8/20,奖励:200.00\n", + "回合:9/20,奖励:200.00\n", + "回合:10/20,奖励:200.00\n", + "回合:11/20,奖励:200.00\n", + "回合:12/20,奖励:200.00\n", + "回合:13/20,奖励:200.00\n", + "回合:14/20,奖励:200.00\n", + "回合:15/20,奖励:200.00\n", + "回合:16/20,奖励:200.00\n", + "回合:17/20,奖励:200.00\n", + "回合:18/20,奖励:200.00\n", + "回合:19/20,奖励:200.00\n", + "回合:20/20,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('joyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/PER_DQN.ipynb b/notebooks/PER_DQN.ipynb new file mode 100644 index 0000000..23ccb29 --- /dev/null +++ b/notebooks/PER_DQN.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法\n", + "\n", + "DQN 经验回放的算法中的均匀采样算法,可能会忘记一些重要的、以后使用的经验数据。针对这样的问题,PER_DQN 提出了优先级经验回放(prioritized experience reolay)的技术来解决,这种方法应用到 DQN 获得了更好的效果。PER_DQN 成功的原因有:1. 提出了sum tree这样复杂度为O(logn)的高效数据结构。 2. 正确估计了 weighted importance sampling. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、 定义模型\n", + "\n", + "这里的 PER_DQN 的模型和 DQN 中类似,也是用的三层的MLP。" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class MLP(nn.Module):\n", + " def __init__(self, n_states,n_actions,hidden_dim=128):\n", + " \"\"\" 初始化q网络,为全连接网络\n", + " \"\"\"\n", + " super(MLP, self).__init__()\n", + " self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n", + " self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n", + " self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n", + " \n", + " def forward(self, x):\n", + " # 各层对应的激活函数\n", + " x = F.relu(self.fc1(x)) \n", + " x = F.relu(self.fc2(x))\n", + " return self.fc3(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "这里的经验回放是和DQN中最大的不同。它使用了sum tree的数据结构,它是一种特殊的二叉树,其父亲节点的值等于子节点的和。节点上的值,定义为每个样本的优先度,这里就用TDerror来衡量。叶子上的数值就是样本优先度。\n", + "\n", + "sum tree 采样过程:根据根节点的priority和采样样本数,划分采样的区间,然后在这些区间中均应采样得到所要选取的样本的优先度。从根节点开始,逐层将样本的优先度和节点的优先度进行对比,最终可以得到所要采样的叶子样本。" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "\n", + "class SumTree:\n", + " '''SumTree for the per(Prioritized Experience Replay) DQN. \n", + " This SumTree code is a modified version and the original code is from:\n", + " https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/5.2_Prioritized_Replay_DQN/RL_brain.py\n", + " '''\n", + " def __init__(self, capacity: int):\n", + " self.capacity = capacity\n", + " self.data_pointer = 0\n", + " self.n_entries = 0\n", + " self.tree = np.zeros(2 * capacity - 1)\n", + " self.data = np.zeros(capacity, dtype = object)\n", + "\n", + " def update(self, tree_idx, p):\n", + " '''Update the sampling weight\n", + " '''\n", + " change = p - self.tree[tree_idx]\n", + " self.tree[tree_idx] = p\n", + "\n", + " while tree_idx != 0:\n", + " tree_idx = (tree_idx - 1) // 2\n", + " self.tree[tree_idx] += change\n", + "\n", + " def add(self, p, data):\n", + " '''Adding new data to the sumTree\n", + " '''\n", + " tree_idx = self.data_pointer + self.capacity - 1\n", + " self.data[self.data_pointer] = data\n", + " # print (\"tree_idx=\", tree_idx)\n", + " # print (\"nonzero = \", np.count_nonzero(self.tree))\n", + " self.update(tree_idx, p)\n", + "\n", + " self.data_pointer += 1\n", + " if self.data_pointer >= self.capacity:\n", + " self.data_pointer = 0\n", + "\n", + " if self.n_entries < self.capacity:\n", + " self.n_entries += 1\n", + "\n", + " def get_leaf(self, v):\n", + " '''Sampling the data\n", + " '''\n", + " parent_idx = 0\n", + " while True:\n", + " cl_idx = 2 * parent_idx + 1\n", + " cr_idx = cl_idx + 1\n", + " if cl_idx >= len(self.tree):\n", + " leaf_idx = parent_idx\n", + " break\n", + " else:\n", + " if v <= self.tree[cl_idx] :\n", + " parent_idx = cl_idx\n", + " else:\n", + " v -= self.tree[cl_idx]\n", + " parent_idx = cr_idx\n", + "\n", + " data_idx = leaf_idx - self.capacity + 1\n", + " return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n", + "\n", + " def total(self):\n", + " return int(self.tree[0])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class ReplayTree:\n", + " '''ReplayTree for the per(Prioritized Experience Replay) DQN. \n", + " '''\n", + " def __init__(self, capacity):\n", + " self.capacity = capacity # the capacity for memory replay\n", + " self.tree = SumTree(capacity)\n", + " self.abs_err_upper = 1.\n", + "\n", + " ## hyper parameter for calculating the importance sampling weight\n", + " self.beta_increment_per_sampling = 0.001\n", + " self.alpha = 0.6\n", + " self.beta = 0.4\n", + " self.epsilon = 0.01 \n", + " self.abs_err_upper = 1.\n", + "\n", + " def __len__(self):\n", + " ''' return the num of storage\n", + " '''\n", + " return self.tree.total()\n", + "\n", + " def push(self, error, sample):\n", + " '''Push the sample into the replay according to the importance sampling weight\n", + " '''\n", + " p = (np.abs(error) + self.epsilon) ** self.alpha\n", + " self.tree.add(p, sample) \n", + "\n", + "\n", + " def sample(self, batch_size):\n", + " '''This is for sampling a batch data and the original code is from:\n", + " https://github.com/rlcode/per/blob/master/prioritized_memory.py\n", + " '''\n", + " pri_segment = self.tree.total() / batch_size\n", + "\n", + " priorities = []\n", + " batch = []\n", + " idxs = []\n", + "\n", + " is_weights = []\n", + "\n", + " self.beta = np.min([1., self.beta + self.beta_increment_per_sampling])\n", + " min_prob = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total() \n", + "\n", + " for i in range(batch_size):\n", + " a = pri_segment * i\n", + " b = pri_segment * (i+1)\n", + "\n", + " s = random.uniform(a, b)\n", + " idx, p, data = self.tree.get_leaf(s)\n", + "\n", + " priorities.append(p)\n", + " batch.append(data)\n", + " idxs.append(idx)\n", + " prob = p / self.tree.total()\n", + "\n", + " sampling_probabilities = np.array(priorities) / self.tree.total()\n", + " is_weights = np.power(self.tree.n_entries * sampling_probabilities, -self.beta)\n", + " is_weights /= is_weights.max()\n", + "\n", + " return zip(*batch), idxs, is_weights\n", + " \n", + " def batch_update(self, tree_idx, abs_errors):\n", + " '''Update the importance sampling weight\n", + " '''\n", + " abs_errors += self.epsilon\n", + "\n", + " clipped_errors = np.minimum(abs_errors, self.abs_err_upper)\n", + " ps = np.power(clipped_errors, self.alpha)\n", + "\n", + " for ti, p in zip(tree_idx, ps):\n", + " self.tree.update(ti, p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、模型算法定义\n", + "\n", + "这里使用三层MLP搭建智能体agent,其中和DQN基本一致,这里不再赘述。" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "\n", + "\n", + "class PER_DQN:\n", + " def __init__(self, model, memory, cfg):\n", + "\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma \n", + " ## e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + "\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " ## 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) \n", + " self.memory = memory # SumTree 经验回放\n", + " self.update_flag = False \n", + " \n", + " def sample_action(self, state):\n", + " ''' sample action with e-greedy policy\n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon 指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # 根据Q值选择动作\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + "\n", + " def predict_action(self,state):\n", + " ''' 预测动作\n", + " '''\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() \n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 不满足一个批量时,不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"Begin to update!\")\n", + " self.update_flag = True\n", + " # 采样一个batch\n", + " (state_batch, action_batch, reward_batch, next_state_batch, done_batch), idxs_batch, is_weights_batch = self.memory.sample(\n", + " self.batch_size)\n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) # shape(batchsize,1)\n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1) # shape(batchsize,1)\n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1) # shape(batchsize,1)\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) \n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)\n", + "\n", + " # loss中根据优先度进行了加权\n", + " loss = torch.mean(torch.pow((q_value_batch - expected_q_value_batch) * torch.from_numpy(is_weights_batch).to(self.device), 2))\n", + "\n", + " # loss = nn.MSELoss()(q_value_batch, expected_q_value_batch) \n", + "\n", + " abs_errors = np.sum(np.abs(q_value_batch.cpu().detach().numpy() - expected_q_value_batch.cpu().detach().numpy()), axis=1)\n", + " # 需要更新样本的优先度\n", + " self.memory.batch_update(idxs_batch, abs_errors) \n", + "\n", + " # 反向传播\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # 梯度截断,防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + " if self.sample_count % self.target_update == 0: # 更新 target_net\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、 定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _= env.step(action) # 更新环境,返回transition\n", + "\n", + " ## PER DQN 特有的内容\n", + " policy_val = agent.policy_net(torch.tensor(state, device = cfg.device))[action]\n", + " target_val = agent.target_net(torch.tensor(next_state, device = cfg.device))\n", + "\n", + " if done:\n", + " error = abs(policy_val - reward)\n", + " else:\n", + " error = abs(policy_val - reward - cfg.gamma * torch.max(target_val))\n", + "\n", + " agent.memory.push(error.cpu().detach().numpy(), (state, action, reward,\n", + " next_state, done)) # 保存transition\n", + " \n", + " agent.update() # 更新智能体\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep + 1) % cfg.target_update == 0: # 智能体目标网络更新\n", + " agent.target_net.load_state_dict(agent.policy_net.state_dict())\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},Epislon:{agent.epsilon:.3f}\")\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.test_eps},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " if cfg.seed !=0:\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + "\n", + " cfg.n_actions = env.action_space.n ## set the env action space\n", + " model = MLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n", + " memory = ReplayTree(cfg.buffer_size)\n", + " agent = PER_DQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config():\n", + " def __init__(self) -> None:\n", + " self.env_name = \"CartPole-v1\" # 环境名字\n", + " self.new_step_api = True # 是否用gym的新api\n", + " self.wrapper = None \n", + " self.render = False \n", + " self.algo_name = \"PER_DQN\" # 算法名字\n", + " self.mode = \"train\" # train or test\n", + " self.seed = 0 # 随机种子\n", + " self.device = \"cpu\" # device to use\n", + " self.train_eps = 100 # 训练的回合数\n", + " self.test_eps = 20 # 测试的回合数\n", + " self.eval_eps = 10 # 评估的回合数\n", + " self.eval_per_episode = 5 # 每个回合的评估次数\n", + " self.max_steps = 200 # 每个回合的最大步数\n", + " self.load_checkpoint = False\n", + " self.load_path = \"tasks\" # 加载模型的路径\n", + " self.show_fig = False # 是否展示图片\n", + " self.save_fig = True # 是否存储图片\n", + "\n", + " # 设置epsilon值\n", + " self.epsilon_start = 0.95 # 起始的epsilon值\n", + " self.epsilon_end = 0.01 # 终止的epsilon值\n", + " self.epsilon_decay = 500 # 衰减率\n", + " self.hidden_dim = 256 \n", + " self.gamma = 0.95 \n", + " self.lr = 0.0001 \n", + " self.buffer_size = 100000 # 经验回放的buffer大小\n", + " self.batch_size = 64 # batch size\n", + " self.target_update = 4 # 目标网络更新频率\n", + " self.value_layers = [\n", + " {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n", + " 'activation': 'none'}]\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "Begin to update!\n", + "回合:10/100,奖励:10.00,Epislon:0.569\n", + "回合:20/100,奖励:12.00,Epislon:0.443\n", + "回合:30/100,奖励:10.00,Epislon:0.357\n", + "回合:40/100,奖励:15.00,Epislon:0.268\n", + "回合:50/100,奖励:125.00,Epislon:0.103\n", + "回合:60/100,奖励:67.00,Epislon:0.024\n", + "回合:70/100,奖励:200.00,Epislon:0.012\n", + "回合:80/100,奖励:200.00,Epislon:0.010\n", + "回合:90/100,奖励:200.00,Epislon:0.010\n", + "回合:100/100,奖励:200.00,Epislon:0.010\n", + "完成训练!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试!\n", + "回合:1/20,奖励:200.00\n", + "回合:2/20,奖励:200.00\n", + "回合:3/20,奖励:200.00\n", + "回合:4/20,奖励:200.00\n", + "回合:5/20,奖励:200.00\n", + "回合:6/20,奖励:200.00\n", + "回合:7/20,奖励:200.00\n", + "回合:8/20,奖励:200.00\n", + "回合:9/20,奖励:200.00\n", + "回合:10/20,奖励:200.00\n", + "回合:11/20,奖励:200.00\n", + "回合:12/20,奖励:200.00\n", + "回合:13/20,奖励:200.00\n", + "回合:14/20,奖励:200.00\n", + "回合:15/20,奖励:200.00\n", + "回合:16/20,奖励:200.00\n", + "回合:17/20,奖励:200.00\n", + "回合:18/20,奖励:200.00\n", + "回合:19/20,奖励:200.00\n", + "回合:20/20,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('joyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/PPO.ipynb b/notebooks/PPO.ipynb new file mode 100644 index 0000000..94cadae --- /dev/null +++ b/notebooks/PPO.ipynb @@ -0,0 +1,522 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PPO实现CarPole-v1(离散动作空间)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 定义模型" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class ActorSoftmax(nn.Module):\n", + " def __init__(self, input_dim, output_dim, hidden_dim=256):\n", + " super(ActorSoftmax, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim)\n", + " def forward(self,x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " probs = F.softmax(self.fc3(x),dim=1)\n", + " return probs\n", + "class Critic(nn.Module):\n", + " def __init__(self,input_dim,output_dim,hidden_dim=256):\n", + " super(Critic,self).__init__()\n", + " assert output_dim == 1 # critic must output a single value\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim)\n", + " def forward(self,x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " value = self.fc3(x)\n", + " return value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 定义经验回放" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from collections import deque\n", + "class ReplayBufferQue:\n", + " '''DQN的经验回放池,每次采样batch_size个样本'''\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " '''_summary_\n", + " Args:\n", + " trainsitions (tuple): _description_\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer):\n", + " batch_size = len(self.buffer)\n", + " if sequential: # sequential sampling\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else:\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " return len(self.buffer)\n", + "\n", + "class PGReplay(ReplayBufferQue):\n", + " '''PG的经验回放池,每次采样所有样本,因此只需要继承ReplayBufferQue,重写sample方法即可\n", + " '''\n", + " def __init__(self):\n", + " self.buffer = deque()\n", + " def sample(self):\n", + " ''' sample all the transitions\n", + " '''\n", + " batch = list(self.buffer)\n", + " return zip(*batch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3 定义智能体" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.distributions import Categorical\n", + "class Agent:\n", + " def __init__(self,cfg) -> None:\n", + " \n", + " self.gamma = cfg.gamma\n", + " self.device = torch.device(cfg.device) \n", + " self.actor = ActorSoftmax(cfg.n_states,cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n", + " self.critic = Critic(cfg.n_states,1,hidden_dim=cfg.critic_hidden_dim).to(self.device)\n", + " self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n", + " self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=cfg.critic_lr)\n", + " self.memory = PGReplay()\n", + " self.k_epochs = cfg.k_epochs # update policy for K epochs\n", + " self.eps_clip = cfg.eps_clip # clip parameter for PPO\n", + " self.entropy_coef = cfg.entropy_coef # entropy coefficient\n", + " self.sample_count = 0\n", + " self.update_freq = cfg.update_freq\n", + "\n", + " def sample_action(self,state):\n", + " self.sample_count += 1\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " probs = self.actor(state)\n", + " dist = Categorical(probs)\n", + " action = dist.sample()\n", + " self.log_probs = dist.log_prob(action).detach()\n", + " return action.detach().cpu().numpy().item()\n", + " @torch.no_grad()\n", + " def predict_action(self,state):\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " probs = self.actor(state)\n", + " dist = Categorical(probs)\n", + " action = dist.sample()\n", + " return action.detach().cpu().numpy().item()\n", + " def update(self):\n", + " # update policy every n steps\n", + " if self.sample_count % self.update_freq != 0:\n", + " return\n", + " # print(\"update policy\")\n", + " old_states, old_actions, old_log_probs, old_rewards, old_dones = self.memory.sample()\n", + " # convert to tensor\n", + " old_states = torch.tensor(np.array(old_states), device=self.device, dtype=torch.float32)\n", + " old_actions = torch.tensor(np.array(old_actions), device=self.device, dtype=torch.float32)\n", + " old_log_probs = torch.tensor(old_log_probs, device=self.device, dtype=torch.float32)\n", + " # monte carlo estimate of state rewards\n", + " returns = []\n", + " discounted_sum = 0\n", + " for reward, done in zip(reversed(old_rewards), reversed(old_dones)):\n", + " if done:\n", + " discounted_sum = 0\n", + " discounted_sum = reward + (self.gamma * discounted_sum)\n", + " returns.insert(0, discounted_sum)\n", + " # Normalizing the rewards:\n", + " returns = torch.tensor(returns, device=self.device, dtype=torch.float32)\n", + " returns = (returns - returns.mean()) / (returns.std() + 1e-5) # 1e-5 to avoid division by zero\n", + " for _ in range(self.k_epochs):\n", + " # compute advantage\n", + " values = self.critic(old_states) # detach to avoid backprop through the critic\n", + " advantage = returns - values.detach()\n", + " # get action probabilities\n", + " probs = self.actor(old_states)\n", + " dist = Categorical(probs)\n", + " # get new action probabilities\n", + " new_probs = dist.log_prob(old_actions)\n", + " # compute ratio (pi_theta / pi_theta__old):\n", + " ratio = torch.exp(new_probs - old_log_probs) # old_log_probs must be detached\n", + " # compute surrogate loss\n", + " surr1 = ratio * advantage\n", + " surr2 = torch.clamp(ratio, 1 - self.eps_clip, 1 + self.eps_clip) * advantage\n", + " # compute actor loss\n", + " actor_loss = -torch.min(surr1, surr2).mean() + self.entropy_coef * dist.entropy().mean()\n", + " # compute critic loss\n", + " critic_loss = (returns - values).pow(2).mean()\n", + " # take gradient step\n", + " self.actor_optimizer.zero_grad()\n", + " self.critic_optimizer.zero_grad()\n", + " actor_loss.backward()\n", + " critic_loss.backward()\n", + " self.actor_optimizer.step()\n", + " self.critic_optimizer.step()\n", + " self.memory.clear()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " best_ep_reward = 0 # 记录最大回合奖励\n", + " output_agent = None\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " agent.memory.push((state, action,agent.log_probs,reward,done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep+1)%cfg.eval_per_episode == 0:\n", + " sum_eval_reward = 0\n", + " for _ in range(cfg.eval_eps):\n", + " eval_ep_reward = 0\n", + " state = env.reset()\n", + " for _ in range(cfg.max_steps):\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " eval_ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " sum_eval_reward += eval_ep_reward\n", + " mean_eval_reward = sum_eval_reward/cfg.eval_eps\n", + " if mean_eval_reward >= best_ep_reward:\n", + " best_ep_reward = mean_eval_reward\n", + " output_agent = copy.deepcopy(agent)\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},评估奖励:{mean_eval_reward:.2f},最佳评估奖励:{best_ep_reward:.2f},更新模型!\")\n", + " else:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.2f},评估奖励:{mean_eval_reward:.2f},最佳评估奖励:{best_ep_reward:.2f}\")\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(\"完成训练!\")\n", + " env.close()\n", + " return output_agent,{'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试!\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境,返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境,返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.test_eps},奖励:{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "import numpy as np\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " if seed == 0:\n", + " return\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度:{n_states},动作空间维度:{n_actions}\")\n", + " # 更新n_states和n_actions到cfg参数中\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions) \n", + " agent = Agent(cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. 设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config:\n", + " def __init__(self) -> None:\n", + " self.env_name = \"CartPole-v1\" # 环境名字\n", + " self.new_step_api = False # 是否用gym的新api\n", + " self.algo_name = \"PPO\" # 算法名字\n", + " self.mode = \"train\" # train or test\n", + " self.seed = 1 # 随机种子\n", + " self.device = \"cuda\" # device to use\n", + " self.train_eps = 200 # 训练的回合数\n", + " self.test_eps = 20 # 测试的回合数\n", + " self.max_steps = 200 # 每个回合的最大步数\n", + " self.eval_eps = 5 # 评估的回合数\n", + " self.eval_per_episode = 10 # 评估的频率\n", + "\n", + " self.gamma = 0.99 # 折扣因子\n", + " self.k_epochs = 4 # 更新策略网络的次数\n", + " self.actor_lr = 0.0003 # actor网络的学习率\n", + " self.critic_lr = 0.0003 # critic网络的学习率\n", + " self.eps_clip = 0.2 # epsilon-clip\n", + " self.entropy_coef = 0.01 # entropy的系数\n", + " self.update_freq = 100 # 更新频率\n", + " self.actor_hidden_dim = 256 # actor网络的隐藏层维度\n", + " self.critic_hidden_dim = 256 # critic网络的隐藏层维度\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. 开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度:4,动作空间维度:2\n", + "开始训练!\n", + "回合:10/200,奖励:11.00,评估奖励:29.20,最佳评估奖励:29.20,更新模型!\n", + "回合:20/200,奖励:68.00,评估奖励:25.00,最佳评估奖励:29.20\n", + "回合:30/200,奖励:60.00,评估奖励:26.20,最佳评估奖励:29.20\n", + "回合:40/200,奖励:105.00,评估奖励:27.60,最佳评估奖励:29.20\n", + "回合:50/200,奖励:26.00,评估奖励:60.60,最佳评估奖励:60.60,更新模型!\n", + "回合:60/200,奖励:122.00,评估奖励:113.40,最佳评估奖励:113.40,更新模型!\n", + "回合:70/200,奖励:65.00,评估奖励:38.00,最佳评估奖励:113.40\n", + "回合:80/200,奖励:175.00,评估奖励:135.40,最佳评估奖励:135.40,更新模型!\n", + "回合:90/200,奖励:200.00,评估奖励:177.20,最佳评估奖励:177.20,更新模型!\n", + "回合:100/200,奖励:115.00,评估奖励:173.60,最佳评估奖励:177.20\n", + "回合:110/200,奖励:200.00,评估奖励:183.20,最佳评估奖励:183.20,更新模型!\n", + "回合:120/200,奖励:196.00,评估奖励:173.60,最佳评估奖励:183.20\n", + "回合:130/200,奖励:46.00,评估奖励:61.40,最佳评估奖励:183.20\n", + "回合:140/200,奖励:200.00,评估奖励:166.40,最佳评估奖励:183.20\n", + "回合:150/200,奖励:172.00,评估奖励:154.40,最佳评估奖励:183.20\n", + "回合:160/200,奖励:61.00,评估奖励:84.80,最佳评估奖励:183.20\n", + "回合:170/200,奖励:127.00,评估奖励:181.60,最佳评估奖励:183.20\n", + "回合:180/200,奖励:152.00,评估奖励:173.20,最佳评估奖励:183.20\n", + "回合:190/200,奖励:200.00,评估奖励:200.00,最佳评估奖励:200.00,更新模型!\n", + "回合:200/200,奖励:176.00,评估奖励:190.20,最佳评估奖励:200.00\n", + "完成训练!\n", + "开始测试!\n", + "回合:1/20,奖励:200.00\n", + "回合:2/20,奖励:200.00\n", + "回合:3/20,奖励:200.00\n", + "回合:4/20,奖励:200.00\n", + "回合:5/20,奖励:200.00\n", + "回合:6/20,奖励:200.00\n", + "回合:7/20,奖励:200.00\n", + "回合:8/20,奖励:200.00\n", + "回合:9/20,奖励:200.00\n", + "回合:10/20,奖励:200.00\n", + "回合:11/20,奖励:200.00\n", + "回合:12/20,奖励:200.00\n", + "回合:13/20,奖励:200.00\n", + "回合:14/20,奖励:200.00\n", + "回合:15/20,奖励:200.00\n", + "回合:16/20,奖励:200.00\n", + "回合:17/20,奖励:200.00\n", + "回合:18/20,奖励:200.00\n", + "回合:19/20,奖励:200.00\n", + "回合:20/20,奖励:200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "best_agent,res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, best_agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/PPO暂存.md b/notebooks/PPO暂存.md new file mode 100644 index 0000000..125ef51 --- /dev/null +++ b/notebooks/PPO暂存.md @@ -0,0 +1,142 @@ +## 原理简介 + +PPO是一种on-policy算法,具有较好的性能,其前身是TRPO算法,也是policy gradient算法的一种,它是现在 OpenAI 默认的强化学习算法,具体原理可参考[PPO算法讲解](https://datawhalechina.github.io/easy-rl/#/chapter5/chapter5)。PPO算法主要有两个变种,一个是结合KL penalty的,一个是用了clip方法,本文实现的是后者即```PPO-clip```。 +## 伪代码 +要实现必先了解伪代码,伪代码如下: +![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvaG5KaW0w,size_16,color_FFFFFF,t_70.png) +这是谷歌找到的一张比较适合的图,本人比较懒就没有修改,上面的```k```就是第```k```个episode,第六步是用随机梯度下降的方法优化,这里的损失函数(即```argmax```后面的部分)可能有点难理解,可参考[PPO paper](https://arxiv.org/abs/1707.06347),如下: +![在这里插入图片描述](assets/20210323154236878.png) +第七步就是一个平方损失函数,即实际回报与期望回报的差平方。 +## 代码实战 +[点击查看完整代码](https://github.com/JohnJim0816/rl-tutorials/tree/master/PPO) +### PPOmemory +首先第三步需要搜集一条轨迹信息,我们可以定义一个```PPOmemory```来存储相关信息: +```python +class PPOMemory: + def __init__(self, batch_size): + self.states = [] + self.probs = [] + self.vals = [] + self.actions = [] + self.rewards = [] + self.dones = [] + self.batch_size = batch_size + def sample(self): + batch_step = np.arange(0, len(self.states), self.batch_size) + indices = np.arange(len(self.states), dtype=np.int64) + np.random.shuffle(indices) + batches = [indices[i:i+self.batch_size] for i in batch_step] + return np.array(self.states),\ + np.array(self.actions),\ + np.array(self.probs),\ + np.array(self.vals),\ + np.array(self.rewards),\ + np.array(self.dones),\ + batches + + def push(self, state, action, probs, vals, reward, done): + self.states.append(state) + self.actions.append(action) + self.probs.append(probs) + self.vals.append(vals) + self.rewards.append(reward) + self.dones.append(done) + + def clear(self): + self.states = [] + self.probs = [] + self.actions = [] + self.rewards = [] + self.dones = [] + self.vals = [] +``` +这里的push函数就是将得到的相关量放入memory中,sample就是随机采样出来,方便第六步的随机梯度下降。 +### PPO model +model就是actor和critic两个网络了: +```python +import torch.nn as nn +from torch.distributions.categorical import Categorical +class Actor(nn.Module): + def __init__(self,n_states, n_actions, + hidden_dim=256): + super(Actor, self).__init__() + + self.actor = nn.Sequential( + nn.Linear(n_states, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, n_actions), + nn.Softmax(dim=-1) + ) + def forward(self, state): + dist = self.actor(state) + dist = Categorical(dist) + return dist + +class Critic(nn.Module): + def __init__(self, n_states,hidden_dim=256): + super(Critic, self).__init__() + self.critic = nn.Sequential( + nn.Linear(n_states, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, 1) + ) + def forward(self, state): + value = self.critic(state) + return value +``` +这里Actor就是得到一个概率分布(Categorica,也可以是别的分布,可以搜索torch distributionsl),critc根据当前状态得到一个值,这里的输入维度可以是```n_states+n_actions```,即将action信息也纳入critic网络中,这样会更好一些,感兴趣的小伙伴可以试试。 + +### PPO update +定义一个update函数主要实现伪代码中的第六步和第七步: +```python +def update(self): + for _ in range(self.n_epochs): + state_arr, action_arr, old_prob_arr, vals_arr,\ + reward_arr, dones_arr, batches = \ + self.memory.sample() + values = vals_arr + ### compute advantage ### + advantage = np.zeros(len(reward_arr), dtype=np.float32) + for t in range(len(reward_arr)-1): + discount = 1 + a_t = 0 + for k in range(t, len(reward_arr)-1): + a_t += discount*(reward_arr[k] + self.gamma*values[k+1]*\ + (1-int(dones_arr[k])) - values[k]) + discount *= self.gamma*self.gae_lambda + advantage[t] = a_t + advantage = torch.tensor(advantage).to(self.device) + ### SGD ### + values = torch.tensor(values).to(self.device) + for batch in batches: + states = torch.tensor(state_arr[batch], dtype=torch.float).to(self.device) + old_probs = torch.tensor(old_prob_arr[batch]).to(self.device) + actions = torch.tensor(action_arr[batch]).to(self.device) + dist = self.actor(states) + critic_value = self.critic(states) + critic_value = torch.squeeze(critic_value) + new_probs = dist.log_prob(actions) + prob_ratio = new_probs.exp() / old_probs.exp() + weighted_probs = advantage[batch] * prob_ratio + weighted_clipped_probs = torch.clamp(prob_ratio, 1-self.policy_clip, + 1+self.policy_clip)*advantage[batch] + actor_loss = -torch.min(weighted_probs, weighted_clipped_probs).mean() + returns = advantage[batch] + values[batch] + critic_loss = (returns-critic_value)**2 + critic_loss = critic_loss.mean() + total_loss = actor_loss + 0.5*critic_loss + self.actor_optimizer.zero_grad() + self.critic_optimizer.zero_grad() + total_loss.backward() + self.actor_optimizer.step() + self.critic_optimizer.step() + self.memory.clear() +``` +该部分首先从memory中提取搜集到的轨迹信息,然后计算gae,即advantage,接着使用随机梯度下降更新网络,最后清除memory以便搜集下一条轨迹信息。 + +最后实现效果如下: +![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvaG5KaW0w,size_16,color_FFFFFF,t_70-20210405110725113.png) \ No newline at end of file diff --git a/notebooks/PolicyGradient.ipynb b/notebooks/PolicyGradient.ipynb new file mode 100644 index 0000000..b6326da --- /dev/null +++ b/notebooks/PolicyGradient.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法\n", + "\n", + "最基础的策略梯度算法就是REINFORCE算法,又称作Monte-Carlo Policy Gradient算法。我们策略优化的目标如下:\n", + "\n", + "$$\n", + "J_{\\theta}= \\Psi_{\\pi} \\nabla_\\theta \\log \\pi_\\theta\\left(a_t \\mid s_t\\right)\n", + "$$\n", + "\n", + "其中$\\Psi_{\\pi}$在REINFORCE算法中表示衰减的回报(具体公式见伪代码),也可以用优势来估计,也就是我们熟知的A3C算法,这个在后面包括GAE算法中都会讲到。\n", + "\n", + "### 1.1. 策略函数设计\n", + "\n", + "既然策略梯度是直接对策略函数进行梯度计算,那么策略函数如何设计呢?一般来讲有两种设计方式,一个是softmax函数,另外一个是高斯分布$\\mathbb{N}\\left(\\phi(\\mathbb{s})^{\\mathbb{\\pi}} \\theta, \\sigma^2\\right)$,前者用于离散动作空间,后者多用于连续动作空间。\n", + "\n", + "softmax函数可以表示为:\n", + "$$\n", + "\\pi_\\theta(s, a)=\\frac{e^{\\phi(s, a)^{T_\\theta}}}{\\sum_b e^{\\phi(s, b)^{T^T}}}\n", + "$$\n", + "对应的梯度为:\n", + "$$\n", + "\\nabla_\\theta \\log \\pi_\\theta(s, a)=\\phi(s, a)-\\mathbb{E}_{\\pi_\\theta}[\\phi(s,)\n", + "$$\n", + "高斯分布对应的梯度为:\n", + "$$\n", + "\\nabla_\\theta \\log \\pi_\\theta(s, a)=\\frac{\\left(a-\\phi(s)^T \\theta\\right) \\phi(s)}{\\sigma^2}\n", + "$$\n", + "但是对于一些特殊的情况,例如在本次演示中动作维度=2且为离散空间,这个时候可以用伯努利分布来实现,这种方式其实是不推荐的,这里给大家做演示也是为了展现一些特殊情况,启发大家一些思考,例如Bernoulli,Binomial,Gaussian分布之间的关系。简单说来,Binomial分布,$n = 1$时就是Bernoulli分布,$n \\rightarrow \\infty$时就是Gaussian分布。\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2. 模型设计\n", + "\n", + "前面讲到,尽管本次演示是离散空间,但是由于动作维度等于2,此时就可以用特殊的高斯分布来表示策略函数,即伯努利分布。伯努利的分布实际上是用一个概率作为输入,然后从中采样动作,伯努利采样出来的动作只可能是0或1,就像投掷出硬币的正反面。在这种情况下,我们的策略模型就需要在MLP的基础上,将状态作为输入,将动作作为倒数第二层输出,并在最后一层增加激活函数来输出对应动作的概率。不清楚激活函数作用的同学可以再看一遍深度学习相关的知识,简单来说其作用就是增加神经网络的非线性。既然需要输出对应动作的概率,那么输出的值需要处于0-1之间,此时sigmoid函数刚好满足我们的需求,实现代码参考如下。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class PGNet(nn.Module):\n", + " def __init__(self, input_dim,output_dim,hidden_dim=128):\n", + " \"\"\" 初始化q网络,为全连接网络\n", + " input_dim: 输入的特征数即环境的状态维度\n", + " output_dim: 输出的动作维度\n", + " \"\"\"\n", + " super(PGNet, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim) # 输入层\n", + " self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim) # 输出层\n", + " def forward(self, x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " x = torch.sigmoid(self.fc3(x))\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3. 更新函数设计\n", + "\n", + "前面提到我们的优化目标也就是策略梯度算法的损失函数如下:\n", + "$$\n", + "J_{\\theta}= \\Psi_{\\pi} \\nabla_\\theta \\log \\pi_\\theta\\left(a_t \\mid s_t\\right)\n", + "$$\n", + "\n", + "我们需要拆开成两个部分$\\Psi_{\\pi}$和$\\nabla_\\theta \\log \\pi_\\theta\\left(a_t \\mid s_t\\right)$分开计算,首先看值函数部分$\\Psi_{\\pi}$,在REINFORCE算法中值函数是从当前时刻开始的衰减回报,如下:\n", + "$$\n", + "G \\leftarrow \\sum_{k=t+1}^{T} \\gamma^{k-1} r_{k}\n", + "$$\n", + "\n", + "这个实际用代码来实现的时候可能有点绕,我们可以倒过来看,在同一回合下,我们的终止时刻是$T$,那么对应的回报$G_T=\\gamma^{T-1}r_T$,而对应的$G_{T-1}=\\gamma^{T-2}r_{T-1}+\\gamma^{T-1}r_T$,在这里代码中我们使用了一个动态规划的技巧,如下:\n", + "```python\n", + "running_add = running_add * self.gamma + reward_pool[i] # running_add初始值为0\n", + "```\n", + "这个公式也是倒过来循环的,第一次的值等于:\n", + "$$\n", + "running\\_add = r_T\n", + "$$\n", + "第二次的值则等于:\n", + "$$\n", + "running\\_add = r_T*\\gamma+r_{T-1}\n", + "$$\n", + "第三次的值等于:\n", + "$$\n", + "running\\_add = (r_T*\\gamma+r_{T-1})*\\gamma+r_{T-2} = r_T*\\gamma^2+r_{T-1}*\\gamma+r_{T-2}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.distributions import Bernoulli\n", + "from torch.autograd import Variable\n", + "import numpy as np\n", + "\n", + "class PolicyGradient:\n", + " \n", + " def __init__(self, model,memory,cfg):\n", + " self.gamma = cfg['gamma']\n", + " self.device = torch.device(cfg['device']) \n", + " self.memory = memory\n", + " self.policy_net = model.to(self.device)\n", + " self.optimizer = torch.optim.RMSprop(self.policy_net.parameters(), lr=cfg['lr'])\n", + "\n", + " def sample_action(self,state):\n", + "\n", + " state = torch.from_numpy(state).float()\n", + " state = Variable(state)\n", + " probs = self.policy_net(state)\n", + " m = Bernoulli(probs) # 伯努利分布\n", + " action = m.sample()\n", + " \n", + " action = action.data.numpy().astype(int)[0] # 转为标量\n", + " return action\n", + " def predict_action(self,state):\n", + "\n", + " state = torch.from_numpy(state).float()\n", + " state = Variable(state)\n", + " probs = self.policy_net(state)\n", + " m = Bernoulli(probs) # 伯努利分布\n", + " action = m.sample()\n", + " action = action.data.numpy().astype(int)[0] # 转为标量\n", + " return action\n", + " \n", + " def update(self):\n", + " state_pool,action_pool,reward_pool= self.memory.sample()\n", + " state_pool,action_pool,reward_pool = list(state_pool),list(action_pool),list(reward_pool)\n", + " # Discount reward\n", + " running_add = 0\n", + " for i in reversed(range(len(reward_pool))):\n", + " if reward_pool[i] == 0:\n", + " running_add = 0\n", + " else:\n", + " running_add = running_add * self.gamma + reward_pool[i]\n", + " reward_pool[i] = running_add\n", + "\n", + " # Normalize reward\n", + " reward_mean = np.mean(reward_pool)\n", + " reward_std = np.std(reward_pool)\n", + " for i in range(len(reward_pool)):\n", + " reward_pool[i] = (reward_pool[i] - reward_mean) / reward_std\n", + "\n", + " # Gradient Desent\n", + " self.optimizer.zero_grad()\n", + "\n", + " for i in range(len(reward_pool)):\n", + " state = state_pool[i]\n", + " action = Variable(torch.FloatTensor([action_pool[i]]))\n", + " reward = reward_pool[i]\n", + " state = Variable(torch.from_numpy(state).float())\n", + " probs = self.policy_net(state)\n", + " m = Bernoulli(probs)\n", + " loss = -m.log_prob(action) * reward # Negtive score function x reward\n", + " # print(loss)\n", + " loss.backward()\n", + " self.optimizer.step()\n", + " self.memory.clear()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('easyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Q-learning/Q-learning探索策略研究.ipynb b/notebooks/Q-learning/Q-learning探索策略研究.ipynb new file mode 100644 index 0000000..7a1c50c --- /dev/null +++ b/notebooks/Q-learning/Q-learning探索策略研究.ipynb @@ -0,0 +1,3167 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q learning with different exploration strategies\n", + "\n", + "Authors: [johnjim0816](https://github.com/johnjim0816) \n", + "Contributer: [Scc_hy](https://github.com/scchy)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 加载需要的package" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
gym version == 0.25.2\n",
+       "
\n" + ], + "text/plain": [ + "gym version == \u001b[1;36m0.25\u001b[0m.\u001b[1;36m2\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import math\n", + "from collections import defaultdict\n", + "from enum import Enum\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import torch\n", + "import gym\n", + "from gym import register\n", + "import os\n", + "import sys\n", + "import warnings\n", + "from tqdm import tqdm\n", + "from rich.console import Console\n", + "file_dir_name = os.path.dirname(os.getcwd())\n", + "os.environ['KMP_DUPLICATE_LIB_OK']='True'\n", + "if file_dir_name not in sys.path:\n", + " sys.path.append(file_dir_name)\n", + "\n", + "from gym.envs.toy_text import FrozenLakeEnv\n", + "from envs.simple_grid import DrunkenWalkEnv\n", + "\n", + "# 可以将print输出美化\n", + "cs = Console()\n", + "warnings.filterwarnings('ignore')\n", + "cs.print(f\"gym version == {gym.__version__}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🚀 1、定义算法" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class QLearning(object):\n", + " def __init__(self,cfg):\n", + " self.explore_type = cfg.explore_type # 探索策略类型\n", + " self.n_actions = cfg.n_actions \n", + " self.lr = cfg.lr # 学习率\n", + " self.gamma = cfg.gamma \n", + " self.epsilon = cfg.epsilon_start\n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.epsilon_decay_flag = cfg.epsilon_decay_flag\n", + " self.Q_table = np.zeros((cfg.n_states, self.n_actions)) # 用np.array 作为QTable 第一维为state, 第二维维每个state可以采取的action\n", + " self.__ucb_init()\n", + " \n", + " @staticmethod\n", + " def explore_type_space():\n", + " return { 'epsilon_greedy', 'boltzmann', 'ucb', 'special_ucb', 'softmax', 'thompson'}\n", + " \n", + " def __softmax(self, actions_v):\n", + " return np.exp(actions_v + 1e-3 ) / np.sum(np.exp(actions_v + 1e-3), axis=0)\n", + "\n", + " def __softmax_policy_init(self):\n", + " self.Q_table = np.random.random(self.Q_table.shape)\n", + "\n", + " def __ucb_init(self):\n", + " self.ucb_sa_visit_cnt_arr = np.array([])\n", + " self.ucb_cnt = 0\n", + " self.ucb_print = 0\n", + " self.ucb_sa_visit_cnt_arr = np.ones(self.Q_table.shape)\n", + "\n", + " def _sp_ucb_policy(self, s):\n", + " \"\"\"ucb策略\n", + " reference: \n", + " \"\"\"\n", + " self.ucb_cnt += 1\n", + " # 先验action\n", + " not_state_once = np.sum(self.ucb_sa_visit_cnt_arr > 1, axis=1).sum() < self.ucb_sa_visit_cnt_arr.shape[0]\n", + " if not_state_once:\n", + " a_final = self._e_greedy(s)\n", + " self.ucb_sa_visit_cnt_arr[s, a_final] += 1\n", + " return a_final\n", + "\n", + " self.ucb_print += 1\n", + " if self.ucb_print == 1:\n", + " print(f'UCB-Start {self.ucb_cnt}')\n", + " b_t = self.__softmax(self.Q_table[s]) + self.__softmax(np.sqrt(2 * np.log(self.ucb_cnt) / self.ucb_sa_visit_cnt_arr[s]))\n", + " a_final = np.argmax(b_t)\n", + " self.ucb_sa_visit_cnt_arr[s, a_final] += 1\n", + " return a_final\n", + " \n", + " def _e_greedy(self, state):\n", + " self.epsilon = self.epsilon_end\n", + " if self.epsilon_decay_flag:\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的,这里选择指数递减\n", + " # e-greedy 策略\n", + " if np.random.uniform(0, 1) < self.epsilon: # 随机选择动作\n", + " return np.random.randint(len(self.Q_table[state]))\n", + " if sum(self.Q_table[state]) != 0:\n", + " return np.argmax(self.Q_table[state]) # 选择Q(s,a)最大对应的动作\n", + " return np.random.randint(len(self.Q_table[state]))\n", + " \n", + " def sample_action(self, state):\n", + " ''' 采样动作,训练时用\n", + " '''\n", + " self.sample_count += 1\n", + " if self.explore_type == 'epsilon_greedy':\n", + " return self._e_greedy(state)\n", + " elif self.explore_type == 'boltzmann':\n", + " # boltzmann 策略\n", + " action_probs = np.exp(self.Q_table[int(state)] / self.epsilon) / np.sum(np.exp(self.Q_table[int(state)] / self.epsilon))\n", + " action = np.random.choice(self.n_actions, p=action_probs)\n", + " return action\n", + " elif self.explore_type == 'ucb':\n", + " # ucb 策略\n", + " if self.sample_count < self.n_actions:\n", + " action = self.sample_count\n", + " else:\n", + " action = np.argmax(\n", + " self.__softmax(self.Q_table[int(state)]) + \n", + " self.__softmax(self.epsilon * np.sqrt(np.log(self.sample_count) / self.sample_count))\n", + " )\n", + " return action\n", + " elif self.explore_type == 'special_ucb':\n", + " return self._sp_ucb_policy(state)\n", + " elif self.explore_type == 'softmax':\n", + " if self.sample_count <= 1:\n", + " self.__softmax_policy_init()\n", + " # softmax 策略\n", + " action_probs = np.exp(self.Q_table[int(state)] / self.epsilon) / np.sum(np.exp(self.Q_table[int(state)] / self.epsilon))\n", + " action = np.random.choice(self.n_actions, p=action_probs)\n", + " return action\n", + " elif self.explore_type == 'thompson':\n", + " # thompson 策略\n", + " success_p = self.__softmax(self.Q_table[state])\n", + " failed_p = 1 - success_p\n", + " samples = np.random.beta(success_p, failed_p)\n", + " return np.argmax(samples)\n", + " else:\n", + " raise NotImplementedError\n", + "\n", + " def predict_action(self,state):\n", + " ''' 预测或选择动作,测试时用\n", + " '''\n", + " if self.explore_type == 'epsilon_greedy':\n", + " action = np.argmax(self.Q_table[int(state)])\n", + " return action\n", + " elif self.explore_type == 'boltzmann':\n", + " action_probs = np.exp(self.Q_table[int(state)] / self.epsilon) / np.sum(np.exp(self.Q_table[int(state)] / self.epsilon))\n", + " action = np.random.choice(self.n_actions, p=action_probs)\n", + " return action\n", + " elif self.explore_type in ['ucb', 'special_ucb']:\n", + " action = np.argmax(self.Q_table[int(state)])\n", + " return action\n", + " elif self.explore_type == 'softmax':\n", + " action_probs = np.exp(self.Q_table[int(state)] / self.epsilon) / np.sum(np.exp(self.Q_table[int(state)] / self.epsilon))\n", + " action = np.random.choice(self.n_actions, p=action_probs)\n", + " return action\n", + " elif self.explore_type == 'thompson':\n", + " success_p = self.__softmax(self.Q_table[state])\n", + " failed_p = 1 - success_p\n", + " samples = np.random.beta(success_p, failed_p)\n", + " return np.argmax(samples)\n", + " else:\n", + " raise NotImplementedError\n", + "\n", + " def update(self, state, action, reward, next_state, terminated):\n", + " Q_predict = self.Q_table[int(state)][action] \n", + " if terminated: # 终止状态\n", + " Q_target = reward \n", + " else:\n", + " Q_target = reward + self.gamma * np.max(self.Q_table[int(next_state)]) \n", + " self.Q_table[int(state)][action] += self.lr * (Q_target - Q_predict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def all_seed(env, seed = 1):\n", + " ''' omnipotent seed for RL, attention the position of seed function, you'd better put it just following the env create function\n", + " Args:\n", + " env (_type_): \n", + " seed (int, optional): _description_. Defaults to 1.\n", + " '''\n", + " import torch\n", + " import numpy as np\n", + " import random\n", + " # print(f\"seed = {seed}\")\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + " print(f'Set env random_seed = {seed}')\n", + "\n", + "\n", + "def train(cfg, env, agent):\n", + " out_dict = {'algo': cfg.algo_name, 'explore_type': cfg.explore_type}\n", + " best = 1 if cfg.env_name == 'FrozenLakeEasy-v0' else 10\n", + " def conv_finished(rewards):\n", + " if len(rewards) <= 11:\n", + " return len(rewards), False\n", + " if np.mean(rewards[-11:-1]) == best:\n", + " return len(rewards), np.mean(rewards[-11:-1]) == np.mean(rewards[-10:])\n", + " return len(rewards), False\n", + "\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录奖励\n", + " fi_flag = False\n", + " tq_bar = tqdm(range(cfg.train_eps))\n", + " all_seed(env, seed = cfg.seed)\n", + " for i_ep in tq_bar:\n", + " tq_bar.set_description(f'Tarin[ {i_ep + 1}/{cfg.train_eps} ](Epsilon:{agent.epsilon:.3f})')\n", + " ep_reward = 0 # 记录每个回合的奖励\n", + " ep_step = 0\n", + " # 重置环境,即开始新的回合\n", + " state = env.reset() \n", + " while cfg.max_step > ep_step:\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 根据算法采样一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一次动作交互\n", + " agent.update(state, action, reward, next_state, terminated) # Q学习算法更新\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " last_10_mean = np.mean(rewards[-10:])\n", + "\n", + " if not fi_flag:\n", + " step, fi_flag = conv_finished(rewards)\n", + " out_dict['conv_eps'] = step\n", + "\n", + " tq_bar.set_postfix(reward=f'{last_10_mean:.3f}')\n", + " tq_bar.update()\n", + "\n", + " out_dict['rewards'] = rewards\n", + " return out_dict #TODO:可以加收敛的回合数\n", + "\n", + "\n", + "def test(cfg, env, agent):\n", + " out_dict = {'algo': cfg.algo_name, 'explore_type': cfg.explore_type}\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " tq_bar = tqdm(range(cfg.test_eps))\n", + " for i_ep in tq_bar:\n", + " tq_bar.set_description(f'Test[ {i_ep + 1}/{cfg.test_eps} ](Epsilon:{agent.epsilon:.3f})')\n", + " ep_step = 0 # 记录每个episode的智能体行走的次数\n", + " ep_reward = 0 # 记录每个episode的reward\n", + " env.seed(cfg.seed)\n", + " state = env.reset() # 重置环境, 重新开一局(即开始新的一个回合)\n", + " while cfg.max_step > ep_step:\n", + " action = agent.predict_action(state) # 根据算法选择一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一个交互\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " ep_step += 1\n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " steps.append(ep_step)\n", + " last_10_mean = np.mean(rewards[-10:])\n", + " \n", + " tq_bar.set_postfix(reward=f'{last_10_mean:.3f}')\n", + " tq_bar.update()\n", + "\n", + " out_dict['rewards'] = rewards\n", + " out_dict['steps'] = steps\n", + " out_dict['meanReward'] = np.mean(rewards)\n", + " out_dict['meanSteps'] = np.mean(steps)\n", + " return out_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## \t📊 3、一些可视化的工具\n", + "这部分脚本大家可以直接Copy使用" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class Direct(Enum):\n", + " Left_v = 0\n", + " Down_v = 1\n", + " Right_v = 2\n", + " Up_v = 3\n", + " Left = -1\n", + " Down = -1\n", + " Right = +1\n", + " Up = +1\n", + " Left_s = r'$\\Leftarrow$'\n", + " Down_s = r'$\\Downarrow$'\n", + " Right_s = r'$\\Rightarrow$'\n", + " Up_s = r'$\\Uparrow$'\n", + "\n", + "\n", + "class QTablePlot:\n", + " def __init__(self, Q_table, env):\n", + " self.Q_table = Q_table\n", + " self.env = env\n", + " self.env_rows, self.env_cols = env.nrow, env.ncol\n", + " self.table = np.zeros((env.nrow * 3, env.ncol * 3))\n", + " self.direct = Direct\n", + " self.text_record_dict = {}\n", + " self.record_SHG = {}\n", + "\n", + " def _fill_table(self, q_table: np.ndarray):\n", + " text_str_list = [\n", + " Direct.Left_s.value, \n", + " Direct.Down_s.value, \n", + " Direct.Right_s.value, \n", + " Direct.Up_s.value\n", + " ]\n", + " env_desc_str = ''.join(''.join(i) for i in self.env.desc.astype(str))\n", + " for r in range(self.env_rows):\n", + " for c in range(self.env_cols):\n", + " s = r * self.env_cols + c\n", + " center_r = 1 + (self.env_rows - r - 1) * 3\n", + " # center_r = 1 + r * 3\n", + " center_c = 1 + c * 3\n", + " # \"Left\",\"Down\",\"Right\",\"Up\"\n", + " self.table[\n", + " center_r , center_c + Direct.Left.value\n", + " ] = q_table[s, Direct.Left_v.value]\n", + " self.table[\n", + " center_r , center_c + Direct.Right.value\n", + " ] = q_table[s, Direct.Right_v.value]\n", + " self.table[\n", + " center_r + Direct.Down.value , center_c\n", + " ] = q_table[s, Direct.Down_v.value]\n", + " self.table[\n", + " center_r + Direct.Up.value , center_c\n", + " ] = q_table[s, Direct.Up_v.value]\n", + " # center\n", + " self.table[\n", + " center_r , center_c\n", + " ] = q_table[s].mean()\n", + "\n", + " idx = np.argmax(q_table[s])\n", + " name = text_str_list[idx]\n", + " mv_v = Direct[Direct(idx).name[:-2]].value\n", + "\n", + " if idx in [0, 2]:\n", + " self.text_record_dict[f'{center_r},{center_c + mv_v}'] = name\n", + "\n", + " else:\n", + " self.text_record_dict[f'{center_r + mv_v},{center_c}'] = name\n", + " \n", + " if env_desc_str[s] != '.' and env_desc_str[s] != 'F':\n", + " self.record_SHG[f'{center_r},{center_c}'] = env_desc_str[s]\n", + " \n", + " @staticmethod\n", + " def exp_smooth(data, weight=0.9): \n", + " '''用于指数平滑曲线\n", + " '''\n", + " last = data[0] # First value in the plot (first timestep)\n", + " smoothed = list()\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + " def exp_smooth_plot_rewards(self, rewards, title=\"\", ax=None):\n", + " sns.set()\n", + " if ax:\n", + " ax.set_title(f\"{title}learning curve(expSmooth)\")\n", + " ax.set_xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " ax.set_xlabel('epsiodes')\n", + " ax.plot(rewards, label='rewards')\n", + " ax.plot(self.exp_smooth(rewards), label='smoothed')\n", + " ax.legend()\n", + " return\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{title}\")\n", + " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(self.exp_smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + "\n", + " def rewards_plot(self, rewards, window_size=10, freq=1, title='', axes=None):\n", + " record_arr = np.array(rewards)\n", + " record_smooth = []\n", + " std_list = []\n", + " if len(record_arr) < window_size:\n", + " window_size = 10\n", + " for i in range(1, len(rewards), freq):\n", + " tmp_arr = record_arr[max(0, i-window_size):i]\n", + " record_smooth.append(np.mean(tmp_arr))\n", + " std_list.append(np.std(tmp_arr))\n", + " \n", + " if axes is None:\n", + " fig, axes = plt.subplots(1, 2, figsize=(16, 4))\n", + "\n", + " self.exp_smooth_plot_rewards(rewards, title, ax=axes[0]) \n", + " axes[1].set_title(f'{title}Learning Rewards Trend')\n", + " axes[1].plot(record_smooth, label=f'Rewards for each {window_size} episode.')\n", + " axes[1].fill_between(\n", + " x=np.arange(len(record_smooth)),\n", + " y1=np.array(record_smooth) - np.array(std_list), \n", + " y2=np.array(record_smooth) + np.array(std_list), \n", + " color='green', alpha=0.1\n", + " )\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + " def Qtable_plot(self, title=''):\n", + " self._fill_table(self.Q_table)\n", + " plt.title(f'{title}Agent Qtable')\n", + " plt.imshow(\n", + " self.table,\n", + " cmap=\"RdBu_r\", \n", + " interpolation=\"bilinear\",\n", + " vmin=-np.abs(self.table).max() , \n", + " vmax=np.abs(self.table).max()\n", + " )\n", + " plt.xlim(-0.5, 3 * self.env_cols - 0.5)\n", + " plt.ylim(-0.5, 3 * self.env_rows - 0.5)\n", + " plt.xticks(np.arange(-0.5, 3 * self.env_cols, 3), range(self.env_cols + 1))\n", + " plt.yticks(np.arange(-0.5, 3 * self.env_rows, 3), range(self.env_rows + 1))\n", + " plt.grid(True)\n", + " for k, v in self.text_record_dict.items():\n", + " y_, x_ = k.split(',')\n", + " plt.text(int(x_), int(y_), f'{v}', va='center', ha='center')\n", + " \n", + " for k, v in self.record_SHG.items():\n", + " y_, x_ = k.split(',')\n", + " plt.text(int(x_), int(y_), f'{v}', va='center', ha='center', color='darkred', fontdict={'weight': 'bold'})\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "walk_in_the_park_env = DrunkenWalkEnv(map_name='walkInThePark')\n", + "alley_env = DrunkenWalkEnv(map_name='theAlley')\n", + "\n", + "lake_env = FrozenLakeEnv(is_slippery=False)\n", + "register(id='FrozenLakeEasy-v0', entry_point=\"gym.envs.toy_text:FrozenLakeEnv\", kwargs={\"is_slippery\": False})\n", + "gym_env = gym.make('FrozenLakeEasy-v0')\n", + "\n", + "env_dict = {\n", + " 'theAlley': alley_env ,\n", + " 'walkInThePark': walk_in_the_park_env,\n", + " 'FrozenLakeEasy-v0': gym_env,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((0, 0.0, False, False, {'prob': 1.0}), (0, 0.0, False, {'prob': 1.0}))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 因为直接is_slippery=False 无法关闭输出,所以用register的方式关闭 滑倒的输出\n", + "state = lake_env.reset()\n", + "st = gym_env.reset()\n", + "lake_env.step(state), gym_env.step(st)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 📌 5、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Config(Env=theAlley, Algo=Q-Learning, exploreType=epsilon_greedy(gamma=0.9,learning_rate=0.1))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "class Config:\n", + " '''配置参数\n", + " '''\n", + " def __init__(self):\n", + " self.env_name = 'theAlley' # 环境名称\n", + " self.algo_name = 'Q-Learning' # 算法名称\n", + " self.explore_type = 'epsilon_greedy' # 探索策略\n", + " self.train_eps = 400 # 训练回合数\n", + " self.test_eps = 20 # 测试回合数\n", + " self.max_steps = 200 # 每个回合最大步数\n", + " self.epsilon_start = 0.65 # e-greedy策略中epsilon的初始值\n", + " self.epsilon_end = 0.005 # e-greedy策略中epsilon的最终值\n", + " self.epsilon_decay = 100 # e-greedy策略中epsilon的衰减率\n", + " self.epsilon_decay_flag = True # e-greedy策略中epsilon是否衰减\n", + " self.max_step = 500 # 一盘游戏如果智能体行动超过 max_step 次就终止\n", + " self.gamma = 0.9 # 折扣因子\n", + " self.lr = 0.1 # 学习率\n", + " self.seed = 1 # 随机种子\n", + " self.device = torch.device('cpu')\n", + " \n", + " def __str__(self):\n", + " return f'Config(Env={self.env_name}, Algo={self.algo_name}, exploreType={self.explore_type}(gamma={self.gamma},learning_rate={self.lr}))'\n", + "\n", + " def __repr__(self):\n", + " return str(self)\n", + "\n", + "\n", + "final_res = [] # 用于记录每个环境的最终结果\n", + "cfg = Config() \n", + "cfg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ✨5、探索策略研究" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
QLearning.explore_type_space():\n",
+       "\n",
+       "{'epsilon_greedy', 'thompson', 'boltzmann', 'ucb', 'softmax', 'special_ucb'}\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mQLearning.explore_type_space\u001b[0m\u001b[1m(\u001b[0m\u001b[1m)\u001b[0m:\n", + "\n", + "\u001b[1m{\u001b[0m\u001b[32m'epsilon_greedy'\u001b[0m, \u001b[32m'thompson'\u001b[0m, \u001b[32m'boltzmann'\u001b[0m, \u001b[32m'ucb'\u001b[0m, \u001b[32m'softmax'\u001b[0m, \u001b[32m'special_ucb'\u001b[0m\u001b[1m}\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cs.print( 'QLearning.explore_type_space():\\n', QLearning.explore_type_space() )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "summary_dict = defaultdict(list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.1、softmax 策略探索\n", + "\n", + "softmax探索的时候, 对Qtable中所有值进行了随机初始化" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=softmax(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35msoftmax\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 22/400 ](Epsilon:0.650): 8%|██▋ | 34/400 [00:00<00:02, 123.53it/s, reward=-5.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|███████████████████████████████| 400/400 [00:02<00:00, 166.57it/s, reward=5.500]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 186.51it/s, reward=5.500]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 284\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=softmax(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35msoftmax\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 18/400 ](Epsilon:0.650): 7%|██▏ | 27/400 [00:00<00:03, 95.93it/s, reward=-2.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|██████████████████████████████| 400/400 [00:02<00:00, 173.48it/s, reward=10.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 339.88it/s, reward=10.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 114\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=softmax(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35msoftmax\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 62/400 ](Epsilon:0.650): 24%|████████ | 97/400 [00:00<00:00, 355.56it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|███████████████████████████████| 400/400 [00:01<00:00, 367.36it/s, reward=0.100]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 396.89it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'softmax'\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.2、epsilon_greedy 策略探索" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=epsilon_greedy(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mepsilon_greedy\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 12/400 ](Epsilon:0.005): 5%|█▋ | 20/400 [00:00<00:05, 75.74it/s, reward=-2.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.005): 100%|████████████████████████████████| 400/400 [00:09<00:00, 42.65it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.005): 100%|█████████████████████████████████████| 20/20 [00:00<00:00, 75.61it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=epsilon_greedy(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mepsilon_greedy\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 21/400 ](Epsilon:0.005): 9%|██▉ | 35/400 [00:00<00:02, 126.91it/s, reward=1.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.005): 100%|██████████████████████████████| 400/400 [00:02<00:00, 176.94it/s, reward=10.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.005): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 331.33it/s, reward=10.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 94\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=epsilon_greedy(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mepsilon_greedy\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 73/400 ](Epsilon:0.008): 28%|█████████ | 114/400 [00:00<00:00, 418.93it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.005): 100%|███████████████████████████████| 400/400 [00:01<00:00, 369.39it/s, reward=1.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.005): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 323.42it/s, reward=1.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 156\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'epsilon_greedy'\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.3、boltzmann 策略探索" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=boltzmann(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mboltzmann\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 18/400 ](Epsilon:0.650): 7%|██▍ | 29/400 [00:00<00:03, 98.22it/s, reward=-5.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|████████████████████████████████| 400/400 [00:04<00:00, 99.99it/s, reward=2.500]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 161.05it/s, reward=-0.500]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=boltzmann(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mboltzmann\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 18/400 ](Epsilon:0.650): 7%|██▏ | 27/400 [00:00<00:03, 96.82it/s, reward=-3.500]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|██████████████████████████████| 400/400 [00:02<00:00, 160.69it/s, reward=10.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 258.69it/s, reward=10.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 143\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=boltzmann(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mboltzmann\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 61/400 ](Epsilon:0.650): 24%|████████ | 97/400 [00:00<00:00, 365.34it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|███████████████████████████████| 400/400 [00:01<00:00, 324.44it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 331.33it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'boltzmann'\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.4、thompson 策略探索" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=thompson(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mthompson\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 24/400 ](Epsilon:0.650): 9%|██▉ | 36/400 [00:00<00:02, 125.91it/s, reward=-5.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|███████████████████████████████| 400/400 [00:03<00:00, 107.30it/s, reward=5.500]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 147.97it/s, reward=8.500]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=thompson(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mthompson\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 17/400 ](Epsilon:0.650): 6%|██▏ | 26/400 [00:00<00:03, 97.80it/s, reward=1.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|██████████████████████████████| 400/400 [00:02<00:00, 143.44it/s, reward=10.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 244.55it/s, reward=10.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 74\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=thompson(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mthompson\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 67/400 ](Epsilon:0.650): 26%|████████▎ | 104/400 [00:00<00:00, 375.29it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|███████████████████████████████| 400/400 [00:01<00:00, 323.49it/s, reward=0.100]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 233.17it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAEJCAYAAAC9nTo+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABGIUlEQVR4nO2debgUxbn/v92znDlzgCAuiDeL4hKORlyjsgloAshhVX4Ro+ISF1xixKuChIhBMWhIEPAqIaJeUXFjU4KCykVRVlFEBBVREBQR2c8ya9fvj16muqZ6m+lZzjn1eZ55ZqaX6qru/vb71lvVVRIhhEAgEDRp5FJnQCAQFB4hdIGgGSCELhA0A4TQBYJmgBC6QNAMEEIXCJoBTUboF1xwAT755BNf0lq+fDkGDhyIgQMHokuXLjjvvPOM/wsXLvTlGG4YM2YMNmzYAAC48sor8cYbbxTt2MXgggsusFy3d+9edOzYEWPHji1oHg4dOoRhw4ZZrt+xYwfuuusu9O7dGwMGDMCQIUPw8ssvm7a59tprsXfvXtvjrFq1Cv369eOuGzVqFGbMmOE98x4IFjT1Rkrnzp0xf/58AMDUqVOxb98+3HvvvUXPx/Lly3HppZcW/bjlwCuvvIILL7wQCxYswIgRI9C6deuCHOfAgQOWBmLnzp0YOnQo7rjjDvz9738HAOzatQt33nkntm7dirvuugsA8P777xckb35SUqEvWbIEjz/+OJLJJCKRCEaOHIkzzjgD99xzD+rr6zF58mRs3rwZw4YNw7PPPouFCxdi27Zt+P7777F792506NAB48ePR4sWLUzpvvjii5g5cyZkWcYRRxyBv/zlLzjuuOMwatQo7N+/H9u3b0ePHj3wpz/9CRMnTsSaNWuQTqdx8sknY8yYMVnp0YwZMwaHH344RowYAQCYP38+Fi9ejGHDhmHixIk45phj8NVXXyESiWDChAk4/vjjkUgkLI8za9YsbNiwAePHjzcdZ9KkSfjhhx9w55134uGHHwYAvP3225gxYwZ+/PFHdOrUCQ888ABkWcZbb72FRx99FIqioKqqCvfccw86duyIqVOn4ptvvsGuXbuwe/dunHLKKTj33HMxb948w1L169cPU6dOtTyvzz//PF544QWEQiFUVFRg3LhxOOGEE7B582aMGzcO+/fvhyRJuPbaazFo0CCsWrUKkyZNws9+9jNs3rwZqVQKf/3rX3HWWWe5vi8URcGLL76IsWPHor6+Hi+99BJuuOEGAEA6ncbDDz+MJUuWoGXLlujYsSO2bNmCmTNn4tChQxg/fjy++OILJJNJdOrUCXfffTeCwSBOPfVU3HDDDXj//ffxww8/4LrrrsPvf/973HPPPYjFYhg4cCDmzJmDQCBg5GP69Ono06cPLr74YmNZ27ZtMWnSJFx44YUYNmwYHnnkEQDAVVddhenTp+Ozzz7Dv/71LyQSCezduxeDBg3C7bffDgCor6/Hbbfdhm3btqFVq1YYN24cjjvuOFPZt2zZgvHjx2P//v1Ip9O48sorMWTIENfnzhJSIr7++mvSr18/snfvXkIIIV988QXp0qULqaurI3V1daRXr15kzpw5pKamhsyfP58QQsiUKVPI+eefT3bv3k3S6TS54447yIQJEwghhPTs2ZOsX7+eLF++nPzmN78he/bsIYQQMnv2bHLRRRcRRVHIyJEjyVVXXWXkYerUqWTChAlEURRCCCH/+Mc/yNixY035nDJlCvnrX/9q/N+4cSPp0qULSSaThBBCfv/735N3332XrFy5knTo0IGsWbOGEELI888/TwYPHuz6ODz0MhFCyBVXXEFuuukmkkqlSH19PenSpQtZs2YN+fLLL0nnzp3JN998QwghZPny5aRLly7k0KFDZMqUKaRnz57k4MGDpKGhgfz6178mf/vb3wghhLz55pukV69etuc1lUqRU045hezatYsQQsjcuXPJCy+8QJLJJLnwwgvJokWLCCGEfP/996Rbt27kww8/JCtXriTV1dVk48aNhBBCZsyYQS6//HLL8vFYunQp6dy5M0kmk2ThwoWkW7duxvmeNWsWufzyy0ksFiPxeJxce+215IorriCEEDJq1CjyzDPPEEIISaVS5M477yTTp08nhBBy0kknkZkzZxJCCPnkk0/Ir371KxKLxcj27dvJ6aefzs1H//79yRtvvMFdN3jwYLJ48WIj7T179hBFUcgVV1xBvv76a+O8VFdXkz179hj3x9q1awkhhLzwwgtkyJAhhBBCRo4cSZ544gmSTCZJ3759yYYNGwghhBw8eJBcdNFF5KOPPuLmwQsls+j6k/Xqq682lkmShG+++QYdOnTApEmT8Lvf/Q4DBgzAgAEDjG369OmDI444AgAwZMgQPPjggxg5cqSxftmyZejbty/atGkDALj44osxfvx47NixAwBMlmXp0qU4dOgQli9fDgBIJpM4/PDDbfNdXV2Nn/70p1i6dCmOO+44/PDDD+jatStWr16NDh064OyzzwYAXHLJJRg3bhz27duX03F49O3bF4FAAJWVlTj22GOxZ88efP755zjvvPPws5/9DADQqVMntGnTxqjbd+7cGS1btgQAHHXUUejWrRsA4Oc//zn279/veF779OmDoUOHokePHujatSu6d++Or7/+GvF4HL169QKgWrlevXph2bJlOPfcc3HMMceguroaAHDyySdj7ty5nso5a9Ys9O/fH8FgEBdeeCHGjh2LN954A/369cM777yDgQMHoqKiAgBw6aWXYubMmQDU6/nJJ5/glVdeAQDEYjFTuhdeeCEA4JRTTkEikUB9fb2nfLEoimL6L0kSpk2bhqVLl2LBggXYsmULCCFoaGgAAPzyl7/EmWeeCQAYPHgw7rvvPhw6dMjYf+vWrfjmm28wevRoY1ksFsPGjRtx+umn55XXkgldURR06tTJcH0AtU501FFHAQC+/vprtG7dGps2bUIikUA4HAYAk2ulKApkWc5Kl4UQglQqBQCIRqOmbUePHo3u3bsDAOrq6hCPxx3zfvnll2P27Nk49thj8bvf/Q6SJGXlTScQCOR8HJZgMHO5JEkCIQSKohjH16HLq583XhpsPnXo8zpx4kR88cUXWL58OaZPn4758+fj5ptvtj1mJBLJyqdbvv32W7zzzjv49NNPsXjxYgBAKpXC008/jX79+mXln77+iqJg8uTJOP744wEABw8eNOVTfzjoy5zydeaZZ2L16tXo3bs3AGDPnj1o3bo1Dhw4gC1btqBjx46m7evr6zF48GD85je/wdlnn41LLrkEb731lnEc9l6VJMlUnnQ6jZYtWxrxIQD48ccfjQd1PpQs6t6pUye8//772LJlCwDgnXfewYABAxCLxbBjxw6MHz8eTz75JNq3b4+JEyca+7399ts4dOgQFEXBSy+9hJ49e5rS7datGxYuXGhEQWfPno3WrVvjF7/4RVYeunbtiueeew6JRAKKouAvf/kL/vnPfzrmvXfv3ti0aRMWLVqESy65xFj+2Wef4bPPPgOgxgnOOOMMtGrVKufjBAIBQzxWdOrUCe+99x62b98OAFixYgV27tyJ0047zTF9Gt553bt3L7p3747WrVvj6quvxu23345PPvkE7du3RzAYNIS4a9cuLFq0CJ07d/Z0TB4vvvgizjrrLCxbtgxLlizBkiVLMGfOHGzcuBEffvghunfvjldffRWJRAKpVMrkLXTt2hVPP/00CCFIJBK46aab8Oyzz9oeLxgMIp1Oc0V/4403YtGiRcYxFixYgP79++Pmm2/G0KFD0a5dOwCZ67Rt2zbU1tbi9ttvxwUXXIBVq1YZ1xwAPv/8c2zatMlUzsrKSuN4xx13HCKRiCH0nTt3ol+/foZ3lg8ls+gnnHACxo0bhzvuuAOEEASDQTz++OOoqKjAf//3f+MPf/gDTjrpJNx7773o37+/cRMdccQRuP7667Fv3z78+te/xvDhw03pdunSBVdffTWuuuoqKIqCNm3a4F//+lfW0xQAbr75Zjz00EMYPHgw0uk0qqurMWrUKMe8h8Nh9O7dGz/++KNRRdDz9sgjj+Dbb79FmzZtjCCa3XGsgnEA8Nvf/hZ33XUX7rvvPtvzOHbsWNx6661Ip9OIRCKYNm2aZyvAO6+RSAQ33XQTrr76akQiEQQCATzwwAMIhUJ47LHH8MADD2Dq1KlIp9O45ZZbcN5552HVqlWejkuTSCTwyiuv4MEHHzQtP/bYY1FTU4Onn34ajzzyCL7++msMGjQI0WgUP/3pTw2x/PnPf8b48ePRv39/JJNJdO7cGdddd53tMY888kh07NgRNTU1eO6553DYYYcZ69q1a4cXX3wRkyZNwrRp0xAMBhEMBnH44Yfjq6++wubNm3HiiSeiT58+uPLKKzF58mT06NEDF110EcLhME466SSccMIJ2LZtG8LhMNq3b49HH30U27dvx+GHH44JEyaY8hIOh/HYY49h/PjxeOKJJ5BKpfCnP/3JUyDTkrxr+UWEDYyVirq6OjJ48GBTkGTlypWkpqamdJnKg1KdV6tgnB3Lli0j8+bNM/7ff//95OGHH/YzW67YtGkT+eqrr4p+3FxpMh1misWyZcvQo0cPdOvWLe8AicA7J554IubNm4f+/fujpqYG+/bty/LqikGHDh2ymsbKGYkQd5GShx56CPv27ctyNwQCQfnjyqKvWLHCcxOJQCAoHxyFvn//fkyaNKkk7pFAIPAHR6Hfe++9GDFiBFq1alWM/AgEggJgK/SXX34Z7dq1Q6dOnYqVH4FAUABsg3HXXHMNdu/ejUAggAMHDqC+vh6DBg0yddFzIh6PA27ifUSx+Nb2NXq8mddLTNJE7wgl6c8w7VtvR9d7Sunr2W8XVEQiiDPdKy2xK5ddmejtmTwSCe7KV4qyublehOm9SJfL+O/vdfNULq+w5bHCw3Vwl55k9PZz3NRt1H3OnDlYvXq156h7PBZz1wXSQhCS/l+xWm9Om1jdELJ+M1ncKB4uQqSyEjGt/7IjduWyK5Ot0CV35StB2VxdL0uhcx5SPl03T+XySomELkkSKqjuxnaIdnSBoBng2qLnirDowqJblk1HWPScEBZdIBCYEEIXCJoBQugCQTOg6QqdrT8qTJ3f6rsISG6O5VSfc5NGMcpUgvMn8E55CN1tIM4FbHAul+P6hh/puxW83YNM//iJELZKIzkPhR94gu5E4bQd/Z3rNnYoCiDLkIiSieLqUW362w1etyvGDcGWz8+y0Q+cfFtIvOSlXGlk+S9Pi47crLlj+lR6Jve5iGK0FEMu2OTb1rKzH7fHKoRn0JjI9xyU8NyVn0WHRR2WezM7pEu3QdO/nSy7G7xcNNbi5Zue1f6SnHmAsJYdsK4GsMem/zvt46ZsjZVClIm+D4tIeczUYiVynjX3evJdiB2AWRAs+VwYnhBy8VKoPEiEZDqX+FE+zjHY/HPhrcvXAyu2CJriA4pD+Vh02IjB48UwCYGXH0YM9LGJ25vdLk+08JBHudx6GHZiB0yCN+3GlpV1912Kzq0H5gnaQ3GKO3h5OJSDsEtg1cvCottaO15d2ivsibUQQ1ZeeEm5uUBePBS/YMUOZJcRyLwNxubNKk0aTkAubw+M7f7qN37cP4WgyGIvgkUn7utvdiJncKqfZ1l1ntgBS8Fbp+tcJ9UfBoV8gHG9FrZMvLo2T4zsxAJW3g2TT788sIJQDnlwoohiLwuL7soS+CEGnktqZ/1yJOsh4OEBlp2Y9Y1gWUXhCdzOOluUmS6HK0+mHGgMAqcpktgLL3RFySlCbbfMS6cYV5bP6rh2F8DqgSA7CMiHBxgNfS4cRQ94Ez7HzXf0Viw8FU8dmXIhn/PoJt5SSIog9vKw6ID3gJcHPFm+fI9v9QAoYPl0nMREJMm98AFbwWdtY5VGMcgnduNlm0KK0WMA1CtFELpHiw7kVTd3s58ry2fa2cNDwKFe6+p4BYJ7DrxUZ9j4hZ3Iy9WF9svyF0r0BbLu5WPRAceL4Jf7Z5eO54dALtsWSgRu0jVcb0b0dh6HU/yilJa8VE1rhXS3C2Ddi9SOnvsJthPll6/9B6v//k/s+3ILQi2qcMw5v0bXcWPRun3uU+VYHc+ynp+VgMveZ37g9QHEtsszore08nY3ns8xFVeUS9t5oevWjvl23yRZlqFUiRDjY8X+r77G69fegGjbo3DRk9PRecw92P7ue3j9DzdkNtIfMrl8HPJkmTeX6eWNXZpWx7f6r5FVJjt33Kpc5eSyezn3uV6vciqvDQW36Orwvv5HXOt37wZRFIQqK9H6uGPRvk8vtPivY3Dom+0gStqY7D5niILaujq0qKrKLGOe3pbj1eVBXtbPjfC0MtTWHlLLxukLb7LwVtbdzbFRAGvuFg8Cr6urQ2VlpXlqbS/uc5GayPKhvHNnw9Fnn4Xjay7Clv+8jmc7d8cTJ5+GzXPn46ddOnkTuYUFfn/lKlx10204cPBg9rb6bwba6uf6MQ4lScaHm2deGeyWUflWy3a7WjabMplE6uRBFAHXHa/cxkk0kd948x+x+K23c0+rEVDwUWAT+3cDSrpg6X+3ajW2Ln4L3y5fiZ1rPkDksNYYtmoZItSE9llQF2/tuvWY/K8Z3M1isRggSZgxZSJatmxlLA8ffgwSe74zb5znE93JG7AVncX/tR9/gsnTLMoWjwOQMGPqRLRs0UI7iJwpG1UeU96c+h5Y5ZmFsZhZo/fSv2U6L7L1djZ5ilS1RKzukGmbhoYYbv7jbaitrUU0WsXd7/o/XIOuXTo7X98SWHRJklBRGXW3bWMV+hfzXsVnL72C8++/D62Pbw8AWPXwP7DqoYkY+PLz+EXP7t4TZW6+hlgM/YcOw/BrhmHIwH7GZuHDj0Fi7/f2SRWg77anOjTvP0VDPIH+l12N4ddciSED+xvL2bJZitzhOFyROwQwLYfqBpyHfXY4jknoGosWLcL4CQ9hwfy5aNWypW3ebCmR2+5F6AWvo6vTB1nf9LnW4Vq0Oxrb3nwbb3y/C2fd/keQdBpfvroAgUgEh1dXu27PXrtuPSZP+3fW8mQyhQ2bPsOAvr1xycD+tmUACiBsjpXSj2EaqYVaz+6z9uMNGW/F2EdCMpnEhk2fq2UbkHmAubLiVnl1cnGtHkLUG2hGxya6hSAXETnFEzR69+6NdR+vR7ceF6K6Q4fs6Y0k4Po/XIuuXbo4H6vMKfwEDgd2591/3Oph8OWrC/DBI1Ox78svQQjBEaecgk6jR+Jn53fN63gAsHrth5i34HU88Jd7zEEaAOE2RyO+b5dDpgtwA7hptnIRkFv94ceY95/X8cCYUWrZqLxmlY0th5WIvNTveQFCJ6vuxaJzjsWz6Drj/zYBXTqdhx7dz3eXJp3vElJWrrsfQmcpZiSXZ6krDmubLfRiXvR8XWUgK796OY2yWQncKn23Qmd/UyJ3I3bPQteOYyd0z5SJFS8r1129kB73cXC5slxYL0nn62J7ucHYffLFwkUHzOXKcu317Tj54J4Pq0AXoFpWhXG7md+OIudZeJ4Lz8E0/Jdb/BRmoUXu6b5yfy+XVxdYHZf1ayvB+1JfLuXN5HQM+nzkIPqs88PLO2+ZnLGsXLHbYdf+blUf97t92mXd3XZfv/JQZIogdI8WnXcRHC5QzsLOJ9CTzwVzGNyCi2IvbqvltufGqgw8K85Ci90LrFVnRV5ugs/nHikjys+i212EfJ7I9P75bsMjF/Hmmr6V6AG+e++EnfVm4L6PbgUrap7rbiFy23H/WHK9L9w8ML1ShiIHiiF0WQbcVqV5N7CV4N1eVL86OrA3fgGEbVX3zBKV3euibqo9VmWmXXMX+TKsOm2VXTazZQ1XZWXVvVhzL/cFb998KFOB65SXRddvMDeCd7qodife6UbPgUIOtcSm7Sh8wFyHtsKmvE7lIRJ/ZFnrHTLbSsxvArgTNjVqryX5en1eKXOB6xQh6i6BuOhSb7pprATvVuxug0v0sTjY3eylHEONd2xX4neZJrdsVp6CU13drmmNTpdT5fDkvtvl12/RNxJx0xSnec3Od2dcuCzBexW71wiyno3GVC/j3Lh2+WcfAq7K6mIb11bdwprr6yQ2T1bNiLmeZzaAWsqoe4kovevOnPwswbPW3c5lZy9GLgL3Uh8sFXbH9vgQ8OT9sO41+4C1ExBrzXnDU1kFEq1Enq/wrfLYyEXNo2wsOk/wltbd602m708fNleB8ygDi25QjPZeD0E30242belZVt3YJw/33StNUOA6ZWfR6ZvIs9h56er7UZhuqKZm0Xnwqjt+pu+lTZ2y5mvWrUc8kQQkCRWRCM4+43TzdrnkRcClvCy6G7G7PqYG711m3nZNxaLzyCV/bqoHkgwCe0ttl8a+/QdQH4sDkoRoZWUmAu8lz+JB4IrysOhexO7U/dKNyN38dpPvUlHoY7u1+G4DcURRr19WIA4oxDBjgmzK43EoyebIKBslBSPUPJqOfBG5IHcUXfhC4MWk9Badh8/tnjm98STwFSLJ6isPMtQ5PVCkDi0CAOUqdCcKOf2wID8kGQQKJNZZ5HZsAiBJmY+gYDQ9M1esro8CM8xINU7bLl/7MR6f+aKx6PGnn8ey1WszVTfJQ3oCRxqnRc8Hv195FDi3jGjnm0A14iAKTj+lGq1atMDqdRtAALRsUYUzT/0VJ21JXC8faDRn0HMTm6A4OHWssVgfrYri8QljseO77/Htzu/x+N/HI6pPKOH1OAJHCj9mXCwG14ewel8ZjNAVznY0nAg9N/KeY9Q9UlmJWEOD6+0bE67LRjeX6c1nCruMZLZjt9X+pxX13pCDIa7bblh0STZfS4/ufVO8ZpLW0cgNrs7S5MmT0bdvX9TU1OCpp57KK3MFQ1j84uO2/zlPkNr/QCCQETkDr+uraD3JDcc6+urVq7Fy5Uq8+uqrSKVS6Nu3L7p374727dsXI3+CxgSvKyynq7LRm44nfj/fQRAYOJ7Fc845B8888wyCwSD27NmDdDqNaNTdELOe4Flk3jJe0xrn1UdB6bEbhJJIjBtusZ2r/wJHXEXdQ6EQpkyZgieffBJ9+vRB27ZtXR/AbR2isRGprCx1FgpGUy1bUy2XGzwF4xoaGjB8+HD07dsXl156qat9XAfjeKOP8AYsUGy24wXX3E7QJ4JxADwG4/RvOmCq8JYT7vZGUyen+7OpWc0qEKev87NcjQhfg3FbtmzBpk2bAACVlZXo1asXPv/88/xy6AduXX1BYbBqsZAtlnto9bCa900E4nLH8czt2LEDY8aMQSKRQCKRwNtvv42zzjqrGHkTNGZcCDfrv5uHhyAnHOvo3bt3x/r16zFo0CAEAgH06tULNTU1xcibQV6dZdyMHCrwBW4POd6rxzZid5zFVVj1nCifDjM2dXTbzjLUusmPTwcg4U8332jfaUbU0S3xVDa2vg0mlpK1jmTvx5z/rLo5YD+5oqiju9q2yTweJ05+FKvWfIBVaz7A3x+ZKurrxcJOcDwR0+uc1gPCG/OJxnUWLV5PXfLOMsyevwCXXjwYl14yGHPmv4Y3lyy1Tkc8BAoGYQXq5H6zIvfimgs33jWNy3W3aVqb/5/XM0PTyTIG9O0DSQ4Y/wGH/u7CdQeQg+vO+c66XlYuvJ6MzXzo6vr83HagaV6zxu26815scUGl3hlCklAZiUASAxkIBAblIfQcxW2L0+uTAkEzovADTxDF+0ifvB5xuSKCOWUHkSQxOGSRKR8V5CpoU71buOtljfCkSkZ5nHleIA4+WHMnxI0naCaUl+tuJ2yHkV97XdDDNhor+kmXEPaddEHRKZ+7n7kRPFlzIeLyRMRHyobyuBL5iNzYiVMUcaMJBADKzXWHhci9TNjgZN2F9Rc0Q8rmrpf00UFZfJiVRdTPi4uX8120uc+bOSWfwMHWTRdTLwkEvlAE153kVud2EjkvkisGK2i8CK+roJTcomchrLhA4DuFFzo9AIHf5NM+m+MsLYICI65FQWj8Z5U3NQ9v5Fd920bAwW3b8Gg0imV33WVaPr1dO8zp3btEuXJBIzm/haDcr1nzvTICQTOiCHX0HF33Rmod6urqUFlZCdmHYKCSTiMVi/mQq0ZIEYOpzeGala+a6Fk4vTworNz2IlBXV4cbhw/H4jff9CW9T6ZNw7Q2bYxP4sABX9IVZGgu16z8ou48GoF1b2howK1//CPi8ThmzZqFWbNmZW1z/XXXoWvXrq7TPHHIEJx2663G//n9+vmS14KRw1BSEiFqpxl9GGj9uwjDdDena1YEoctAMTs/UTeIRJSiWfV3330XW7ZswYLXXkOrVq18STPati2OPucc478UCPiSbiFxLXL6dWTNsSTgi924juzDIE+a0zVrHBa9EdC7d2+sW7cO3c4/H9XV1aioqMjaxqt1aBTYDQPGEzlvvjxNuBIhzmJn089D8M3pmgmh+8jIkSORSqXQpUsX9OjRo9TZKTqOkzfwJlo0JWAvdmNfH7205nLNCj/cc+0B52Bavr3h2Ivvph09j/b1pjh0sI6YTbXx0PiGe5Zl88cLPNeRenCY+tlb/RbkjdV55opc+0hsqwpr6S2uadY6gSPlIXSWXASfD+Km8Qdmgg3TSK+MqCUHsWftSyOul2cKX0eXJBCH54nl222ybO/WiwteWqwCcKxVthC5vl5CZpIdwxUnCiTImfq6vrqILSlNibI4Y0SSrS+eF8suhF98LM654bLzhgnT6/JsFcuugxRRxJuNeVAWQtexFHwubry4KYqG5CRC1k1XKEFbvd1Iu/DiAZ43RXDdZVCOGR/mQhJJ9nVMd+HuFQlWnLzAm2KugxMogAKjX1WWCy/whfJoR6fqZTpZYneqrwsaH3Q9nCd2DWMbAEYTu3gQeKL0Fp0Wsx8D/Tt1qPC5w4XAjGtrTgfnDCF7jMeI6+ia0p8p9mJR/8VTu5FA17l5WImc3UdhHgxOD31Rd3dN+bjubi6anfvOe8IX4Q2o5o5lLIW25pzlIArWrN+IWCIJQEIkEsHZp5+quvAB2bw9NKsvRobOmfJx3WmxU79dBebEk700uGlHB7ICcPoDYN/+/aiLJQBIiEYrTWkYdXWJEb3PL7Y0F0p/hnzqf26CcwMWfGZWQdac53THmKx2daIgMxQ4MW/D9LATXZfzp/RCBxwFzq2r+3HBxU3jH7zecED2m2ymOjiBMV0X217Ouv1sXV7gifIQei4Id61xIOfusYlgrH80mzPJvWnEjeQfrIiZ/8Yca3rvR0kGJEn9QPvW95Gz9xez8ORH+Zwxt0LkXWSbJjpBAWHOs+kdciAjaF241Of9Dzfg8efnattImDbzZSxb8xH1PrrMfWCIa5sb5dG85gd+9ZEXeIJIMiQwdWZa7MgEQokkGePDnX5KB7SsqsLqjzcCAFq0qMKZHU+xtOaWs64K4bui0Zwl31xvcWP4D2WxDavOilU2r49Go3j8b2OwY+cu7Pj+B0x76D5Eq6oY197hWolr6ZrCDyUVi8H1IejoLLsMVBMZ2/xC4zSklA/NeU1xWCIdT0NJ0VF0hf7v/qWWlKK2gwdCoWyR8x4eMmcbP8vViPAylJQr1/3RRx/F66+/DgDo3r077r777txz5wannnIeX3AR0dsiIqn91iXGWSRQX1iBDHXyHs3dDwRDlLUXdfBC4XhWly9fjvfeew9z587FvHnz8Omnn+JNn2a18AU/BqwQ5AWhA24sJsvMCc7RIufuw6kKCDzjaNGPPPJIjBo1CuFwGABw/PHH47vvvit4xgy8dIcVN0Px4XlftFWnuzWDsez6tnS1ihU5jWwzEpHAFkehn3jiicbvrVu34vXXX+dOXVN0aPfd7UsxVoibJzfY8y7L6kspnCg73Sdd78NuDAjCEzp9DNF8mjeum9c2b96MG2+8EXfffTeOPfZY1wdwGyxobEQqK503aqQ01bI11XK5wZXQ165di9tuuw2jR49GTU2NpwPkFHW3+W1y3a0CcmICh5zxVDb2JRXAfhIH3j6MRad70Bnf9OQN+jJeK4pf5Wok+Bp137lzJ2655RZMmjQJnTp1yjtz+WKqp4vhpUoPr9qkXxdTxxmtSY33gDV6w7kUucAzjkKfMWMG4vE4JkyYYCwbOnQoLrvssoJmzISXOngJ50dv1mjXyHgQ02LXLLfepJbV9MYTOGAtciF6z5Rnhxnefyv3HTBbdTduO/tfuO4Gnl139jftwutYTKFswBOunSXPQehN8Zr53mGm3LBsZhNt58WF9rQoy61bdgAZ6w7A6BLPemh2AmfXCyueE+UldDsX3WMTmq3bLm6WwkCLHbAWPADTezBF8MKaO+Ul9FwRlrx08Kwz00kGQPZY7dQly3ooe/0vcKS8hF6soZ3EgIL+YuWK2yxz/TaiuE6+UD5CtwvE8f7nkr7JjCjZN2RTuqncnC8/yms1EqzDMokneDHKa8EoD6H7LWqAP9+anditjltON1k+58VKRE7HsSu/G5E7jMibdZ2EsAtC4YWuj/bpZXuHZW6HbnYtdmMHzg1mJwY/b8h8RezHdk7lt3so5nHdsqy7mweyeBh4ojwsuo5bN9ADlmIH7C2cmxvJbtALt/t4xWl/r+nzxOvm/NgtdyNwTt8H07US4vaV8hC62xsI7q05u4/j2PBubmqnG82rQNxit7+DlbTcjRcws0rbi/vuJHJel2Vq6ixbsQtypvxcd30fn+EGf+yO6cWNz3W7XPb1KmyesOTsDke29WS3DzA7kbP5YNN0I3Yh/JwpD4uu43CT21oplxMq2t7gVnnx6g14IY+Hh6NLbLUvuwlH+Fxx81oqOMdwtOL0ejpNL5NiCtF7ojyE7uJmL9TcaVbpZlk4YwcL0Xu56QotbjtLy+vQou9vZVHpbR3iKLYi9xDYFC68v5Sn607hSeA+TpNs6eo7xRO8Nkd52MaVK2zxXyJEfUvMKn1JNqXpGAnnHMeTyHkPED0PvAcOvZ8QvWfKw6Iz5GW9/Xg/nXpYOArezY2YZ6Q8JwEBnNlNM/9Nomf7qLsNjuUicl5+bcQu8IeyEXpZTWts0fQDWAjeblkOEXOdXMVjErhF64G+jSF4thurG8vKy6dTfZzJo+n4HIxjC0ueF0Vw3UnhReyHFbeqhzPWhVsWr1bcrXtO40LklgK3cde5Lr2dG20XWWdxkU/T8WlBC6vuK2Vj0XMmF5G7daUtglVAHl03LY7t2KLA7uskcCuh02LSlusjvpiGV85FcF4fRoKi0XgemYrC/7iFKJmP0zZW/5ljWjZJ2aXPwdaK24hcIiR70EU6z+wy3odJz3Qs/VvR19tY81w8Dq/H5T3EyoSD27bh0WgUy+66y7R8ert2mNO7d4lylaHwFl1RSn9hvLrRVhFhDq4sey4Ct9rfShz0b+726rfJnrLWnVcOC8ues8gtgnFZLrwbRL3dNU3/LFmJycK601antvaQdTp2lt3F8S3bw3MROcc668skQk1wSB23tvaQe8vO5NsXkfPyzCt3EUb5raurg+LTcZR0GqlYzPiUC01b6FY3UJYLSkxusEQI3l+5GlffeCsO7N9vva+V2G1u4Cyh6OnwBO5W5PT2PIEz2yxftQZX3fLfOHBgv+05ySoPm8d8RO52W2NdYQRfV1eHG4cPx2Kf5hP8ZNo0TGvTxvgkDhzwJd18KfwosAf3uH8q++2GuahDf/jROkx+/N/c3RtiMUiShCf+5xG0bNnKWF7R+kjED+xR/9iNd+bmhnXTZdWNyE3bqd9r163HI//+X5g6LGkBt1gsDkgSZkx+GC1btjTOffiInyKx5ztAYiZT0MtmGvfNuqrAzS8vz3q61DGMiRX15QWawKGhoQE333ILamtrEY1Guftdf9116Nq1q2P6B7dtwzPV1ThxyBCcduutxvL5/frhyDPOwMWLFrnKpxfKbBRYGZCct/KerMUFpoXDio3Ttn3mGafjf6f/T1Y0mEgSGmIxDPjd5Vj09lIMGTTAnIZdHqyO7xe8ujX1rQvirNM7Yub//IN7DurjCfS//A9Y9H/LMGRgP9O6LJHrOJXX4wPJsnjQxoDXy6XA6I/vZ7fYd999F1u2bMGC115Dq1atnHdwQbRtWxx9zjnGfykQ8CXdfGkczWte2lPZ2Vt4HVeoZWvXfYwpj03PSiaZSmLDxs8woOYiXDKwv3k/Tp5sRy/1kl+vWAXUiIIP1n+Kyf96MmuXZCqFDZu+wICLfotLBtRY59mj1QRcVC2QXc3hvVhkJXYjLR+8v969e2PdunXodv75qK6uRkVFRdY2bi16uVNeQverg4Qxjriz4M864wz8778fz7Iyq9euw7wF/8G4MfdAol1JDo5DS1NpO079nJU4va/Eb4fmiBySjLNOPw3PPDYpa/PVH63HvP8swv2j7zaXzcp1BrLcZ9umRYsgoamZjOqbIAFZo8QCjNgBQFHUovpYxRs5ciRSqRS6dOmCHj16+JZuuVH4OnrtgcK4rxr0Rff0TjbgLl/sTSXLqGh5GOKH9mUdn7s95zi59l1X97Xp3moV8NL/s+LleCHhNkcjvm+XO6Ezkyly2/S1/3Tk39TkqtfBJSp95mM8eLRts7ZxgZippZHg5iluaW14Fh7gW3l2HS8dqzxZ5bHQdXX2+Kxraydy2oqz6ViI3ATvgWIlckrgEiFavgiInj/auov2cV8pK6H75ZI5Ch7gu/VWcKoUriYdKIC4s9x3uxiEvpwXP6CWcQNvbkROH8NiOStyQ+B0dF530RUAgezyGOsBGNV2XlkFlhRe6JIEUqLmekvBA9ait9qGSdOEx5vNdT3dYhtuXZ3NA9t8xdmWa8Xp31bzoHGbDSkBG668jcjZKokuZqJw6+wSZJBCtN40E8rKorvCSVScm9CxHu8iCOhJ4LTVpAXno4XXRWr5koht8NBB4ID9ZIdeymIhcv0hQOTMLShBBlEUo0U2y2obx7TxWARcykvoflww1m1lYAVrZ1k9T9RYghvOJFov2DUHOs1oqq2TsgafQ7Y1R7a1VwN5KXWdkjKJHUTSmtI0sZsellqbtKJkXHyBK4rgusvgN54UAQfRAx7jAl6Fry8vYKuDJ+ziCn70C2Cj/opiErhJ5HQdnBK7RJj6OmWx1RdftH0s2t8FfMrLoueCCzFnbedme7v9vKxnty1U9D2X7SzE7Th1Ma8MtHBNEXdC/c6IXCIEJJ0GgprAdbETJbu+zlZ/hMA9Uz5C99ttB5xFlc8x3TwAHKoFeb2okYt3AeTWguCQpu0LMKwrr4s8mVDXp5ARO1EoUQcyLroubqKoy4nm2wtc03xcd51cxZWr1dSXeT2uV+/EKn9uWw68pOtk1S3q5rQlJ0pa7ekWBCQSMCx4Zt+MVbe05MK6u6Z8LHqxKNSNUcobzqVLbruP23VOWSFmS24s06Ps6TRIKgEoCtZs+AyxFIEky4hEo/j1aaeoVl3fX7PqkpQZr04iopktF8pH6IUQSiGDYG7yy7N8+dbTXQbUXPfac1rH28ahjg6F3x1WIsSw5CSVwN79B1GfSAJyAFXxZGY7qPVyQ9REybbeIvLuiebnujcyjCGWuCtdtnuzvx0PmuN5YzvCUHVzvV6uCj2tDbahfRvWmmTq6MYDQkJWuzmxf8lIkE35WPSmjt8Rdy+dW3j7FBKmXm647EoaSCUNsRNFAbR6PFHSahRee4FFD8xJRO1EI0lKpk+8wDPirBUaNzdmPq/nuhl9hV7mB3p6LvMtEWJYb0PsyUSmnV0XvJLOBPAEviIseglx08Rm+1aZHeVg+bQHApEDkEJhYzGB2utNfT2VaN8SIAeMV1L1V1Fz7vknMFEGd0MzxE1grNCegN/oVp75mAQrB9RXUYNhLN/4FabNXwIEAoAcwLSXX8d7H32anQaQ/Q66wDPCopcLvCGlTP28rR8Anvvk+4kkg0gKJD3ILsmQZFmtX4MRbTCoRtRTCZxx8klo1SKK1Ru3AABatojijFOrATlofjjwBO6h2iBQEWermLgVqZumMd6NXmRrlxX8y7LmmhsuBwE5mBF7MIyqFi3w+Jg/YseuH/Ht7r2Ydv/dqIpG1TT1bTVB0/EHyzfvBLYUfiipWAwFPkTR8TwsEfuyB7OMOyECr+6eS3OaRzG4LpveZz2tfStpLbCm/0+p7enUctMLLSn17TUFEogcQCAYVB8ImtCJJAGBYOZBQS+Xg+oDgH4g+FWuRoSXoaRc3QW1tbXo168fduzYkVfGBBTUzenZqrsZZrpYGA8cZgx43RrLAUqkmrWWg2r/9mAQcijEFzlTx8/1wSVQcTxrH3/8MS677DJs3bq1CNkRmETscFPnPMS0H1h5D6xAZaquTdW/QQubJ3I6AKelTbvt4hVVbzierZdeegljx47FUUcdVYz8NH0sxOk6oFZOQSimLOww0YZQA0Gz2HVxM1beJHLaLReBuLxxjLqPHz++GPlo2tDRczfQEXgLkZeLRVOj7FAHimBbCEC1mQeCWk84CRKRASVlcssNkQeCZnedXc9SJueh3Cl485rbYEFjI1JZWeosFIymWramWi43FFzoIuquwYu8c/5bTu7g9s20POvtrstG92UHMhM6UC+xsNuYBqBgy8UG3niWnK27u4y4eypXI6JJTuDQpLBx5bO6xeY6aUQx0I9N51dbRkB1mKHErk/OIEmZfbiRdTuRCzwjhF4OMMK36gPvatKIEpGpqysmsQNQBQ+YRG+M7soRuJoef+pkdjuBO1wLfcmSJYXMR9OHteIO//MeU67Q0PnVfhtiB0CPBK1OlBhQ3XnawnPax60meCTsMoEnhEUvJyzEnnM32WJAW2Yqr+qXbBpYwhgtRgqokXcwHW3oNAH+K7i8b4EjQuilhFdX54idu5/df6tlfsOInK6zmwUPcEXPy6ufI+UIDITQi4kLYVsuo9eVE6zIGUztLQG9OpK9ref4Q7mdhzJHCL0ccCN2qxu7HDqRsNF31gI7eShW6bldLnBECL0ccBpVlf1P3/B+jiibK3Z5tVjmKtBoNcutHZb9DSqN+d6ao3cghF5M3AjaapnX9W5uXp4F5qVvlZZVJyA7USv2+3BnfaF/23U8YqL4kkS/CPMTSCltdhj2hRl93yaMEHop8cvyuU0bLl1n9kHB8yZshOf4fj0raqb3nCkdfbmimPdjj892spGze89J6aS6nqgPgawOOE1Y7ELo5USuIvfg4kpQsnvbOeXFSvSM2GwFzhO3/m10m6W6x3K60dIzvujrSTqtphsIqINQSuaBKqAPYAEA6YQm8CCIpKiCDwSN3npNGSH0YuFUj3UjcidB2z0YaCudNlvsrHucdel5Lr6VyJnJFdV1FuIG1JFoaHHrI9KYhJ/KiFpJg6SSgJKGQk8EEQxBkgPqdzCsDmyhD3KhaA+DZEx9O44okOQgiN6TrxnM+CKEXg44iZwncJd1e3OdN52ps9LCZ6u6hOqiCpgFzxG78UILnQfCmZaJ+S0RBWCGosoIP2Wa3YWkkobA9THh9TnciJKGpAlcqoiA6L+DIUjhClXs0Fx3QB2gUv+WMpNFNGWrLoReCmwsr63IHb0AYrte3QaZ7qaswqljGtrmtZNT6Zryy1pxjsBNkzDqY8qZxplLAakUSCqhipua8IGkkpmZXuhlmkWXKyohJSKqVQ9HIFVEIKWSkMLqG15SOqGVmxK5ktYGv+CfiqaCEHqpsRIN4BihVvdxiFKzvynhGqKnLT19bFk2W3faytOiZV9P1Y/J1q/15XQdXEllBJ5MqFZas94kqf/WRB+PZa1XkimkEykEI2GQaBRSOAK5ohLQHgqoiBiuO9IJ6KU06uV03/smjBB6ucITuZPAbQJlpuUcF1WCbHbrAdWl54mdzSctco9BNklJAemEasUTlJA1UZNEDCSZNH4jlUQ6Fkc6kUI6lkA6mYKSSCFUFUEglkCoKgKSiEGOVEFKJdSPFrBDIg6EYTS9QXfZm7jIASH04uDC0jq2NfNEzq7jbsssk2Rq/nGzaI3XSWnrzYrdDbmKPBFT3XHtN1JJKPEGk8BTsQSURAqpWML4T9IKUrE4QlWVUJIphKq0oaZTScjUuSSJGCQ5AElKqGVJBzL1d6KUas7foiCEXm7Y1clh0YbMfGeJm05Thtl95SARor1aahZ71jHsRpQx6tz89cYY77TINVGrv2PGbyuBJ+tiUDSLHqyKqL+1TyitIFSVVrOulzcRA+QA5EBAPbaiReAJadIiB4TQS4dd3ZxZnxXgotfz6syswPWbWZIyTWuybESfeZjETuUzy6p7FLkRVSdqIE5JqfVy2pKTeAxKrA4kHtOErYpaF7j+PxVLINWQQjqpIBxLGqIn6TSUtAKSVhBGplGBxFWhk2BInQdOyw/hnf8mhhB6OWHTjGZZJ6ctrIXAM7+hue66lbaw7rRbz9TXTXllH0Yma82IXJ+phRK5EWyjrDct8mRdDKn6GFINCSTrG5BuSCBZH0M6lkCiNoFULIVEbRLpZBrpRAWUNAFJq3lS0pm86fO4kkQMCIbUOnwoDKKkACWUqVo0YYTQiwnXFXew5vDQVdRC4MZH7woKSuxaTzmTddfThZwdjWfyzHoZJjHzRE51ftHbx5FKmkSu1Ner1rpeFXuyrkGz6Akk6+JI1CWRqE0gWZdEoi6BdEJBOpFGOpEG0Sw5URTIARlyQIakdYhRGuogB0MgoTBIMgEpWNFsgnGNuvXw4LZteDQaxbK77jItn96uHeb07l2iXOWIU6cYjvWUOMEuVmCmbfVmLCUFSUlT86JRlphKP8stVxRktZvT2+u/FQeR081oussez1h0VuSJg/VIHqpHbF89GvbFENvXgNi+mPY7jlrtW18WPxhD4mC9up/2gABgDvhp7fdZgc0cIYTg06eewgvnnovH27TBv//rvzCvpgY7V6zIK12/EBa9FNjdVGw9m13HWiDWTWa2k5jt2Xq5ybp7eexbxQioB4456m7u6Wa0hWtNanrzGS3yxME6w32PHYgbFjx+MI5EbRINdUnUphTEFIL0gRhapM3nTArIkMNByCH1NjceKGE1is89nzmy4t578eE//oEThwzB2aNGIVlbi9UPPoh5NTUYumIFDvvlL/M+Rj6UTOh1dXWorKyE7MP0Oko6jVQs5kOuiktW/3DuNoR7I1o2WwHZIsty3YFDdfVo0aKF9l8TO5h6uX4sfT3bHGfRhz0rOGclcr2Onkxmout1Wp1cc9d1kccPqkKPH4wjfjCB+ngKB5IKDqYUNKQVpEkAqE0gBoI2AQlyQEYgHIAcqjeErsRikCKZDjdSKgWEFNTX1aIiWInsSoo7ar/9FusmT8bPf/tb9H7mGWP5Eaeeis2zZ0PRZo4tJSVx3evq6nDj8OFY/OabvqT3ybRpmNamjfFJHDjgS7pFh7GSWQG4LCtpISyOyCVCjO6m7635CMPuuBf7Dxw0i1Nh6vzsA0Y/JqcJMKu/O8lE2Hkih/E7YXbZY2rgjRV5/GAcDZprvr8hiR8TafyYSGN3PIXd8TT2JtL4SErjETmGPftixj6p+hhSdaoRSMUSGQ8imQCUNOprD+H6O0Zj8Vtv53zZdn3wAZRUCr/o1ctYlorFcFiHDjjnz39G65NOyjltvyi6RW9oaMCtf/wj4vE4Zs2ahVmzZmVtc/1116Fr166u0zxxyBCcduutxv/5/fr5kteyR5YBBZnJEgCTOD/Y8BkeefIFsM46AMgBGdePuh9PTrwPLVv+JDvoxg7MkAt0l1k5kOmKKsvqb1lWl8sypEAAkqwGziRZC6LJqlXOfNT/3yGNN1oBKUVCmgSRBkFIkhCSgQCAx+QYRgWjaBEKQA4FjWCcmnZAPSaAhngcw+//J2LxBGa9PAfPz56fVQQv92I6mVTT/fFHzPj5z43lHa64Ar+ZPj3Hk+gPRRf6u+++iy1btmDBa6+hVatWvqQZbdsWR59zjvFfCgR8SbdkGCOlShmrTonOmLiQEjWRpIzYtW3OPvVkPPvP+7QFSiYdSUZ9PIl+f7gdb7y7CkP69c4M1gBYjzxLbYM0lR7Rx3RXHzyQiNEDTx3lRVGviRIACQJSCiBBAOnMW2cIRxCMqG3hetTcKAtV95YDMn51QMJJ9UnKdSc4IiyjTTiAwE8q8IDcgI+QRt8WIYSqIghVqS+1BCNh9WWXYAhSKIx3PtqIL7dtx+svPIUWR7QDqWjh6TLpHH3uuZACAWxduBBn3n47Klq3xpClS5GsrS0bo1N0offu3Rvr1q1Dt/PPR3V1NSoqKrK28WrRGz367KlWo79ylhNJbRKDDGMmU1bsH2z4DJNmPKc9FAggSSAAkqk0Nnz+JQb26olLanplBEwNw0R/eE1sah4k6sUYvQ6v5YNOSw6CKClIobD64oomdoTCQCoJKRQCSYUgRyII6EJn2sOlgAw5IEEOSPiSpDAnFIeSIlAIoEBGUCJQggq+QR26VUXR52dtEG4ZRbAqgmCVOrmiVBGBFAobr7D2Of88fPj5NnSu+X+o/uVJqKiMZpXRzb1YdfTROGPECHw4cSIWXnopTho6FOlYDFtefVW9vMHSx7xLkoORI0cilUqhS5cu6NGjRymyUBa4mY3FZNUBU0eWLLHD7Maf1fFXePaR8eaHhCRj1cefYt6i/8P9d9+mubK6oDlCt4J9o0234LRVB/VA0jvqyAE18h+E4b5LwTDkCgWKoiAYSZgsOACjLVwOSJACMk4NBdChLoJEXQKJ2iRSsRQqD4vg60oJK0kKt53UDhU/iSLcKopQtNKw6FI4Yry+imAIkIO459brkSQyOnftih6/yb1JtvO4cWjdvj02PPEE3r7hBhBC0KZDB3S6/36ceuONOafrFxIp8FSnYjZVcJuidLgjszD7WXZ9pQNhdDp2+1mMraYPlhg+8udI/LgjeztmjDWJGTDC1GaezgThjHfN6Xb9VMoYKYZoveCUWB1IQx1IIgaloY7qIBMz9YpL1sWQakghUZdEsi6BZEMKqVgKFa0qUHlYBBWtKhBuVYlwyyjCrapQ0boFwi2jaHnVXxFb/ATkaCtIVS0hR1sBFVEo4SqQcBQkVAkSzrbo5YyYTbXcsXLR7dbx3gmn68f6dox1N+Y807Y3TYHEiNx0LImZzdQCo7rAseoEiuHC6/V1AOowTylACkLtd55Oq4ND6EM+KWmEAFMQLa0F1eRQEMFIAoFwHMFIEMG6JNKJNCp+UoGKVmGEW0YRqoog3KrK+C1HVQFL4YhpqCkiB81VliaMEHq5oNfTadignNU74brY9XX6akbwRppWc5JTxzXVy+l9TPmF+aGj5cXIA+XCAwCRg2qTG0CJPZwZ900bCUYGQOQAQoGA2o01HEQ6HIQcCkGub0A6FDQEH6oMqkJvFUFQC7yFW1ZpYo8iEI1CjlSpWdRHnQlHtIEjqXL70J+jnBFCLyZWQTUvPbM4dWMjLWobiSjqoIdE6wijjRijr8+qj+u/AbPVp9O3iMYTKBk961Yd6mEJAGoqdFXsuhsfDEJSQplmNxY5gICsNbvJqjWXw0GkIwkEE0mktXZ3JZlCKKoLvdKItAeiUUiRqFonByBVVGpWXbXmRA5kezNNFCH0coT7QGCa2izEbmyvJ6UvCDBNZxyB89x3APxpi9mHE5MHk9iJktX0J8lBtU4fCiMLra1bSiWhyDICwRDkcAxKIolAJIy0Ju5UQwKhZBLpZAqhaCWClWEEo6rIpYqIOspMZVVmzDhtmCmijw4bCBrei+tBNRopQujlhI37DnDE7gLCPjRsBM615BYurTEXOifab2wDTeyBoNouTiTDuutiJ0BG7FpHFsgBSHIAJJWAHAypI80EQwiEk5BTSQQjqtADEXUwCqIoCETCCEUjkCMRI7ouayI3LHo4olrxQBhEDrhrXWgiCKGXCruAHLueETuAbMGzlp3dn02b+s6ao5wReZY1d1M2DdqyQwGIDEhEiz0QJTP0MmXZpWBI7SabDEHSusnqgifptPo/lUQgqr39llZMApcqtE4x4UjGXQeAUBgkEDasuWHZmwHNo5Rljqt6OuMys51YWGtq7GPhYmcF2+hvuznKWRHzrDondmASu94aoGh1dv1YkqQOCJFMaNHxEIiSVsWeTpuHetbHdNf60MsVlZlhnoMhVeD6f+0hQgJhQLPm+mwupubDJowQerlBu+82QjWwEH5me4vuwDwrbTUTqZNF1yPwcCF2PUCoKIZ1J5Ks1tclWR0IQg5AVtIgwbA6Eo0udiUNSYvQm4SvpI3JG0BP3hCiRA2ABCvMltyYuqlpixwQQm/85GKJHMTNddUtI+7IeCNGm3l2fd1IV3PX1dVypu6ui1z/yAoQ0N+sM8+zBk38erMc0YWujwWnTcek0HOwAUAwrE3WENTmX5PMTYxNGCH0YmBR3zbXvSn3nbXqfsGxXJYvsPB+6/+ZjjuZwJxiEjtAVSmY7Y3ecpqFV19iCVA9+cy9+ghRgBCMXoD0Sz0SUQzrbAhZd8u1yDqgue6aqI1gnOgwIyh7XLicts1GVuuclnMeVjyxAxzrzgoe0Cy4tlpfpy/XUfjL9aCkVZdeuv5NAqHMf9mis1ATRQi9jLC06jS5WGUv67xsx1h3Q+xAZoxlAESCtl3AunmQFrgH6E5C9Lep+67+HdSCcjZNjE0VIfRSY9fMRoudndPcqsnM7X+nPLnZhu20QzLjvvMEDyC7/z30QCLVRdcuL17PA7WMBML22zVhhNAbIdyIOO9/sW5mq3o7UbLftWfq8KZ8Ms17ejqmdbztveSzmdJ8Sy4QNCOE0AWCZoAQukDQDBBCFwiaAULoAkEzwJXQX3vtNfTt2xe9evXCc889V+g8CQQCn3FsXtu1axcmTZqEOXPmIBwOY+jQoTj33HNxwgknFCN/AoHABxyFvnz5cpx33nlo3bo1AHVc9jfeeAO3UjOj2CJJOc9pVc5IVm+LWe9h8Zv9z7aL69+Z5aZjZ82wYrPOJe7LxisTpyy8VabJY2Rme05ZeeXyWD7v16zM8VAeR6H/8MMPOPLII43/Rx11FNavX+/6ALwJGpoCbofZbYw01bI11XK5wbGOriiK6UlICGl6T0aBoInjKPSjjz4au3fvNv7v3r0bRx11VEEzJRAI/MVR6J07d8aKFSuwd+9eNDQ0YPHixTj//POLkTeBQOATjnX0tm3bYsSIERg2bBiSySSGDBmCjh07FiNvAoHAJwo+95pAICg9omecQNAMEEIXCJoBQugCQTNACF0gaAYUROhN+SWY2tpa9OvXDzt27Ch1Vnzl0UcfRU1NDWpqavDwww+XOju+MXnyZPTt2xc1NTV46qmnSp0d33nooYcwatQox+18F7r+Eszzzz+PefPm4cUXX8SXX37p92FKwscff4zLLrsMW7duLXVWfGX58uV47733MHfuXMybNw+ffvop3nzzzVJnK29Wr16NlStX4tVXX8Xs2bMxc+ZMfPXVV6XOlm+sWLECc+fOdbWt70KnX4KJRqPGSzBNgZdeegljx45tcj0DjzzySIwaNQrhcBihUAjHH388vvvuu1JnK2/OOeccPPPMMwgGg9izZw/S6TSi0Wips+UL+/fvx6RJkzB8+HBX2/s+Cmy+L8GUM+PHjy91FgrCiSeeaPzeunUrXn/9dcyaNauEOfKPUCiEKVOm4Mknn0SfPn3Qtm3bUmfJF+69916MGDECO3fudLW97xZdvATTeNm8eTOuvfZa3H333Tj22GNLnR3fuO2227BixQrs3LkTL730Uqmzkzcvv/wy2rVrh06dOrnex3eLfvTRR+ODDz4w/ouXYBoHa9euxW233YbRo0ejpqam1NnxhS1btiCRSKC6uhqVlZXo1asXPv/881JnK28WLlyI3bt3Y+DAgThw4ADq6+vx4IMPYvTo0dY7EZ/5/vvvSc+ePcmePXtIfX09GTBgAPn444/9PkxJ6dmzJ9m+fXups+Eb3333HTn33HPJ8uXLS50VX1m6dCm5+OKLSTweJ/F4nFxzzTVkwYIFpc6Wr8yePZuMHDnScTvfLbp4CabxMWPGDMTjcUyYMMFYNnToUFx22WUlzFX+dO/eHevXr8egQYMQCATQq1evJuOteEW81CIQNANEzziBoBkghC4QNAOE0AWCZoAQukDQDBBCFwiaAULoAkEzQAhdIGgGCKELBM2A/w/VSOVGjYY9QgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'thompson'\n", + "\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.5、ucb 策略探索\n", + "\n", + "special_ucb 在前期用e-greedy进行了初始化" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 5/400 ](Epsilon:0.650): 2%|▋ | 7/400 [00:00<00:14, 26.27it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|████████████████████████████████| 400/400 [00:14<00:00, 26.89it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|█████████████████████████████████████| 20/20 [00:00<00:00, 73.83it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAABJCAYAAAAg7q3TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAX2ElEQVR4nO3daVBUVx738S/QgCga0+ISjVHjMqgRQaIGQREmAtIsERkEE5FxiZbGEE25lssMjgR5mLgkNWomis+4S9CyXOKKMgaMGsdAEoUYV4iAKCDNIjTd53lh2Y8LYUluG5qczyvv0ud3ONf+9+nbt29bCCEEkiRJktmy/L07IEmSJP02spBLkiSZOVnIJUmSzJws5JIkSWZOFnJJkiQzJwu5JEmSmZOF/A/I29ub7777TpG20tPTCQ4OJjg4GHd3d9544w3j8qFDhxTJMIU9e/Ywbdq0Bu3r7e39i9uys7P505/+xGeffaZU12qVk5PDrFmzfnF7VlYWM2bMwNfXl+DgYCIiIjh+/Lhxu1arJTIyst6cusZlwoQJHD58uPGdl0xO9Xt3QDJvw4YNY9++fQB88sknFBcXs3Tp0t+5V8/P9u3bCQwMZNu2bUyaNAmVyjRPqdu3b3P9+vVat126dIkpU6bw0Ucf4enpCcDVq1eJjo6moKCAt99+m/v37yv24i01PbKQm4mUlBTWrVuHTqejRYsWzJ8/HxcXFxYuXEhFRQVr1qzhypUrREZGsnXrVg4dOsTNmzfJz8+nsLAQR0dHVqxYgb29/RPt7tq1iy1btmBpaYmDgwNLliyhR48eLFiwgJKSEnJychg5ciTR0dEkJCRw/vx59Ho9/fr1Y/Hixc+097jFixfTrl07Zs+eDcC+ffs4evQokZGRJCQk0LlzZ65du0aLFi2Ii4ujZ8+eVFdX/2LOjh07+P7771mxYsUTObm5uQQGBnLx4sValzds2MDevXtRqVR069aNuLg4AAoLC5k8eTJ37tyhS5cuLF++nPbt2zf4mJSVlbF//36SkpLIysriyJEjaDQaACorK1m2bBkZGRm0bt2aXr16ARAXF0dBQQExMTHk5eWh0+nQaDRMnz6d3NxcoqKi8PT0JCMjg9LSUubOnYu3tzeLFy+moKCAyZMns3Hjxif6sXr1aqZOnWos4gA9e/YkPj6eqKgoQkNDWbhwIQ8ePCA4OJg9e/awd+9edu3ahU6n4/79+0ydOpXx48c3eFz+97//kZCQQGVlJZaWlrz33nt4eXk1eOwkhQmpybt+/boICAgQRUVFQgghfvzxR+Hu7i7Ky8tFeXm58PHxEXv27BEajUbs27dPCCHE2rVrxYgRI0RhYaHQ6/Vizpw5Ii4uTgghhJeXl8jMzBTp6enizTffFPfu3RNCCJGcnCxGjx4tDAaDmD9/vpg4caKxD5988omIi4sTBoNBCCHEP//5T7Fs2bIn+rl27Vrx97//3bh86dIl4e7uLnQ6nRBCiPHjx4v//ve/4uuvvxaOjo7i/PnzQgghtm/fLsaMGdPgnKfl5OQIZ2fnWpePHz8ufHx8RElJiRBCiNjYWPGvf/1LJCcnC2dnZ3Hjxg1jTnR0dK3te3l51bp+69atxn7/+9//FqGhocZtCQkJYs6cOUKv1wutVisCAwPF/PnzhRBCTJgwQZw4cUIIIcSDBw/EhAkTxMGDB0VOTo7o06ePSElJEUIIcfjwYTFy5EghhBBff/210Gg0tfZj0KBB4rvvvqt125AhQ8QPP/zwxJiUlZWJsLAw4/+nixcvGrfVNS7vvPOO+PLLL0VJSYnw8fEROTk5Qggh8vPzxYgRI8TPP/9cax8k05MzcjOQlpbGnTt3iIqKMq6zsLDg1q1bODo6smrVKsLCwggKCiIoKMi4j5+fHw4ODgCEhoYSGxvL/PnzjdtPnz6Nv78/arUagJCQEFasWEFubi4Arq6uxn1PnTqFVqslPT0dAJ1OR7t27ersd9++fXn55Zc5deoUPXr04M6dO3h4eHDu3DkcHR15/fXXARg7diwxMTEUFxf/qpy6nDlzBj8/P1544QUAFi5cCDw8Fzxs2DC6detmHJ/Q0NBGtb1z507CwsIACAoK4uOPP+bixYu4uLiQmprKwoULsbS0xN7enjFjxpCdnU1FRQXnz5/n/v37rFmzBoCKigqysrJwcnLC2traOLPu168fJSUlv/pvf8RgMDyx3KpVK9avX09qaio3btwgKyuLiooK4/b6xuXbb7+lsLCQmTNnGtdZWFiQnZ1N586df3N/pcaThdwMGAwG3NzcWL16tXFdXl4eHTp0AOD69eu0bduWy5cvU11djY2NDQBWVlZPtGFpaflMu08TQlBTUwNAy5Ytn9h30aJFxiJTXl5OVVVVvX1/++23SU5Opnv37oSFhWFhYfFM3x6xsrL6VTkWFhaIx24ZpNPpnmjzUSZAaWkppaWlz/TBYDA06vz2N998w5UrV/j8889JTEwEwNrams2bN+Pi4oJKpXqiT4/G3mAwIIRg586d2NnZAVBUVIStrS3FxcVYW1sb932833UZNGgQ586d47XXXgMenhpxcHAgOzsbnU5H7969KSwsNO6fn5/PuHHjCAsLw9XVFT8/P06ePPnEmNU1Lnq9np49e5KUlGRcV1BQYJwQSM+fvGrFDLi5uZGWlsbVq1cBSE1NJSgoiAcPHpCbm8uKFSvYtGkTr776KgkJCcbHnThxAq1Wi8FgYPfu3c+cwxw+fDiHDh2iqKgIgOTkZNq2bWucjT3Ow8ODbdu2UV1djcFgYMmSJXz88cf19t3X15fLly9z5MgRxo4da1yflZVFVlYW8PA8vYuLC23atPlVOW3atEGn0/HTTz8BcPDgQeO2YcOGcezYMcrKyoCHH8hu3rwZgLNnz3L79m3g4ex6xIgR9f49j+zYsYPg4GBSU1NJSUkhJSWF9evXc+zYMW7fvo2npyfJyckYDAYqKys5cOAAFhYW2Nvb4+zsbCz+paWlREREcOLEiTrzrKysnniBetycOXPYtGkTqampAGzevJmQkBDmzp3LBx98gK2tLSqVCr1ejxCC77//HrVazYwZM/Dw8DAWcb1e36BxcXZ25ubNm5w/fx6Ay5cv4+vrS0FBQYPHT1KWnJGbgV69ehETE8OcOXMQQqBSqVi3bh22trZ8+OGHTJ48mT59+rB06VICAwMZNmwYAA4ODkydOpXi4mIGDx7M9OnTn2jX3d2dqKgoJk6ciMFgQK1Ws2HDhmdm7gAzZsxg5cqVjBkzBr1eT9++fVmwYEG9fbexscHX15e7d+8+MWNzcHBg9erV/Pzzz6jVauLj4+vN+aUPO1u3bs3cuXOZOnUqarUaPz8/4zZPT09++uknIiIijGO5fPlyjh49Sp8+fVi0aBF3797l1VdfJSYmpiGHg6KiIo4ePUpycvIT693c3HB2dmbLli1ER0cTExNDYGAgrVu3pl27drRo0QKAhIQEli9fTmBgINXV1QQEBBAUFGQ8pVWbXr16YWtrS2hoKElJSU/M1vv27cvnn3/OmjVriI2NxdLSklatWqFWq8nIyOD27dt07NgRJycnNBoNiYmJdOzYET8/PywsLBgyZAhqtZqbN28C1DsuarWatWvXEh8fT1VVFUII4uPjefnllxs0fpLyLISQt7FtjprKpYAVFRW88847LF26FGdnZ+DhjG/58uUcOHDgd+1bQ3l7e5OSktKoxxw8eBB7e3s8PT0xGAzMmjULd3d345Uhz8uFCxd45ZVXGnU1jmR+5KkVyWROnz7NyJEjGT58uLGI/1H07t2bdevWERwcTEBAAB06dOAvf/nLc++Hq6urLOJ/AA2akZeVlREeHs769evl2ydJkqQmpt4ZeUZGBhEREdy4ceM5dEeSJElqrHoL+e7du1m2bJnxUjdJkiSpaan3qpWnrxCQJEmSmhb5YackSZKZM/l15COjYvn5TrFJM64c+j/09p9r9hkyp+lmyJymm9Hccrp0eJFTmxc16jEmL+Q/3ynmZt49U8c0mwyZ03QzZE7TzWiOOY0hT61IkiSZuQbPyBv7zTZJkiTp+ZAzckmSJDMnC7kkSZKZk4VckiTJzDWJ29j2L7mBd/63OFSVUm2p4marjhzqMpgi2za/d9f+0NpWaZl3+QvSHPpx8OWhxvVLMreRZ6fm896jf8fe/bHJY9PECcHrRVd4o/Ay7avuo7O04rZdO453cuGWfUfF4373Gbm6qpSIG6fQWrdkR/eRHOnsSs+y20TcOFn/gyVJkpog37wLhOSkcbfFCyR1G8GhzkNQV2uZfPUI7R+UKJ73XGbkFqIGgRXU8tNV9rpKLBHoLK24Z9uGrBde4b51K16sLgMhan3Mr8lRUnPKaUiGJQKVocbkOUpoTjny2DTdnLoy2lSX43Hne7Jbd2Fn95HG9Xl2apxKrmNpgp+AMH0hN9TQqeoHSlWdKVc9e1/knFbt+eGFV+h//xb979+iVGXHlTZdSO3g1OgiXleOUppTTkMz3O5exu3uZZPn/FbNKUcem6abU1/GyxV3sUJwpU0X4zqVoYbCFi9wopMzBgvlT4SYtJBXVlZikfc1FsJAm5o82tTkPbNPiXVXtvX4M6+UFeBYmkuP8nxcin7C8X4OH/cdS6XKtkE5naou15tTafXib/p7LIS+2eQ0ZMyEePjTbJlte5DWvp9x/aSrRxTNMZcxe1458tg03ZyGjJmN4eGPV1uKhz9u3rLmAYu/32HcfuHFXiR3G/6r+1AbkxbykydPQrWW/BaDMFjUHjWg+DrOxRc41GUwRzu7AuCdf5E387+lS8VdfnrsVa2uHGtDBbl2rr+Yo4SW+uJmk9OQMWtbpQVAq7Ijp9X/v42xoREfrchj03jy2DTdnIaMmdaqAj3n6Xs/h686DOCBlQ3remuwMdQwuREvtI1h0kLu7+/PB39bS7f7Z6myaIWo5S3FA6uW/Kk0l9a6Cv7b0QkLYeC1khvoLKwosGvYK6e/vz+T5sbTrfKXc5R4xS9XOWBrKG0WOQ0Zs0ezvt9CHpvGk8em6eY0dMxOd3iNkXe+4+3rJ8h4sScqg55+9x/+uLXZnVoBEA4D0JZXUmnZlgpVu2d3aAE7uqvwLMhk7K3TWAB5LV7k/776Jlrrlg3OKbJ5FQvEL+copDnl1JfxaNZn6hylNKcceWyabk5DMo52fp17tm0YejfbWNfu2Lbl8EuufO3QV/E+PZerVu7Z9Kxz+w9tu/ND2+4mz1FKc8qpK6PEtjWLnP/6zPrlTm8rmqOk5pQjj03TzWlIxoV2fbjQro/J+wJN4DpySZIk6beRhVySJMnMyUIuSZJk5mQhlyRJMnOykEuSJJm5BhXy/fv34+/vj4+PD9u2bTN1nyRJkqRGqPfyw4KCAlatWsWePXuwsbEhPDycoUOH0qtXr+fRP0mSJKke9Rby9PR03njjDdq2bQuAr68vhw8f5r333mtQQJcOv+3bWg3V7SXTfcngeWbInKabIXOabkZzyvk1NdNCiLrvqbhhwwYqKiqYPXs2AElJSWRmZrJ8+fJf10tJkiRJUfWeIzcYDFg8djtZIcQTy5IkSdLvq95C3qlTJwoLC43LhYWFdOjQoY5HSJIkSc9TvYV82LBhnDlzhqKiIiorKzl69CgjRox4Hn2TJEmSGqDeDzs7duzI7NmziYyMRKfTERoaipOT0/PomyRJktQA9X7YKUmSJDVt8pudkiRJZk4WckmSJDMnC7kkSZKZk4VckiTJzMlCLkmSZOZMUsif590Sy8rKCAgIIDc312QZn376KRqNBo1GQ3x8vEky1qxZg7+/PxqNhsTERJNkPG7lypUsWLDAZO1PmDABjUZDcHAwwcHBZGRkmCQnJSWFkJAQRo8ezT/+8Q+TZCQlJRn/juDgYFxdXYmJiVE8Z9++fcb/ZytXrlS8/Uc+++wzfH19CQwMZN26dYq2/fTzMT09ncDAQHx8fFi1apVJswDmzZvHnj17TJaxa9cuAgICCAwMZOHChVRXV5skZ/v27Wg0Gvz9/Vm5ciX1XlwoFJafny+8vLxEcXGxKC8vF4GBgeLKlStKxwghhPj2229FQECA6N+/v8jJyTFJRlpamhg3bpyoqqoS1dXVIjIyUhw9elTRjLNnz4rw8HCh0+lEZWWl8PLyElevXlU043Hp6eli6NChYv78+SZp32AwCA8PD6HT6UzS/iO3bt0SHh4eIi8vT1RXV4uIiAhx6tQpk2b++OOPYtSoUeLevXuKtltRUSEGDx4s7t27J3Q6nQgNDRVpaWmKZgjx8P9zQECA0Gq1oqamRkybNk0cOXJEkbaffj5WVlYKT09PcevWLaHT6cSkSZMUOz5PZ+Xn54tp06YJJycnkZycbJKMa9euiVGjRgmtVisMBoOYN2+eSExMVDzn1q1bYtSoUaK8vFzU1NSIcePGidOnT9fZhuIz8sfvltiyZUvj3RJNYffu3Sxbtsyktwxo3749CxYswMbGBmtra3r27Mnt27cVzRgyZAj/+c9/UKlU3Lt3D71eT8uWLRXNeKSkpIRVq1Yxffp0k7QPcO3aNQAmTZpEUFAQW7duNUnOsWPH8Pf3p1OnTlhbW7Nq1SoGDhxokqxH/va3vzF79mzUarWi7er1egwGA5WVldTU1FBTU4Otra2iGQCXLl3Cw8MDe3t7rKysGD58OMePH1ek7aefj5mZmXTr1o2uXbuiUqkIDAxUrBY8nbV//37+/Oc/M3r0aEXary3DxsaGZcuWYW9vj4WFBX369FGkFjyd07VrVw4ePEjLli0pLS2lrKyMNm3a1NlGvd/sbKw7d+7Qvn1743KHDh3IzMxUOgaAFStWmKTdx/Xu3dv47xs3bvDll1+yY8cOxXOsra1Zu3YtmzZtws/Pj44dOyqeAbB06VJmz55NXl6eSdoHKC0txc3NjSVLlqDT6YiMjKRHjx64u7srmnPz5k2sra2ZPn06eXl5jBw5kg8++EDRjMelp6fz4MEDRYvFI/b29kRHRzN69Gjs7OwYPHgwgwYNUjynf//+xMbGMm3aNOzs7EhJSan/bXsDPf18rK0WFBQUmCRrypQpAFy4cEGR9mvL6NKlC126dAGgqKiIbdu28dFHHymeAw/rwe7du1m5ciVOTk44OjrW2YbiM/LmerfEK1euMGnSJObNm0f37t1NkvH+++9z5swZ8vLy2L17t+LtJyUl8dJLL+Hm5qZ4249zcXEhPj6e1q1bo1arCQ0NJTU1VfEcvV7PmTNniI2NZdeuXWRmZrJ3717Fcx7ZuXMnf/3rX03SdlZWFsnJyZw8eZLTp09jaWnJxo0bFc9xc3MjJCSECRMmMGXKFFxdXbG2tlY8B5pvLSgoKGDixImMHTuWoUOHmiwnLCyMs2fP4uDgwKefflrnvooX8uZ4t8QLFy4QFRXFhx9+yJgxYxRv/+rVq1y+fBkAOzs7fHx8yM7OVjzn0KFDpKWlERwczNq1a0lJSSE2NlbxnG+++YYzZ84Yl4UQqFSKv/nDwcEBNzc31Go1LVq04M033zTZu7/q6mrOnz+Pt7e3Sdr/6quvcHNzo127dtjY2BASEsK5c+cUzykrK8PHx4f9+/ezZcsWbGxs6Nq1q+I50DxrwdWrVwkPD2fMmDHMnDnTJBl5eXnGdxYqlQqNRlNvPVC8kDe3uyXm5eUxc+ZMEhIS0Gg0JsnIzc1l8eLFVFdXU11dzYkTJ3B1dVU8JzExkQMHDrBv3z7ef/99vL29WbRokeI5Wq2W+Ph4qqqqKCsrY+/evYwaNUrxHC8vL7766itKS0vR6/WcPn2a/v37K54DkJ2dTffu3U322YWjoyPp6elUVFQghCAlJYUBAwYonpObm8uMGTOoqalBq9XyxRdfmORUEcDAgQO5fv06N2/eRK/Xc+DAAbOuBWVlZUyePJno6GgmTZpkshytVsvcuXMpLS1FCMGRI0fqrQeKT5Oa290SN27cSFVVFXFxccZ14eHhREREKJbh6elJZmYmb731FlZWVvj4+JjsReN58PLyIiMjg7feeguDwcD48eNxcXFRPGfgwIFMmTKF8ePHo9PpcHd3Z+zYsYrnAOTk5NCpUyeTtA3g4eHBpUuXCAkJwdramgEDBvDuu+8qnuPo6IiPjw9BQUHo9XqioqJMMmkAsLW1JS4ujlmzZlFVVYWnpyd+fn4myXoevvjiC+7evUtiYqLxEmFvb2+io6MVzenTpw/vvvsu4eHhWFlZ8frrr9d7Sk/e/VCSJMnMyW92SpIkmTlZyCVJksycLOSSJElmThZySZIkMycLuSRJkpmThVySJMnMyUIuSZJk5v4f7+2wHGL4qzAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 6/400 ](Epsilon:0.650): 2%|▋ | 8/400 [00:00<00:13, 28.10it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|████████████████████████████████| 400/400 [00:14<00:00, 27.32it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|█████████████████████████████████████| 20/20 [00:00<00:00, 77.89it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 7/400 ](Epsilon:0.650): 2%|▉ | 10/400 [00:00<00:10, 36.96it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.650): 100%|████████████████████████████████| 400/400 [00:14<00:00, 27.52it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.650): 100%|█████████████████████████████████████| 20/20 [00:00<00:00, 87.73it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'ucb'\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = theAlley\n", + "状态数:13, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=theAlley, Algo=Q-Learning, exploreType=special_ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mtheAlley\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mspecial_ucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 20/400 ](Epsilon:0.349): 8%|██▌ | 32/400 [00:00<00:02, 129.63it/s, reward=-3.500]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n", + "UCB-Start 64\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.349): 100%|████████████████████████████████| 400/400 [00:15<00:00, 25.49it/s, reward=0.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:theAlley, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.349): 100%|█████████████████████████████████████| 20/20 [00:00<00:00, 73.42it/s, reward=0.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = walkInThePark\n", + "状态数:48, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=walkInThePark, Algo=Q-Learning, exploreType=special_ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mwalkInThePark\u001b[0m, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mspecial_ucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 14/400 ](Epsilon:0.310): 5%|█▋ | 20/400 [00:00<00:05, 65.22it/s, reward=-2.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n", + "UCB-Start 76\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.310): 100%|██████████████████████████████| 400/400 [00:02<00:00, 176.69it/s, reward=10.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:walkInThePark, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.310): 100%|███████████████████████████████████| 20/20 [00:00<00:00, 313.29it/s, reward=10.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 67\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------------------------------------------------------------------------------------------\n", + "EnvName = FrozenLakeEasy-v0\n", + "状态数:16, 动作数:4\n" + ] + }, + { + "data": { + "text/html": [ + "
Config(Env=FrozenLakeEasy-v0, Algo=Q-Learning, exploreType=special_ucb(gamma=0.9,learning_rate=0.1))\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mConfig\u001b[0m\u001b[1m(\u001b[0m\u001b[33mEnv\u001b[0m=\u001b[35mFrozenLakeEasy\u001b[0m-v0, \u001b[33mAlgo\u001b[0m=\u001b[35mQ\u001b[0m-Learning, \u001b[33mexploreType\u001b[0m=\u001b[1;35mspecial_ucb\u001b[0m\u001b[1m(\u001b[0m\u001b[33mgamma\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.9\u001b[0m,\u001b[33mlearning_rate\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.1\u001b[0m\u001b[1m)\u001b[0m\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 61/400 ](Epsilon:0.451): 23%|███████▌ | 92/400 [00:00<00:00, 312.95it/s, reward=0.000]]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set env random_seed = 1\n", + "UCB-Start 38\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Tarin[ 400/400 ](Epsilon:0.451): 100%|███████████████████████████████| 400/400 [00:01<00:00, 286.00it/s, reward=1.000]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "环境:FrozenLakeEasy-v0, 算法:Q-Learning, 设备:cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Test[ 20/20 ](Epsilon:0.451): 100%|████████████████████████████████████| 20/20 [00:00<00:00, 354.80it/s, reward=1.000]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "convEps: 320\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6QAAAEXCAYAAAC6fokvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAC1H0lEQVR4nOydd5wURdrHf92Tl11YNgGCBEVAhRUJiiQVFRRZI6coQRRRTz0UFfFAxYSBQzGcr4Ez3JlODj0VA3CiiAIqoCJKUCTHzXlid71/zE5P6pnpmemZ6Z59vnz47PR0T/VTobvqqeeppzjGGANBEARBEARBEARBpBk+0wIQBEEQBEEQBEEQrRNSSAmCIAiCIAiCIIiMQAopQRAEQRAEQRAEkRFIISUIgiAIgiAIgiAyAimkBEEQBEEQBEEQREYghZQgCIIgCIIgCILICKSQ6pRRo0Zhy5YtqqS1bt06XHzxxbj44osxbNgwDBkyRDr+9NNPVbmHVpg7dy7WrVsX9ZrnnnsODz30kOr3VprugQMHMHnyZNlzvXv3RnV1tdqihbFq1So88sgjKb9PqmlsbMS0adPgcDhUT/unn37C5MmTUVZWhnHjxuH666/H77//rvp95Pj73/+Ozz//HABwzz334JVXXpG97q677sIff/yRFpkIgogO9duJofd+W816jwe1+/FRo0ZhzJgxuPjii3HJJZdg7NixGDduHNasWaPaPRLhlVdewT333KPo2vr6euk5Oe+881BaWiodP/HEEymR76GHHsJzzz2XkrSzCWOmBSAyz9ChQ/Hhhx8C8L58a2pqcP/992dYqtQwf/78TIugC8455xycc845mRYjaRYuXIg//elPsFqtqqbrcrlw44034tVXX8XJJ58MAPjwww8xffp0rFq1CgaDQdX7hfLdd9+hZ8+eMa+77bbbcOedd+Ldd98Fx3EplYkgiPRB/TYRi1T04wsXLkS/fv2k4+XLl2POnDn45ptvVL1Pqmjbtq303Hz33Xd4+OGHpWMis5BCmka++OILvPDCC3C73bBarZg9ezZOPfVU/PWvf0VzczOeeeYZ/P7775gyZQrefPNNfPrpp9i7dy+OHDmCiooK9OnTB/Pnz0dubm5Quu+++y7eeOMN8DyPoqIi3HfffejRowfuuece1NbWYv/+/TjrrLNw2223YeHChdiwYQMEQcBJJ52Ee++9Nyy9QO69914UFhZi5syZALyD7pUrV2LKlClYuHAhjjnmGOzatQtWqxWPP/44jj/+eLhcroj3eeedd/DLL7+EdTAejwcPP/wwfvjhB5hMJnTp0gWPPfYYampqMHnyZIwYMQKbN28GYwz3338/Bg0aBAB44YUXsHLlSoiiiM6dO2PevHno0KEDKioqMG/ePOzatQs8z2PChAmYMmUKJk+ejIkTJ+L888/Hiy++iFWrVsHhcMBut2P27Nk477zzFNWl70X28ccfhx17PB787W9/w+rVq2EwGHDqqadi3rx5AIA//vgDEydORF1dHU488UTMmzcvavlH4z//+Q/eeecdiKKI/Px83HfffTj++OOxe/duPPTQQ2hqapLazdNPPw2LxYK+ffvinHPOwfbt27Fw4UJcffXVuOGGG7B27VqUl5fj+uuvx9VXX433338fK1aswEsvvYTJkyejf//++OGHH3D48GGcccYZePjhh8HzPN5//328/PLLsFqtGDJkCP71r39h69atYbJ++eWXePrppyGKInJycvDggw8iNzcXZWVl+PHHHwF4Z5h9x++//z6WLl0Ku92O3NxcuN1uXHvttRgzZgwA4G9/+xsAYNasWRHL4fDhw/jyyy9x7733AkDEdulwOHDJJZdg/vz5OPPMM/H0009j8+bNeOWVV3DuuefiwgsvxNq1a9HQ0IBrr70WV199Nex2OxoaGtDc3Czl8aKLLkJubi4EQcDGjRvx1FNPoVOnTti9ezdsNhtuuOEGvPHGG9i9ezdGjx6NOXPmAIj8/DY0NODBBx/E9u3bwXEcRowYgTvuuAPvvvsufvnlFyxYsEBSfH/88UdMmDABlZWVOOGEE/Dkk08iJycHxx57LPLy8rBq1Sqce+65CbUzgmjNUL9N/baa/XYoeurHQ2GM4cCBA2jXrl3U/LhcLtx000346quvAADTpk1DUVERnnjiCbhcLowYMQKff/45VqxYgXfffRdutxt1dXWYPn26lI/A8cCrr76KRx55BOvWrUNhYSEKCwuRl5cHAFi5ciVeeOEFcBwHg8GAu+++G4MHD1ZcH6NGjUJpaSl27NiBO+64A6WlpXjooYdw+PBhuN1uXHjhhbjppptw4MABTJ06FWeeeSY2b96M+vp6zJo1C+eddx4aGxsxd+5cbN++HSUlJTAYDBg4cGCcLaMVwoi0sHv3bjZu3DhWXV3NGGPst99+Y8OGDWNNTU2sqamJjR49mr3//vvswgsvZB9++CFjjLFnn32WjRw5klVUVDBBENgdd9zBHn/8ccYYY2effTb7+eef2bp169i5557LqqqqGGOMvffee+yCCy5goiiy2bNns2uuuUaS4bnnnmOPP/44E0WRMcbYk08+yebNmxck57PPPssefPBB6Xjr1q1s2LBhzO12M8YYu/rqq9maNWvYt99+y/r06cM2bNjAGGPs7bffZpdeeqni+4SyYcMGdv7550u/WbBgAdu0aRPbv38/69WrF/voo48YY4ytXr2aDRs2jLlcLvbf//6X3X777ZJs//73v9n111/PGGPslltuYU888QRjjLH6+np24YUXsj179rBJkyaxzz77jB04cIBNnjyZ2e12xhhjH3/8MRs3bpxsGcjx7bffsgsvvFD2+J///CebOHEis9vtTBAEdtttt7H//ve/7Nlnn2VnnXUWq6qqYqIosjvvvJMtWLAgLO39+/ezSZMmyd63V69erKqqin333Xfs6quvZs3NzYwxxr7++mt2/vnnM8YYe/zxx9kHH3zAGGPM5XKxcePGseXLl0u//+9//xuU3htvvMEYY2zLli2sb9++zOFwsPfee4/dcMMNjDHGJk2axGbMmMEEQWANDQ1s+PDhbP369ez3339nZ5xxBjt8+DBjzFvvvXr1CpO5oqKCDRw4kP3666+MMcZWrFjBpk2bxvbv38/69+8flG/f8XvvvccGDx7MGhoaGGOMLV26VJLH4/Gw4cOHs927d0cthzfeeIPNnj1bSj9au/z666/ZiBEj2MqVK9mZZ54pPU9nn302u++++5goiuzw4cPs9NNPZ9u3b2eMMfbqq6+y0tJSNmrUKHbXXXex//znP5Ic3377LTvxxBOlPE+bNo1deeWVzOl0sqqqKnbyySezI0eORH1+7777bvbwww8zURSZ0+lk1113HXvppZekOvnss88YY4zNnj2bjR8/njU3NzOPx8MuvfTSoDp+9dVX2d133x3emAiCiAr128H3CYX6bT/R+m1fvYeip37cl4/Ro0ezsrIyNmLECDZixAj217/+le3bty9mfkaNGsV27NjB7HY7O+uss9jIkSMZY962cf3117PGxkZ2xRVXSM/ajz/+GHE88Prrr7MpU6Ywp9PJmpqa2KWXXir19eeccw778ccfpfs/99xzsnlhLLw9+PL497//XTqePHkyW7VqFWOMMYfDwSZPnsw++eQTqY1/8cUXjDHGli9fzs466yzGGGPz589nd999NxNFkVVVVbGRI0eyZ599NqIchBeykKYJ38zV1KlTpe84jsO+ffvQp08fLFq0CFdccQUuuugiXHTRRdI1559/PoqKigAA48ePx6OPPorZs2dL57/++muMHTsWBQUFAIDLLrsM8+fPx4EDBwAgaFZm9erVaGhokNZiuN1uFBYWRpX7xBNPRJcuXbB69Wr06NED5eXlGD58OL7//nv06dNHmvG8/PLL8dBDD6Gmpiah+/Tq1QsGgwF/+tOfMHz4cIwZMwalpaXS7FtZWRkA4Mwzz4TBYMCOHTvw5ZdfYsuWLbj88ssBAKIowm63A/Cur5k1axYAIC8vT5oR9dG5c2csWLAAy5Ytw969e7F582Y0NTVFlVEpvrU9PjfRp59+GoDXreq8886T6uryyy/HggULErrH6tWrsXfvXkyYMEH6rr6+HrW1tZg1axbWrl2LxYsXY8+ePSgvLw+y5PnqzIfPpefkk0+Gy+UKutbH2WefDZ7nkZubi27duqGurg7bt2/HsGHD0LFjRwDApEmTZNdJ/PDDDzjhhBNw0kknAQBGjx6N0aNHS200Er1795ZmoceOHYsFCxagoqICW7duRffu3dG9e3csWbIkYjns2rULXbt2DSqzSO1y+PDhGDt2LP7yl7/gzTfflOoIAK6++mpwHIeOHTtixIgRWLt2LXr37o1rr70Wf/rTn7BhwwZs2LABixcvxuLFi7F06VIAQJcuXaQ8d+3aFXl5eTCbzSgoKECbNm1QV1cX9flds2YN3nnnHXAcB7PZjAkTJuCf//wnbrjhhrCyOvfcc2Gz2QAAJ5xwQtA64y5duuCzzz6LWtYEQYRD/Tb122r226HoqR/34XPZ3b9/P6699lqceOKJOPbYY2Pm57zzzsOaNWtwwgknYMiQIdixYwd+//13rFq1CqNHj0abNm3w4osv4quvvsKePXuwffv2oDwEjgfWr1+PcePGwWw2w2w2o6ysDDt27AAAXHjhhbj11ltx5plnYtiwYZg+fbqyygjAV7bNzc3YsGED6urq8Mwzz0jfbd++HaWlpTCZTDjzzDMBACeddBJqa2sl+ebMmQOO41BQUKDYgt/aIYU0TYiiiDPOOEN6yQHA4cOHUVJSAgDYvXs38vPzsW3bNrhcLpjNZgAIWosmiiJ4ng9LNxTGGDweDwAgJycn6No5c+ZID1BTUxOcTmdM2SdOnIj33nsP3bt3xxVXXCGtRZNbJ2cwGBK6j8+v/4cffsC3336L22+/HdOmTZM6stA8++7jc00BvC6ZdXV1AACj0Ri0Zm7//v1o3769dPzrr7/i5ptvxtSpUzFs2DAMHjwYDz74YMyy8MFxHBhj0rHb7ZY+G43Bj1VlZaVUT6H1GXqtUkRRxMUXXyx13qIoory8HO3atcPMmTMhCAIuuOACnHXWWTh8+HCQrIFtAgAsFouUJwBB1/oIXIPpy7vBYAi6NtK6SYPBEFQXjDHs2LEDeXl5EcswVE6bzYYxY8bg448/xo8//og//elPMcuB47ig5yNau2SM4Y8//kBRURF++umnoM4+sI58z+CmTZvw448/4vrrr8fZZ5+Ns88+G3fccQfGjRuHtWvXon379tIzLJdOYHqh+J5fURSDyk0URem5DiUw7dC2aTQaw94bBEHEhvpt6rd95ROYj0T77VD01I+Hcuyxx2LBggWYMmUKTjnlFJSWlkbNz7nnnotnnnkG5eXlGDZsGAoLC/HNN99gzZo1mDlzJo4cOYIrr7wSV1xxBQYOHIjzzz8fX375ZcT8BhIo88yZM3H55Zdj7dq1eP/99/Hqq69Kk8RK8d1LFEUwxvDvf/9bmvCtrq6GxWJBTU0NTCaT9GyHxmhIpExbOzRKSRNnnHEG1q5dK0W8/Oqrr3DRRRfB4XDgwIEDmD9/Pl599VUcd9xxWLhwofS7VatWoaGhAaIoYsmSJTj77LOD0h0xYgQ+/fRTySLy3nvvIT8/H926dQuTYfjw4XjrrbfgcrkgiiLuu+8+PPXUUzFlHzNmDLZt24YVK1ZIs5oAsH37dmzfvh2Adz3MqaeeirZt2yZ0ny+//BJTp07Fqaeeir/85S+45JJL8MsvvwDwvgB8Udy++OILmEwm9OrVC8OHD8fSpUvR2NgIAHjmmWdw9913S+X93nvvAQAaGhpwzTXXYM+ePdL9NmzYgL59++Laa6/FaaedhlWrVkEQhJhl4aOgoACHDh1CVVUVGGP45JNPpHNnnHEGPv74Yyn/DzzwgHT+iy++QF1dHQRBwJIlSzBy5EjF9wxk+PDh+OSTT1BeXg4AeOedd3DNNdcAAL755hvccsstGDt2LABg8+bNceUtHhnWr1+Po0ePAvCuHZHjlFNOwR9//CFFoF21ahVmzZqFtm3bwu12Y+fOnQAQVIZyXHHFFfjvf/+LH374QVpLGq0cevTogf379wfJG6ldvv7662hubsZ7772H119/HT///LP0uw8++AAAcOjQIaxduxYjR45EQUEBXnjhBWzcuFG6rqKiAo2NjejVq5eyAkT053f48OF48803wRiDy+XCkiVLMHToUADeDi6SchrKgQMHcNxxxymWiSAIL9RvU7/tk1+NfjsUPfXjcgwYMACXXHIJHnjgAYiiGDU/AwYMwP79+7F69WoMHToUw4YNwz//+U90794d7du3xy+//IKCggLcfPPNGD58uKSMyuV5xIgR+OCDD+B0OuF0OqWo0h6PB6NGjYLdbsdVV12FefPmYceOHXC5XAmVTW5uLvr374/XXnsNgNfae9VVV2HVqlVRfzdixAgsXboUoiiirq4u5vWEF7KQpomePXvioYcewh133AHGGIxGI1544QVYLBbceeedmDZtGnr16oX7778fZWVl0sCzqKgI06dPR01NDQYPHoybbropKN1hw4Zh6tSpuOaaayCKIgoKCvDSSy/JWkRuvvlmPPHEE7j00kshCAJOPPFERaGyzWYzxowZg8rKyiBXxqKiIjz99NM4ePAgCgoKJDeWaPeJFBxh5MiRWLNmDcaNG4ecnBy0a9cODz/8MADvzN+HH36IhQsXwmq14vnnn5fchI4ePSrN/nbq1AmPP/44AOD+++/HAw88gLKyMjDGcOONN6Jv377S/caNG4eVK1figgsugCiKOPvss1FXVyd1krHo2bMnJkyYgMsvvxzFxcU466yzpLDuEyZMwMGDB3HZZZeBMYbTTjsNkydPxgsvvIDjjz8eN954I+rr6zFw4EBZ90slDB8+HNOnT8d1110HjuOQm5uLv//97+A4DjNnzsQtt9yCnJwc5ObmYvDgwdi3b19C94lGjx498Ne//hXTpk2D2WzGiSeeKM0iBlJUVISFCxdi9uzZEAQBubm5WLRoEfLy8jBr1ixMnz4dBQUFOP/886Per2/fvjAYDDj//POl2eBo5XDuuefiH//4BwRBgMFgiNgut27dihdffBFLly5Fhw4dMGfOHNx5553473//C8Cr0F122WVwOBy49957JeXu+eefx6JFi3DkyBFYLBbk5eXh0UcfxXHHHYeKigpFZRjt+b333nvxyCOPoKysDG63GyNGjJCe/1GjRuGpp54KsyrL8fXXX2PSpEmK5CEIwg/129Rvq9VvT5o0Kah+77rrLkycOFE3/Xgk7rjjDlxwwQVYsmQJJkyYEDE/HMdh5MiR2LJlCwoKCjBw4EDU1dVh9OjRALzPxNKlS3H++eeD4zicdtppKCgowN69e8PuOWHCBOzbtw/jxo0LmsgxGo2YM2cO7rrrLsna/uijj4Z5K8XDwoUL8fDDD6OsrAwulwvjxo3DRRddFHXJ0V/+8hfMmzcPF1xwAQoKCuKapG7VpGepKpEIShbppwPfonHfQnHG5BeDp4LQwDetgWjBEbTEvn372HPPPccEQWCMeYMVjR8/PsNSBXPvvfeyTz75JOHfRwpGoRf27t3L/vSnP0lBRwiCSC3Ub1O/rSf00I8TrQOykBJR+frrr3HnnXfiqquuQv/+/TMtTlq5/fbbsXv3btlzixYtavVukB07dkR5eTnKyspgMBgkC6GWmDVrFm677TaMGjVK9b1I9cDTTz+NRx55hPYgJYhWBPXb1G8rRQ/9ONE64BiTWflMEARBEARBEARBECmGghoRBEEQBEEQBEEQGYEUUoIgCIIgCIIgCCIjkEJKEARBEARBEARBZARSSAmCIAiCIAiCIIiMoIkouzU1TRBF/cdWKizMRVWVsv2wtE625CVb8gFQXrRItuQDyJ688DyH9u3bZFqMrECtvlmvbYvkTj96lZ3kTj96lb21yh2rb9aEQiqKLCsUUgBZkw8ge/KSLfkAKC9aJFvyAWRXXojkUbNv1mvbIrnTj15lJ7nTj15lJ7nDIZddgiAIgiAIgiAIIiOQQkoQBEEQBEEQBEFkBE247BIEQRAEQRBEtsMYQ01NBVwuB4DMum6Wl/MQRTGjMiSKXmXPbrk5mM1WtG9fDI7j4kpfkULa2NiICRMm4MUXX0SXLl2Czm3btg1z585FU1MTBg0ahAcffBBGI+m5BEEQBJFKovXNn3/+OZ577jkwxtClSxc89thjaNeuXYYkJQjCR2NjHTiOQ4cOXcBxmXVUNBp5eDz6U44A/cqezXIzJqK2thKNjXXIy8uPK/2YT8LmzZtx1VVXYc+ePbLnZ82ahfvvvx8rVqwAYwxLliyJSwCCIAiCIOIjWt/c2NiIBx54AC+//DI++ugj9O7dG88991z6hSQIIgy7vRF5efkZV0YJQm04jkdeXnvY7fFH4435NCxZsgTz5s1DSUlJ2LmDBw/C4XCgf//+AIDLLrsMy5cvj1sIgiCIbIUxBlEP/0UNyKDC/9ZCtL7Z7XZj3rx56NChAwCgd+/eOHz4cLpFJAhCBlEUYDCQJyGRnRgMRoiiEPfvYj4R8+fPj3iuvLwcxcXF0nFxcTGOHj0atxBK+HbrEazadABzJw9KSfrZyLa9NXhz5Q48cO1gmIyGlN+PMYZH/rUR55/eDYP7hA+S9ER5TTP+9s6PmDN5ENrnWTItTsY5VNmERUt+wr3XDEa7NuaE0vAIIh56fQPGn9UTo4py8dDrGzB2SDcM0kBb+X7bUaz4fh/uu2Zw2Lkd+2rwz+U7MO/awbCYvM/R/vJGPPfez3jmzrMB+NvLTRf3xQsf/oLZVw9Acb4NdU0uzHn5W9idnrTmR014iMjjHGjLNyOPd8DKuVv+uwI+u2GEACMntvwVYIQo/TVwIniI4ADwYOBa/vOc7zOk88Hfe8/54ALWW/m/937Hc4DIgPKTrsLQy8anpWwySbS+uX379jjvvPMAAA6HAy+//DImT56cLtEIgohBvOvrCPVgjIGBgQNH9ZACEi3TpKZoRFEMujFjLCFBCgtzY15T07Qfuw/Vo7g4L+7004mW5Pt+RwUOVzXD1saK9m2tcf8+3rwIIsPuww2obXZrqhwSkWVfVTOq6p3wcJzu86IGfxxtRFW9E8zAJyxDo92NAxVNqHd4IIoMe45op63UbDqA3YcbUFSUG/YO2/h7JY5UN8PWxoLCdjYAwI5D9aisc6Cqzo4ex7TD/io7quqd2FfZjOp6J1zMW1cNrjrYnR6M7N8ZXTpkPp+R4EQPbPZy2BzlsNkrYHVUwOqshslVD5OnKUgRDISBh2CwQDBYIPJGMM4AkTOC8eaWv0aInAGMM4BxPAAeIscBnE/V5Fq+58A4+WOf6smkaglWUQPPceDQ81SatPTR0NCAW265BX369MGll14a9++V9M1K0cJznggkd/rRq+xK5S4v52E0asNd99ChQ7jiikvQo8dxALzj+qamJlx44ThMn/7ntMvz0EPzMGDAQIwbd1HMa7dv34bZs+9Ep06d8OKLryi+h0f0wCN4YDGawavgNj1kyAB8++0Piq596aX/A8/zmD79JgDed/S8eXNx8OABtG/fHvPnP4HCwqKk5Fmz5its374VN9yQXP39+c/Tcf31N2LgQH+fqrTd8nz8Y8WkFNKOHTuioqJCOq6srJR1H4pFVVVjzM1Wm5pcYAyoqGiIO/10UVycpyn5GhqdAIDKqkZ4nO64fptIXoSW6FtNTU7NlEOidVJbawcA1NQ0oyI3MYug2mSyfdXVBZSHNbHXRpPD2wYbG52SetOokbbS1OQCAJRXNIAPUUgbGhwAgMrKRogur6XTVx6A951UW9cMAGhs9F5bW2tHRUUDqqubAAClxxVgQK9iaAUmeiAc2gHh4K8QjvwOoXI3ILRYcTkOXNsS8IUdwLc5AVxOPricfPA5+eBy2oIz5wBmGziTDTCaNTfDzPPakidTlJeXY9q0aRgyZAjmzJmTUBpK+mYlaK1vVArJnX70Kns8couiqKmgNkVFxXjttbel48rKCkyYcCnOPns0unfvkVZZWMvyESXls3bt1xg9+gLceOMtcZWnS/BAYAJ4JsCg0rxArPs3Njbiueeewuefr8CkSddI17/wwt/Rr19/LFjwNJYv/wRPPvk3PPTQY0nJMnToCAwdOiLpNsYYgyD422o8wZhEUQx7HnieizrJmZRC2rlzZ1gsFmzatAkDBw7Ehx9+iJEjRyaTZES8BnYiHljLeqp0Lavy3Sc7lnFlRSZUQ426ldIA02AbYf4/nOwZ+V+FlIsYkMdAtKCzMVGEcOBnuHd+B8++zYCrGeAN4Iu6w3TyuWh//EloNBSAb9cBnMGUaXGJJBAEATfddBMuuOAC3HzzzZkWhyAIHVFZWQnGGHJycgAAb7zxOr788n8QBBGnnz4Ef/7zDMyefQcuvXQ8zjhjGF566Xn89tsOPPnks6isrMTMmTfjjTeW4KWXnsemTRtQX1+PoqIiPPTQYygoKMS4ceeid++TUFVViX/841944YVnsXbtNygqKoIoijj11IFoamrEAw/MRVVVFQDguuumY/jwMyUZ16//Bu+99x8AgNlsxsUXX4bHH38YR48egcFgwA033IIhQ4bilVdewq+//oLy8iO4/PIrceml473enOBw4MB+LHpqAerr62CxWDFz5iz06tUHu3btxKJFf4PdbkdNTTUmT56KSy4Zj/r6Ojz22MPYt28PTCYz/vKXmRg40LvM529/exS//LIFADB//gJ06XJsUJl+/fVqdOnSFRMmTAr6fv36tfj7318GAJx77hg89dQCeDyeoN1Kqqur8Le/PYqjR4+C53nceOMtGDz4dLzyyks4evQI9uzZjbq6Wlx88WW4+uop+PTTZfjxx02YO/cB/P3vT2PDhu/A8xxGjDgL1113AxwOB5544hHs3PkbeJ7HhAmTcMEF4+ByufDEEw9j+/Zt6NjxGNTV1UoyeNvA5xAEQWoDak9GJ6SQTp8+HTNmzEC/fv2wcOFC3HvvvWhsbMTJJ5+MKVOmqCqgD//ALzG34NZIYJml9X5ZoMyJaS47reOf3Ei8PAInSHyfVTC+qIJfoWTgQzTSwHM+REn+4HLxWZNCf8OFarlphHmccG/9Aq5fPgdrrAJnyYWx+wCYug+EoctJ4IzeNdK5xXmw69AyQfjx9c1HjhzB1q1bIQgCVqxYAQDo27dv1HWnBEGkn7VbDuObn1MTcGx4aScM69cp5nWVlRWYOvVquFxO1NXVok+fk/HoowtRUtIB3367Djt2bMPixf8Cx3F4+OH7sXLlZxg6dBg2bdqAM84Yhs2bf0R5+VEIgoDvvluHM84YjgMH9mPfvj148cVXwfM8Hn74fqxY8RmuumoSamtrMXHiFAwYMAhffvk5fvttB958cwkaGhowdeoEAMCaNavRseMx+NvfnsHvv+/AypXLgxTSM84YjksvvRyiyHDttdNx3333YMCAQZgwYRIOHjyAm2++Hq+99hYAwOVy4s03vcqrb/0oADz26EO444670atXH+zevQtz5tyFd955H8uWfYhrrpmGQYNOw8GDBzB16tW45JLxWLz4RXTpciwee2wh/vhjJxYsmI+XXnoNADBo0GmYNWsO/v73p/Hhh+/jlltuCyrjCy4YBwB45ZWXwsre56JrNBrRpk0b1NbWoKjI71H1zDMLceGFF2H48DNRWVmJm2+ehtdf91q0d+zYhhdeeBWiKGLatEkYOPA06XdHjhzGt9+uw5tvLoHD4cCjjz4Ip9OJV199Ce3atcMbbyxBbW0tpk+/Biec0Bvff/8tAOCtt5Zi//59uOaaqwBAagOvvfYGBIFJbWDMmLEx21Y8KFZIv/jiC+nz4sWLpc99+vTB0qVLVRVKlsgGDCIC6R/rp9cim1KyytqrHskUh++33g5BjRTVI1o9Mxbw8pG+DP7rP4zwDGTgpcVEEe5tX8L1w4dg9noYOvWBacgEGLufCo6nCI/Zglzf3K9fP2zfvj1TIhEEoSOKiorx+utvQxRF/P3vi7Bnz24MHnw6AGDjxu+xdesvmDbNGxTN6XSgQ4eOuPTS8bjnnjvQ3OxdltKz5wn47bft+PbbdRg//kp06XIsbr11JpYt+wD79u3Fr79uQefO/r2STz65LwDgxx834cwzz4bRaET79u0xZMgwAEDfvqV46aXnUVlZjjPOGI6pU6dFzcMPP2zA7Nn3AgA6d+6Ck07qi61bfwEAnHRSX+k6Xx9tb27G9u1b8eijD0nn7HY76upqceutt+O779bjjTdewx9/7ITd7l2S89NPmzBvnndS7/jje0rKKACMGHEWAKBHj+OwefOPiss+dJJfzui2ceP32Lt3L/7xD68y6/F4cPDgAQBeq6rPkj18+Ehs2rQB+fn5ALz1arFY8Oc/X4ehQ0fgz3/+S4tX60bcc899AID8/HyMGDESP/64CT/9tAkXXXQZAODYY7uiX79S6f5bt/6CqVMngjF/G1Ab3YxKGGmk8ZMhl91sQFIsMiyHVmBhH5JJJP3u5LGIqEgiTPcM+S5YIxXF4Ct86aV7WaNQtQ+ONa9BrNgNQ6c+MJ93K4wde6VXCIIgCCIqw/ops2KmA57ncfPNt+Haa6/GO++8gYkTr4EoCrjiiqskV9OGhgYYDAbk5ORAFBlWr/4C/fqdgoKCAmzcuAE7dmxD376l2L59Gx54YC4mTLgaZ599DgwGPkj5sli8gTY5jgvqdw0GbyT7Y4/tirffXopvv12PtWvX4N//fhNvvvkf8Lz8os/wte4MgiC03MvrBeTdgs3bSQuiCLPZLFkaAaC8/Cjatm2He++9G3l5bTFs2Aicc85ofP6518vEaDQGKYt79+7Bscd2lc7586N8YFNcXILq6iqUlHSAx+NBc3Mz2rXLD7pGEEQ8++wLaNu2HQCvS3X79u2xZs1qqbx8ZWAM2FHDaDTi5Zdfx08//YD169fippuuxXPPvQzGgteBMgYIggde5covuy9tXxuYNGkKPB5RagNqo40wXwqQc5sjopNut9NsqqN0uztrHb+LbfIuuyLT3nrjaPUtdy5UoQ4tn/BnLz0aKWMMrm2r0fzBQ2CNVbCOugm2cbNJGSUIgiBiYjQaccstt+P1119BVVUlBgwYjBUrPkVzczM8Hg/++tc7sXr1KgDAkCFD8c9/voJTTx2IAQMG47333sXJJ/eDwWDATz9twqmnDsQll4zHscd2xbp130AUwwPiDBp0Gr744n9wuVyor6/Hd9+tBwC89967eOWVlzBq1Lm48857UFNTg6ampohyDxw4CB9//AEA4ODBA9iyZTNOPrk06BqRifCIbnAch7zcXHTpcixWrPgUALBhw7e45ZYbWj5/j+uvvwkjRpyFb79dB8C7Lv+UUwZIyunevXtw551/SXoJ4ZAhw7B8+ScAgC+++B9OOaV/0PpRX97ef9/rcrx79y5MmXIlnE5vAMU1a1ZLZbd27RoMHjxE+t1vv23HrbfegFNOORW33no7unc/Dvv27cWAAYPxyScfAgBqa2vx9derceqpgzBo0GlYuXI5RFHEkSOHsWXLzwAQtQ2oiX4spBoZuOqRdBVdqLVIz8h5abZm1Hj+/FZW5lfotFLC0epbkjXsq4B8BB+HppeOZe9MFOD85p9wb18DQ5e+sI66EbxVn9snEARBEJlhyJCh6Nu3H/7xjxcxe/a92LnzN9xww1SIooDTTx8qrYccOnQ4/v3vN1Fa2h82mw0ejxtDhw4HAJxzzmjMmTMLU6ZcCQDo3ftEHD58KOxeI0achW3btmLKlCtRUFCI7t2928+cf/6FeOCBuZgy5UoYDAbccssM5OVF7s9uv30WFiyYj08/XQaO4zB79r0oKgrePsW39ygPDiIY5t73IBY9uQBvv/0vGI0mPPTQo+A4DtddNx1//vP1sFjMOP74E9Cp0zE4fPgQpk27EU888QiuueYqGAwG3HffQ0krpNOn34T58x/ApElXIC8vF/ff/0jYNTNn3o0FC+bjmmsmgDGG++57CDk5bQB4rb+33HI9mpqaMHnytejR4zhs2/YrAKBXrz7o27cUU6ZcCavVin79TsGQIUNx6qkD8OSTT2DKlCshiiKmTLkOvXv3wfHH98Tu3X9g4sTx6NixE4477ngAXlfgnTt/w7RpU1qCGvnbwF13zcD119+EPn1OSqocAD0ppNm0PjFNpNvtNLuUuKzKTNL4n79kLKS+tIIS1gTRJlOiuSv7FVHvX98EcGh6qVZImeCB44sX4dm9Eeb+42AedBm4CK5NBEEQBAEAxxxzDJYuXRb2/aJFz0ufp069HlOnXh92zSmnnIqvvvpOOv7448+lz8XFJVi8+J+y9/zmm41BxzfccDNuuCE8Gvjf/vZMVNmnT79J2oakqKgYCxY8HXbNtGk3Sp9Z0Jo/Dt26dZci3AYyYcKksGi4Ph555Imw7wLzM3ZsGcaOLYso87RpNwZtn9K2bTs88cSiiNcDkfMGAKWl/YPyGCrDLbfcFhZgyWjMxf33PxyWltFolNbhhjJ16vW4/vobwrZ9Wbjw2aiyx4N+FFJyoYybjEXZzYI6yqa8qIE62774J5VEFdJTk2ju5tGi7PqWYoS67KYzyi4TBTg+fx6evT/CMmQCzKXnp+xeBEEQBKFHvAGDAo61MiNOANCRQkoGq/iRjQ6a2ju23Ddd90sdcoFsWjUqNiXG/ItItdIhRI2yG8U0GnouYrCmFFpInd/+26uMDp0Ic9/zUncjgiAIgtAtARbS4Pg9uiTUMqp3dOPTlU3rE9NN+taQZg9aiwKbafzPX/Iuu970kk5OVaIuCZDJeqj8vmN/oL9gF+dUvWhdv34O9y//g6nfGFJGCYIgCCIC5PGmbfSjkEZxqSPkoSi7iUMuu8FIdZtUGv4ItL4Q7VopXr9iGS6Q3w2XBVzPZP+G5ssfZFd9E6lQuRfOde/A0PUUWE6/UvX0CYIgiNRAY4v04tv/nHaNTD2Jtm39KKSZFkCPpH0f0uyxYtM+pMFIbSiZNaSynzRSwgoMwEzmc5ilNDTqbstftTtB5nHB8eXL4Gx5sJ01nQIYEQRB6ASj0YympnpSSjOI12OXyl9tGGNoaqqH0WiO+7c6WkOqLYuKHkj3OsisWneZVZlJHr+CnoTLru8vU0fBVZNo+ZKVNeQ73+/DrKm+oEYqa6TOje9DrDkI2/l3gLPmqps4QRAEkTLaty9GTU0FGhtrMy0KeJ6X3R9UD8QjO2MMHiaAb5ke9tlLjbwhhRLKo9cyVyq30WhG+/bFcaevG4VUDBn4EbFJu9tpFrm5RnPhbI2oEWU3cFIp1JKYaaJH2WVh58L2UfX9Xoq623Lccn2ye5UFItQchHvLCpj6nAlj19LYPyAIgiA0g8FgRFFRp0yLAQAoLs5DRUVDpsVICKWye0QPquyVcLoakWvOkb5jYOiY1zXVYoah1zJPtdw68vMiC2m8pNuFVmtKRjLQvrfyJLftS8vfADVfK5MXLOyDzDmZ71iIAhpmSU5B9pzfLQGMVpgHX65+4gRBEASRRbhFN+qcdbAZrdJ3HDgp5gOhDXSjkGpk3KpL0u2ymw0aqSoWwSyCqeBjG9g+NDd5EU0embYQSQEVxWBF1Pc9r5KF1HNwK4R9m2EZUAbe1laVNAmCIAgiWxGZCJ43wBDgnstxHFhSYRoJtdGdQpoNEVzTRaai7GrF6pUMLJu0axXwP3/JpBHosuv7Mjm51CLasyKGuuciOC+Bf8WQY3+U3eRlZIzB+e274PKKYDr53OQTJAiCIIgshzERnFwEfVJINYV+FFLahzQB0ut2qjmrVxKQy24waujnQS67mpu8iF3fUfchDclPaPtRwz4qHPwVYtVeWAZcDC6BCHYEQRAE0drwiB5wIb1w6DGReXSjkJI+Gj+ZGutrRsdIBmpvwchYCeNOIiAprW2ro1QR9X/p+yPvshtmYVeh73Nt/gxcTj6MPc9IPjGCIAiCaAUITATHBas7HMeB6TDSbTajG4XUP77TyhBWP6QrUmw2ublqLehOplGlamVMjFop3mj1HWoNlf0uQn58x8muIRWq9kE4+CtMfc8DZ9BNcHSCIAiCyCge0QOek1F3OBrjaQn9KKTS1gsZFkRH+PdETM/9sqmOQtcItnbUWUPqS4OF79eZYaLVN5ORNfQ73xlRegbUbT+un5cDRgvMJ56lToIEQRAE0QoQA/YfDSLAW4vIPPpRSDMtgB5JsxUqiwykfgtYNmRGBdSOsivzMbOEuOBGucT7OcSlO2yv0pD0kjGQMkcjPH98B1PvEeAsbRJPiCAIgiBaGR7mCXPZBUAWUo2hG4XUr1xR41FKupWqrFLikte/sgo5t9W40wiwJmotym60yZSosoYqpiILvlRaQpq4Rur+4ztAFGDqMzLhNIjspLGxEePGjcOBAwfCzm3btg2XXXYZxowZg7lz58Lj8WRAQoIgiMwiiIK8yy5ZSDWFbhTSdLufZgPpdjvNJjfXbMqLGoRaBJNKgzFZN9hMIlk4o52TcdkNfS+Fbh/jO07GQur+fS34gmNhKOyaeCJE1rF582ZcddVV2LNnj+z5WbNm4f7778eKFSvAGMOSJUvSKyBBEIQGECKsIfVG/NfGGITQkULqg2YzlJN2K5TGAtUkQ1ZZe9VARQWSQXsGaL9FM3JQI7nvWMiH8K2PksuhWHsYYvkumHoNTSodIvtYsmQJ5s2bh5KSkrBzBw8ehMPhQP/+/QEAl112GZYvX55mCQmCIDKLyCJH0qWtX7SFbsI1as3FT0+k22U3GyopdH/J1o4axRC4l7DmLNDRLMAyywVC19T6gxqF/sb7N9Eou+7f1wEcR1u9EGHMnz8/4rny8nIUFxdLx8XFxTh69Gg6xCIIgtAMkRTSfYeb8enacpj4WnBpts2ZTAa43UJa75kMbduYcUPZSSm/j44U0sgudYQ8mYqyqxklIwmyKS9qEBghN9k0vC67LZ81MnkR7VmROxfuoht6bYilNAF9lDEG9+/rYOh8Mvic/PgTIFotoiiCC5gEYYwFHSulsDBXNZmKi/NUSyudkNzpR6+yk9zpJ5bsLsGFBkMuci3B77Kvf6rF/sNO9O5hQbqNKAweGM1pvWVSGC0CrG29n1PZVvSjkEoftDGA1QVpDgSlxjpDrUAuu8GwqCZEhWkEJME02liiPStM7nPIMxaqiPqOE7GPilX7wBqrYBpwcQK/JlozHTt2REVFhXRcWVkp69obi6qqRogq7ONVXJyHioqGpNNJNyR3+tGr7CR3+lEiu1Nwoqq+Cc4QBbC61gGrhcdt4/vBYrCkUMpw9Fjmoh1ALpKSm+e5qJOc+llDqs3xq6ZJd1mFDsJ1DbmIB6NGUCOfeyvTXvFGa7Kh60QDP0t5avlaFOXTS8Q65dm3GQBg6HpK3L8lWjedO3eGxWLBpk2bAAAffvghRo6kKM0EQbQuIrns2p0CrBae1pFqCN0opBRlN35CI32m4YaBf3RNeHCa1k2oK2pCyLnsaqSxRHtW5JYLhK0xjuCy6ztOZAmpZ99P4IuPA5/TLv4fE62S6dOnY8uWLQCAhQsX4rHHHsP555+P5uZmTJkyJcPSEQRBpJdIYwyHQ4DVQsqoltCNy64PrQxg9UC63Zw16oWZEFll7VWR5PYhbfkL7a3RjfashLrnBn4Mc9UNnchIMH9icx3E8t0wD7oksQSIVsMXX3whfV68eLH0uU+fPli6dGkmRCIIgtAEIkRZG6jdKcBqJgupltCNhVQrA1ddkWYFMZvW+WaTcq0GalSp3DpUzZRvtPqWCcAUqlCHuuyGphdvlF1h/88AGIxd+8f1O4IgCIIgvDAmAlx4z253irBadKMCtQp0Uxtpdz/NAtJthdKa1SsZ1Ajik02EuqAmloY/LTE0PG2GiRplF+HnQhXRUBfk0L/xTsJ69m0Gl5MPvrBrfD8kCIIgCAIAIIiC7LYudqcAi4VPKL4DkRr0o5BKH7QxgNUD/uVt5LIbNxpb45hpknVBBYLdWeXiBGkB2fqW0Z3DXHYRrLCH5i+eLo+JAjwHfoGx6ynUWRIEQRBEgniYAJ4LVnUYY3A4BdjIQqopFNXGsmXLMHbsWIwePRpvvfVW2Plff/0Vl19+OS666CLceOONqK+vV11QHxobv2qa0IAr6buv/mtJa1FgM46Kkw0sQCPVSvlGjbIr8wmhVlMpqJF8evEolmLlXsDtgKHzyYp/QxAEQRBEMKF7MgOA28MgiCCXXY0RszaOHj2KRYsW4e2338YHH3yAd999Fzt37gy6Zv78+ZgxYwY++ugj9OjRA6+88orqglKU3fhJt5szk3Ft1CvZ5H6sBmpE2fVb0Jk6UXtVJFp9yz1H/utCLKKivMU0HjuncGQHAMDQqVccvyIIgiAIIhCBecCH9MB2pwAAtO2LxoipkK5btw5DhgxBfn4+cnJyMGbMGCxfvjzoGlEU0dTUBACw2+2wWq3qS0oulHEjb9lJ4f2yqGq0ti2JVkimNJhfIw34LilxVCOae7ucp4HvO/++oyFrbEN/E0efJxz+DVy7DuBz8pX/iCAIgiCIIEQmhu27Zne0KKRmspBqiZjbvpSXl6O4uFg6Likpwc8//xx0zT333IPrrrsOjz76KGw2G5YsWRKXEIWFuTGvMZkMAID27duguDgvrvTTiZZks1pMAIC2bW0JyRXvb2rsHgCAyWzQVDkkIktOGzMAoE2uRfd5UQNbjrc8cnOtCctwqMYBADBbjJICZzYbNVG+ZrP3VZifnxMmj9Xqe478ebfZTC1nGYqL85CTYwEAcLy348tp4203uXneybnCwlwUt8+JKQdjIvaW/47cXqdlpFy0UBcEQRAEoQYeUYCRNwR9Z3d6Z5KtFNRIU8RUSEP9rxljQccOhwNz587F66+/jtLSUrz22muYPXs2Xn75ZcVCVFU1+qNuRsDl8io71dVNyNPorEZxcR4qKhoyLYaE3eECANTW2eOWK5G8VNd4reROp0cz5ZBonTQ1OgEAjQ1O3edFDZqavG2pocGRsAw1dc0AAIfDLRkOnU63JsrX6fS+X2pqmlFhDX4t2u3evNcFPEfNzd7vGAMqKhrQ2ORtLx6Pt6NrbPSWU0ODVwmvqW4C5xFiyiFUH4Bob4S7/XFpLxetvb8Shec5RZOcBEEQRHbDIILjgvt0R4DLLqEdYtZGx44dUVFRIR1XVFSgpKREOv7tt99gsVhQWloKALjyyivx/fffqy6oFCxEM2FQtE+63U7990vL7VIKuewGE7aNSVJpAMzn6pq0ZOoQbVsbyT1XzmU3pJ2ErnWX1pAqnIUVDresH+3YW7HsBEEQBEGEI4iesCi70hpSM1lHtURMhXTo0KFYv349qqurYbfbsXLlSowcOVI6361bNxw5cgS7du0CAKxatQr9+vVLmcCkHygn7VF2s2jSgKLsypPU8xewvFJrAbCibWvDZFpD2He+P1JQo8jpRUM48hu4Nu3B5RXF90OCIAiCICQYY7LxGySXXSsFNdISMV12O3TogJkzZ2LKlClwu90YP348SktLMX36dMyYMQP9+vXDY489httvvx2MMRQWFuLRRx9VXVCyVCVCyOA45XfT2F4eSUBRdoNRoxz8ShoLirirCViUZ0XG8h/qDeA7JVlRQ9LjFfR5jDEIh3fA0KkPrWshCIIgiCQQfa5YIVBQI20SUyEFgLKyMpSVlQV9t3jxYunzmWeeiTPPPFNdyUIIdYEjYpM5l13911EWZEFVorm0Kk/D/1cu4m4mCXW9lT0X8F1YMN0Ql+awZ0GBgsmaasCaa2Ho0DMe0QmCIAiCCIGByY4x7C4BFjMPnuNo8ldD6GZ6IFEXuNZMiLEm9feLZmXSGaGKRmtHjecvsH1otXzlxQlfP8sgr4CKIc+ApI8quLdYuRcAYCjuHofEBEEQBEGE4t3yJfx7h0OEzWIIP0FkFN0opFFd6ghZMjXY15iOkSDU3oJQwaAZpIRqy0Aa9VlR4sYrueyG7EvqQ8kkrFC5B+A48AXHxr6YIAiCIIiIMDAwFt752p0CbBYeHK8fFag1oJva8HmCa82iomXS7eacjS672ZAXNRBDXFITIkCJC41Gm2mi1bfcc+QPGBYc3CiSxVSJW5BQuRd8fidwJkt8whMEQRAEEUTkoEYCrGQh1Ry6UUjlAosQ0Ul3UWWT8pZNW9ioSVL6aFBUIJnvMkg093a59a4+l10xpJ2ErTeNI3ti1V7whd2U/4AgCIIgCFlEJsqOMXwWUkJb6KZGNBONU0+k2QqV7jWrqYSRy24QakbZZYxp73lWsCSAyXwO3b6GhVpMW45iRdkVm+vAmmpgKOquUGCCIAiCICLBwGS9kxxOEVaLAbx+VKBWgW5qg1wo4yftUXal++q/jsJdMls3oVFkE0uj5S/CLYuZJtqSALkIvKF7/EoWUzGSghpdIxWrvAGN+CKykBIEQRBEsjAwcDJjDLKQahPd1Ai5UMZPyJg59ffLpsBT1N6CUKMtBa2v1NoEU7QgS3KeBtI2OEGHYV4CSnd9ESr3AQAMRV0Vi0wQBEEQhDyMiQjVSD2CCLeHwWrhwelHBWoV6Kg2skjZSRNp3+tRY5FTk4FcdkNQUYFkYJorXxal8crJyEI/sdDzwV/EUkjFyj3g2paAM+fEkJQgCIIgiFgIohCmdNodXn8o2vZFe+hGIY22cT0hT9qj7Er31X8dkYt4MGLIWslECLQepnuuJBbxR9kNcc0NyUloelwMl12hci8M5K5LxMmyZcswduxYjB49Gm+99VbY+V9//RWXX345LrroItx4442or6/PgJQEQRDpR2Tha0jtTgEAYLVwirZjI9KHbhTSbLK+ZStpt8imEHIRD0GFqmUBharGmlQ1idZ0ZaPshiicYdkI/UmUjo+5msEaKijCLhEXR48exaJFi/D222/jgw8+wLvvvoudO3cGXTN//nzMmDEDH330EXr06IFXXnklQ9ISBEGkFxFi2GSwQ1JIDYq2YyPSh24U0mgudYQ8EQfLKbtfy9/03C6laM2lNNNI5aBSUCN/eonLpC6xnxUm8znSxIU/+q73b7Qou2LtYQCAoX1npcISBNatW4chQ4YgPz8fOTk5GDNmDJYvXx50jSiKaGpqAgDY7XZYrdZMiEoQBJF2BNEDngtx2XX6XHZ1o/60GoyZFkAxEVzjiMj4A9Gk22U3LbdLLdrTmDKLCgGrArdIYaK2FH4Wpb5l23NoEKMILrt+ImukPoWUz+8US0yCkCgvL0dxcbF0XFJSgp9//jnomnvuuQfXXXcdHn30UdhsNixZsiSuexQW5qoiKwAUF+epllY6IbnTj15lJ7nTTzTZXZZ6uEUTzAaz9J3hoBMA0LEkF8WFOShul5m867XMUym3bhRSrW0ToQfS7XaqNTfMZCCX3WDUeP4C3Vy1tt7Yv05U7hxrOSe3hlTeshqaXjTPILHmEMAbwLUtjnwRQYQgimKQyxkLWS/lcDgwd+5cvP766ygtLcVrr72G2bNn4+WXX1Z8j6qqRmkro2QoLs5DRUVD0umkG5I7/ehVdpI7/cSSvaKhHiJEmHiX/7tKr8eIw+FAVZUIqyv9eddrmScrN89zUSc5dWSzTq/7aTaQdmtyNrrsZkNmVEGFyQbZNZhJiKQiiqLssvDvQvcjDU8vdgbF2sPg23UAx1PUP0I5HTt2REVFhXRcUVGBkpIS6fi3336DxWJBaWkpAODKK6/E999/n3Y5CYIgMoFHFMLWkEpBjcx8mDsvkVl0UxtM5hMRgzRHis0mL9d0uztrHTWaULCSry2XXSVLAoLWkIZcH/a7EP2Wj2Ii9Sqk5K5LxMfQoUOxfv16VFdXw263Y+XKlRg5cqR0vlu3bjhy5Ah27doFAFi1ahX69euXKXEJgiDSCoMYpnQ6nCJMRg5GAwU00hq6cdmN5lJHyJOxoEZaMXslQSTLV2tFjecvsH2IGivfaC7JYoh7LhBuUQ39WZgFOELfxwQPxPpyGI8bHL/QRKumQ4cOmDlzJqZMmQK3243x48ejtLQU06dPx4wZM9CvXz889thjuP3228EYQ2FhIR599NFMi00QBJEW5KLs2p0CbBYDGEAWUo2hI4U0i/xB00S6x/ySApym+6WUNCvzWoep0JqCHmHNTV5EqW85ZTVEQY8VZTfSXKxYXw4wkQIaEQlRVlaGsrKyoO8WL14sfT7zzDNx5plnplssgiCIjMIYAxNFcEYZhdRKy2O0iG4UUh/kQqkcv5UvvWWmGR0jCchlNwQ1ghoFuOlqbVudaEsCouioERfDhv4m0n5n/gi7xyiQkiAIgiCIQBrdjTDxJjS5mtAQEKTIw4Swa+1OkbZ80Si6UUgpym78+KODpul+0l/9V1K63Z21jirPX4BVlIkqpKci0YIsRY2y6zuOkJ7Iom34Aoi1hwAAfH7HOCUmCIIgCMLpcYIzcrB7msFxgIHzWkDzDOFblNgdAvLbmsDAwOknjE6rQD+1QQqC5skmt2qtRYHNPBGC98SdgvdDxGBAGSKau7ncemK/whm+vjTsR9G2fKk9DK5NATiTNW6ZCYIgCKK1IzABDAxiSxAjA2+AgTfIrhH1rSEltIduFNJoLnWEPOkOMpRF+mhWWXvVgIV9SCCNAKVPq0Gjoj0rMktII7oyB3rLx4ywS+tHCYIgCCIhRFEAGIMghgcxCsXR4rLLGAPP60YFahXopjbIhTJ+0h5lV429KjVCNll71UANi7FfSWOaC4AVzSWZyVhBY7vsxn72GGOkkBIEQRBEEghMgMhEMIgR4zUAgCAyON0iWUg1io4U0pa/mRVDV6Q/ym7wX12TTXlRAb8CpkKUXRasnGqCKPmTbdch3geh+QjcpzRS/8iaawG3g9aPEgRBEESCiBAhMhGiKES1kDqc3iBHNquhZQ0p7UWqJXSjkPrQzABWB4RFAk3TDbOhhshlV57kghqFu+xq5XGO5pIcLcpuJNfjwPQiRthtqAQA8HkliuUkCIIgCMKPKDIITGyZAI6sZNqd3miKVrNX9SGFVFvoRiEll934SX+U3exz2dV/TtRBjSi7WnbZjfZ+ieqyGyEfgelF6vJYQwUAgGtblKDUBEEQBNG6YRAhsOjWUcYYvttSA6DFQpoF49RsQz8KqfSXGpFi0lxUWg1UkwhhFrDWjoouu2DpD7gVi0AX27BzIX+Dro+Uj8D0IvSRkoU0lxRSgiAIgkgEEV533WgGzyOVTqz9qRoAUNDODCB6wEEi/ehHIc0iZSddpFuJjzao1x2kkQYRzaVVcRpB1kRt+nfLVncU5TliUKOA9CK5ELGGCnC2duCM5kREJQiCIIhWDxO9FtJo44kmu3f96JRxXdChwJImyYh40JFCSi678ZK5KLvpuV8qESO4YrZW1I6yK2ps8kKZy67/u7D9R0MNpApcdsWGSnBtixOWmSAIgiBaM4wxMDCvQhoFe0tAo/y2Jt8vZfcpJTKHbmqDXHbjJ+1ukRoLVKMG2ZSXZFAjym6gUVSrQY2UuuxGukYuvUheQWJDJfg8ctclCIIgiERgYC2T3FFmf+FXSGnLF+2iG4U0G5WdVJPuomIyn/SK1tY4aoVkSiPYmqgta3q0JQH+cyzsuzBLqXRB4N/wXpKJAlhjFa0fJQiCIIgE8VlIAQbGokXYDVZIY0XkJdKPIoV02bJlGDt2LEaPHo233nor7PyuXbswefJkXHTRRZg2bRrq6upUF1Qj41Z9kWYlXmuRU5OBliwHo8Ya7sAk/G1SWyUsL014u5YsqRGescC88jJ9HmuqBphILrsEQRAEkSC+/URZDAupwynCwAMmo/8i2vZFW8RUSI8ePYpFixbh7bffxgcffIB3330XO3fulM4zxvDnP/8Z06dPx0cffYQTTzwRL7/8suqC+rcw0dYAVsvIbVeR0vtJ903L7VJKpLWBrRU12lKg1VlrkxcRLZ2Q3/ImtHmEuezGKC//HqSkkBIEQRBEIohMBMdxECFGHVDYnQKsFgNZRTVMTIV03bp1GDJkCPLz85GTk4MxY8Zg+fLl0vlff/0VOTk5GDlyJADgpptuwsSJE1UXlKLsxk+6iyyr3FyzKS8qoEZbCgx6pbnJi2jzD3JtwadwivKKZ6DCKtcBMkkhJZddgiAIgkgE77iCizmYsDuE4PWjjEPEAA9ERoipkJaXl6O42D+LX1JSgqNHj0rH+/btQ1FREebMmYNLL70U8+bNQ05OTmqkBemj8ZB2JV5jVq9koPkPeZJSIGWDGmmjhKN5ECsKdBTBZRdMvs8TGyoAjgOXWxCvqARBEARBoGUMwXFed92oQY1E2Cz6CZvTGjHGukAUxaAZfsaCFwJ7PB58//33ePPNN9GvXz88/fTTePzxx/H4448rFqKwMFfxtbm5FhQX5ym+Pt1oSTaDwVtPthxzQnLF+5s2uVYAXouQlsohEVlMJu9MmsVi1H1e1MCoQnnktPHu/cXznKSI8rw22orvldZG5v1iMHg7MZvN/xwZjS2BERhDcXEezJbgV6nZbEBxcR4sVhMMPB+WZrmrFmJeIUo6tE9FdhJGC3VBEARBEEpg8LtcRbN3OpwCcqx+CynjaA2p1oipkHbs2BEbN26UjisqKlBSUiIdFxcXo1u3bujXrx8AYNy4cZgxY0ZcQlRVNUIUo1tKfOfrGxyoqGiIK/10UVycpynZPB4RANDU5IxbrkTy0tDgAACIgqiZcki0TpxODwDA7nDrPi9q4FKhPBobve1D8IiShdQjME2UryB4BWqQeb+43S3PUbP/OXK5vOXBGFBR0QCHwx30G6fDg4qKBtjtLogsPI/2yiNAm0JN5N2H1t5ficLzXFyTnARBEIQ+kbysOCCaT5vdKaAg35wWmYjEiKmQDh06FM899xyqq6ths9mwcuVKPPzww9L5U089FdXV1di+fTv69OmDL774AieffHLSgjHGUFNTAZfLAYDhzxd2BGMMuTYnjhzZm3T6qaC8nIcoipkWQ+LqM9tDEPORY2FSmRkMRuTm5sNma6P6/bQWqEYVsioziaNGUFz/ukrmd4PViMuuD3lxIm9RE2ktbOD3kVx2DZ2Tf08SrZtly5bhhRdegMfjwTXXXBMWv2HXrl2YN28e6urqUFxcjKeeegrt2rXLkLQEQRDqwuCNrisyEQYu8h6jXpfdAAupxsYehAKFtEOHDpg5cyamTJkCt9uN8ePHo7S0FNOnT8eMGTPQr18/PP/887j33ntht9vRsWNHLFiwIGnBGhvrwHEcOnToAo7j4UQDGGMoaGtF2zbanOUwGnnJKqkFBEMj3B4R7XLNaJ9nBWMMbrcLtbUVAKC6Uqq5QDVJIGajcp0EqkTZldIKj1KbaaLlj8nozv7IuxE2iglIL1QfZYIbrKmWAhoRSeGLgP/+++/DbDZjwoQJOP3009GzZ08A/gj4c+fOxciRI7Fw4UK8/PLLmDVrVoYlJwiCUAcGBo4BIgCOk18jyhiDwykErSHlWv4R2iGmQgoAZWVlKCsrC/pu8eLF0udTTjkFS5cuVVUwu70RBQUdIjYwIjahQ2WO42A2W5CfX4y6ukr1FVKNBapRg2zKSzKooUD6lTR5JS+TRMufP4CRTJTdlq9Ct6OKFmWXNdUAYKSQEkkRGAEfgBQB/9ZbbwUgHwG/vr4+U+ISBEGoD2MAx8BEFlHB3HvYDpEh2EKqmelwwocihTQTiKIAg0Gz4ukak8kMQfCon7BWtAsV0JrCpBXUiLLbEme3JT1tFHDUKLsy2ioLPRcl4VCXXbGpBgDA5WgroBGhL+Qi4P/888/ScWAE/G3btuG4447DfffdF9c91FyLq9eAWSR3+tGr7HqWu8nVBI8YPi60Gq2wGC0ZkMpPo6sRgijAyBvRxtwGgiig0dWIOkcd2uQbUWjNg0twwWaywWq0Bv3W5RLw8nvbAACdO+VK7zSLCyhp2xY2ky3t+QH03VZShaY1PtrAVh3kLKWpvE+M+FS6ICvXwyaBvzySd9kVGaChpdYA4nfZDVszGnIsBqQX5rLrU0jb5CcqLkGkJQK+koCDStBrwCySO/3oVXa9y72nbjcE5gmyMnpED9pbC1GcUxwlhdTzR83vAAcYOTO6tesGu8eOffV70aEoH9XVjbAYrBAZg4d3oYkLVqprG7wBB4f0a4/uHc2oqmoEADS4GmF1NcBmTIFxJgZ6byuJEivgIPnD6oDx48tw+PCh+H+Y5s00WTQzk85QbAFrJaixp21wWXo/a2XyIlr25Fx2mSR/dEuv99sQl91mr0LKtyELKZE4HTt2REVFhXSsJAJ+oAWVIAjChwgROcY2yDH5/1uM1oyPgbz7jAI2Yw4YROk7A+e1luaY2sDAG2AymMHLLPGzOwUAQI8uOeADJuw4jtaQag3dKKQaGbcSUWCSG2aGBVEDrUXdyTBqzG0ErjHW3ORFNBdtJtOuQ64P/VmgVTXcZbcWMJqBDLkKEdnB0KFDsX79elRXV8Nut2PlypXSelEgOAI+ANUi4BMEkX2wEI8LwBv4x6cEZgoG1uJpxEH0KaQtkXWV4FNIbeaQCLyMvDC1hqZddoNJ3mUwGX74YSNeeOFZCIKITp06wWbLwa5df0AURUycOAVnn30uysouwLvvfoCcnDa46abrMHz4SEyaNBX/+99y/PzzZtx00y147LGHUVFRjsrKCgwadBruuec+/PjjJint4447HjNm3IGHHroP5eVH0b37cXC5XACAnTt/x4IF8yEIAsxmM+bMmYdjj+2akfKQJYvWXYqkjwahdpRdUU7JyyDRXJKjRdkNu0gmvdA+jzXVgGvTnjpDIikyFQGfIIjswmeFDIWDdzuVTMOBA8dxYKJfIeUUjh0cDu9vbNZg+xvHRQ6CRGQGXSika7ccxucb9wPwbq1i5NUz7A4v7YRh/Topunb//n1YuvRjvPHGaygqKsa99z6IpqZG3HTTdTjppL4YOHAwfvzxB5x66kAcPXoEP/30AyZNmorvvluPc84ZjXXrvsEJJ/TCI488AbfbjUmT/oQdO7YHpZ2bm4unnnoCvXr1wcKFz+Knn37AF1/8DwCwZMnbmDBhEkaNOhefffYxfv11S1SFNN1jfdlopDon0+4qWiFQmUw2FRlDY8aJGtRIdjIsWEEP008DPoR2eqy5FnxOfhLSEoSXTETAJwgiu4g4ZuO4jCukQcoy13LcEllXCXZXi4XUImMhJYVUU+hCIQ0igyPYY4/thtzcXGzc+D2cTgc++eQjAIDD4cDu3bswdOhwbNr0PXiew3nnnY9Vq1bC4/Fg8+afMGvWHFgsFmzd+guWLHkbe/bsRl1dHez25qC0AeDHHzfhgQceBQD07z8AxxzTGQBwxhnD8NRTC/Ddd+swbNhIDBs2IgOlEBm5aKR6hWnMgpdxVKhaFqDVam2LoKjbvsj4K4daTcOyEaCoykXZNXQ4PglpCYIgCEJFZDq/QDfZTMHAArzvGBgYRCYqVibtjggKKchlV2voQiEd1q8TOhd598xsn2dBu9zMhKC2WLz3FUUB9933MHr37gMAqK6uQtu27WC3N+Htt9+EwWDEwIGDsW/fHnz88Qc4/vjjYbFYsHTpv7F69Re46KJLMX78adi9+w9pQO5LG/A+JIEDdYPB+yCdffa56Nu3FGvXfo0lS97G+vXfYPbse2PKna4hv39PxjTdMIVoRE/SDKq47Aa0D61NXiQaZTeSYi0Gfh8SCZU119CWLwRBEIQmiOyyy0HIcEj8wL7Vp4TGMw6xO0VwACyWEM9KjiykWkM3QY20xIABg/HBB143qMrKSlxzzVU4evQI2rdvD4vFgrVr16C0tD8GDBiM119/BUOHei2ZGzZ8h4suugyjR18Al8uF33//DaLMwz5o0GlYseJTAMC2bb/i4MEDAID77/8rtm3biksuuRzXX3+T5O6rFZjMJ73iN+bpPy9qoEYMIibTQrRWuvLVHe6yK+/GK59eUJfnbAIED3ja8oUgCILQAIFWyPBzGrCQhrjsevtdhRZSpwCLmQ+KsAvQ2E6LkEKaANddNx1OpxOTJ1+B2267CTffPAOdO3cB4HWrzc3NQ05ODgYOHIzKygoMHTocAHDFFVfjtddexpQpV+KZZ55E376lstu5TJt2Iw4ePIBJk67Am2++LrnsTp58Lf71r1dx3XUT8X//9yzuuuueGJKm94HLKjdX2oc0CDUMmnJRdrXSKUR12YXMuRALaahXQODa0sB+UGzZ8oWjLV8IgiAIDRCpH9aCS6s3yi7nO2hx2WWKZXM4BdisMu66LYGSCO2gC5fdwIclU8PXAQMGYcCAQQCANm1ycf/9D8teN3Xq9Zg69XoAwPHH98Q332yUzg0cOBjvvPN+xPR9tGmTi0cf/Zvsdf/4x7/iFz5tPrtpuk8aUCeITzaRvMtucEwgbU1esFANM/Cc3BpS6Vzk3/m+D+z0WFMtAJDLLkEQBKEJIm2jook1pIwhyP+OMYiIYw2pU4Qt1F0XIJddDUIW0iwm3YN93+1ErWgZSeC3mOk/L2ogxtC7lOArS5Fpb51xNL1Sbn1paHTd0J8Flldgl8eavBZSctklCIIgtECQFTKAwK1WMopvUpdrsZDK7JkaCbtTgFUmoBHtQ6o9SCElVENrgWqSQVojmAV5UQUVysFflixAOdVWASt12Q21kEaLsosgl91aAABH274QBEEQGiCq5xMX43yKCY6yy7WMHuKLshsaYZcxBk7F7SMJdaAaaQWkO8qutlSMBCGf3SD8CnryUXaDPHA0ULxyls/gC3znIn8XakkPVFgDO07WVAPOmgfOYEpSaoIgCIJQiUj6HcuspxgL6XgZY3HtjepwCmEuuwwMPKk/mkMXNSIXTISIh/QUWvASQX1XlJhNyrUKqBLUKMDqLIa4vGYSue1cgs+HK+Nhlt2woEb+v4FeQay5lqyjBEEQhGaIHmWXZd5CKkXZ9XemSp1tvWtIwy2kylMg0oUuFFJCH2gh+JR6kMtuILFi98SVRqg1McOFLLcdTfD5yOdE0b8uNlKagd2e2FRDEXYJgiAIzRCtD870OksGBi6gE/ZG2RWDZ3oj4PaI8AgsTCEFKKCRFtGHQioT3ZLQODqvKK1tS5J5fBZNFaLsshCrZOIpqkJwFYdLIxtlN+wyeYspC42y21wLniykBEEQhEaIFGW35WRmgzsyBr9Girii7NqdAgDAGrLtCwMDz5NCqjX0oZASCZHuV0jgIF1rwWriRefiq44qFtKAKLtMQxppIi67ocGMQn8X5PLt20JNFMDsdWQhJQiCIDRDkBVS7nwGB0RB60WlKLtMoULq/S2tIdUHVCMa4tChg3jssYcAAD/8sBG33npDwml9+ukyvPjc496DNL1LsmmLFIqyG4xUDMkENQr4FKyPZrqQAxVNJVcFGnsjrYX1tx9ft8ns9QBjtIaUIAiC0A6MRe6Hucz30T7lk2ux1jIo2/bF4fBaSMNcdhkDz5H6ozV0WCOZHrymjiNHDuPgwQOqp5uuEotladIV5LIbROi+m4ml4f/LZL7PFLGUY1krKAs9F7ou1p+er+Nk9joAAJfTLmmZCYIgCEItIul3vq1WMoXXQurbh9S73idel92woEYAKaQaxJhpAZTg/n0t2v6yGgBgMHBoNqjXkEy9R8LUa1jUa8rLj+Khh+6D3W4Hz3O47bZZeOCBOTj33DHYsOE7GAwGTJ16Pd59903s378ft9xyO8455zxUV1fh8ccfxtGjR2AwGHDDDbdgyJChcDgceOKJR7Bz52/geR4TJkzCBReMwzPPLMShQwfx5JNP4Oyzz0FtbS3uumsGDh48gK5du+Hhh5+A2WzGZ599jP/85x2IIkPv3n1wxx2zYbFYsHz5J/jnP19Bmza56NixI4A0by0RpJDqW5GjKLvBqOGyiwA312D31yTSVIGYLrsy62elKMERwg/LRdll9noAAG/NS15ogiAIglABkUVR8DK8D6kYEodBZCKYKALhcYrCiOayy+nRHpfl6KRGMhu99eOPP8TQocPxyitvYNq0m/Dzzz8BAAoKCvHKK2+ge/ceePPN1/HMM/+H++57CG+++RoAYNGiv2HAgEH45z//jYcffgKPPfYQqqur8OqrL6Fdu3Z4440leOaZF/Hqq4uxc+fvuO22u9C794m4887ZAICjR4/gjjtm4623lqK6ugobN36PXbv+wLJlH+CFF17F66+/jfbtC/DOO2+gsrICL7zwLJ5/fjFefPFVNDc3p72cYkUr1RfJWwSzCclFVQWXXRbispvpUg6a/ZVdQxrlXIRTUpqMBbjsNgAAOFvbBCUlCIIgCHUJskKGwKK586aBQGsoB04agyhx2Y0Y1ChEySW0gS4spMYThqG+7SkAgLa5ZrTLs6b1/oMGnYa5c+/Gb7/twNChw3H55Vfg/feXYMiQoQCADh06oqioGEajER07dkJDg3fg+cMPGzB79r0AgM6du+Ckk/pi69ZfsGnTRtxzz30AgPz8fIwYMRI//rgJxx/fM+i+PXuegGOO6QwA6NatB+rqanH48EEcOLAfN954LQDA43GjV68+2LJlM/r2LUVBQSEAYPToC/DVN+tSXzgByLk06hU1FLCsQoVyCLQmBlsbk046KWK67Ib8DfwNE8MDHgVezODvOJnDayHlbGQhJQiCILRBqBUykExvjyKKgetFOQgQFW8hKrnsmmW2fSGFVHPoQiENIgOD19LS/njzzSVYt+4brFq1Ep9+ugwAYDL5XWINhvAGL4aNtBkEQQALjBoG7+BWEDxhvw9Mk+O8M0OCIGLUqHNx++2zAADNzc0QBAGbNn0fNLCWkyfVZGWUXX1nQzV85ZGM8hjo3aqlyYuEouyGWNBDfya5fDP4o+zaGwDeCJhsyQtNEARBECoQa01mJifmWaCFlOMgiqLiMYPDKcJs4mEwBOeNouxqE33USIYHrP/3f89gxYrPcMEF4zBz5mz89tsORb8bOHAQPv74AwDAwYMHsGXLZpx8cikGDBiMTz75EABQW1uLr79ejVNPHQSDwQhBEKKmeeqpA7FmzWrU1FSDMYYnn3wMS5a8jdLS/vj1159RUVEOURTxxRf/SyLHiZHpSGxqokYQn2wi0AU18TQCPssod5kjxnpWmayHTViE/c6vxPq6QtHeAM6WRzOzBEEQhGYItkKGkOEou4H35sBBYIJyC6lDCFs/Cnj7ZZ76Yc2hD4U0w1x++ZVYvXoVpk69GnPm3IV7731Q0e9uv30WfvhhI6ZMuRJz5tyF2bPvRVFREa699nrU19djypQrceut0zFlynXo3bsPunfvjsbGBjz88H0R0zzhhF649trpmDHjJkyefAUEQcSkSVNRUFCI22+fhdtvvxnTp1+DnJw20m8oym7ikMuulwixe+JMI8BNV4yhBKaRYGOtMpddHz5PgFCPgMCjQJddzkrrRwn1WLZsGcaOHYvRo0fjrbfeinjd6tWrMWrUqDRKRhCEXmAQI57zbbWSKQIndTmOg8gExQMRu1MI3/LFmypF2dUgunDZzbRK0KFDR/zf//0j6LuhQ4dLn6dNu1H63KnTMVi61OvSW1RUjAULng5Lr02bXNx//8Nh37drl4833lgiHQ8YMEj6PHfuA9LnsrJLUFZ2Sdjvzz77XJx99rnS8Z7D3jVr6dNIAz9mutaSQ5SxirVm1Imy6/8oamjyIhGX3Vgu6YEuzoFBjWj9KKEWR48exaJFi/D+++/DbDZjwoQJOP3009GzZ3AsgsrKSjzxxBMZkpIgCD0QOcouy2gnLTJRClXPgWsJwKQMu1OEVUYhZaSQahLd1QjpB9qFxXJ91BPkshuCrzzUd9nNdCkHyaI0ym6Igh4W0yjghLTti6MBHG35QqjEunXrMGTIEOTn5yMnJwdjxozB8uXLw6679957ceutt2ZAQoIg9IB32xd54lUC1SZ0favABMXjEIdT3mUXjIu88SqRMXRhISWSJT0Dft0roQFQlN1gWNiHBNKI4LKb8Si7QZ8jCyOnQoftRxrtN/Z62vKFUI3y8nIUFxdLxyUlJfj555+DrvnXv/6Fk046Caecckq6xYsbxhicgjPqNRzHwWKwpEki7eAW3N61c1EwG8xJW33SdR+1EUQBbtEd9RoDZ4DJkOa92VOMyES4BFfUa6Ll2yN64PA44BE9URU033WprPtIeRFEESbeq6pwAEQoj5Brdwo4xhq+KwcjXVSTkEJKqEZkC5gOoSi7QaiyhjTgs6aiMEc3kAZYQSP79ob+LrC8OI4D8zgBj5MspIRqhAYiCd1b77fffsPKlSvx+uuv48iRIwndo7AwN2k5fRQXR2/7Do8De2oORR3w8hyPzgXHpzUwWCy508H+uv1odjdHdKv0iB4c2+5Y5Fn8siYi997avXB4HJHvwzzo2q4rcs3qtQs54pW9zlGH6voKGHn5Ia3IRORZ8lDctkAN8SKS7rbS6GpEVV0FjJx8vhkYrEYrjsnvJnu+vKkcu2uOIKetAbmWXNlnL08ww+VxoYE1o1u7bmhjbiOTUvI0uhpRXVcJAxfsYts234xcc27L+lERTa4mGDgrcsw5AKK/oxxOEe3bWcOuMTsZStq2TVlelKCF90oipFJuTSukspvXamgcq2WiKYQsyibISd5U7qMuEcllNwi5dZTxJ+L/GBzUSDsuu9HXkPq/E0OV1Aguu6zFZZfZvXsT0xpSQi06duyIjRs3SscVFRUoKSmRjpcvX46KigpcfvnlcLvdKC8vx9VXX423335b8T2qqhplti+Ln+LiPFRUNES9xuFxoLqhGXlRlJ0mVz3yhPq0WeiUyJ0OjtbVwcgbYODlt3NrcjtQ6W6Aw+w9TlTu8rq6FiuY/PigyeVEhbsBdlPq3tmJyF7rqEODw4Uck/yQ1i0KcDTUw+xMnYdKJtpKo7sR9Y1OtDFHUsQZ6oU65Ljl5SpvqkNOOwua6jyoaWqOeq8mlxPl7nrkmlLjvtvoakBdsx1tTKHPP4dqNAUdAyLsaERhYS6qqhpl0xMEBqdbBJgQdk2jqxk2dxOajZlxRdbKeyVekpWb57moEwiK3uqZiORnNJrR1FSf8cFqNhDofurxuFFbWwmzOdyNIVnEGJYmPULtz4u/DSWehhhB8ct0EQfdXkaYaOL5gxdFsJi2BDViDu9LnKcou4RKDB06FOvXr0d1dTXsdjtWrlyJkSNHSudnzJiBFStW4MMPP8TLL7+MkpKSuJTRdMPAou6FSEQmXev8GDIb4CZROHAQo0SS1S2MeYMOJUG2PnN2l9f1XDbKLpe9+dYzMS2kmYrk1759MWpqKtDYWAtBZGhs8K4t8TgMcNu1uQ6A53nvpr0agDGgsd4BAHA1G8Cc3jLjeQNstlzk5rZLxV2DBdAxarioZhUql0eQhVSlNBMlWkyjYOtp+OeIExahLrt2b8RrspASatGhQwfMnDkTU6ZMgdvtxvjx41FaWorp06djxowZ6NevX6ZFJFSCQQQXwS1TTUIDyISi1Tgwopw3HaGuIp7iaLtq78zgcERRSJnydahE+oj5hguM5AdAiuQXGrXPF8nvySefVEUwg8GIoqJOAIDKWjue+td6AMBZp3bGlDE9o/00Y2jJDO8RRMz952oAQP+eRZgxvjTl95RzadQrTG0NTOeo4bIb+FNBQybSSEonIB/IyHtd8HehWQgKdsT5LaQU1IhQk7KyMpSVlQV9t3jx4rDrunTpgi+++CJdYiWEoncL53+miGAyGQlVD2Sjt1OySpzIRM0oZt79RtWTxe70Pg9yUXY5jrwxtEhMhTQdkfxiBU4QeH+DslpNml4MrBXZ3B5/52QyGxKSK97fWK1+y3VhYRsUtrPFfc9UkEjefWtoeAOvmToFMte+ON5bHkZDYm0JAMwW/+smcHBQUJiLgrbqu5ArxuiXy2IJfr8IATMrJpM/71Ifzrx1whuCOzdfuzEYDbCYjcjhnXAAKO5yDHiLNp4LObTU1gmC8BLbyqXO4JqJIjhjFAtphrcAiURMyy64TM97poRYShzHcWAqee1pte4jYXfGsJCSQqo5Yiqk6YjkFytwQlWtXfpst7s0Y4UMRUsW0kCF1On0xC1XInlptvtDdldWNkJ0eeL6fSpItE58iojHI2imTjPZvgTBWx7uJMrD4fCH5Q983isrGyE4o4fsTyVVdQ7ps93hDsqfENCZO13+58hnARUZQ0VFAzye4I5a8IioqGiA2y3A7RbQUFkJGIyorHOD4zL/XMihpfdXMsQKnEBoEwYFlk+mvmufXqABNKE23v1HtdGuRJWDbfoUUqtVPhCYVizDhJ+YQY06duyIiooK6ThaJL8bbrhBiuSnJtFc6gh5YkUOTc1NA++fpnumCL/LZYYF0QjqR9kNTztTRHXZjdCmpSi7kdJEQJRdAMxRD87aljpBgiBUx7slRnLvUcaYAmVfm1ayWH0Ix3FgWRjUSG0lLpuI5rJLQY20SUyFVBOR/LJI0UkXwWvf0lNombhnyqAlpLIkUx6Bv9XSPqQs4kHI+0Yu+lEERV06ZL6gRg0U0IggkoSBZXwCKxMwMT1r/fQ6YSa7RSDhhYussMc3TkvtZITagakoqJH+iKmQBkbyu+SSSzBu3Dgpkt+WLVvSIWPEwCJEFDJQaExuwK5T/PqGzjOiEoEKVuJp+H8sRvicCaI/KvLRgH0duX8/0shpcy1BjSigEUFEhoHF3MGCrBrypHNbE71ONmfjti9JW8WRvYq83SnAaOBgMpKFVC8oiiOe6Uh+5LIbP2IGyizIApaWO6YOqcyouQEIVMDUibIramjT2mjvlyAx5T5HaCZiiOWU2evB53dSQ1yCaLUwKHErzS7SFVXYu8do9Gs4TpvBgZiCoEbZSkyFsmXddbJloIZbeDTU3ofY7hTk3XW9N8taRVzPxLSQaoFgt7mMiaFb0lZkkdwbdYhfH9V3PtRC7eoMUgLVTTp+ounGQUpo+Lps//ZAob6+/j9+l12ykBJERBhDLBMpDSLl8SqKGX+TEmkm6W1fRO1sf6L2WMvuFGGVcddljIHjdaH6tDp0USukj8ZPJrZ5FLWkZKgE9fFeQpZMJkSQm66WghpFPIjWSfosoN6j0CDhLOCDCW5AcIGz0hpSgiBSQ7LvUSWW2HS6BseDN1psZNTc/kRLKLEqqrXuWqt1Hwm7U4BNJsKuyETw+lB9Wh2KXHYzDbnsxk/gQDoTZab3avJHlc2wIBpBlSi7AWhp8iLS2lbvOQScC/8+YrCIgG1hbGIzAIAnCylBRERJwBTGuFbntaLElZYgIhHNq4AhPcGylBC6xaRSDhy146OvjuC0vu2xfG251Pc6XSJ6dQvf/ouBgedIIdUiulBIo7rUEbJkQpEKtsrqu6ZYoImLiLhWMq4kNLuGVOE5WZdd33FkRdbMvPucchbaG5MgoqEV90G9wSH5bU2UWNI4joOoQUujokmKlmizWlHA1CBRJS5RtDiu23fEjgNHHTCb6uByixh8cr50rt8J4ZPApJBqF10opNFc6ojYpOsdosWXVaL4chLqitlaUUM/10WU3SiLSIOXDoQELYqQBcYAa4tCCmubpOQkiFZPlC0sspV0BTUC9Dsh4C0jfcqeclhkhT0eF9xUr1OOFZgqEvaW7V1q6t1o28aIsjM7xrgRg4HXherT6tDFNEE0lzpCnoxH2dV5NbW2QU8sAl1QE04j4LOooQaSTJTdSMGYA12cLT4LqZkUUoKIhNdll5SKROCgzOVZDZK1xGYKxrIvQnOiSlwgep2E8GF3ehXSuga37JrRUBhAFlKNootaId0gATLhERnd1KQrIrlitlZUKYYIil/Gi1jhsyI3mInk2h2oqJqZEwDAWXISFpEgiNb5PlYrKE3M+yi4h1aVF1GBYqZV2dOBWkGNUjkZkaiMdqdXJpEBVnNslcYbCEoXqk+rQ3e10gr7o4RgET5n2z1ThgprJrORZJ6/SBb0TJdxtCUBQZ2kbCAjeZfdQD3VIvrWkJKFlCAiISpY3+cdFGf6jZF+lChT6bKQEtkDS/Ma1Gh4FcX48VlIASizkDIGnrZ90SS6qJWgiLEZlENXyAykU39LDWkZScIiKBqtFTWCPEUKapRpq0e0PVHlJlnkFOtIa08ZmDeokcEEzmhOXliCIFodMZVwFZQKhthrVdPpGhwPivbTzML1x7G2uwFaLOwqDci0WPeOQIVUZt/RUBgYbfuiUXRRK9kUvTVdiBkos+AtMvRdT5L4Os+HWvjXkCafhjcd7UxeRHu/yJ2TtZqGZCJQUTWLDrKOEkQMlLhdAq1vDMCYAmWLICIQyQIab7CsVLdAkYkJTaz4XHYBhQopY+A1YhUmgtGdQprpwaseoSKLn0jBalorapdDNKtkJgkb68pt9RKkj0aKauS/1sJIISUIInVw4OKKmCqHd61qrBtxmrSSKVrbyBRYmnVGokpcNuGLsgsANosSlYa2fdEquqgVctmNn0wEjREzcM/UQS67PqJFoY2HQOuqplx2o7xVYs2F+bIRajn2p8nIQkoQasFln1IRCyWutOqhX+VGK2shtQZjKq27TvFkhFIPiVAC15BaY6whdXgcEEQBPB/bkkqkH30opOSyGzeZLjO9Dxr81jB950MNgpSyZIoj0GVXlP06I0RzNY/tsiu3stT/tci8UXZJISWI6IgaCrCiNzhwadtKS699u17ljkaiShzQUh46LxKPR4Tb48+EzRxd0RSYBx1zOyHXlJtq0YgE0IVCCrnxHxGVTFiVZcfpOkXv8quKSss9g4MBaaeAo4kiH2U37KvwKLsBx2bRDtCWL0QKWLZsGcaOHYvRo0fjrbfeCjv/+eef4+KLL8ZFF12Em2++GXV1dRmQUl2yUbGIhteVNvWKupI1hVqNcqx025dWOcGsUjAnNdzCo5GIjM0B7roAYLPGUGkYB47cdTWLLmpGiy9AzZOBdbfZ9LL3tbk0TTprGqbSjFAkS2SmldOgyZtoymnIXwBgYiTXbr811SQ6wVloRpZQl6NHj2LRokV4++238cEHH+Ddd9/Fzp07pfONjY144IEH8PLLL+Ojjz5C79698dxzz2VQ4ugwJUoFvY8jkso9IgltksyYK96gRqnGK058AjU7PAAAo8H7u1hBjRjXuvej1Tr6UEijuNQR8gR2TWmLsht4f53XkxrbnGQLwc9fEukElGW63MuUEM29PXhddLjLrl9JlXfZ5ZgIE3OBIwspoTLr1q3DkCFDkJ+fj5ycHIwZMwbLly+XzrvdbsybNw8dOnQAAPTu3RuHDx/OlLhEClHD1VmJC2c6XYPjQdF+mlm4/liJEseYOtu+aLHum+1eC2n7tiYAChRSilitaYyZFkAJ2WR5SxuZiGKqoa081IKanoplEEHxy3gZR2u2MdxzIywhlb63wgkA4My0hpRQl/LychQXF0vHJSUl+Pnnn6Xj9u3b47zzzgMAOBwOvPzyy5g8eXLa5VSKooApHNPACyO9aM2SReiLSAqY1xXc+yxt2laLdT9Vh13D8xwuObsjOpfYUiqjVx4RHBeukqz9qRo/bKsFAAw/tRClJ7TFm5/sR32TB+4Wj932bU2oqHHFjLLLcRxF2NUwulBIA2llfVHCqBaIJg7ELNFHNaUsaYJwK2EiBEfZDUhdQy67oRXOIh74LmdBp9pyzbgxbxVebToLAGCDAwDAWUkhJdQlNAgQY0zWStTQ0IBbbrkFffr0waWXXhrXPQoL1XM1Ly7Oi3reZcmFW3TDbDBHvMbiAopy85BniZ6WmsSSO9U4PCbYTW2QG8XtnzEGu8eO4gK/rPHKbXcbYTflIC/KfUQmwuVxBd0nFcQrew2XG7V8gJa20y4XFqMlGdGiku620mDIgdlojqpkWVxAcds82EzBSqVH9KDB4JX393121DV6cEI3v/wiY9jyWx3KawWUnpgLQRTgET0obp+aPDYYcmXzsn3PfjQ2C3B7RPxx0I7+JxVhx94mdO2Ug5JCM07omotRQzrgp2216NK5XVRLucUFlLRrm9I2oJRMv1cSJZVy60IhFSNYVojIyO6VmNb767eeMl12WkOMrK/Fif/HQuC2L8kkqQLRXJID27HPfTfUZTfwuIuxGl2MNeht9LpGWshCSqSIjh07YuPGjdJxRUUFSkpKgq4pLy/HtGnTMGTIEMyZMyfue1RVNaripldcnIeKiobo92pshEd0wxRFIW1yN8Jgr4MjTeNJJXKnGrvHjqqGJjgjF4tXIRXsaCd4ZU1E7mZ3M6obm+EyRx7Qi0yES3AhT0hdmcQrO2MM1XWNcJqiX9foakKOuwEWgytJCeXJRFupqmuE2RBdIW10NcHirEeOyRP0vUf0oLquEbmdclHX4ETHIguuHN1JOi8yhl9+q0Nltd37Hmip+1xPavJYUVcPm8EWplA2NLnQtZMNDU0e1NU7cehIPQBg5IACjBjcCVVVjQAYhp3SDtXVTVHv0eRuRBt3I8wpagNK0cJ7JRGSlZvnuaiTnPqwXWfC/VTnyEUHTec9dayPhljMMieHZlCpOCKu1cxwGUebPJE7E2o1DTy2cd6OrovB6/5kg/eYLKSE2gwdOhTr169HdXU17HY7Vq5ciZEjR0rnBUHATTfdhAsuuABz587V/JYqIhOBGDLS+i95OI4DE9MT1CiVkVZTC9P1RLkcydRFYFnYnWLY+kue42C18EH7fGYCn2w2Cw+7U4Td6c1zrPWisjCQy66G0YWFNHgAmF0vlHRAJRYfGtKVNEGwlTiJqH4Bn4OCBWmolMMGLDLW4TALesCxTyHtbKwGY4zWkBIpo0OHDpg5cyamTJkCt9uN8ePHo7S0FNOnT8eMGTNw5MgRbN26FYIgYMWKFQCAvn37Yv78+RmWnIgHtYLSxLwPYq9V1eKEgOL9NDU+IZMoMetEQTAnh1OAVWb9pdVigKNFIc3Uti8OpwCbhYfbY0BFjUtSkOXkjQlF2dU0+lBIVYry2ZrIhJtztrhWR4u62hpRLcpuoPtroMtuhos4mktyrCi7ohh8jU8hPcZQA1EQYGtRSGkfUiIVlJWVoaysLOi7xYsXAwD69euH7du3Z0KshFCylyTAKQt+lGUoGUT7gtRo3RJOaIPACQi7U5C1ONosBtgdabKQyrRdjyDC7WGwWQxwexjsTgGOFnkStZDS86Fd9KGQtszuUDOKA+Yvs7QN+Bnz3i+d90wJGSg7DSNtYQIk6bMLqX2IAZ8zrvQHPisRLgk8xwK+C/wFB79CauYEiLWHYONaLKQWspASBJEYSiykyQ60GVjMfV7T6RqsFMUWZKYtbxw1YKIIzhij3mOUj9vjV/pCsVl42F3++k533dsd3vtZrQa4BREOp4hmZxIKKchCqmX04UztGxBzXOYHrzpBGjRzXNpewQz+TlHPtcQC2hsBSAo6xyXVoQe2D1HUzkx+4LMSFmU3sC2EaKTe91HwNTmcS7K4CpX7YOOccHNmcHxinSdBtBaU9O0cx+l+j+t4YdDOu1KrUPlEJvq2L5AsoHJbptisfgtpKss40tZGdqdfNpvFAAagtsEDngfMpvjkYYyB43lqKxpGFwqpr/vhdSGtRmgpNJ5H2sx8jAXUkY4HDYHtrbUNfuQIev6SdNn1tQ8x6HMy0iVPYP5CRQk+x8K/Y/5AGTwP2HgXKsW2cDEDxKp9sMEJt8Ga6iwQhO7xjklpsJgwyVoAFVoaA/ev1ApK5NGi3Mmgzv60HJrt3ui7Nqu8y64jg0GNHAHWUJ9FtKbOBZvFELdiycDA60PlabXoonakAR/HZXzwqhfEgDJL1zuYgYH3WcDSc8uUENjedG3qVQlf+0n2+WMtaXjT9LeVTE9esCjPity5oO8QoKByHGycC83MikNCe7CqvbBxLrj51G8qThCtgVQHVtEiSlxp1ULJGF9rFiYGpmgio9VOdnAsah/bFGVNps1ikKLaetNKzRKbSIGpAiPq+uSrrncn5K7rHXPoQuVpteiidoLd5khDiIdk3SzjInDBuI6rKbC96TgbquHrgLx1m5xGKrl0Mw25dwfVd6hGGnBOUkhDvgtx2bXDjAOeAojV+5DDkYWUIJTAIGpO2dEVKVIWsgWG9EQrThfJWnx9FlbJQhphDalHYHB7MjMJFOiya7V61ZWaepese3EsRIgwcLR0RsvoQyFt+SvnUkfII1m1+PTp8CLzz7Bmw4vfb8DTf16SIdhFNfF0RMaCZuA1YiCN6pIcvFwg+CTXMgAUJYXdG9TIATMOCAWAy45j+Cp4DGQhJQgiQRhDOkykIlMS5RiaCw6ktH/OxskOpZbhaJGpmx2Rt1GxtiipUqTdNNe9775WqwE2s1cWQfTLFRdkIdU8uqidaC51hDy+l0Z6y4wFuGSm657qE+SyC5oECXTZTbZe+YBBgb98teOyG+qSLHcu1GUXAIwQMNL0K/J4BxzMggOeAgDeaLtuniykBBELJdu+cBwHUWNRXrVCa584JeLD5ybb7IhmIW1RSF2pfeZiBjUyG4LWuCbksguQQqpx9FE70VzqCFmCI8WmM6hRFiikLX99eWn1TS7AZTepKLsB7QPQTvlGe1bkIi77vQ/8UXZPs/yBCy3fw8J54IAFB4UCwGAGALjJQkoQRIrhkNz7WfH+rhpzDVbqistpzLKbLPEENYpqIbVHWUPa4ibr2/sz3YGhHE4RZhMHg4ELctP1yaUUxhicghMGXhc7XbZaFNXOsmXL8MILL8Dj8eCaa67BxIkTg85//vnneO6558AYQ5cuXfDYY4+hXbt2qgnpDxqCjA9e9Qafxrg8LMBlV88V5VdCvH9FxsC31oAIUO/5YxFcdjMdqCwwf5H6Wj5gECbti9zyHQODh/k7SAfMEMED+ccAVXvIZZcgYsAYw4qvq9DQFH2M3bObDUP7tS6Pg217arHqh0oYuJqI11jMPM45Iy+p+2zdXYc1mytg4KojXmO1GHDesNyk7qM29U0ufLCqGkyojXgNxwGD+7VBh57pkyvVON0CPvqiCh535HYBAKV9bDi9d/j3hyqb8N5XFaip8yt9ofiU1E/XlqMo34zzhqem7u0uDz5cVQXBE5yXw5VOSQazKUAhjdNC6hJdsBqsaGOi/cC1TEyF9OjRo1i0aBHef/99mM1mTJgwAaeffjp69vQ+2Y2NjXjggQfw3nvvoUOHDnjmmWfw3HPP4d5771VNSCmoCk9RdpUiBpRZRqLs6rieQl12WzuSgs4nF+TJ6zIT7rKb6ckLFuVZkXuOQl2YGQNMnD80voOzeH/TriNY1R6INCtLEFFpaHZjwy+NaJdrRI7M9hMAUFPvRlWdC0P7FadZusyyYWsV/thnR0mBRfa8y8NQVevCiT0t6FWc+Lv0u1+qsGu/A8XtzbLnnW4R1XVu9OttRs9C7XTwvx+ox9adzShub4ZRRqkCgKNVTuTkAAOP147cybK/vAFbfmtGQTsTLCZ5i2FFjQsMoqxCumVnDXbstqNLBxtO7ZMv+/vi9hYc1yUHtQ1u7D9ixyknWnBCgYqZaGHvkQb88nszCtuZQhRPHr26eZVgjuMw6KR8HK50oGfX+BRLkYnINefBZqTJYS0Tc6S0bt06DBkyBPn5+QCAMWPGYPny5bj11lsBAG63G/PmzUOHDh0AAL1798ayZctUFTJwAJjpwatuCBo0p00j1YwbZjKEuuxqyDspI4StqWUJbtQewWU34+Ub+KxEaLg8x0GQLKQt3wWYjG2cS7pW9L1WC7oCu76FUXSBIIjINDncAIAxQ0vQv7e8d9V7nx/C7/salbuWZgnNTg+KC8z4y1XHyZ4/WuXEM2/vgsOZXLk0OwUcU2LGTePl77P/iB0v/GcPnK5Mv7CD8bWd6y7pina5Jtlr/vbPnUmXj9Zoaln7eeXozji2o7yi9dLSPXA4Rdn91JudHhgMwH1/7ouqqkbZ31vMPK6/tBv2HW7Gi0v3wuEQU+L23NxSh1dd0AXHFEf2gLjsnE4Jpc8Yg4HWj2qemDVUXl6O4mL/jGRJSQmOHj0qHbdv3x7nnXceAMDhcODll1/GueeemwJRfS5yKUk66/AVUzq30syaKLshLrtaWi+TSZLd0UfrUXbl5ruC3LdDTKQc523zImOwcm7pNy7OOyhivc7CSns/HGh/WuqEJ4gsoMnufX6iueJZLYasUyqU0OwQZCOg+vCdc7iSUxbsDk/U+/jW8GmtDqIF5fFha2k7uh6XhNDk264lgkeB71ykgETNDg+sZmVKmi+qrSNFwY18yrVSeeKFQYSRPJU0T8waEkUxJKCHvHWkoaEBt9xyC/r06YNLL700LiEKC6P7pecerPcKazTAYORRXJzcWolUohXZKhq9Vhmj0QDRLSQkV7y/MRp5GAXviysvz6aZsog7HxaH96/Rm5fColxYzdp4mWWiTJnBWw6+8igqzIXBEH/HwRv4oBkwX3pt21oz2lbyDjdI8vCG4PdLVbNbOucRGIqL8+BuWeVmNBoAxlBYkAsb50ITrHilfiQa2vYAYEdhcT4+sZ+KCW3baeZZiIVe5CSyi2Zny4A0hkLk8jAIQvYoFUqwOwW0bxetXFqUBRUspEUR3IKBgC1AnKKmJmmbHR7wPGAyRvbasVp4OJweTcmdLM1Ob98U9ZkxG3DYKUJEeNtodkaf6AhKJ8V1L00qRFGuk4JxAC3B0jwxR9kdO3bExo0bpeOKigqUlJQEXVNeXo5p06ZhyJAhmDNnTtxCVFU1Qoyy6LC+3u79IDK43QIqKhrivkc6KC7O04xsNTXN3g8igyiIccuVSF7cHkFaPFpXZ9dEWSSSj9pGp/dDS14qKxphMWd+Q+VMta+qWv/zBwDlFQ0wJqCQCh4RhgCXXa20lbo6f/48nuD3S9BzJDJUVDSgqroZNs6J4eJWfITeqKxqhI1zwcnM+MPTESUtfX9lixtUc7NTE89CLLT0/koGnudiTnIS2sLndhnLyiVdq17MRM1jd3rQyRLZjdFk5GDgOdiTdKe0O4WgSKahqKX4qk1zi2U32jISm8WA+qbsWjohKXFRxiZWKw+HU5A91xzDIh6IFG3XmRqF3jchZUmZhRTgdbKpSGsmZg0NHToU69evR3V1Nex2O1auXImRI0dK5wVBwE033YQLLrgAc+fOTcnmw8Fuc6onn9Wk02UXWRplN5vcfBIhyKU1yZQC28dV3Cfoa9qnmdKVfVYC2oIUZZcxnGg6hDP5jehjPAi0uOw6YZauBQAmUnAsglCCIrdLa2rdBrVKsyO6oshxHGxWHo4k1nYKoginS4Q1ioXKYOBgNnFwJukarDbNztiKlddll2XV+uNmhydidFwfNosBTheDIITn266g3HwYDTxMRg4Op5CiNaReWVLVVzIkGPeCSCsxLaQdOnTAzJkzMWXKFLjdbowfPx6lpaWYPn06ZsyYgSNHjmDr1q0QBAErVqwAAPTt2xfz589XTUgpqApF2VVMYJmly0tFDHDn1rNnjBR1NQvyogaBbSnwOF68a4y9aVjgwXHcATgsIhgbq46gCSJGeVbkzjHmD2J0kukQxJZjZ0t0XV85Se8q6gcJIipNkstebAudT3ltDbg9AjwCk9xlI2FLcn2t3enbizK2YmdPkZUsUZodHthiWNZsVl5zlt1kUaqIA17lEyFOI80OAW3zlHt+2SyGpCY9ohGPtTYROHDgKaiR5lG0MK6srAxlZWVB3y1evBgA0K9fP2zfvl19yQLw7xNIJlKlBG9Nkb4yk5SWtN0xdWgmCmyGCX7+kisPX5laWxS6E0xHsNujDVcqnuNkoxH6zvnOMEAKYnSi6SCYKMLGuVHf0uMHRiMGSB8liFg0O9wwGrmoSwF8A1Z7BBfEbERS1GMM1n0BnxLt630u08osjRqzkCpQZmwWbwwAp1sAsmQbWyVBiWxRnhlvECv5qMRypDKoWLPTA6s5lT2lCI56Ys2jjymDQLe5zEqiG9Rzs4zjngyQdn3RsRbnV+albzIlijYIc2FOMBnGpDL1KXQmTkRO7c7k5EuSUBft4HMs4JzfROqzkBYYmsDqDsHKueDy7T/ako5vXTy5ChFEdJQNrn3WntajkCoN9mKz8Em5MitxmQa0Gek4Pkth9rQdRYq4Vd6rQGQM9jiCGgEtbSxFkxFNZCEloBOFVHKb49Lnfqp3AveOTJebM8tSl93W7iYe+PwBiU82sACXXRvv3yalTdW2JCVMjmjPSqCngejXR2Hh3BBaXp/coV9h4/1rSHmp3QQqswRBRKLJ6YHVEv1BkZQKh7YUolTiUyRSbblUbiHVnutrs0OIGQzHl69scvdWosRZzfKKuMPpAUNsy3sgybqFRyPVLrsASCHVAbqqIY5Pr/upnpEspHz63JwZApQWHVsVQ11UCS9cki7Mge3D57JbJ9qQW709o8910LMSIkfwOf93Ns6NRrTBIU8++MNbYOXccPsspOTqTRBx0exwxx5cS+6H2lKIUomS6MO+88koCz5FLUfJfVza2fbFa+nzwBpl7TEQsP7YmT0KqSLLsFVeEW9SONERlFaSbuHRsMexJ2pCcCCXXR2gC4U03IWSiElAmaWt72AAz/s/6xVJIW3Ji1Y630yh2vPHmFSmVngHWj+6usPkqoNYcyDJxJORy/uHl1sSIFlP/ZMsjLEWF10ztro7w1DxOwDAxZmla4FACym9uIjUsGzZMowdOxajR4/GW2+9FXZ+27ZtuOyyyzBmzBjMnTsXHo82B+RKXHZNRh5GAxdxG4tsRKmF1Grh4XSJEdfAq3Ufm1VbLrtOl+ANMtcKXXbtCtfOAuGTOP76Vh7UyGpNzi08GkqU60Txeu5F3xaI0Ab6UEhBLrvxElRmabpnUJTdNN0zJVCU3SDUCmoUGGXX2uKy+4OzOwDAs/enJCRMjsBnJbThMgA9jUdwjetN5MAhfW/l3HDBgl/dXaTvfGtI+RBXb+oHiVRw9OhRLFq0CG+//TY++OADvPvuu9i5M3g99qxZs3D//fdjxYoVYIxhyZIlGZI2Os1OjyL3Qa/LaPYoFbHwWfSUWEgZ87piJoLfEhtb8XW5GTyiNpRSydU4RkAcaS2lXZsTMvHiEUQ43WIc666D890slVt8FlKni0FQue5dbl8k6VTtQcpoD1KdoCjKbqaRgo6Qy65iMlVmya4z1AKB6wYBnSvXKiCtqeWTd8f2u+x6O8QjQjs053UFv/NbmPuPy8gsZuCzEmphYAzoYqhGe1aHUuMe6Tsb54KLa4fdnmLpWjcf4rLrC2pErkJECli3bh2GDBmC/Px8AMCYMWOwfPly3HrrrQCAgwcPwuFwoH///gCAyy67DM8++yyuvvrqtMnocgv49Nu9EMHBbndHvK6+yY3jFET8tFkN2HPYgbdW/qammJHvZzNFlTvV7Dla75Uj5rYmXsVj6Zd7kWuxxC33H4fqYDRwMJliK74A8O7nu2A1mhWnHw/xyN4orX2NHfQJAL7fWo3KqtS0nXS2FXfLvqKxlDiTkYOBB379owFvOf35rqizA4h/DSkA/Fvlund5vBNMqVJIRSbCwCu3BBOZQxcKqQ8epBwoRVKqgLQVWnCU3fTcMxX4LYK+L3ScGTUIbEtIYg1pQJRdG+cCA+CCCbVFpyJn94cQq/fDUNg1WWkTkMv7V647ZGCS8jzQ9EfQd02cBQw8PG07w1h/UErBl06i7nMEoYTy8nIUF/snREpKSvDzzz9HPF9cXIyjR4/GdY/CwtzYF0WhtsGJ77YfRWNz9K2dLGYePY9rE/N+J/fMx3dbqvDttsNJyaUnTujWBgVFObCZbBGvOaknj/99V45fdlUnfJ/ex+WiffscWIyWyPc5AVi9qRI//V6V8H3Upn1bM7p1tUZtO+1Fhq6dbDha7UR5dXa0nba5JnTvZon5zPQ5Pg+7DzSHPTMdCi049tgcAMqe85NPYPjqh9TUfbtcE7p3i16HkYj1G5fggoEzoLhdXqLipYTiYm3Jo5RUyq0LhVSKgim7yIuQx19m6VtCyrLCT5+i7AbjX1ObXN0GRtn1uryawcChprAfjtnzMdy/r8uMQhr4rITWNfNbc7sbKyDWHQVjtpYgRt5Z4uZ+f4L1m+dQYegAwBO2fy2tfSdSgSiKQe/bwCjnSs4roaqqUdq+KFEevX4I8tqbUFHZEPEaj+jGkabDqKpqjJrWOae1x7ABNnTKPSYpmZRSXJQXVe50UNFcjtoaO5oNkV2Vc8zArROPQZGtEFajLSG5jzYdRU1NM0x8ZCtffg7wl4mdUJxTDIsxNRt6xiu73dOMant1zLZz7aWdYOSMKLAVJiuiLOluK06PAxXNFTHzfcXoDhBEER3adAj6vt5ZjyZ7I9AOMdMAgPw2HP4ysRNK2pTAbIg8aZEITo8DFfbYeQmlsDA35m9cggsWgwVWV2af40CKi/NQUaEdeZSSrNw8z0WdQNCJQur9y0XZuJ4IRgwos3S5zzLmV1r0XE+SIkGaBAA5BT3BbV/gL1Mr55IUOsHUBsaupfDs/BbstCvA8eld7xH4fgl1RxYZYOFccMMIA/PAvXM9WMezvQp1i4uuq+A43FczESe2zQNQE15OWTBJQ2iPjh07YuPGjdJxRUUFSkpKgs5XVFRIx5WVlUHn0wXHcbCZbLAZI6/f84gmxeu8eI6HzRjZWqgmseROBxaDBU7BGfM6DhysRhtsRltCclsMZnjE2C6nHM/DarTBmiKFNF7ZRSYqescyxmAxWVPWdtLdVjhwyvpKxmAxmMPy7fI40eSOT7ngeB4WgzUldc+laJ2n12VXF6pOq0cXK33DXCiJ2GQiyi4C+gX96qP+rT4k92MdZ0YFwix9CRcHk8rUyrmlqLSMAcYTzgBrroVwKHN7kso/Ky3uuXwedno6wv37ejDRBSMnSgp1qN4ZFmU39aITrZChQ4di/fr1qK6uht1ux8qVKzFy5EjpfOfOnWGxWLBp0yYAwIcffhh0XmsoWZvOGEvZwFWrcOCVrdtPcmsLnuOVvdqZtiKHc1DmOZdtwW04mSB8cni3WwvPt9wErJLEUlH3nLfxpgSRiTBytIZUD+jj6QwIqtLKdQPF+F40XBq1eO8awSwIBCRt9aGdTlcL+IMaJQZjQBfhACxwwxawbycDg7Frf8Bsg3v7V+oIG5dckZ8VxvzK80bncWD1R2E58gsASPKLIe3FH9TImwY1IyIVdOjQATNnzsSUKVNwySWXYNy4cSgtLcX06dOxZcsWAMDChQvx2GOP4fzzz0dzczOmTJmSYanl4cApGugysFbnucLzvLJJ0SQHR0oVX45jmgrUplRBChyfZAscp2ASB/KTOHJKqpL7paLulSrXicAgwkgWUl2gi1oSJQtNAjM6rZTASLHpcp8NdNnVs1Ux1GVXz+7HahCqcCVat2bmwgVN7yM/5wRYODfcXJuW9ADOaIapz5lwb1kJsaESfF6ROsIrINqz4lNI3ZwVP7i6Y6J1C9r8vgIA4Glx2fWtsfO1Fz7EZVdL1gQiuygrK0NZWVnQd4sXL5Y+9+nTB0uXLk23WHGj3NqTXVYuJfBKLaQKlfqI9+F5MI8yK7WWUG5d05bcyaJUMWSMgZdz7eU4gMXZXlhqosZ7J6RSUz8MHLgElG8i/eiqlmgfUuUEbV2Srii7AEzMjeQ2Bsk8kstu6BetnGT3IbVyTvBgOM2yE4V8o7Rvpw9z3/MAAK5fP09KznjxLwmQ24fU67Lr4SxwwwjjiWfD2HgEAAJcdoNdc7Nh6yOCSCeKlQrGErLs6BleYRyIZK1XHJRP+GvJQgpAcR+dTW0nHldlufriwMWtjwIpdNlNVXfJsqvesxld1JLvZWxA69kQO3l8ZeZJmz7FMRF/qnsFF9g261qJ87Y3hjZo8h5nVpyM4xsLGZFcwAYLvAEzTJyIPN4BDx+s0PG5hTAeNxjubV+BuexJ3SsuGMMg8y5cVvsaTAjZnsJnIW2R1XjSKLCW9Sgeg89l13upz0Lq668ly6nGxm4EoTWSXQ+X/SgrnGQVUqXXacnrQ7HLLrJrMiMeV+VICmn8S0hTMxpKdXvKpnrPZnRRS4wBwy3bMb72H7CwNA5UdQxjQKlpHybUvIgivj4t1hoDc8PG7DjbuhUGDYXYjhfGgG6GSlxZ8zJONh1o9ZYuxhi6GSpwdfXz6G4sT9xlt0UhbRC9EfrcLS6vgcmZ+40B3Pa0riUVGdDZUI12Yg3O4H8JO+dVSL2ycra2sB8zEADg4a0t1wS7NPtdvVsS0dDgjSC0CqdgraS+fW8SI57BdFIuu0oj8icZPEltFLt7Mi6r3sXxBAKSWzubSFvhOC5ldZ8yZTeChZjQHvpQSAGUGOqRIzZhBL850+LoAgagyFAPM3NhrO2ntHTjPguYhfOg4+E1abhj6sjnmwEAZbZNYL7oNK0Ub1tqgAECLrZtAktwX0IL57U+fm7vCwBwcVYpfR+GkuNgOOZEuH76BMzVnIzYccrmbbvDjVvAHAH7mjFRctkFvMpzQ88x+MbRC/XGwpbvfGtF0fI32GWXukKCiI1Sl9HWFmXXG/02PVF2FVtiNaTYKXZd1ZginSzKAwFFtgxrKcpuqtpUtlnGsxl91BJj0oDxdMNWiI1VGRZI+zDmXfsGAAMteyCU7075PS0t7o4NohUlFd9DbKpJ+T1TgW/dIAB0MtbBsOe7DEuUYZh3kgEAjjNVgDuU2KSQpcXl9zdPJ7zScBZ25ZS2pB/cKVpOvxLM0QDXT58mLnMc+J4VN2eCGW64fl7uPym4wXNMci8GAI+1AP9pHgIYvDHhxJb5Cn9QI++xGKKoEgQRGSXKQsQALdmM0uAzSSoL6VJ81UZxnlMUkCdTKLWQRlLIElICU1T3qYyyy4EjhVQn6KKWxJYBsYPPAQA4N76fYYm0D2spMw+MaBQtcH3/n5S7nvpcMlfYSwEwODdoP7qjHN6y8+blqNAWpl+XgXlcMX6VvYgBE0JVQhsYfv4ATIx/PbdvwsLBTPjZ3RUuY25L+sHXGYq7w9hzCFxbVkBsrE5OeAX4npUGQ3tsEXrA9ctKadKLa9mQ3iO5FzP/mteQaLphLrvSti/ZMwgiiFTBQZnLbmuLsqs0+EzSLo9pUnzVJh7XVS3JrQpKqjyCq3JCSmAKLaSpnCsghVQf6KaWrHCjydAW6z0nwfPbOngO78i0SJrGZ+Vz8VassJdCPLwNnl3fp/SePoX0kJCPwyXD4PltLTwHt6b0nqkgUCF9r+k08PZauH74KMNSZRafxfiD5kHg64/AvWVl3Gn4ytTBvJbFaP2aZfDlAGNwfvdu/MLGCWuRzcObsdw1yCvjN//yWmPc3jXr/gBMAVGYW+QPc9kFRdkliHjh+dguu9m4l2QslLqkqrG+L5Y+qsV3WjxbBmUTioMaRbBqxrvVCmMMXIq8E1JlIRWZCAPtQaobdKGQMngtNB7OjC89p4LLK4Ljq1fBPM5Mi6ZdmHdNp4c34xtnb3BFPeBc+yZEe33KbulbI+hgJhzoeBa4th3g+PqfurMu+pR5AQbs8BwDd7chcG3+BEL5rkyLlhFYi4XUzXktm8IxpXBufB9i7eG40vGtMXYyE4DwtZaB8HnFMA8og+eP7+DetSHJHMSA+bZ2MaOG5cEy6DII+zbDs+t78KEWUgQqpPKWUHLZJYj4UbbfZutbDxaXS2oSLxvFUXY16DKtaO1xCgPyZApFgcAinI83ym6qFXoleYkXr0JqUDVNInVo780ig29zeg9vgZMZYT3zOrD6o3B+r0+X0HTgs/J5ODNE8DCOuA7MZYfzm3+l7J7mAIVD5IywjrjGW08b3kvZPVOBv715rWL2vpeBs7WD46tXwAR3hqVLP8w3ucFZAHBwDrgKMJph/+oVMFF5wCdLi5IvwNtBxNrX1Nz/QvBF3eH85l8Qm+uSzUZExID3C2MMpr7ngS/uAee6t2BqLgfg3+JFzmU39JgLibKbbYMggkgFPMfH3OS4tQYoUWI5TlZRVKKgaNFlWvFaSI25GquBskmcCBbSBMoilXWvNC/xIDIRJs6kappE6tDWmyUCXguNBx7eDMYA4zEnwnTyOXD/8j+4d2/KtHiaxGfl81l2uPxjYB50CTy7N8L166qU3DPQAsYAGDuf5K2nLSvgTrG7sKr41t9yLW6a5hxYR14LseYgnGvf0KTbUiphCFbQmbUdrMMmQTy6Ey6F64R9gYMCgwP5xk+RSpPjjbCeNR3MbYdj9eKE1q0qxeJTSAFwvAHWM6eBuR3o9MeHAAAhcIsaad9R719pDWnLcaiimmVjIIJICd6gOtFpZa9eAMoULjUURSUKindPS20NG5W6e3Jc9m3/oWTddaT2E++6TS3WfSxEJsJoIIVUL+imdVk4N4SWASPgjcTJlxwHx5cvQ6jan1HZtEiolQ8MMJ8yFoau/eFc91ZK1naapTWCJmngYBlyFfgOPeFY/QqE6oOq3zMV+FzE3QFlZ+x6Csz9x8G9fQ3cKVLoNQtjsLZMCHkPGUw9z4DpxLPh2vwp3L+vi50EgvfzBAIGQFE6VENBZ1iGTYZw4Bc4v/13UtmILJt3wkvgzdLAxlDQBdaR18EgOAAAYoDcYS67kuIp77JLEIQyYllIvIPo7FIqYqFE4VJDWVCioDAwKWibllDk7pllUXYBZeuuo0XGjWdyPdV1r0S5jheRCTBxtIZUL+hCIQ1WrloGf0YzbKNngDPbYF/xNG0FI4M0yIb3ZcJxPGyjbgSf3wn2z5+HUH1A3fvBDREc3PD77HMGI2zn3gLOZIH9sych1leoes9U4GtvPquYT7EwD77Mq9CvfxuevT9mUsS0Ehj0JxDLsIkwdOoNx5pX4Tm0PXoaLetQBS7AQsoFu7ZGwtznTJj6jYH7l//B9cvnCeUhKqLotYgbzEGdu6nnEFR2Gg434+EytWnJh19/liyhYvCxz2U39HuCICKjRKHKtr0klaAk+Iy3f0/yPkoUXw267AJxuK5m2btY0d69EVyV411Tm+q6V6RcxwljgMFACqle0N6bRQ7BDSMnQjBYggavfE4+bGNuB3M1o3nZYxAbtK/spAvfVh2eQFdDAJzZBtuY28AZTLB//ISq1mUzfPfjgma6+DbtYRt7F5jHieZPFmh+8oBJZResgEkKfVE32P/3d7j3/JAhCdOLbz2yX0H3fs/xRljPuxV8Xgnsy5+C59C2qGkEupAD8SlqltOvhLHbqXCuexOuX/6XWEYiwLVYQQXeEmasPdRtLO6vHQ/RYAXg7ZRjbvsS8n0rGz8TRELwrdTKFYt4ouwme5+YUVeZNtfwKt0yKNvajrdtxPAqiOCqHPdWKymu+1SsIWVI7bpXQl10UVMG0RulNdClTjpX3B05F94N5mxG87LHIVTty4CEGkSy8vm3q/DBty1BTtlfAYMJzR8/rtoWOlbOJVnAQl8rhsKuyLngTjBHI5o/nA+hcq8q90wVQdblgMxwZhtyxt4FvqgbHP97Hu4dX2dIwvThX4/sc2EOmGyw5sFWdo9XKf1sEdy7N0ZMxxLg9gsEbJuiZGab52E99xYYuw+Ec91bcP7woWruPUbB/34JS5Lj0MysCPQuDt/2JfjY91dy5VVFSoLIblqrlSsWitZ2qmW9ij0foEm8xl2tSpc6FCmIESZx4t1qhSm9X4IoCWqWCBRlVz/oQyFt2XrBu4Y0vMEainsgZ9xsQBTQ/MEjcO/8Nt0iag/RI1mVvQSXG9+uA3LK7gFvzYP94wVw/fK/pAf4FgSvMwzFUHIcci76KwCg+aP5mq0nrzXPJVkEQ+EsbZAz9i4YOvWC46tX4Fj7JpjgSbOUaYT5FHT/1ieB8La2sI27G3xhFzj+93c4v18aFn3XV6YeQ4CFlJc0UkVwBiOs5/4Zxp5nwLXxv3D87zkwV3OiufLL4Xu/GKxhwoS65wbKy/MhFlI+2ELqV1Rb1wCaIBKB57jYfVArddmNmWUVrFeK3D+RWqUkUZS8YxVH49URigKBgUXMdzxbraRa4VeSl3jhNOpiTsiji5ryDxjDXep8GIq6IeeyB2Ao7g7HFy/CvuqFlO65qXU4j7/MAPl1enzbEuRcej+MXUvhXPeWd41nQ2XC9wx064xYT4VdkXPp/eALu3rr6fP/A3M0JnzPVMBagviEriENhDPnwDb2Lu/axl8/R/N/H4RQsTvdoqYF0eeya4hct7ytLXLK/gpTn5Fw/fQxmj96JGiNsi9StiDjshtP8B+ON8J69g2wnHEVPHt/QtPS++DZ93OCOWuRo+X9Isq8X1iIsinKbPsS5rLru1akKLsEoRSvopPYerhsJ7Y7avKKopI1hV63V+0NGxVZ17NwMoNL0s01XjfZVNZ9snmJBFlI9YP23iwyGESfhVTGpS4APicftgvvhnngpfDs3oimJX+F6+flYB5XmiTVDnxAmUWDM+fAOvovsAydCOHI72j6z1w4N/4XojN+y5OFc8NjkHfZDZItJx85ZX+FedBl8OzZhMZ3Z8P182eaqSfGmHc9rCFG2fEGWM+4CrbRt4E5GtD8wUNwrHkdYmN1miRNE6IHZk4IcGGWr13OYIJ15HWwjroJrL4Cze/Pg2PdWxDt9VKUXUHGZTdeOI6Dud8Y5Fw0B5zRAvvyp2D/398h1BxKKL3AJQFhCmmorHG47La27YEIIhm8FpLY9p7WRroURUVRdhkDn+R+p6lAkbtnFk5mKFl3Hb39KPBKaCHVdZ9M3bgFFwRRgFNwotndhGZ3E5rcjeB4XpMWfUIeXYSfMvjWeBmsAMSo13IGIywDL4axxyA4178N57f/huvn5TCdfC5MfUaCt7VNg8SZh/f4rT5A9MExx/Ew9z3PGzTm23/D9cOH2LdtFYy9z4LppFHgcwsU3dMKv4U05kJ73gDLgItg7D4Azu/ehfPbd+H6eQVMJ58D04lngbfmKbpnShBc4LnAsot+ubH7qWjTqRecG/8L97Yv4f79G5hOGA5T33NgKDg2DQKnFsnaHsGFORRTzyEwdDkZru//A/evn8O9fQ34E4Z7LaQyLruJ6m2GDj2Rc/mDcG3+FK7Nn8GzZxOMPQbD1PdcGDqcoLiDMwRaSOGUvUZyww2QN9QSGuqy6/NKoCi7BKGMmB67WWjlikW6FEVdR9mN4e7JGAOnQUU6WRRZOKMo4lqKssspcdmPgMPjhKFFOS+yFUv5NfC6UHGIFnRRWz5rn2gwgzGHot8YCjoj58JZ8BzaBtePy+DasBSuTR/A0OVkmHoMgrHbqeCsuakUO6MYPP7IoYCyQT+fVwTbebdCqNgD/PoJmn/6BK7Nn8BwzIkw9hgEY/cB4HPyI/7ewrnhiON+gHe/x5wL7oTn4FavYrHhPbg2ttTT8afD2K0/OEsbZYmpBBdWdgoCbVjawDpsEsylY+D6cRncv6+Fe/tq8EXdYTxuEEw9BoFv1zGlcqcKX3koVdABb7Aj68jrYC69AM4fPoJnx2oAgMdg86crrbVM3OrBGUywDLgYppNGwb35M7i2fQnPru/B53fyttkeg8AXdo2qnAa77AYrpKHuuCzAZTfyPqTBiipBEApQsg1Fa4yyq1BRTLZcFCu+Gpxgi+XuqVVFOlmSXXcdz1Yrqa77ZKLschzgYSKMHI+2lnZZZwlvLShSSJctW4YXXngBHo8H11xzDSZOnBh0ftu2bZg7dy6ampowaNAgPPjggzAa1dN1jS0DRg+vXCGVfnvMiTAecyKEmoNwb18Dz+6NcOzbDHA8+KJuMHTsBUPHE2Ao7AoutyhrZtE4MdBCKsT1mBuKu6P4T/fg6K5dcG9fA/euDXB+8y84v3kDfEHnljLrBUNRN3BtS8DxBmmrlCYFLrtyGDufBGPnkyBUH4Rn5zq4//gOjtWLAXDgi7rC0KmPv57yisCl0A2Dcwevv40nL3xeMawjr4PltCvg/u0buHd9D9f3S+H6fim4vGIYOvnKrjv4/E7gjNHdgrWAfz2yf09bpfD5nWAbdSOaB4zHW6/9B53a9QNQ7j0XX0yj6Pex5sFy+hUwD7gY7p3r4fnjO7h++hiuH5eBy8n3t9mS48C3PwacySr91igG13cQIe64QdGqQ77zHYe67FLfSKjNoUOHMGvWLFRVVaFHjx5YuHAh2rQJnrgrLy/HX//6V1RWVoLnedx9990444wzMiRxbDhwYAqeldY42PQFn4mW96QVUkVRV7W5dQrP82CeKAppVi+fSNxCyivYLicwodRG2U3MQup9Lngw0QOT0doq3w/ZQkyt8ejRo1i0aBHef/99mM1mTJgwAaeffjp69uwpXTNr1iw88sgj6N+/P+bMmYMlS5bg6quvVk1IaY2XwQqGusTSaN8ZhjOuAhsyAWLFbnj2/gjhyG9wb10F95YVLReZwOd3Ap9/DPi8InBt2oNvUwCuTXtw1lxwlhzAZE2pMqQWfIubs2i0AGhOyC+SzyuGZfDlMA+6DGLNQXj2/ADh8A64f18H99YvWi4ygG/XCVx+J7ThXaiIw6ooh6GgMwyn/QnmweMhVuyCZ/8WCIe2B9eTyeqtp7xibz3lFYHPLQBnbeutJ2teSz0l9mLy7UvpswgmojFx1lyYS8+HufR8iI1V3rI7tB3Cvp/h+W1ty0UcuLwSGNofA65tCfg27cG1KfD+tbUFLDngzDngMrwon5cspC17cSZStdZ2WO/shUtM/kGzNNuq4liBM1lgPvEsmE88C6KjAcKeH+E5uBXCkd/g2fW9/7rcQvDtjwHfriMKG3cBCMyff+DnE02KCBz4XYglNCyoEUXZJVLEgw8+iKuvvhoXXnghnn/+efzf//0fZs2aFXTNggULMGrUKEycOBG7du3C5MmTsWbNGhgM2gzyoWi/zVbosgv4rUeR8q6m9Sqa4hstYmsmURIhWIvBmJIlloIYy1VZ2brtlrRSrpAqCGomg4d5YOJNEEUBFt4a+weEZompkK5btw5DhgxBfn4+AGDMmDFYvnw5br31VgDAwYMH4XA40L9///9v7+6Do6rvPY6/zz7maSGEPCHFiOJcuIxSp1oIghTmGh6SCMMwI3YaROaiOFoKTi0PtTLDNGBzmaFgU28rjoyKGuoDGS16cXTKtRCR5KposYih4SmQBxIgTyT7cO4fG5YkJCSBhN0TPq+Znc05u3vy/Z7v2fPNL+fsWQDmzp3L5s2bezUgLd2/h+bGri+i4zoX/M7KQOtFR/b/s7LHy+5cHHgmg2cyxm0+3PUncTdU4G6swNVYifvEIRwtn2OYl39e1cQg4IjC74gm4IgOxmRzELA5qHS7afHbWqedmDYHpmFvPURiYBo2MGyYGGBcmg4+ZgC21nujw2GV9n8cd/YYbR4zAVvFP4PrzB4FNPLF4Wpio509XkODys9z/nzbo9EuiJkAt02AW/24G04Hb40VuBsqcJWX4jChIToFgJPVDX1QJw/EToTbJ2Lc5g3+vvpyohpO4WqswlleirO5BMP0X/bKgGEn4Iim1unGZzgxbS4C9tabzYVpd2Ia9tb62DBt9tZpG/6zZ4LLsLsBk4NHa6it7/yzhT3mGAc3j4MRJq6mKtwNp4LrrbECd1U5zuPfYAt4O32p3+4i4IihxhWD13BiXty2bA4ChqPdtGlztG5ftvbblGFr3TZsl7Y9Lt1f2qaMy7az5orjbdaHj4NlNVSf692ZCs0twRoZbQZ2F38+UVXfB9tKV0bD8NEwHBwXaomqP4G7sTL4Pq+twFl+iER/C3WBqOC2QHD/cvGPrrJTwSt1X/xj78vDVZyuaWoX/7HKunbTF597rKJ1fj9lJjcmr9fL/v37yc/PB4I992c/+9llA9L777+fCRMmAJCWlkZzczONjY14PGH8fP4V9GigMwAvTNMzrUePuky9bwYLPTlDLBIvEmN0c3EeE7PdPxUHiu4GlN0NNm1GL772pZ8PMvdmcNyWP+An1hlHwAwQ5ejZdS4kMnU7IK2srCQpKSk0nZyczIEDB7p8PCkpiYqKil4Fkfr9u/jOVV3xOfVmNCkpg4HjvLDjm14tv2digJGtNzAI4DEuMNjWSLytkRijmWibN3hvtBBjtBBttOA0mnDix2H4cRp+HATv3a33dgLB70IKw77Qa9oZNmIYfFbDK/9zqB9+gxu4ufUGYLJk6jgGlf6TkkNVlBy6ck2vTiwwqvUWHD4NMpqItzUQa2sm1mgmznaBOOMC0UYLbsOHy/DhMry4aMJl+HAbPpyGDwcmdgLYjQB2AtgwsRnBHWKLaSd15Ej4vyPs+LQ/vs7FDtzUegMwiTa8xNsaGGxrDMUfY7QQYwtua8F8mnHSiMMItNvunG22t7Z59JWACcNuuRlKjvD27iNXvZwRqYNwu+w0t/gZlhSHJ8ZJ8aEqivtlW+mMAaS03u4guN5b8MS6mZsSvODZfxf+o90rHHYbt/wgHoBXd30XXIoBt9+cABzhs38E93djbk2k8NMjjL41Ef73CJ8dDM4fPmwwSUmROQjoyCpx3shqa2uJi4sLfSymq547ffr00M8vvfQSY8aM6fVgdOjQvrvOQnfb1gWfkwbHGexXGO9E4SEpwXNdB0WR8J5ocHi44L/Q5d8Rht9J8uDBeNyXYr2auOscg/D6vV1+zMDmd5MUP4g4V/9ef6O3sTuafPjq6nF2cfDfadqIc8aRNLh/a3m9t5XoFoPGs7Vd5m2aBh77IJKGdB5XILqRmqYa3J7uz5ro79p3l0tn6lvqiRlk5weDEmnyxeJxe4hxxvRLfH0tEvYrV6M/4+52QBoIBNr9R7Lj6RzdPd4TDfc+ibf5yl/5ETc0kfGD47ll8fiIvVjIkIRYamsaAPC33kJMk+B3RgRab2bo3gjNC7Q+x+zwOmh3KkObx0PHs9r9+yr4c8zgeMYmDGX9ox58/itfnfhKufSUzWaQmhDDv48Yz7lrPaLYR66Uhwn4Wm+XZgYg4Cfa7eT2IXHkPZ4SOroXblfKJQDtrw8b2t7abnNttreO22Lb17RbRnAbc8fEcntKCnlLUmj2Xt36sNttpAyJ5nePpeOOceHC5N/+czznG8L/dT+D49zERDnI7WT/EhftZFCsi/WPTcDnC76PYqKcDPG4eXH1f3C64jzRbgcJg6J4ftl9RLsd/NfjE7nQ4sPltJPkcVFVVReOtHolKcljiTi7Y7MZfTqQCqcPPviA9evXt5uXlpZ2WY+9Us/dunUrBQUFvPbaa73+/WfO1PdJv+3JthUwA0T7hlzxOQYGZ6p715euRaS8Jxz+OKICXZ+O6AIazvq5YAvGerVxO30ebJ2ccdT299TX+miy9d86uZrYfQGI9Q/t0Mw7PslBVUtkxX2t/AF/t3nbDXuXcfn8Dm5OuJmq6u7j7u/a9ySXjpISPVRV19F4LkDAdFLX6KXBCP/7tTuRsl/prWuNu7ve3O2ANDU1leLi4tB0VVUVycnJ7R6vqrp0dKO6urrd4z2RfPMtPW56w4Ze3yuu9kZSkocYe+SdFpKS0Pv/GF1LLnHRTuJ6cXpwf7rWmiQOju7+SddJJGxfifHXvj4GxbpCOzZPjAtPTORc2OlK+5eUIZe/j1KHxmIPXPpnT7Q7uEsdOlifZZFrN3PmTGbOnNluntfrZfz48fj9fux2+2U9ua28vDx2797Ntm3bSE2N7Kt82wwbsc7I7e/h5La7cXd20bU+FuWw5n7LYXPguAG/4sNusxNru/r3jMvuItYVS6Ozdwcs+sPV5NI2djuR+dl46bluz3uZOHEiRUVF1NTU0NTUxK5du7jvvvtCjw8fPhy3201JSQkAhYWF7R4XERGRvuF0Orn77rvZuXMnADt27Oi0527dupV9+/bxxhtvRPxgVEREbmzdDkhTUlJYvnw5CxYsYM6cOWRlZXHnnXeyePFivv76awA2bNjA+vXrmTFjBo2NjSxYsKDfAxcREbkRrVmzhu3btzNr1iyKi4tZtmwZAG+88QabNm3CNE3y8/OpqakhJyeH2bNnM3v27F5f30FEROR66NE5DtnZ2WRnZ7eb9+KLL4Z+Hj16NG+99VbfRiYiIiKXGT58OK+++upl8x966KHQz/v377+eIYmIiFy1yLt+t4iIiIiIiNwQNCAVERERERGRsNCAVERERERERMIiIq6Tbevq254tSLlEnoGSByiXSDRQ8oCBkctAyCFS9OW6tGpdFPf1Z9XYFff1Z9XYb8S4u3utYZrmtX/rtYiIiIiIiEgv6ZRdERERERERCQsNSEVERERERCQsNCAVERERERGRsNCAVERERERERMJCA1IREREREREJCw1IRUREREREJCw0IBUREREREZGw0IBUREREREREwkIDUhEREREREQmLsA5I33vvPWbNmkVGRgbbtm0LZyi9lpOTQ2ZmJrNnz2b27Nl89dVX7N27l+zsbDIyMti4cWO4Q+xWfX09WVlZnDhxAqDL+L/99lvmzp3L9OnT+fWvf43P5wtXyJ3qmMeqVavIyMgI1eajjz4CIj+PP/zhD2RmZpKZmUleXh5g3Zp0lotV67Jp0yZmzZpFZmYmL7/8MmDNunSWh1VrctHvfvc7Vq5cCVizJgOdlXq81Xq6lfu3FXu2VfuzlXuxVXuv1Xtt2PqqGSanT582p06datbW1poNDQ1mdna2efjw4XCF0yuBQMCcNGmS6fV6Q/OamprMKVOmmMeOHTO9Xq+5aNEi829/+1sYo7yyL7/80szKyjLHjh1rHj9+/IrxZ2Zmml988YVpmqa5atUqc9u2bWGMvL2OeZimaWZlZZkVFRWXPTeS89izZ4/54IMPms3NzWZLS4u5YMEC87333rNkTTrLZdeuXZasy759+8z58+ebXq/XbGpqMqdOnWp+++23lqtLZ3mUlpZasiYX7d271xw/fry5YsUKy+6/BjIr9Xir9XQr928r9myr9mcr92Kr9l6r99pw9tWwHSHdu3cvEyZMID4+npiYGKZPn86HH34YrnB65ciRIwAsWrSIBx54gNdee40DBw6QlpbGiBEjcDgcZGdnR3Q+27dvZ82aNSQnJwN0Gf/Jkye5cOECP/zhDwGYO3duROXVMY+mpibKy8tZvXo12dnZbN68mUAgEPF5JCUlsXLlSlwuF06nk9tuu42ysjJL1qSzXMrLyy1Zlx//+Me88sorOBwOzpw5g9/v5/z585arS2d5REVFWbImAGfPnmXjxo0sWbIEsO7+ayCzUo+3Wk+3cv+2Ys+2an+2ci+2au+1cq8Nd18N24C0srKSpKSk0HRycjIVFRXhCqdXzp8/T3p6Ovn5+WzdupU333yT8vJyS+WTm5vL3XffHZruqh4d5yclJUVUXh3zqK6uZsKECaxbt47t27dTXFzMW2+9FfF53H777aE3d1lZGR988AGGYViyJp3lMnnyZEvWBcDpdLJ582YyMzNJT0+37HulYx4+n8+yNXn22WdZvnw5gwYNAqy7/xrIrNTjrdbTrdy/rdizrdqfrd6Lrdp7rdprw91XwzYgDQQCGIYRmjZNs910JLvrrrvIy8vD4/GQkJDAvHnz2Lx5s2Xzga7rYbU6jRgxgvz8fJKTk4mOjiYnJ4fdu3dbJo/Dhw+zaNEifvWrXzFixAhL16RtLrfeequl67J06VKKioo4deoUZWVllq1L2zyKioosWZO//OUvDBs2jPT09NC8gbL/GkistO6t3tOtvP1bqWdbtT9buRdbtfdarddGQl91XPMSrlJqairFxcWh6aqqqtApHJGuuLgYr9cbKpxpmgwfPpyqqqrQc6yUDwTr0Vn8HedXV1dHdF6HDh2irKyM6dOnA8HaOBwOS+RRUlLC0qVLWb16NZmZmXz++eeWrUnHXKxal9LSUlpaWhgzZgzR0dFkZGTw4YcfYrfbQ8+xQl06y2Pnzp3Ex8dbriY7d+6kqqqK2bNnc+7cORobGzl58qTlajLQWanHW72nW7l/W6U3WLU/W7UXW7X3WrXXRkJfDdsR0okTJ1JUVERNTQ1NTU3s2rWL++67L1zh9EpdXR15eXk0NzdTX1/Pu+++y1NPPcW//vUvjh49it/v5/3337dMPgDjxo3rNP7hw4fjdrspKSkBoLCwMKLzMk2TdevWce7cObxeLwUFBdx///0Rn8epU6d44okn2LBhA5mZmYB1a9JZLlaty4kTJ3jmmWdoaWmhpaWFjz/+mPnz51uuLp3lcc8991iyJi+//DLvv/8+hYWFLF26lGnTprFlyxbL1WSgs1KPt3pPt2qvAGv0Bqv2Zyv3Yqv2Xqv22kjoq2E7QpqSksLy5ctZsGABXq+XefPmceedd4YrnF6ZOnUqX331FXPmzCEQCPDTn/6Uu+66i+eee46f//znNDc3M2XKFGbMmBHuUHvM7XZ3Gf+GDRt45plnqK+vZ+zYsSxYsCDM0XZt9OjRPProozz00EP4fD4yMjLIysoCIjuPl156iebmZp577rnQvPnz51uyJl3lYsW6TJkyhQMHDjBnzhzsdjsZGRlkZmaSkJBgqbp0lseTTz7JkCFDLFeTzgyU/ddAYqUeb/WebuXt3wo926r92cq92Kq9dyD12uu9XzFM0zSveSkiIiIiIiIivRS2U3ZFRERERETkxqYBqYiIiIiIiISFBqQiIiIiIiISFhqQioiIiIiISFhoQCoiIiIiIiJhoQGpSARavHgx33//fa9e89hjj/HOO+/0U0QiIiIiIn0vbN9DKiJde/HFF8MdgoiIiIhIv9OAVKQPffLJJ7zwwgt4vV6ioqJYsWIFf//73zl69CinT5+mqqqK0aNHk5ubS1xcHK+//jpvvvkmTqcTt9vN2rVrGTVqFNOmTWPTpk3ccccdFBQU8Oqrr2Kz2UhMTOQ3v/kNI0eOpKKigpUrV1JZWclNN93EmTNnQnGUlpaSm5vL2bNn8fv95OTkMG/ePBoaGli1ahVHjx7FZrMxduxY1q5di82mkyVERERE5PrTgFSkj5SVlbFx40ZeeeUVhgwZwuHDh3nkkUfIzs5m//79vP322yQkJPD000+Tn5/PL3/5S9atW8cnn3xCcnIyO3bsoKSkhFGjRoWWWVRUxJYtWygoKCAhIYF33nmHJ554gr/+9a+sXbuWcePGsWzZMo4ePcqcOXMA8Pl8LF26lLy8PMaOHUtdXR0PPvggo0aNoqysjIaGBgoLC/H7/axZs4bjx4+TlpYWprUmIiIiIjcyDUhF+siePXuorKxk4cKFoXmGYXDs2DFmzJhBYmIiAPPmzWPdunWsWLGCGTNmMH/+fH7yk58wadIkpkyZ0m6Zn376KbNmzSIhIQGAuXPnkpuby4kTJ9i7dy8rVqwAIC0tjfHjxwPBgfGxY8dYvXp1aDkXLlzg4MGDTJ48mY0bN5KTk8PEiRN5+OGHNRgVERERkbDRgFSkjwQCAdLT0/n9738fmnfq1CkKCgpoaWlp97yLp8hu2LCB7777jr179/LnP/+ZwsJCNm3a1O65HZmmic/nwzAMTNMMzXc4gm9nv9+Px+OhsLAw9Fh1dTUejwe3281HH33Evn37+Oyzz3jkkUdYu3Yt06ZN67P1ICIiIiLSU/rgmEgfSU9PZ8+ePZSWlgKwe/duHnjgAZqbm/n444+pq6sjEAiwfft2pk6dSk1NDVOmTCE+Pp6FCxeybNkyvv7663bLnDx5Mjt37qSmpgaAt99+m/j4eNLS0pg8eTIFBQUAlJeXs2/fPgBGjhxJVFRUaEB66tQpsrKy+Oabb3j99ddZtWoVkyZN4umnn2bSpEkcPHjweq0iEREREZF2dIRUpI+MGjWKtWvX8tRTT2GaJg6HgxdeeIGioiISExNZvHgxtbW13HPPPSxZsoSoqCgef/xxFi5cSFRUFHa7nd/+9rftlnnvvfeycOFCHn74YQKBAAkJCfzpT3/CZrOxZs0aVq1axcyZM0lNTWX06NEAuFwu/vjHP5Kbm8uWLVvw+Xz84he/4Ec/+hFjxozh888/Z9asWURHRzNs2DBycnLCsbpERERERDDMtuf8iUife/7556mtreXZZ58NdygiIiIiIhFFp+yKiIiIiIhIWOgIqYiIiIiIiISFjpCKiIiIiIhIWGhAKiIiIiIiImGhAamIiIiIiIiEhQakIiIiIiIiEhYakIqIiIiIiEhYaEAqIiIiIiIiYfH/xKc5aHXnd2MAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfg.explore_type = 'special_ucb'\n", + "\n", + "for env_name, env in env_dict.items():\n", + " print('---'*45)\n", + " print(f'EnvName = {env_name}')\n", + " n_states = env.observation_space.n\n", + " n_actions = env.action_space.n\n", + " print(f'状态数:{n_states}, 动作数:{n_actions}')\n", + " setattr(cfg, 'env_name', env_name)\n", + " setattr(cfg, 'n_states', n_states)\n", + " setattr(cfg, 'n_actions', n_actions)\n", + " cs.print(cfg)\n", + " agent = QLearning(cfg)\n", + " train_res = train(cfg, env, agent) # TODO:这里输出结果用字典表示,方便后面提取数据\n", + " final_play_res = test(cfg, env, agent)\n", + " # summary\n", + " summary_dict['envName'].append(env_name)\n", + " summary_dict['algoName'].append(train_res['algo'])\n", + " summary_dict['exploreType'].append(train_res['explore_type'])\n", + " summary_dict['convEps'].append(train_res['conv_eps'])\n", + " summary_dict['meanReward'].append(final_play_res['meanReward'])\n", + " summary_dict['meanSteps'].append(final_play_res['meanSteps'])\n", + " print('convEps:', summary_dict['convEps'][-1])\n", + " # Plot\n", + " PLOTER = QTablePlot(agent.Q_table, env)\n", + " PLOTER.rewards_plot(train_res['rewards'], title=f'exploreType: {cfg.explore_type} | ')\n", + " PLOTER.Qtable_plot(f'exploreType: {cfg.explore_type} | ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ✨ 6、总结\n", + "\n", + "\n", + "- 📍 在action有限的情况下,一般epsilon_greedy探索策略更加的简单高效, 可以将epsilon_greedy探索策略作为第一选择策略 \n", + "- 📍 在epsilon_greedy探索策略表现不佳的时候,我们可以第一优先使用softmax探索策略 \n", + "\n", + "\n", + "**1- `softmax`探索策略:**\n", + "- 在`FrozenLakeEasy-v0` 环境中难以收敛\n", + " - 训练好的QTable几乎不可用:\n", + " - 在`FrozenLakeEasy-v0`: 进行20轮游戏,每局平均获取奖励0.10,每局行动8.35步\n", + "- 在`theAlley` 进行284轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励4.75,每局行动42.10步。\n", + "- 在`walkInThePark` 进行114轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励10,每局行动17.95步。\n", + "\n", + "**2- `epsilon_greedy`探索策略:**\n", + "- 在`theAlley` 环境中难以收敛且训练的QTable不可用\n", + "- 在`FrozenLakeEasy-v0` 进行156轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励1,每局行动6步。\n", + "- 在`walkInThePark` 进行94轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励10,每局行动15步。\n", + "\n", + "\n", + "**3- `boltzmann`探索策略:**\n", + "- `theAlley` 和 `FrozenLakeEasy-v0` 环境中难以收敛\n", + " - 训练好的QTable有一定的可用性:\n", + " - 在`theAlley` :进行20轮游戏,每局平均获取奖励3.25,每局行动39.05步\n", + " - 在`FrozenLakeEasy-v0` 中几乎不可用\n", + "- 在`walkInThePark` 进行143轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励10,每局行动15.25步。\n", + "\n", + "\n", + "\n", + "**4- `thompson`探索策略:**\n", + "- `theAlley` 和 `FrozenLakeEasy-v0` 环境中难以收敛\n", + " - 训练好的QTable有一定的可用性:\n", + " - 在`theAlley` :进行20轮游戏,每局平均获取奖励6.25,每局行动43.55步\n", + " - 在`FrozenLakeEasy-v0` 中几乎不可用\n", + "- 在`walkInThePark` 进行74轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励10,每局行动16.05步。\n", + "\n", + "**5-`ucb`探索策略:**\n", + "- 在`theAlley`、 `FrozenLakeEasy-v0` 和 `walkInThePark` 环境中均难以收敛\n", + "- 且训练的QTable不可用\n", + "\n", + "\n", + "**5- `special_ucb`探索策略:**\n", + "- 在`theAlley` 环境中难以收敛且训练的QTable不可用\n", + "- 在`FrozenLakeEasy-v0` 进行320轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励1,每局行动6步。\n", + "- 在`walkInThePark` 进行67轮次之后收敛,用训练好的QTable进行20轮游戏,每局平均获取奖励10,每局行动15步。\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
envNamealgoNameexploreTypeconvEpsmeanRewardmeanSteps
8FrozenLakeEasy-v0Q-Learningboltzmann4000.006.20
7walkInTheParkQ-Learningboltzmann14310.0015.25
6theAlleyQ-Learningboltzmann4003.2539.05
3theAlleyQ-Learningepsilon_greedy4000.00500.00
4walkInTheParkQ-Learningepsilon_greedy9410.0015.00
5FrozenLakeEasy-v0Q-Learningepsilon_greedy1561.006.00
0theAlleyQ-Learningsoftmax2844.7542.10
1walkInTheParkQ-Learningsoftmax11410.0017.95
2FrozenLakeEasy-v0Q-Learningsoftmax4000.108.35
16walkInTheParkQ-Learningspecial_ucb6710.0015.00
15theAlleyQ-Learningspecial_ucb4000.00500.00
17FrozenLakeEasy-v0Q-Learningspecial_ucb3201.006.00
9theAlleyQ-Learningthompson4006.2543.55
10walkInTheParkQ-Learningthompson7410.0016.05
11FrozenLakeEasy-v0Q-Learningthompson4000.008.40
12theAlleyQ-Learningucb4000.00500.00
13walkInTheParkQ-Learningucb4000.00500.00
14FrozenLakeEasy-v0Q-Learningucb4000.00500.00
\n", + "
" + ], + "text/plain": [ + " envName algoName exploreType convEps meanReward \\\n", + "8 FrozenLakeEasy-v0 Q-Learning boltzmann 400 0.00 \n", + "7 walkInThePark Q-Learning boltzmann 143 10.00 \n", + "6 theAlley Q-Learning boltzmann 400 3.25 \n", + "3 theAlley Q-Learning epsilon_greedy 400 0.00 \n", + "4 walkInThePark Q-Learning epsilon_greedy 94 10.00 \n", + "5 FrozenLakeEasy-v0 Q-Learning epsilon_greedy 156 1.00 \n", + "0 theAlley Q-Learning softmax 284 4.75 \n", + "1 walkInThePark Q-Learning softmax 114 10.00 \n", + "2 FrozenLakeEasy-v0 Q-Learning softmax 400 0.10 \n", + "16 walkInThePark Q-Learning special_ucb 67 10.00 \n", + "15 theAlley Q-Learning special_ucb 400 0.00 \n", + "17 FrozenLakeEasy-v0 Q-Learning special_ucb 320 1.00 \n", + "9 theAlley Q-Learning thompson 400 6.25 \n", + "10 walkInThePark Q-Learning thompson 74 10.00 \n", + "11 FrozenLakeEasy-v0 Q-Learning thompson 400 0.00 \n", + "12 theAlley Q-Learning ucb 400 0.00 \n", + "13 walkInThePark Q-Learning ucb 400 0.00 \n", + "14 FrozenLakeEasy-v0 Q-Learning ucb 400 0.00 \n", + "\n", + " meanSteps \n", + "8 6.20 \n", + "7 15.25 \n", + "6 39.05 \n", + "3 500.00 \n", + "4 15.00 \n", + "5 6.00 \n", + "0 42.10 \n", + "1 17.95 \n", + "2 8.35 \n", + "16 15.00 \n", + "15 500.00 \n", + "17 6.00 \n", + "9 43.55 \n", + "10 16.05 \n", + "11 8.40 \n", + "12 500.00 \n", + "13 500.00 \n", + "14 500.00 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
envNamealgoNameexploreTypeconvEpsmeanRewardmeanSteps
8FrozenLakeEasy-v0Q-Learningboltzmann4000.006.20
11FrozenLakeEasy-v0Q-Learningthompson4000.008.40
14FrozenLakeEasy-v0Q-Learningucb4000.00500.00
2FrozenLakeEasy-v0Q-Learningsoftmax4000.108.35
5FrozenLakeEasy-v0Q-Learningepsilon_greedy1561.006.00
17FrozenLakeEasy-v0Q-Learningspecial_ucb3201.006.00
3theAlleyQ-Learningepsilon_greedy4000.00500.00
12theAlleyQ-Learningucb4000.00500.00
15theAlleyQ-Learningspecial_ucb4000.00500.00
6theAlleyQ-Learningboltzmann4003.2539.05
0theAlleyQ-Learningsoftmax2844.7542.10
9theAlleyQ-Learningthompson4006.2543.55
13walkInTheParkQ-Learningucb4000.00500.00
1walkInTheParkQ-Learningsoftmax11410.0017.95
4walkInTheParkQ-Learningepsilon_greedy9410.0015.00
7walkInTheParkQ-Learningboltzmann14310.0015.25
10walkInTheParkQ-Learningthompson7410.0016.05
16walkInTheParkQ-Learningspecial_ucb6710.0015.00
\n", + "
" + ], + "text/plain": [ + " envName algoName exploreType convEps meanReward \\\n", + "8 FrozenLakeEasy-v0 Q-Learning boltzmann 400 0.00 \n", + "11 FrozenLakeEasy-v0 Q-Learning thompson 400 0.00 \n", + "14 FrozenLakeEasy-v0 Q-Learning ucb 400 0.00 \n", + "2 FrozenLakeEasy-v0 Q-Learning softmax 400 0.10 \n", + "5 FrozenLakeEasy-v0 Q-Learning epsilon_greedy 156 1.00 \n", + "17 FrozenLakeEasy-v0 Q-Learning special_ucb 320 1.00 \n", + "3 theAlley Q-Learning epsilon_greedy 400 0.00 \n", + "12 theAlley Q-Learning ucb 400 0.00 \n", + "15 theAlley Q-Learning special_ucb 400 0.00 \n", + "6 theAlley Q-Learning boltzmann 400 3.25 \n", + "0 theAlley Q-Learning softmax 284 4.75 \n", + "9 theAlley Q-Learning thompson 400 6.25 \n", + "13 walkInThePark Q-Learning ucb 400 0.00 \n", + "1 walkInThePark Q-Learning softmax 114 10.00 \n", + "4 walkInThePark Q-Learning epsilon_greedy 94 10.00 \n", + "7 walkInThePark Q-Learning boltzmann 143 10.00 \n", + "10 walkInThePark Q-Learning thompson 74 10.00 \n", + "16 walkInThePark Q-Learning special_ucb 67 10.00 \n", + "\n", + " meanSteps \n", + "8 6.20 \n", + "11 8.40 \n", + "14 500.00 \n", + "2 8.35 \n", + "5 6.00 \n", + "17 6.00 \n", + "3 500.00 \n", + "12 500.00 \n", + "15 500.00 \n", + "6 39.05 \n", + "0 42.10 \n", + "9 43.55 \n", + "13 500.00 \n", + "1 17.95 \n", + "4 15.00 \n", + "7 15.25 \n", + "10 16.05 \n", + "16 15.00 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "display(pd.DataFrame(summary_dict).sort_values(by='exploreType'))\n", + "pd.DataFrame(summary_dict).sort_values(by=['envName', 'meanReward'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "vscode": { + "interpreter": { + "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Q-learning/QLearning.ipynb b/notebooks/Q-learning/QLearning.ipynb new file mode 100644 index 0000000..b71900c --- /dev/null +++ b/notebooks/Q-learning/QLearning.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法\n", + "强化学习算法的模式都比较固定,一般包括sample(即训练时采样动作),predict(测试时预测动作),update(算法更新)以及保存模型和加载模型等几个方法,其中对于每种算法samle和update的方式是不相同,而其他方法就大同小异。" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import math\n", + "import torch\n", + "from collections import defaultdict\n", + "\n", + "class QLearning(object):\n", + " def __init__(self,n_states,\n", + " n_actions,cfg):\n", + " self.n_actions = n_actions \n", + " self.lr = cfg.lr # 学习率\n", + " self.gamma = cfg.gamma \n", + " self.epsilon = cfg.epsilon_start\n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.Q_table = defaultdict(lambda: np.zeros(n_actions)) # 用嵌套字典存放状态->动作->状态-动作值(Q值)的映射,即Q表\n", + " def sample_action(self, state):\n", + " ''' 采样动作,训练时用\n", + " '''\n", + " self.sample_count += 1\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) # epsilon是会递减的,这里选择指数递减\n", + " # e-greedy 策略\n", + " if np.random.uniform(0, 1) > self.epsilon:\n", + " action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n", + " else:\n", + " action = np.random.choice(self.n_actions) # 随机选择动作\n", + " return action\n", + " def predict_action(self,state):\n", + " ''' 预测或选择动作,测试时用\n", + " '''\n", + " action = np.argmax(self.Q_table[str(state)])\n", + " return action\n", + " def update(self, state, action, reward, next_state, terminated):\n", + " Q_predict = self.Q_table[str(state)][action] \n", + " if terminated: # 终止状态\n", + " Q_target = reward \n", + " else:\n", + " Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) \n", + " self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练\n", + "强化学习算法的训练方式也比较固定,如下:\n", + "```python\n", + "for i_ep in range(train_eps): # 遍历每个回合\n", + " state = env.reset() # 重置环境,即开始新的回合\n", + " while True: # 对于一些比较复杂的游戏可以设置每回合最大的步长,例如while ep_step<100,就是每回合最大步长为100。\n", + " action = agent.sample(state) # 根据算法采样一个动作\n", + " next_state, reward, terminated, _ = env.step(action) # 与环境进行一次动作交互\n", + " agent.memory.push(state, action, reward, next_state, terminated) # 记录memory\n", + " agent.update(state, action, reward, next_state, terminated) # 算法更新\n", + " state = next_state # 更新状态\n", + " if terminated:\n", + " break\n", + "```\n", + "首先对于每个回合,回合开始时环境需要重置,好比我们每次开一把游戏需要从头再来一样。我们可以设置智能体在每回合数的最大步长,尤其是对于比较复杂的游戏,这样做的好处之一就是帮助智能体在训练中快速收敛,比如我们先验地知道最优解的大概步数,那么理论上智能体收敛时也应该是这个步数附近,设置最大步数可以方便智能体接近这个最优解。在每个回合中,智能体首先需要采样(sample),或者说采用探索策略例如常见的$\\varepsilon$-greedy策略或者UCB探索策略等等。采样的过程是将当前的状态state作为输入,智能体采样输出动作action。然后环境根据采样出来的动作反馈出下一个状态以及相应的reward等信息。接下来对于具有memory的智能体例如包含replay memory的DQN来说,需要将相应的transition(记住这个词,中文不好翻译,通常是状态、动作、奖励等信息)。紧接着就是智能体更新,对于深度强化学习此时一般从memory中随机采样一些transition进行更新,对于Q learning一般是采样上一次的transition。更新公式是比较关键的部分,但是也很通用,一般基于值的算法更新公式都是一个套路如下:\n", + "$$\n", + "y_{j}= \\begin{cases}r_{j} & \\text { for terminal } s_{t+1} \\\\ r_{j}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{t+1}, a^{\\prime} ; \\theta\\right) & \\text { for non-terminal } s_{t+1}\\end{cases}\n", + "$$\n", + "智能体更新完之后,通常需要更新状态,即```state = next_state```,然后会检查是否完成了这一回合的游戏,即```terminated==True```,注意完成并不代表这回合成功,也有可能是失败的太离谱,等同学们有了自定义强化学习环境的经验就知道了(等你长大就知道了XD)。\n", + "如果需要记录奖励、损失等等的话可以再加上,如下方代码,实际项目中更多地使用tensorboard来记录相应的数据,甚至于笔者就在这些教学代码中使用过,但是看起来有些繁琐,容易给大家增加不必要的学习难度,因此学有余力以及需要在项目研究中做强化学习的可以去看看,也很简单。\n", + "此外稍微复杂一些的强化学习不是一次性写完代码就能收敛的,这时需要我们做一个调参侠。为了检查我们参数调得好不好,可以在终端print出奖励、损失以及epsilon等随着回合数的变化,这点说明一下强化学习的训练过程一般都是先探索然后收敛的,官方的话就是权衡exploration and exploitation。e-greedy策略的做法就是前期探索,然后逐渐减小探索率至慢慢收敛,也就是这个epsilon。这个值越大比如0.9就说明智能体90%的概率在随机探索,通常情况下会设置三个值,epsilon_start、epsilon_end以及epsilon_decay,即初始值、终止值和衰减率,其中初始值一般是0.95不变,终止值是0.01,也就是说即使在收敛阶段也让智能体保持很小概率的探索,这样做的原因就是智能体已经学出了一个不错的策略,但是保不齐还有更好的策略,好比我们知道要出人头地学历高比较重要,但是“人还是要有梦想的,万一实现了呢”,总是存在意外的可能,对吧。回归正题,比较关键的是epsilon_decay这个衰减率,这个epsilon衰减太快了学来的策略往往过拟合,好比一条只能选择一朵花的花道上,你早早选择了一朵看起来还可以的花,却错过了后面更多的好花。但是衰减的太慢会影响收敛的速度,好比你走过了花道的尽头也还没选出一朵花来,相比前者不如更甚。当然强化学习的调参相比于深度学习只能说是有过之无不及,比较复杂,不止epsilon这一个,这就需要同学们的耐心学习了。\n", + "强化学习测试的代码跟训练基本上是一样的,因此我放到同一个代码段里。相比于训练代码,测试代码主要有以下几点不同:1、测试模型的过程是不需要更新的,这个是不言而喻的;2、测试代码不需要采样(sample)动作,相比之代替的是预测(sample)动作,其区别就是采样动作时可能会使用各种策略例如$\\varepsilon$-greedy策略,而预测动作不需要,只需要根据训练时学习好的Q表或者网络模型代入状态得到动作即可;3、测试过程终端一般只需要看奖励,不需要看epislon等,反正它在测试中也是无意义的。" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg,env,agent):\n", + " print('开始训练!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录奖励\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录每个回合的奖励\n", + " state = env.reset(seed=cfg.seed) # 重置环境,即开始新的回合\n", + " while True:\n", + " action = agent.sample_action(state) # 根据算法采样一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一次动作交互\n", + " agent.update(state, action, reward, next_state, terminated) # Q学习算法更新\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " if (i_ep+1)%20==0:\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.1f},Epsilon:{agent.epsilon:.3f}\")\n", + " print('完成训练!')\n", + " return {\"rewards\":rewards}\n", + "def test(cfg,env,agent):\n", + " print('开始测试!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录所有回合的奖励\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录每个episode的reward\n", + " state = env.reset(seed=cfg.seed) # 重置环境, 重新开一局(即开始新的一个回合)\n", + " while True:\n", + " action = agent.predict_action(state) # 根据算法选择一个动作\n", + " next_state, reward, terminated, info = env.step(action) # 与环境进行一个交互\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if terminated:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合数:{i_ep+1}/{cfg.test_eps}, 奖励:{ep_reward:.1f}\")\n", + " print('完成测试!')\n", + " return {\"rewards\":rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3、定义环境\n", + "\n", + "OpenAI Gym中其实集成了很多强化学习环境,足够大家学习了,但是在做强化学习的应用中免不了要自己创建环境,比如在本项目中其实不太好找到Qlearning能学出来的环境,Qlearning实在是太弱了,需要足够简单的环境才行,因此本项目写了一个环境,大家感兴趣的话可以看一下,一般环境接口最关键的部分即使reset和step。" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import turtle\n", + "import numpy as np\n", + "\n", + "# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n", + "\n", + "class CliffWalkingWapper(gym.Wrapper):\n", + " def __init__(self, env):\n", + " gym.Wrapper.__init__(self, env)\n", + " self.t = None\n", + " self.unit = 50\n", + " self.max_x = 12\n", + " self.max_y = 4\n", + "\n", + " def draw_x_line(self, y, x0, x1, color='gray'):\n", + " assert x1 > x0\n", + " self.t.color(color)\n", + " self.t.setheading(0)\n", + " self.t.up()\n", + " self.t.goto(x0, y)\n", + " self.t.down()\n", + " self.t.forward(x1 - x0)\n", + "\n", + " def draw_y_line(self, x, y0, y1, color='gray'):\n", + " assert y1 > y0\n", + " self.t.color(color)\n", + " self.t.setheading(90)\n", + " self.t.up()\n", + " self.t.goto(x, y0)\n", + " self.t.down()\n", + " self.t.forward(y1 - y0)\n", + "\n", + " def draw_box(self, x, y, fillcolor='', line_color='gray'):\n", + " self.t.up()\n", + " self.t.goto(x * self.unit, y * self.unit)\n", + " self.t.color(line_color)\n", + " self.t.fillcolor(fillcolor)\n", + " self.t.setheading(90)\n", + " self.t.down()\n", + " self.t.begin_fill()\n", + " for i in range(4):\n", + " self.t.forward(self.unit)\n", + " self.t.right(90)\n", + " self.t.end_fill()\n", + "\n", + " def move_player(self, x, y):\n", + " self.t.up()\n", + " self.t.setheading(90)\n", + " self.t.fillcolor('red')\n", + " self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n", + "\n", + " def render(self):\n", + " if self.t == None:\n", + " self.t = turtle.Turtle()\n", + " self.wn = turtle.Screen()\n", + " self.wn.setup(self.unit * self.max_x + 100,\n", + " self.unit * self.max_y + 100)\n", + " self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n", + " self.unit * self.max_y)\n", + " self.t.shape('circle')\n", + " self.t.width(2)\n", + " self.t.speed(0)\n", + " self.t.color('gray')\n", + " for _ in range(2):\n", + " self.t.forward(self.max_x * self.unit)\n", + " self.t.left(90)\n", + " self.t.forward(self.max_y * self.unit)\n", + " self.t.left(90)\n", + " for i in range(1, self.max_y):\n", + " self.draw_x_line(\n", + " y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n", + " for i in range(1, self.max_x):\n", + " self.draw_y_line(\n", + " x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n", + "\n", + " for i in range(1, self.max_x - 1):\n", + " self.draw_box(i, 0, 'black')\n", + " self.draw_box(self.max_x - 1, 0, 'yellow')\n", + " self.t.shape('turtle')\n", + "\n", + " x_pos = self.s % self.max_x\n", + " y_pos = self.max_y - 1 - int(self.s / self.max_x)\n", + " self.move_player(x_pos, y_pos)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "def env_agent_config(cfg,seed=1):\n", + " '''创建环境和智能体\n", + " ''' \n", + " env = gym.make(cfg.env_name,new_step_api=True) \n", + " env = CliffWalkingWapper(env)\n", + " n_states = env.observation_space.n # 状态维度\n", + " n_actions = env.action_space.n # 动作维度\n", + " agent = QLearning(n_states,n_actions,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数\n", + "\n", + "到这里所有qlearning模块就算完成了,下面需要设置一些参数,方便大家“炼丹”,其中默认的是笔者已经调好的~。另外为了定义了一个画图函数,用来描述奖励的变化。" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config:\n", + " '''配置参数\n", + " '''\n", + " def __init__(self):\n", + " self.env_name = 'CliffWalking-v0' # 环境名称\n", + " self.algo_name = 'Q-Learning' # 算法名称\n", + " self.train_eps = 400 # 训练回合数\n", + " self.test_eps = 20 # 测试回合数\n", + " self.max_steps = 200 # 每个回合最大步数\n", + " self.epsilon_start = 0.95 # e-greedy策略中epsilon的初始值\n", + " self.epsilon_end = 0.01 # e-greedy策略中epsilon的最终值\n", + " self.epsilon_decay = 300 # e-greedy策略中epsilon的衰减率\n", + " self.gamma = 0.9 # 折扣因子\n", + " self.lr = 0.1 # 学习率\n", + " self.seed = 1 # 随机种子\n", + " if torch.cuda.is_available(): # 是否使用GPUs\n", + " self.device = torch.device('cuda')\n", + " else:\n", + " self.device = torch.device('cpu')\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线\n", + " '''\n", + " last = data[0] # First value in the plot (first timestep)\n", + " smoothed = list()\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,title=\"learning curve\"):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{title}\")\n", + " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、我准备好了!\n", + "\n", + "到现在我们真的可以像海绵宝宝那样大声说出来“我准备好了!“,跟着注释来看下效果吧~。" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\gym\\core.py:318: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n", + " \"Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始训练!\n", + "环境:CliffWalking-v0, 算法:Q-Learning, 设备:cuda\n", + "回合:20/400,奖励:-126.0,Epsilon:0.010\n", + "回合:40/400,奖励:-43.0,Epsilon:0.010\n", + "回合:60/400,奖励:-37.0,Epsilon:0.010\n", + "回合:80/400,奖励:-52.0,Epsilon:0.010\n", + "回合:100/400,奖励:-49.0,Epsilon:0.010\n", + "回合:120/400,奖励:-38.0,Epsilon:0.010\n", + "回合:140/400,奖励:-26.0,Epsilon:0.010\n", + "回合:160/400,奖励:-23.0,Epsilon:0.010\n", + "回合:180/400,奖励:-17.0,Epsilon:0.010\n", + "回合:200/400,奖励:-36.0,Epsilon:0.010\n", + "回合:220/400,奖励:-18.0,Epsilon:0.010\n", + "回合:240/400,奖励:-29.0,Epsilon:0.010\n", + "回合:260/400,奖励:-13.0,Epsilon:0.010\n", + "回合:280/400,奖励:-16.0,Epsilon:0.010\n", + "回合:300/400,奖励:-13.0,Epsilon:0.010\n", + "回合:320/400,奖励:-14.0,Epsilon:0.010\n", + "回合:340/400,奖励:-13.0,Epsilon:0.010\n", + "回合:360/400,奖励:-13.0,Epsilon:0.010\n", + "回合:380/400,奖励:-13.0,Epsilon:0.010\n", + "回合:400/400,奖励:-13.0,Epsilon:0.010\n", + "完成训练!\n", + "开始测试!\n", + "环境:CliffWalking-v0, 算法:Q-Learning, 设备:cuda\n", + "回合数:1/20, 奖励:-13.0\n", + "回合数:2/20, 奖励:-13.0\n", + "回合数:3/20, 奖励:-13.0\n", + "回合数:4/20, 奖励:-13.0\n", + "回合数:5/20, 奖励:-13.0\n", + "回合数:6/20, 奖励:-13.0\n", + "回合数:7/20, 奖励:-13.0\n", + "回合数:8/20, 奖励:-13.0\n", + "回合数:9/20, 奖励:-13.0\n", + "回合数:10/20, 奖励:-13.0\n", + "回合数:11/20, 奖励:-13.0\n", + "回合数:12/20, 奖励:-13.0\n", + "回合数:13/20, 奖励:-13.0\n", + "回合数:14/20, 奖励:-13.0\n", + "回合数:15/20, 奖励:-13.0\n", + "回合数:16/20, 奖励:-13.0\n", + "回合数:17/20, 奖励:-13.0\n", + "回合数:18/20, 奖励:-13.0\n", + "回合数:19/20, 奖励:-13.0\n", + "回合数:20/20, 奖励:-13.0\n", + "完成测试!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\seaborn\\rcmod.py:400: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n", + " if LooseVersion(mpl.__version__) >= \"3.0\":\n", + "c:\\Users\\24438\\anaconda3\\envs\\easyrl\\lib\\site-packages\\setuptools\\_distutils\\version.py:346: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n", + " other = LooseVersion(other)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.13 ('gsc': conda)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "216dab6b21526179d387c06b08cb2654f2959273fc1353fb08296303e34d0db1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..7e68db5 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,23 @@ +# 蘑菇书附书代码 + +## 安装说明 + +目前支持Python 3.7和Gym 0.25.2版本。 + +创建Conda环境(需先安装Anaconda) +```bash +conda create -n joyrl python=3.7 +conda activate joyrl +pip install -r requirements.txt +``` + +安装Torch: + +```bash +# CPU +conda install pytorch==1.10.0 torchvision==0.11.0 torchaudio==0.10.0 cpuonly -c pytorch +# GPU +conda install pytorch==1.10.0 torchvision==0.11.0 torchaudio==0.10.0 cudatoolkit=11.3 -c pytorch -c conda-forge +# GPU镜像安装 +pip install torch==1.10.0+cu113 torchvision==0.11.0+cu113 torchaudio==0.10.0 --extra-index-url https://download.pytorch.org/whl/cu113 +``` diff --git a/notebooks/Sarsa.ipynb b/notebooks/Sarsa.ipynb new file mode 100644 index 0000000..740cf10 --- /dev/null +++ b/notebooks/Sarsa.ipynb @@ -0,0 +1,896 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1、定义算法\n", + "\n", + "在阅读该教程之前,请先阅读Q learning教程。Sarsa算法跟Q learning算法基本模式相同,但是根本的区别在于,Sarsa是先做出动作然后拿这个做的动作去更新,而Q learning是假定下一步最大奖励对应的动作拿去更新,然后再使用$\\varepsilon$-greedy策略,也就是说Sarsa是on-policy的,而Q learning是off-policy的。如下方代码所示,只有在更新的地方Sarsa与Q learning有着细微的区别。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from collections import defaultdict\n", + "import torch\n", + "import math\n", + "class Sarsa(object):\n", + " def __init__(self,\n", + " n_actions,cfg):\n", + " self.n_actions = n_actions \n", + " self.lr = cfg.lr \n", + " self.gamma = cfg.gamma \n", + " self.sample_count = 0 \n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay \n", + " self.Q = defaultdict(lambda: np.zeros(n_actions)) # Q table\n", + " def sample(self, state):\n", + " self.sample_count += 1\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) # The probability to select a random action, is is log decayed\n", + " best_action = np.argmax(self.Q[state])\n", + " action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions\n", + " action_probs[best_action] += (1.0 - self.epsilon)\n", + " action = np.random.choice(np.arange(len(action_probs)), p=action_probs) \n", + " return action\n", + " def predict(self,state):\n", + " return np.argmax(self.Q[state])\n", + " def update(self, state, action, reward, next_state, next_action,done):\n", + " Q_predict = self.Q[state][action]\n", + " if done:\n", + " Q_target = reward # 终止状态\n", + " else:\n", + " Q_target = reward + self.gamma * self.Q[next_state][next_action] # 与Q learning不同,Sarsa是拿下一步动作对应的Q值去更新\n", + " self.Q[state][action] += self.lr * (Q_target - Q_predict) \n", + " def save(self,path):\n", + " '''把 Q表格 的数据保存到文件中\n", + " '''\n", + " import dill\n", + " torch.save(\n", + " obj=self.Q,\n", + " f=path+\"sarsa_model.pkl\",\n", + " pickle_module=dill\n", + " )\n", + " def load(self, path):\n", + " '''从文件中读取数据到 Q表格\n", + " '''\n", + " import dill\n", + " self.Q =torch.load(f=path+'sarsa_model.pkl',pickle_module=dill)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、定义训练\n", + "\n", + "同样地,跟Q learning差别也不大" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg,env,agent):\n", + " print('开始训练!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录奖励\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录每个回合的奖励\n", + " state = env.reset() # 重置环境,即开始新的回合\n", + " action = agent.sample(state)\n", + " while True:\n", + " action = agent.sample(state) # 根据算法采样一个动作\n", + " next_state, reward, done, _ = env.step(action) # 与环境进行一次动作交互\n", + " next_action = agent.sample(next_state)\n", + " agent.update(state, action, reward, next_state, next_action,done) # 算法更新\n", + " state = next_state # 更新状态\n", + " action = next_action\n", + " ep_reward += reward\n", + " if done:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合:{i_ep+1}/{cfg.train_eps},奖励:{ep_reward:.1f},Epsilon:{agent.epsilon}\")\n", + " print('完成训练!')\n", + " return {\"rewards\":rewards}\n", + " \n", + "def test(cfg,env,agent):\n", + " print('开始测试!')\n", + " print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n", + " rewards = [] # 记录所有回合的奖励\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录每个episode的reward\n", + " state = env.reset() # 重置环境, 重新开一局(即开始新的一个回合)\n", + " while True:\n", + " action = agent.predict(state) # 根据算法选择一个动作\n", + " next_state, reward, done, _ = env.step(action) # 与环境进行一个交互\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if done:\n", + " break\n", + " rewards.append(ep_reward)\n", + " print(f\"回合数:{i_ep+1}/{cfg.test_eps}, 奖励:{ep_reward:.1f}\")\n", + " print('完成测试!')\n", + " return {\"rewards\":rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3、定义环境\n", + "为了具体看看Q learning和Sarsa的不同,笔者决定跟Q learning使用相同的环境\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import turtle\n", + "import numpy as np\n", + "\n", + "# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n", + "\n", + "def GridWorld(gridmap=None, is_slippery=False):\n", + " if gridmap is None:\n", + " gridmap = ['SFFF', 'FHFH', 'FFFH', 'HFFG']\n", + " env = gym.make(\"FrozenLake-v0\", desc=gridmap, is_slippery=False)\n", + " env = FrozenLakeWapper(env)\n", + " return env\n", + "\n", + "\n", + "class FrozenLakeWapper(gym.Wrapper):\n", + " def __init__(self, env):\n", + " gym.Wrapper.__init__(self, env)\n", + " self.max_y = env.desc.shape[0]\n", + " self.max_x = env.desc.shape[1]\n", + " self.t = None\n", + " self.unit = 50\n", + "\n", + " def draw_box(self, x, y, fillcolor='', line_color='gray'):\n", + " self.t.up()\n", + " self.t.goto(x * self.unit, y * self.unit)\n", + " self.t.color(line_color)\n", + " self.t.fillcolor(fillcolor)\n", + " self.t.setheading(90)\n", + " self.t.down()\n", + " self.t.begin_fill()\n", + " for _ in range(4):\n", + " self.t.forward(self.unit)\n", + " self.t.right(90)\n", + " self.t.end_fill()\n", + "\n", + " def move_player(self, x, y):\n", + " self.t.up()\n", + " self.t.setheading(90)\n", + " self.t.fillcolor('red')\n", + " self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n", + "\n", + " def render(self):\n", + " if self.t == None:\n", + " self.t = turtle.Turtle()\n", + " self.wn = turtle.Screen()\n", + " self.wn.setup(self.unit * self.max_x + 100,\n", + " self.unit * self.max_y + 100)\n", + " self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n", + " self.unit * self.max_y)\n", + " self.t.shape('circle')\n", + " self.t.width(2)\n", + " self.t.speed(0)\n", + " self.t.color('gray')\n", + " for i in range(self.desc.shape[0]):\n", + " for j in range(self.desc.shape[1]):\n", + " x = j\n", + " y = self.max_y - 1 - i\n", + " if self.desc[i][j] == b'S': # Start\n", + " self.draw_box(x, y, 'white')\n", + " elif self.desc[i][j] == b'F': # Frozen ice\n", + " self.draw_box(x, y, 'white')\n", + " elif self.desc[i][j] == b'G': # Goal\n", + " self.draw_box(x, y, 'yellow')\n", + " elif self.desc[i][j] == b'H': # Hole\n", + " self.draw_box(x, y, 'black')\n", + " else:\n", + " self.draw_box(x, y, 'white')\n", + " self.t.shape('turtle')\n", + "\n", + " x_pos = self.s % self.max_x\n", + " y_pos = self.max_y - 1 - int(self.s / self.max_x)\n", + " self.move_player(x_pos, y_pos)\n", + "\n", + "\n", + "class CliffWalkingWapper(gym.Wrapper):\n", + " def __init__(self, env):\n", + " gym.Wrapper.__init__(self, env)\n", + " self.t = None\n", + " self.unit = 50\n", + " self.max_x = 12\n", + " self.max_y = 4\n", + "\n", + " def draw_x_line(self, y, x0, x1, color='gray'):\n", + " assert x1 > x0\n", + " self.t.color(color)\n", + " self.t.setheading(0)\n", + " self.t.up()\n", + " self.t.goto(x0, y)\n", + " self.t.down()\n", + " self.t.forward(x1 - x0)\n", + "\n", + " def draw_y_line(self, x, y0, y1, color='gray'):\n", + " assert y1 > y0\n", + " self.t.color(color)\n", + " self.t.setheading(90)\n", + " self.t.up()\n", + " self.t.goto(x, y0)\n", + " self.t.down()\n", + " self.t.forward(y1 - y0)\n", + "\n", + " def draw_box(self, x, y, fillcolor='', line_color='gray'):\n", + " self.t.up()\n", + " self.t.goto(x * self.unit, y * self.unit)\n", + " self.t.color(line_color)\n", + " self.t.fillcolor(fillcolor)\n", + " self.t.setheading(90)\n", + " self.t.down()\n", + " self.t.begin_fill()\n", + " for i in range(4):\n", + " self.t.forward(self.unit)\n", + " self.t.right(90)\n", + " self.t.end_fill()\n", + "\n", + " def move_player(self, x, y):\n", + " self.t.up()\n", + " self.t.setheading(90)\n", + " self.t.fillcolor('red')\n", + " self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n", + "\n", + " def render(self):\n", + " if self.t == None:\n", + " self.t = turtle.Turtle()\n", + " self.wn = turtle.Screen()\n", + " self.wn.setup(self.unit * self.max_x + 100,\n", + " self.unit * self.max_y + 100)\n", + " self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n", + " self.unit * self.max_y)\n", + " self.t.shape('circle')\n", + " self.t.width(2)\n", + " self.t.speed(0)\n", + " self.t.color('gray')\n", + " for _ in range(2):\n", + " self.t.forward(self.max_x * self.unit)\n", + " self.t.left(90)\n", + " self.t.forward(self.max_y * self.unit)\n", + " self.t.left(90)\n", + " for i in range(1, self.max_y):\n", + " self.draw_x_line(\n", + " y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n", + " for i in range(1, self.max_x):\n", + " self.draw_y_line(\n", + " x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n", + "\n", + " for i in range(1, self.max_x - 1):\n", + " self.draw_box(i, 0, 'black')\n", + " self.draw_box(self.max_x - 1, 0, 'yellow')\n", + " self.t.shape('turtle')\n", + "\n", + " x_pos = self.s % self.max_x\n", + " y_pos = self.max_y - 1 - int(self.s / self.max_x)\n", + " self.move_player(x_pos, y_pos)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def env_agent_config(cfg,seed=1):\n", + " '''创建环境和智能体\n", + " Args:\n", + " cfg ([type]): [description]\n", + " seed (int, optional): 随机种子. Defaults to 1.\n", + " Returns:\n", + " env [type]: 环境\n", + " agent : 智能体\n", + " ''' \n", + " env = gym.make(cfg.env_name) \n", + " env = CliffWalkingWapper(env)\n", + " env.seed(seed) # 设置随机种子\n", + " n_states = env.observation_space.n # 状态维度\n", + " n_actions = env.action_space.n # 动作维度\n", + " print(f\"状态数:{n_states},动作数:{n_actions}\")\n", + " agent = Sarsa(n_actions,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数\n", + "同样的参数也是一样" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "def get_args():\n", + " \"\"\" \n", + " \"\"\"\n", + " curr_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\") # 获取当前时间\n", + " parser = argparse.ArgumentParser(description=\"hyperparameters\") \n", + " parser.add_argument('--algo_name',default='Sarsa',type=str,help=\"name of algorithm\")\n", + " parser.add_argument('--env_name',default='CliffWalking-v0',type=str,help=\"name of environment\")\n", + " parser.add_argument('--train_eps',default=400,type=int,help=\"episodes of training\") # 训练的回合数\n", + " parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\") # 测试的回合数\n", + " parser.add_argument('--gamma',default=0.90,type=float,help=\"discounted factor\") # 折扣因子\n", + " parser.add_argument('--epsilon_start',default=0.95,type=float,help=\"initial value of epsilon\") # e-greedy策略中初始epsilon\n", + " parser.add_argument('--epsilon_end',default=0.01,type=float,help=\"final value of epsilon\") # e-greedy策略中的终止epsilon\n", + " parser.add_argument('--epsilon_decay',default=300,type=int,help=\"decay rate of epsilon\") # e-greedy策略中epsilon的衰减率\n", + " parser.add_argument('--lr',default=0.1,type=float,help=\"learning rate\")\n", + " parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\") \n", + " args = parser.parse_args([]) \n", + " return args\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线,类似于Tensorboard中的smooth\n", + "\n", + " Args:\n", + " data (List):输入数据\n", + " weight (Float): 平滑权重,处于0-1之间,数值越高说明越平滑,一般取0.9\n", + "\n", + " Returns:\n", + " smoothed (List): 平滑后的数据\n", + " '''\n", + " last = data[0] # First value in the plot (first timestep)\n", + " smoothed = list()\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例,方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练\n", + "训练结果会发现,Sarsa收敛速度更快,但收敛值会比Q-learning低" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态数:48,动作数:4\n", + "开始训练!\n", + "环境:CliffWalking-v0, 算法:Sarsa, 设备:cpu\n", + "回合:1/400,奖励:-1524.0,Epsilon:0.2029722781251147\n", + "回合:2/400,奖励:-1294.0,Epsilon:0.011808588201828951\n", + "回合:3/400,奖励:-192.0,Epsilon:0.01050118158853445\n", + "回合:4/400,奖励:-346.0,Epsilon:0.010049747911736582\n", + "回合:5/400,奖励:-252.0,Epsilon:0.010009240861841986\n", + "回合:6/400,奖励:-168.0,Epsilon:0.010003005072880926\n", + "回合:7/400,奖励:-393.0,Epsilon:0.01000042188120369\n", + "回合:8/400,奖励:-169.0,Epsilon:0.010000136281659052\n", + "回合:9/400,奖励:-97.0,Epsilon:0.010000071145264558\n", + "回合:10/400,奖励:-134.0,Epsilon:0.010000029022085234\n", + "回合:11/400,奖励:-124.0,Epsilon:0.010000012655059554\n", + "回合:12/400,奖励:-74.0,Epsilon:0.010000007701309915\n", + "回合:13/400,奖励:-135.0,Epsilon:0.010000003120699265\n", + "回合:14/400,奖励:-84.0,Epsilon:0.010000001776639691\n", + "回合:15/400,奖励:-101.0,Epsilon:0.010000000903081117\n", + "回合:16/400,奖励:-111.0,Epsilon:0.010000000429438717\n", + "回合:17/400,奖励:-114.0,Epsilon:0.010000000200165738\n", + "回合:18/400,奖励:-114.0,Epsilon:0.010000000093299278\n", + "回合:19/400,奖励:-82.0,Epsilon:0.010000000053829002\n", + "回合:20/400,奖励:-85.0,Epsilon:0.01000000003044167\n", + "回合:21/400,奖励:-108.0,Epsilon:0.010000000014768242\n", + "回合:22/400,奖励:-66.0,Epsilon:0.010000000009479634\n", + "回合:23/400,奖励:-74.0,Epsilon:0.010000000005768887\n", + "回合:24/400,奖励:-114.0,Epsilon:0.010000000002688936\n", + "回合:25/400,奖励:-98.0,Epsilon:0.010000000001394421\n", + "回合:26/400,奖励:-94.0,Epsilon:0.010000000000742658\n", + "回合:27/400,奖励:-58.0,Epsilon:0.010000000000502822\n", + "回合:28/400,奖励:-100.0,Epsilon:0.010000000000257298\n", + "回合:29/400,奖励:-208.0,Epsilon:0.010000000000123995\n", + "回合:30/400,奖励:-184.0,Epsilon:0.010000000000070121\n", + "回合:31/400,奖励:-62.0,Epsilon:0.010000000000046227\n", + "回合:32/400,奖励:-117.0,Epsilon:0.01000000000002112\n", + "回合:33/400,奖励:-47.0,Epsilon:0.010000000000015387\n", + "回合:34/400,奖励:-54.0,Epsilon:0.0100000000000107\n", + "回合:35/400,奖励:-120.0,Epsilon:0.010000000000004792\n", + "回合:36/400,奖励:-75.0,Epsilon:0.010000000000002897\n", + "回合:37/400,奖励:-62.0,Epsilon:0.01000000000000191\n", + "回合:38/400,奖励:-70.0,Epsilon:0.010000000000001194\n", + "回合:39/400,奖励:-67.0,Epsilon:0.010000000000000762\n", + "回合:40/400,奖励:-87.0,Epsilon:0.010000000000000425\n", + "回合:41/400,奖励:-92.0,Epsilon:0.01000000000000023\n", + "回合:42/400,奖励:-79.0,Epsilon:0.010000000000000136\n", + "回合:43/400,奖励:-49.0,Epsilon:0.010000000000000097\n", + "回合:44/400,奖励:-103.0,Epsilon:0.010000000000000049\n", + "回合:45/400,奖励:-40.0,Epsilon:0.010000000000000037\n", + "回合:46/400,奖励:-214.0,Epsilon:0.010000000000000018\n", + "回合:47/400,奖励:-83.0,Epsilon:0.01000000000000001\n", + "回合:48/400,奖励:-62.0,Epsilon:0.010000000000000007\n", + "回合:49/400,奖励:-37.0,Epsilon:0.010000000000000005\n", + "回合:50/400,奖励:-73.0,Epsilon:0.010000000000000004\n", + "回合:51/400,奖励:-66.0,Epsilon:0.010000000000000002\n", + "回合:52/400,奖励:-48.0,Epsilon:0.010000000000000002\n", + "回合:53/400,奖励:-96.0,Epsilon:0.01\n", + "回合:54/400,奖励:-189.0,Epsilon:0.01\n", + "回合:55/400,奖励:-42.0,Epsilon:0.01\n", + "回合:56/400,奖励:-46.0,Epsilon:0.01\n", + "回合:57/400,奖励:-85.0,Epsilon:0.01\n", + "回合:58/400,奖励:-52.0,Epsilon:0.01\n", + "回合:59/400,奖励:-86.0,Epsilon:0.01\n", + "回合:60/400,奖励:-41.0,Epsilon:0.01\n", + "回合:61/400,奖励:-51.0,Epsilon:0.01\n", + "回合:62/400,奖励:-59.0,Epsilon:0.01\n", + "回合:63/400,奖励:-145.0,Epsilon:0.01\n", + "回合:64/400,奖励:-76.0,Epsilon:0.01\n", + "回合:65/400,奖励:-43.0,Epsilon:0.01\n", + "回合:66/400,奖励:-49.0,Epsilon:0.01\n", + "回合:67/400,奖励:-36.0,Epsilon:0.01\n", + "回合:68/400,奖励:-41.0,Epsilon:0.01\n", + "回合:69/400,奖励:-69.0,Epsilon:0.01\n", + "回合:70/400,奖励:-38.0,Epsilon:0.01\n", + "回合:71/400,奖励:-63.0,Epsilon:0.01\n", + "回合:72/400,奖励:-46.0,Epsilon:0.01\n", + "回合:73/400,奖励:-30.0,Epsilon:0.01\n", + "回合:74/400,奖励:-45.0,Epsilon:0.01\n", + "回合:75/400,奖励:-38.0,Epsilon:0.01\n", + "回合:76/400,奖励:-88.0,Epsilon:0.01\n", + "回合:77/400,奖励:-19.0,Epsilon:0.01\n", + "回合:78/400,奖励:-40.0,Epsilon:0.01\n", + "回合:79/400,奖励:-62.0,Epsilon:0.01\n", + "回合:80/400,奖励:-25.0,Epsilon:0.01\n", + "回合:81/400,奖励:-54.0,Epsilon:0.01\n", + "回合:82/400,奖励:-41.0,Epsilon:0.01\n", + "回合:83/400,奖励:-57.0,Epsilon:0.01\n", + "回合:84/400,奖励:-52.0,Epsilon:0.01\n", + "回合:85/400,奖励:-42.0,Epsilon:0.01\n", + "回合:86/400,奖励:-51.0,Epsilon:0.01\n", + "回合:87/400,奖励:-53.0,Epsilon:0.01\n", + "回合:88/400,奖励:-42.0,Epsilon:0.01\n", + "回合:89/400,奖励:-53.0,Epsilon:0.01\n", + "回合:90/400,奖励:-31.0,Epsilon:0.01\n", + "回合:91/400,奖励:-75.0,Epsilon:0.01\n", + "回合:92/400,奖励:-148.0,Epsilon:0.01\n", + "回合:93/400,奖励:-41.0,Epsilon:0.01\n", + "回合:94/400,奖励:-47.0,Epsilon:0.01\n", + "回合:95/400,奖励:-184.0,Epsilon:0.01\n", + "回合:96/400,奖励:-34.0,Epsilon:0.01\n", + "回合:97/400,奖励:-45.0,Epsilon:0.01\n", + "回合:98/400,奖励:-52.0,Epsilon:0.01\n", + "回合:99/400,奖励:-44.0,Epsilon:0.01\n", + "回合:100/400,奖励:-49.0,Epsilon:0.01\n", + "回合:101/400,奖励:-30.0,Epsilon:0.01\n", + "回合:102/400,奖励:-49.0,Epsilon:0.01\n", + "回合:103/400,奖励:-23.0,Epsilon:0.01\n", + "回合:104/400,奖励:-37.0,Epsilon:0.01\n", + "回合:105/400,奖励:-37.0,Epsilon:0.01\n", + "回合:106/400,奖励:-44.0,Epsilon:0.01\n", + "回合:107/400,奖励:-40.0,Epsilon:0.01\n", + "回合:108/400,奖励:-28.0,Epsilon:0.01\n", + "回合:109/400,奖励:-50.0,Epsilon:0.01\n", + "回合:110/400,奖励:-46.0,Epsilon:0.01\n", + "回合:111/400,奖励:-28.0,Epsilon:0.01\n", + "回合:112/400,奖励:-35.0,Epsilon:0.01\n", + "回合:113/400,奖励:-35.0,Epsilon:0.01\n", + "回合:114/400,奖励:-45.0,Epsilon:0.01\n", + "回合:115/400,奖励:-38.0,Epsilon:0.01\n", + "回合:116/400,奖励:-39.0,Epsilon:0.01\n", + "回合:117/400,奖励:-27.0,Epsilon:0.01\n", + "回合:118/400,奖励:-49.0,Epsilon:0.01\n", + "回合:119/400,奖励:-27.0,Epsilon:0.01\n", + "回合:120/400,奖励:-25.0,Epsilon:0.01\n", + "回合:121/400,奖励:-50.0,Epsilon:0.01\n", + "回合:122/400,奖励:-41.0,Epsilon:0.01\n", + "回合:123/400,奖励:-22.0,Epsilon:0.01\n", + "回合:124/400,奖励:-38.0,Epsilon:0.01\n", + "回合:125/400,奖励:-125.0,Epsilon:0.01\n", + "回合:126/400,奖励:-25.0,Epsilon:0.01\n", + "回合:127/400,奖励:-40.0,Epsilon:0.01\n", + "回合:128/400,奖励:-33.0,Epsilon:0.01\n", + "回合:129/400,奖励:-56.0,Epsilon:0.01\n", + "回合:130/400,奖励:-32.0,Epsilon:0.01\n", + "回合:131/400,奖励:-21.0,Epsilon:0.01\n", + "回合:132/400,奖励:-33.0,Epsilon:0.01\n", + "回合:133/400,奖励:-23.0,Epsilon:0.01\n", + "回合:134/400,奖励:-33.0,Epsilon:0.01\n", + "回合:135/400,奖励:-34.0,Epsilon:0.01\n", + "回合:136/400,奖励:-33.0,Epsilon:0.01\n", + "回合:137/400,奖励:-21.0,Epsilon:0.01\n", + "回合:138/400,奖励:-40.0,Epsilon:0.01\n", + "回合:139/400,奖励:-23.0,Epsilon:0.01\n", + "回合:140/400,奖励:-31.0,Epsilon:0.01\n", + "回合:141/400,奖励:-31.0,Epsilon:0.01\n", + "回合:142/400,奖励:-26.0,Epsilon:0.01\n", + "回合:143/400,奖励:-26.0,Epsilon:0.01\n", + "回合:144/400,奖励:-32.0,Epsilon:0.01\n", + "回合:145/400,奖励:-27.0,Epsilon:0.01\n", + "回合:146/400,奖励:-33.0,Epsilon:0.01\n", + "回合:147/400,奖励:-35.0,Epsilon:0.01\n", + "回合:148/400,奖励:-21.0,Epsilon:0.01\n", + "回合:149/400,奖励:-23.0,Epsilon:0.01\n", + "回合:150/400,奖励:-33.0,Epsilon:0.01\n", + "回合:151/400,奖励:-25.0,Epsilon:0.01\n", + "回合:152/400,奖励:-41.0,Epsilon:0.01\n", + "回合:153/400,奖励:-31.0,Epsilon:0.01\n", + "回合:154/400,奖励:-28.0,Epsilon:0.01\n", + "回合:155/400,奖励:-133.0,Epsilon:0.01\n", + "回合:156/400,奖励:-22.0,Epsilon:0.01\n", + "回合:157/400,奖励:-21.0,Epsilon:0.01\n", + "回合:158/400,奖励:-33.0,Epsilon:0.01\n", + "回合:159/400,奖励:-33.0,Epsilon:0.01\n", + "回合:160/400,奖励:-24.0,Epsilon:0.01\n", + "回合:161/400,奖励:-34.0,Epsilon:0.01\n", + "回合:162/400,奖励:-20.0,Epsilon:0.01\n", + "回合:163/400,奖励:-21.0,Epsilon:0.01\n", + "回合:164/400,奖励:-126.0,Epsilon:0.01\n", + "回合:165/400,奖励:-36.0,Epsilon:0.01\n", + "回合:166/400,奖励:-18.0,Epsilon:0.01\n", + "回合:167/400,奖励:-35.0,Epsilon:0.01\n", + "回合:168/400,奖励:-26.0,Epsilon:0.01\n", + "回合:169/400,奖励:-24.0,Epsilon:0.01\n", + "回合:170/400,奖励:-33.0,Epsilon:0.01\n", + "回合:171/400,奖励:-17.0,Epsilon:0.01\n", + "回合:172/400,奖励:-23.0,Epsilon:0.01\n", + "回合:173/400,奖励:-26.0,Epsilon:0.01\n", + "回合:174/400,奖励:-23.0,Epsilon:0.01\n", + "回合:175/400,奖励:-21.0,Epsilon:0.01\n", + "回合:176/400,奖励:-35.0,Epsilon:0.01\n", + "回合:177/400,奖励:-26.0,Epsilon:0.01\n", + "回合:178/400,奖励:-17.0,Epsilon:0.01\n", + "回合:179/400,奖励:-20.0,Epsilon:0.01\n", + "回合:180/400,奖励:-28.0,Epsilon:0.01\n", + "回合:181/400,奖励:-34.0,Epsilon:0.01\n", + "回合:182/400,奖励:-27.0,Epsilon:0.01\n", + "回合:183/400,奖励:-22.0,Epsilon:0.01\n", + "回合:184/400,奖励:-24.0,Epsilon:0.01\n", + "回合:185/400,奖励:-26.0,Epsilon:0.01\n", + "回合:186/400,奖励:-20.0,Epsilon:0.01\n", + "回合:187/400,奖励:-30.0,Epsilon:0.01\n", + "回合:188/400,奖励:-28.0,Epsilon:0.01\n", + "回合:189/400,奖励:-15.0,Epsilon:0.01\n", + "回合:190/400,奖励:-30.0,Epsilon:0.01\n", + "回合:191/400,奖励:-29.0,Epsilon:0.01\n", + "回合:192/400,奖励:-22.0,Epsilon:0.01\n", + "回合:193/400,奖励:-25.0,Epsilon:0.01\n", + "回合:194/400,奖励:-21.0,Epsilon:0.01\n", + "回合:195/400,奖励:-19.0,Epsilon:0.01\n", + "回合:196/400,奖励:-23.0,Epsilon:0.01\n", + "回合:197/400,奖励:-21.0,Epsilon:0.01\n", + "回合:198/400,奖励:-32.0,Epsilon:0.01\n", + "回合:199/400,奖励:-30.0,Epsilon:0.01\n", + "回合:200/400,奖励:-22.0,Epsilon:0.01\n", + "回合:201/400,奖励:-20.0,Epsilon:0.01\n", + "回合:202/400,奖励:-27.0,Epsilon:0.01\n", + "回合:203/400,奖励:-21.0,Epsilon:0.01\n", + "回合:204/400,奖励:-26.0,Epsilon:0.01\n", + "回合:205/400,奖励:-19.0,Epsilon:0.01\n", + "回合:206/400,奖励:-17.0,Epsilon:0.01\n", + "回合:207/400,奖励:-31.0,Epsilon:0.01\n", + "回合:208/400,奖励:-18.0,Epsilon:0.01\n", + "回合:209/400,奖励:-24.0,Epsilon:0.01\n", + "回合:210/400,奖励:-17.0,Epsilon:0.01\n", + "回合:211/400,奖励:-26.0,Epsilon:0.01\n", + "回合:212/400,奖励:-27.0,Epsilon:0.01\n", + "回合:213/400,奖励:-33.0,Epsilon:0.01\n", + "回合:214/400,奖励:-16.0,Epsilon:0.01\n", + "回合:215/400,奖励:-32.0,Epsilon:0.01\n", + "回合:216/400,奖励:-19.0,Epsilon:0.01\n", + "回合:217/400,奖励:-20.0,Epsilon:0.01\n", + "回合:218/400,奖励:-15.0,Epsilon:0.01\n", + "回合:219/400,奖励:-119.0,Epsilon:0.01\n", + "回合:220/400,奖励:-26.0,Epsilon:0.01\n", + "回合:221/400,奖励:-26.0,Epsilon:0.01\n", + "回合:222/400,奖励:-22.0,Epsilon:0.01\n", + "回合:223/400,奖励:-22.0,Epsilon:0.01\n", + "回合:224/400,奖励:-15.0,Epsilon:0.01\n", + "回合:225/400,奖励:-24.0,Epsilon:0.01\n", + "回合:226/400,奖励:-15.0,Epsilon:0.01\n", + "回合:227/400,奖励:-31.0,Epsilon:0.01\n", + "回合:228/400,奖励:-24.0,Epsilon:0.01\n", + "回合:229/400,奖励:-20.0,Epsilon:0.01\n", + "回合:230/400,奖励:-20.0,Epsilon:0.01\n", + "回合:231/400,奖励:-22.0,Epsilon:0.01\n", + "回合:232/400,奖励:-15.0,Epsilon:0.01\n", + "回合:233/400,奖励:-19.0,Epsilon:0.01\n", + "回合:234/400,奖励:-21.0,Epsilon:0.01\n", + "回合:235/400,奖励:-27.0,Epsilon:0.01\n", + "回合:236/400,奖励:-15.0,Epsilon:0.01\n", + "回合:237/400,奖励:-25.0,Epsilon:0.01\n", + "回合:238/400,奖励:-22.0,Epsilon:0.01\n", + "回合:239/400,奖励:-16.0,Epsilon:0.01\n", + "回合:240/400,奖励:-18.0,Epsilon:0.01\n", + "回合:241/400,奖励:-13.0,Epsilon:0.01\n", + "回合:242/400,奖励:-13.0,Epsilon:0.01\n", + "回合:243/400,奖励:-13.0,Epsilon:0.01\n", + "回合:244/400,奖励:-23.0,Epsilon:0.01\n", + "回合:245/400,奖励:-29.0,Epsilon:0.01\n", + "回合:246/400,奖励:-26.0,Epsilon:0.01\n", + "回合:247/400,奖励:-19.0,Epsilon:0.01\n", + "回合:248/400,奖励:-21.0,Epsilon:0.01\n", + "回合:249/400,奖励:-17.0,Epsilon:0.01\n", + "回合:250/400,奖励:-17.0,Epsilon:0.01\n", + "回合:251/400,奖励:-15.0,Epsilon:0.01\n", + "回合:252/400,奖励:-20.0,Epsilon:0.01\n", + "回合:253/400,奖励:-23.0,Epsilon:0.01\n", + "回合:254/400,奖励:-19.0,Epsilon:0.01\n", + "回合:255/400,奖励:-21.0,Epsilon:0.01\n", + "回合:256/400,奖励:-19.0,Epsilon:0.01\n", + "回合:257/400,奖励:-17.0,Epsilon:0.01\n", + "回合:258/400,奖励:-17.0,Epsilon:0.01\n", + "回合:259/400,奖励:-15.0,Epsilon:0.01\n", + "回合:260/400,奖励:-21.0,Epsilon:0.01\n", + "回合:261/400,奖励:-17.0,Epsilon:0.01\n", + "回合:262/400,奖励:-19.0,Epsilon:0.01\n", + "回合:263/400,奖励:-19.0,Epsilon:0.01\n", + "回合:264/400,奖励:-15.0,Epsilon:0.01\n", + "回合:265/400,奖励:-19.0,Epsilon:0.01\n", + "回合:266/400,奖励:-17.0,Epsilon:0.01\n", + "回合:267/400,奖励:-15.0,Epsilon:0.01\n", + "回合:268/400,奖励:-19.0,Epsilon:0.01\n", + "回合:269/400,奖励:-27.0,Epsilon:0.01\n", + "回合:270/400,奖励:-15.0,Epsilon:0.01\n", + "回合:271/400,奖励:-17.0,Epsilon:0.01\n", + "回合:272/400,奖励:-17.0,Epsilon:0.01\n", + "回合:273/400,奖励:-25.0,Epsilon:0.01\n", + "回合:274/400,奖励:-19.0,Epsilon:0.01\n", + "回合:275/400,奖励:-22.0,Epsilon:0.01\n", + "回合:276/400,奖励:-23.0,Epsilon:0.01\n", + "回合:277/400,奖励:-18.0,Epsilon:0.01\n", + "回合:278/400,奖励:-23.0,Epsilon:0.01\n", + "回合:279/400,奖励:-21.0,Epsilon:0.01\n", + "回合:280/400,奖励:-21.0,Epsilon:0.01\n", + "回合:281/400,奖励:-21.0,Epsilon:0.01\n", + "回合:282/400,奖励:-19.0,Epsilon:0.01\n", + "回合:283/400,奖励:-18.0,Epsilon:0.01\n", + "回合:284/400,奖励:-15.0,Epsilon:0.01\n", + "回合:285/400,奖励:-19.0,Epsilon:0.01\n", + "回合:286/400,奖励:-19.0,Epsilon:0.01\n", + "回合:287/400,奖励:-21.0,Epsilon:0.01\n", + "回合:288/400,奖励:-15.0,Epsilon:0.01\n", + "回合:289/400,奖励:-32.0,Epsilon:0.01\n", + "回合:290/400,奖励:-18.0,Epsilon:0.01\n", + "回合:291/400,奖励:-17.0,Epsilon:0.01\n", + "回合:292/400,奖励:-15.0,Epsilon:0.01\n", + "回合:293/400,奖励:-24.0,Epsilon:0.01\n", + "回合:294/400,奖励:-22.0,Epsilon:0.01\n", + "回合:295/400,奖励:-31.0,Epsilon:0.01\n", + "回合:296/400,奖励:-17.0,Epsilon:0.01\n", + "回合:297/400,奖励:-19.0,Epsilon:0.01\n", + "回合:298/400,奖励:-19.0,Epsilon:0.01\n", + "回合:299/400,奖励:-20.0,Epsilon:0.01\n", + "回合:300/400,奖励:-21.0,Epsilon:0.01\n", + "回合:301/400,奖励:-26.0,Epsilon:0.01\n", + "回合:302/400,奖励:-20.0,Epsilon:0.01\n", + "回合:303/400,奖励:-16.0,Epsilon:0.01\n", + "回合:304/400,奖励:-20.0,Epsilon:0.01\n", + "回合:305/400,奖励:-21.0,Epsilon:0.01\n", + "回合:306/400,奖励:-16.0,Epsilon:0.01\n", + "回合:307/400,奖励:-19.0,Epsilon:0.01\n", + "回合:308/400,奖励:-24.0,Epsilon:0.01\n", + "回合:309/400,奖励:-20.0,Epsilon:0.01\n", + "回合:310/400,奖励:-17.0,Epsilon:0.01\n", + "回合:311/400,奖励:-16.0,Epsilon:0.01\n", + "回合:312/400,奖励:-25.0,Epsilon:0.01\n", + "回合:313/400,奖励:-16.0,Epsilon:0.01\n", + "回合:314/400,奖励:-19.0,Epsilon:0.01\n", + "回合:315/400,奖励:-19.0,Epsilon:0.01\n", + "回合:316/400,奖励:-27.0,Epsilon:0.01\n", + "回合:317/400,奖励:-15.0,Epsilon:0.01\n", + "回合:318/400,奖励:-15.0,Epsilon:0.01\n", + "回合:319/400,奖励:-15.0,Epsilon:0.01\n", + "回合:320/400,奖励:-19.0,Epsilon:0.01\n", + "回合:321/400,奖励:-23.0,Epsilon:0.01\n", + "回合:322/400,奖励:-24.0,Epsilon:0.01\n", + "回合:323/400,奖励:-15.0,Epsilon:0.01\n", + "回合:324/400,奖励:-20.0,Epsilon:0.01\n", + "回合:325/400,奖励:-18.0,Epsilon:0.01\n", + "回合:326/400,奖励:-19.0,Epsilon:0.01\n", + "回合:327/400,奖励:-19.0,Epsilon:0.01\n", + "回合:328/400,奖励:-26.0,Epsilon:0.01\n", + "回合:329/400,奖励:-16.0,Epsilon:0.01\n", + "回合:330/400,奖励:-18.0,Epsilon:0.01\n", + "回合:331/400,奖励:-15.0,Epsilon:0.01\n", + "回合:332/400,奖励:-15.0,Epsilon:0.01\n", + "回合:333/400,奖励:-17.0,Epsilon:0.01\n", + "回合:334/400,奖励:-17.0,Epsilon:0.01\n", + "回合:335/400,奖励:-16.0,Epsilon:0.01\n", + "回合:336/400,奖励:-24.0,Epsilon:0.01\n", + "回合:337/400,奖励:-15.0,Epsilon:0.01\n", + "回合:338/400,奖励:-18.0,Epsilon:0.01\n", + "回合:339/400,奖励:-16.0,Epsilon:0.01\n", + "回合:340/400,奖励:-15.0,Epsilon:0.01\n", + "回合:341/400,奖励:-18.0,Epsilon:0.01\n", + "回合:342/400,奖励:-15.0,Epsilon:0.01\n", + "回合:343/400,奖励:-20.0,Epsilon:0.01\n", + "回合:344/400,奖励:-18.0,Epsilon:0.01\n", + "回合:345/400,奖励:-17.0,Epsilon:0.01\n", + "回合:346/400,奖励:-19.0,Epsilon:0.01\n", + "回合:347/400,奖励:-15.0,Epsilon:0.01\n", + "回合:348/400,奖励:-15.0,Epsilon:0.01\n", + "回合:349/400,奖励:-15.0,Epsilon:0.01\n", + "回合:350/400,奖励:-18.0,Epsilon:0.01\n", + "回合:351/400,奖励:-16.0,Epsilon:0.01\n", + "回合:352/400,奖励:-16.0,Epsilon:0.01\n", + "回合:353/400,奖励:-15.0,Epsilon:0.01\n", + "回合:354/400,奖励:-20.0,Epsilon:0.01\n", + "回合:355/400,奖励:-15.0,Epsilon:0.01\n", + "回合:356/400,奖励:-17.0,Epsilon:0.01\n", + "回合:357/400,奖励:-15.0,Epsilon:0.01\n", + "回合:358/400,奖励:-17.0,Epsilon:0.01\n", + "回合:359/400,奖励:-15.0,Epsilon:0.01\n", + "回合:360/400,奖励:-16.0,Epsilon:0.01\n", + "回合:361/400,奖励:-15.0,Epsilon:0.01\n", + "回合:362/400,奖励:-18.0,Epsilon:0.01\n", + "回合:363/400,奖励:-17.0,Epsilon:0.01\n", + "回合:364/400,奖励:-22.0,Epsilon:0.01\n", + "回合:365/400,奖励:-15.0,Epsilon:0.01\n", + "回合:366/400,奖励:-15.0,Epsilon:0.01\n", + "回合:367/400,奖励:-15.0,Epsilon:0.01\n", + "回合:368/400,奖励:-16.0,Epsilon:0.01\n", + "回合:369/400,奖励:-16.0,Epsilon:0.01\n", + "回合:370/400,奖励:-15.0,Epsilon:0.01\n", + "回合:371/400,奖励:-20.0,Epsilon:0.01\n", + "回合:372/400,奖励:-15.0,Epsilon:0.01\n", + "回合:373/400,奖励:-15.0,Epsilon:0.01\n", + "回合:374/400,奖励:-15.0,Epsilon:0.01\n", + "回合:375/400,奖励:-16.0,Epsilon:0.01\n", + "回合:376/400,奖励:-15.0,Epsilon:0.01\n", + "回合:377/400,奖励:-15.0,Epsilon:0.01\n", + "回合:378/400,奖励:-17.0,Epsilon:0.01\n", + "回合:379/400,奖励:-20.0,Epsilon:0.01\n", + "回合:380/400,奖励:-17.0,Epsilon:0.01\n", + "回合:381/400,奖励:-15.0,Epsilon:0.01\n", + "回合:382/400,奖励:-15.0,Epsilon:0.01\n", + "回合:383/400,奖励:-15.0,Epsilon:0.01\n", + "回合:384/400,奖励:-15.0,Epsilon:0.01\n", + "回合:385/400,奖励:-16.0,Epsilon:0.01\n", + "回合:386/400,奖励:-15.0,Epsilon:0.01\n", + "回合:387/400,奖励:-18.0,Epsilon:0.01\n", + "回合:388/400,奖励:-15.0,Epsilon:0.01\n", + "回合:389/400,奖励:-15.0,Epsilon:0.01\n", + "回合:390/400,奖励:-15.0,Epsilon:0.01\n", + "回合:391/400,奖励:-16.0,Epsilon:0.01\n", + "回合:392/400,奖励:-18.0,Epsilon:0.01\n", + "回合:393/400,奖励:-15.0,Epsilon:0.01\n", + "回合:394/400,奖励:-15.0,Epsilon:0.01\n", + "回合:395/400,奖励:-15.0,Epsilon:0.01\n", + "回合:396/400,奖励:-20.0,Epsilon:0.01\n", + "回合:397/400,奖励:-15.0,Epsilon:0.01\n", + "回合:398/400,奖励:-15.0,Epsilon:0.01\n", + "回合:399/400,奖励:-15.0,Epsilon:0.01\n", + "回合:400/400,奖励:-15.0,Epsilon:0.01\n", + "完成训练!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试!\n", + "环境:CliffWalking-v0, 算法:Sarsa, 设备:cpu\n", + "回合数:1/20, 奖励:-15.0\n", + "回合数:2/20, 奖励:-15.0\n", + "回合数:3/20, 奖励:-15.0\n", + "回合数:4/20, 奖励:-15.0\n", + "回合数:5/20, 奖励:-15.0\n", + "回合数:6/20, 奖励:-15.0\n", + "回合数:7/20, 奖励:-15.0\n", + "回合数:8/20, 奖励:-15.0\n", + "回合数:9/20, 奖励:-15.0\n", + "回合数:10/20, 奖励:-15.0\n", + "回合数:11/20, 奖励:-15.0\n", + "回合数:12/20, 奖励:-15.0\n", + "回合数:13/20, 奖励:-15.0\n", + "回合数:14/20, 奖励:-15.0\n", + "回合数:15/20, 奖励:-15.0\n", + "回合数:16/20, 奖励:-15.0\n", + "回合数:17/20, 奖励:-15.0\n", + "回合数:18/20, 奖励:-15.0\n", + "回合数:19/20, 奖励:-15.0\n", + "回合数:20/20, 奖励:-15.0\n", + "完成测试!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = get_args() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.12 ('rl_tutorials')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "4f613f1ab80ec98dc1b91d6e720de51301598a187317378e53e49b773c1123dd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Value Iteration/README.md b/notebooks/Value Iteration/README.md new file mode 100644 index 0000000..e69de29 diff --git a/notebooks/Value Iteration/value_iteration.ipynb b/notebooks/Value Iteration/value_iteration.ipynb new file mode 100644 index 0000000..188fa2e --- /dev/null +++ b/notebooks/Value Iteration/value_iteration.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 值迭代算法\n", + "作者:stzhao\n", + "github: https://github.com/zhaoshitian" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 一、定义环境\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sys,os\n", + "curr_path = os.path.abspath('')\n", + "parent_path = os.path.dirname(curr_path)\n", + "sys.path.append(parent_path)\n", + "from envs.simple_grid import DrunkenWalkEnv" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "def all_seed(env,seed = 1):\n", + " ## 这个函数主要是为了固定随机种子\n", + " import numpy as np\n", + " import random\n", + " import os\n", + " env.seed(seed) \n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " os.environ['PYTHONHASHSEED'] = str(seed) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "env = DrunkenWalkEnv(map_name=\"theAlley\")\n", + "all_seed(env, seed = 1) # 设置随机种子为1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 二、价值迭代算法\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def value_iteration(env, theta=0.005, discount_factor=0.9):\n", + " Q = np.zeros((env.nS, env.nA)) # 初始化一个Q表格\n", + " count = 0\n", + " while True:\n", + " delta = 0.0\n", + " Q_tmp = np.zeros((env.nS, env.nA))\n", + " for state in range(env.nS):\n", + " for a in range(env.nA):\n", + " accum = 0.0\n", + " reward_total = 0.0\n", + " for prob, next_state, reward, done in env.P[state][a]:\n", + " accum += prob* np.max(Q[next_state, :])\n", + " reward_total += prob * reward\n", + " Q_tmp[state, a] = reward_total + discount_factor * accum\n", + " delta = max(delta, abs(Q_tmp[state, a] - Q[state, a]))\n", + " Q = Q_tmp\n", + " \n", + " count += 1\n", + " if delta < theta or count > 100: # 这里设置了即使算法没有收敛,跑100次也退出循环\n", + " break \n", + " return Q" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2.25015697e+22 2.53142659e+22 4.50031394e+22 2.53142659e+22]\n", + " [2.81269621e+22 5.41444021e+22 1.01257064e+23 5.41444021e+22]\n", + " [6.32856648e+22 1.21824905e+23 2.27828393e+23 1.21824905e+23]\n", + " [1.42392746e+23 2.74106036e+23 5.12613885e+23 2.74106036e+23]\n", + " [3.20383678e+23 5.76690620e+23 1.15338124e+24 5.76690620e+23]\n", + " [7.20863276e+23 1.38766181e+24 2.59510779e+24 1.38766181e+24]\n", + " [1.62194237e+24 3.12223906e+24 5.83899253e+24 3.12223906e+24]\n", + " [3.64937033e+24 7.02503789e+24 1.31377332e+25 7.02503789e+24]\n", + " [8.21108325e+24 1.47799498e+25 2.95598997e+25 1.47799498e+25]\n", + " [1.84749373e+25 3.55642543e+25 6.65097743e+25 3.55642543e+25]\n", + " [4.15686089e+25 8.00195722e+25 1.49646992e+26 8.00195722e+25]\n", + " [9.35293701e+25 1.80044037e+26 3.36705732e+26 1.80044037e+26]\n", + " [5.89235032e+26 7.36543790e+26 7.57587898e+26 7.36543790e+26]]\n" + ] + } + ], + "source": [ + "Q = value_iteration(env)\n", + "print(Q)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]\n" + ] + } + ], + "source": [ + "policy = np.zeros([env.nS, env.nA]) # 初始化一个策略表格\n", + "for state in range(env.nS):\n", + " best_action = np.argmax(Q[state, :]) #根据价值迭代算法得到的Q表格选择出策略\n", + " policy[state, best_action] = 1\n", + "\n", + "policy = [int(np.argwhere(policy[i]==1)) for i in range(env.nS) ]\n", + "print(policy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 三、测试" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "num_episode = 1000 # 测试1000次\n", + "def test(env,policy):\n", + " \n", + " rewards = [] # 记录所有回合的奖励\n", + " success = [] # 记录该回合是否成功走到终点\n", + " for i_ep in range(num_episode):\n", + " ep_reward = 0 # 记录每个episode的reward\n", + " state = env.reset() # 重置环境, 重新开一局(即开始新的一个回合) 这里state=0\n", + " while True:\n", + " action = policy[state] # 根据算法选择一个动作\n", + " next_state, reward, done, _ = env.step(action) # 与环境进行一个交互\n", + " state = next_state # 更新状态\n", + " ep_reward += reward\n", + " if done:\n", + " break\n", + " if state==12: # 即走到终点\n", + " success.append(1)\n", + " else:\n", + " success.append(0)\n", + " rewards.append(ep_reward)\n", + " acc_suc = np.array(success).sum()/num_episode\n", + " print(\"测试的成功率是:\", acc_suc)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "测试的成功率是: 0.64\n" + ] + } + ], + "source": [ + "test(env, policy)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('RL')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "88a829278351aa402b7d6303191a511008218041c5cfdb889d81328a3ea60fbc" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/common/multiprocessing_env.py b/notebooks/common/multiprocessing_env.py new file mode 100644 index 0000000..28c8aba --- /dev/null +++ b/notebooks/common/multiprocessing_env.py @@ -0,0 +1,153 @@ +# 该代码来自 openai baseline,用于多线程环境 +# https://github.com/openai/baselines/tree/master/baselines/common/vec_env + +import numpy as np +from multiprocessing import Process, Pipe + +def worker(remote, parent_remote, env_fn_wrapper): + parent_remote.close() + env = env_fn_wrapper.x() + while True: + cmd, data = remote.recv() + if cmd == 'step': + ob, reward, done, info = env.step(data) + if done: + ob = env.reset() + remote.send((ob, reward, done, info)) + elif cmd == 'reset': + ob = env.reset() + remote.send(ob) + elif cmd == 'reset_task': + ob = env.reset_task() + remote.send(ob) + elif cmd == 'close': + remote.close() + break + elif cmd == 'get_spaces': + remote.send((env.observation_space, env.action_space)) + else: + raise NotImplementedError + +class VecEnv(object): + """ + An abstract asynchronous, vectorized environment. + """ + def __init__(self, num_envs, observation_space, action_space): + self.num_envs = num_envs + self.observation_space = observation_space + self.action_space = action_space + + def reset(self): + """ + Reset all the environments and return an array of + observations, or a tuple of observation arrays. + If step_async is still doing work, that work will + be cancelled and step_wait() should not be called + until step_async() is invoked again. + """ + pass + + def step_async(self, actions): + """ + Tell all the environments to start taking a step + with the given actions. + Call step_wait() to get the results of the step. + You should not call this if a step_async run is + already pending. + """ + pass + + def step_wait(self): + """ + Wait for the step taken with step_async(). + Returns (obs, rews, dones, infos): + - obs: an array of observations, or a tuple of + arrays of observations. + - rews: an array of rewards + - dones: an array of "episode done" booleans + - infos: a sequence of info objects + """ + pass + + def close(self): + """ + Clean up the environments' resources. + """ + pass + + def step(self, actions): + self.step_async(actions) + return self.step_wait() + + +class CloudpickleWrapper(object): + """ + Uses cloudpickle to serialize contents (otherwise multiprocessing tries to use pickle) + """ + def __init__(self, x): + self.x = x + def __getstate__(self): + import cloudpickle + return cloudpickle.dumps(self.x) + def __setstate__(self, ob): + import pickle + self.x = pickle.loads(ob) + + +class SubprocVecEnv(VecEnv): + def __init__(self, env_fns, spaces=None): + """ + envs: list of gym environments to run in subprocesses + """ + self.waiting = False + self.closed = False + nenvs = len(env_fns) + self.nenvs = nenvs + self.remotes, self.work_remotes = zip(*[Pipe() for _ in range(nenvs)]) + self.ps = [Process(target=worker, args=(work_remote, remote, CloudpickleWrapper(env_fn))) + for (work_remote, remote, env_fn) in zip(self.work_remotes, self.remotes, env_fns)] + for p in self.ps: + p.daemon = True # if the main process crashes, we should not cause things to hang + p.start() + for remote in self.work_remotes: + remote.close() + + self.remotes[0].send(('get_spaces', None)) + observation_space, action_space = self.remotes[0].recv() + VecEnv.__init__(self, len(env_fns), observation_space, action_space) + + def step_async(self, actions): + for remote, action in zip(self.remotes, actions): + remote.send(('step', action)) + self.waiting = True + + def step_wait(self): + results = [remote.recv() for remote in self.remotes] + self.waiting = False + obs, rews, dones, infos = zip(*results) + return np.stack(obs), np.stack(rews), np.stack(dones), infos + + def reset(self): + for remote in self.remotes: + remote.send(('reset', None)) + return np.stack([remote.recv() for remote in self.remotes]) + + def reset_task(self): + for remote in self.remotes: + remote.send(('reset_task', None)) + return np.stack([remote.recv() for remote in self.remotes]) + + def close(self): + if self.closed: + return + if self.waiting: + for remote in self.remotes: + remote.recv() + for remote in self.remotes: + remote.send(('close', None)) + for p in self.ps: + p.join() + self.closed = True + + def __len__(self): + return self.nenvs \ No newline at end of file diff --git a/notebooks/envs/racetrack.py b/notebooks/envs/racetrack.py new file mode 100644 index 0000000..87f1669 --- /dev/null +++ b/notebooks/envs/racetrack.py @@ -0,0 +1,243 @@ +import time +import random +import numpy as np +import os +import matplotlib.pyplot as plt +import matplotlib.patheffects as pe +from IPython.display import clear_output +from gym.spaces import Discrete,Box +from gym import Env +from matplotlib import colors + +class RacetrackEnv(Env) : + """ + Class representing a race-track environment inspired by exercise 5.12 in Sutton & Barto 2018 (p.111). + Please do not make changes to this class - it will be overwritten with a clean version when it comes to marking. + + The dynamics of this environment are detailed in this coursework exercise's jupyter notebook, although I have + included rather verbose comments here for those of you who are interested in how the environment has been + implemented (though this should not impact your solution code).ss + """ + + ACTIONS_DICT = { + 0 : (1, -1), # Acc Vert., Brake Horiz. + 1 : (1, 0), # Acc Vert., Hold Horiz. + 2 : (1, 1), # Acc Vert., Acc Horiz. + 3 : (0, -1), # Hold Vert., Brake Horiz. + 4 : (0, 0), # Hold Vert., Hold Horiz. + 5 : (0, 1), # Hold Vert., Acc Horiz. + 6 : (-1, -1), # Brake Vert., Brake Horiz. + 7 : (-1, 0), # Brake Vert., Hold Horiz. + 8 : (-1, 1) # Brake Vert., Acc Horiz. + } + + + CELL_TYPES_DICT = { + 0 : "track", + 1 : "wall", + 2 : "start", + 3 : "goal" + } + metadata = {'render_modes': ['human'], + "render_fps": 4,} + + def __init__(self,render_mode = 'human') : + # Load racetrack map from file. + self.track = np.flip(np.loadtxt(os.path.dirname(__file__)+"/track.txt", dtype = int), axis = 0) + + + # Discover start grid squares. + self.initial_states = [] + for y in range(self.track.shape[0]) : + for x in range(self.track.shape[1]) : + if (self.CELL_TYPES_DICT[self.track[y, x]] == "start") : + self.initial_states.append((y, x)) + high= np.array([np.finfo(np.float32).max, np.finfo(np.float32).max, np.finfo(np.float32).max, np.finfo(np.float32).max]) + self.observation_space = Box(low=-high, high=high, shape=(4,), dtype=np.float32) + self.action_space = Discrete(9) + self.is_reset = False + + def step(self, action : int) : + """ + Takes a given action in the environment's current state, and returns a next state, + reward, and whether the next state is done or not. + + Arguments: + action {int} -- The action to take in the environment's current state. Should be an integer in the range [0-8]. + + Raises: + RuntimeError: Raised when the environment needs resetting.\n + TypeError: Raised when an action of an invalid type is given.\n + ValueError: Raised when an action outside the range [0-8] is given.\n + + Returns: + A tuple of:\n + {(int, int, int, int)} -- The next state, a tuple of (y_pos, x_pos, y_velocity, x_velocity).\n + {int} -- The reward earned by taking the given action in the current environment state.\n + {bool} -- Whether the environment's next state is done or not.\n + + """ + + # Check whether a reset is needed. + if (not self.is_reset) : + raise RuntimeError(".step() has been called when .reset() is needed.\n" + + "You need to call .reset() before using .step() for the first time, and after an episode ends.\n" + + ".reset() initialises the environment at the start of an episode, then returns an initial state.") + + # Check that action is the correct type (either a python integer or a numpy integer). + if (not (isinstance(action, int) or isinstance(action, np.integer))) : + raise TypeError("action should be an integer.\n" + + "action value {} of type {} was supplied.".format(action, type(action))) + + # Check that action is an allowed value. + if (action < 0 or action > 8) : + raise ValueError("action must be an integer in the range [0-8] corresponding to one of the legal actions.\n" + + "action value {} was supplied.".format(action)) + + + # Update Velocity. + # With probability, 0.85 update velocity components as intended. + if (np.random.uniform() < 0.8) : + (d_y, d_x) = self.ACTIONS_DICT[action] + # With probability, 0.15 Do not change velocity components. + else : + (d_y, d_x) = (0, 0) + + self.velocity = (self.velocity[0] + d_y, self.velocity[1] + d_x) + + # Keep velocity within bounds (-10, 10). + if (self.velocity[0] > 10) : + self.velocity[0] = 10 + elif (self.velocity[0] < -10) : + self.velocity[0] = -10 + if (self.velocity[1] > 10) : + self.velocity[1] = 10 + elif (self.velocity[1] < -10) : + self.velocity[1] = -10 + + # Update Position. + new_position = (self.position[0] + self.velocity[0], self.position[1] + self.velocity[1]) + + reward = 0 + done = False + + # If position is out-of-bounds, return to start and set velocity components to zero. + if (new_position[0] < 0 or new_position[1] < 0 or new_position[0] >= self.track.shape[0] or new_position[1] >= self.track.shape[1]) : + self.position = random.choice(self.initial_states) + self.velocity = (0, 0) + reward -= 10 + # If position is in a wall grid-square, return to start and set velocity components to zero. + elif (self.CELL_TYPES_DICT[self.track[new_position]] == "wall") : + self.position = random.choice(self.initial_states) + self.velocity = (0, 0) + reward -= 10 + # If position is in a track grid-squre or a start-square, update position. + elif (self.CELL_TYPES_DICT[self.track[new_position]] in ["track", "start"]) : + self.position = new_position + # If position is in a goal grid-square, end episode. + elif (self.CELL_TYPES_DICT[self.track[new_position]] == "goal") : + self.position = new_position + reward += 10 + done = True + # If this gets reached, then the student has touched something they shouldn't have. Naughty! + else : + raise RuntimeError("You've met with a terrible fate, haven't you?\nDon't modify things you shouldn't!") + + # Penalise every timestep. + reward -= 1 + + # Require a reset if the current state is done. + if (done) : + self.is_reset = False + + # Return next state, reward, and whether the episode has ended. + return np.array([self.position[0], self.position[1], self.velocity[0], self.velocity[1]]), reward, done,{} + + + def reset(self,seed=None) : + """ + Resets the environment, ready for a new episode to begin, then returns an initial state. + The initial state will be a starting grid square randomly chosen using a uniform distribution, + with both components of the velocity being zero. + + Returns: + {(int, int, int, int)} -- an initial state, a tuple of (y_pos, x_pos, y_velocity, x_velocity). + """ + + # Pick random starting grid-square. + self.position = random.choice(self.initial_states) + + # Set both velocity components to zero. + self.velocity = (0, 0) + + self.is_reset = True + + return np.array([self.position[0], self.position[1], self.velocity[0], self.velocity[1]]) + + + def render(self, render_mode = 'human') : + """ + Renders a pretty matplotlib plot representing the current state of the environment. + Calling this method on subsequent timesteps will update the plot. + This is VERY VERY SLOW and wil slow down training a lot. Only use for debugging/testing. + + Arguments: + sleep_time {float} -- How many seconds (or partial seconds) you want to wait on this rendered frame. + + """ + # Turn interactive render_mode on. + plt.ion() + fig = plt.figure(num = "env_render") + ax = plt.gca() + ax.clear() + clear_output(wait = True) + + # Prepare the environment plot and mark the car's position. + env_plot = np.copy(self.track) + env_plot[self.position] = 4 + env_plot = np.flip(env_plot, axis = 0) + + # Plot the gridworld. + cmap = colors.ListedColormap(["white", "black", "green", "red", "yellow"]) + bounds = list(range(6)) + norm = colors.BoundaryNorm(bounds, cmap.N) + ax.imshow(env_plot, cmap = cmap, norm = norm, zorder = 0) + + # Plot the velocity. + if (not self.velocity == (0, 0)) : + ax.arrow(self.position[1], self.track.shape[0] - 1 - self.position[0], self.velocity[1], -self.velocity[0], + path_effects=[pe.Stroke(linewidth=1, foreground='black')], color = "yellow", width = 0.1, length_includes_head = True, zorder = 2) + + # Set up axes. + ax.grid(which = 'major', axis = 'both', linestyle = '-', color = 'k', linewidth = 2, zorder = 1) + ax.set_xticks(np.arange(-0.5, self.track.shape[1] , 1)); + ax.set_xticklabels([]) + ax.set_yticks(np.arange(-0.5, self.track.shape[0], 1)); + ax.set_yticklabels([]) + + # Draw everything. + #fig.canvas.draw() + #fig.canvas.flush_events() + plt.show() + # time sleep + time.sleep(0.1) + + def get_actions(self) : + """ + Returns the available actions in the current state - will always be a list + of integers in the range [0-8]. + """ + return [*self.ACTIONS_DICT] +if __name__ == "__main__": + num_steps = 1000000 + env = RacetrackEnv() + state = env.reset() + print(state) + for _ in range(num_steps) : + + next_state, reward, done,_ = env.step(random.choice(env.get_actions())) + print(next_state) + env.render() + + if (done) : + _ = env.reset() diff --git a/notebooks/envs/simple_grid.py b/notebooks/envs/simple_grid.py new file mode 100644 index 0000000..c4758a8 --- /dev/null +++ b/notebooks/envs/simple_grid.py @@ -0,0 +1,303 @@ +#!/usr/bin/env python + +# simple_grid.py +# based on frozen_lake.py +# adapted by Frans Oliehoek. +# +import sys +from contextlib import closing + +import numpy as np +from io import StringIO +#from six import StringIO, b +import gym +from gym import utils +from gym import Env, spaces +from gym.utils import seeding + + +def categorical_sample(prob_n, np_random): + """ + Sample from categorical distribution + Each row specifies class probabilities + """ + prob_n = np.asarray(prob_n) + csprob_n = np.cumsum(prob_n) + return (csprob_n > np_random.rand()).argmax() + + +class DiscreteEnv(Env): + + """ + Has the following members + - nS: number of states + - nA: number of actions + - P: transitions (*) + - isd: initial state distribution (**) + + (*) dictionary of lists, where + P[s][a] == [(probability, nextstate, reward, done), ...] + (**) list or array of length nS + + + """ + + def __init__(self, nS, nA, P, isd): + self.P = P + self.isd = isd + self.lastaction = None # for rendering + self.nS = nS + self.nA = nA + + self.action_space = spaces.Discrete(self.nA) + self.observation_space = spaces.Discrete(self.nS) + + self.seed() + self.s = categorical_sample(self.isd, self.np_random) + + def seed(self, seed=None): + self.np_random, seed = seeding.np_random(seed) + return [seed] + + def reset(self): + self.s = categorical_sample(self.isd, self.np_random) + self.lastaction = None + return int(self.s) + + def step(self, a): + transitions = self.P[self.s][a] + i = categorical_sample([t[0] for t in transitions], self.np_random) + p, s, r, d = transitions[i] + self.s = s + self.lastaction = a + return (int(s), r, d, {"prob": p}) +LEFT = 0 +DOWN = 1 +RIGHT = 2 +UP = 3 + +MAPS = { + "theAlley": [ + "S...H...H...G" + ], + "walkInThePark": [ + "S.......", + ".....H..", + "........", + "......H.", + "........", + "...H...G" + ], + "1Dtest": [ + + ], + "4x4": [ + "S...", + ".H.H", + "...H", + "H..G" + ], + "8x8": [ + "S.......", + "........", + "...H....", + ".....H..", + "...H....", + ".HH...H.", + ".H..H.H.", + "...H...G" + ], +} + +POTHOLE_PROB = 0.2 +BROKEN_LEG_PENALTY = -5 +SLEEP_DEPRIVATION_PENALTY = -0.0 +REWARD = 10 + +def generate_random_map(size=8, p=0.8): + """Generates a random valid map (one that has a path from start to goal) + :param size: size of each side of the grid + :param p: probability that a tile is frozen + """ + valid = False + + # DFS to check that it's a valid path. + def is_valid(res): + frontier, discovered = [], set() + frontier.append((0,0)) + while frontier: + r, c = frontier.pop() + if not (r,c) in discovered: + discovered.add((r,c)) + directions = [(1, 0), (0, 1), (-1, 0), (0, -1)] + for x, y in directions: + r_new = r + x + c_new = c + y + if r_new < 0 or r_new >= size or c_new < 0 or c_new >= size: + continue + if res[r_new][c_new] == 'G': + return True + if (res[r_new][c_new] not in '#H'): + frontier.append((r_new, c_new)) + return False + + while not valid: + p = min(1, p) + res = np.random.choice(['.', 'H'], (size, size), p=[p, 1-p]) + res[0][0] = 'S' + res[-1][-1] = 'G' + valid = is_valid(res) + return ["".join(x) for x in res] + + +class DrunkenWalkEnv(DiscreteEnv): + """ + A simple grid environment, completely based on the code of 'FrozenLake', credits to + the original authors. + + You're finding your way home (G) after a great party which was happening at (S). + Unfortunately, due to recreational intoxication you find yourself only moving into + the intended direction 80% of the time, and perpendicular to that the other 20%. + + To make matters worse, the local community has been cutting the budgets for pavement + maintenance, which means that the way to home is full of potholes, which are very likely + to make you trip. If you fall, you are obviously magically transported back to the party, + without getting some of that hard-earned sleep. + + S... + .H.H + ...H + H..G + + S : starting point + . : normal pavement + H : pothole, you have a POTHOLE_PROB chance of tripping + G : goal, time for bed + + The episode ends when you reach the goal or trip. + You receive a reward of +10 if you reach the goal, + but get a SLEEP_DEPRIVATION_PENALTY and otherwise. + + """ + + metadata = {'render.modes': ['human', 'ansi']} + + def __init__(self, desc=None, map_name="4x4",is_slippery=True): + """ This generates a map and sets all transition probabilities. + + (by passing constructed nS, nA, P, isd to DiscreteEnv) + """ + if desc is None and map_name is None: + desc = generate_random_map() + elif desc is None: + desc = MAPS[map_name] + + self.desc = desc = np.asarray(desc,dtype='c') + self.nrow, self.ncol = nrow, ncol = desc.shape + self.reward_range = (0, 1) + + nA = 4 + nS = nrow * ncol + + isd = np.array(desc == b'S').astype('float64').ravel() + isd /= isd.sum() + + # We need to pass 'P' to DiscreteEnv: + # P dictionary dict of dicts of lists, where + # P[s][a] == [(probability, nextstate, reward, done), ...] + P = {s : {a : [] for a in range(nA)} for s in range(nS)} + + def convert_rc_to_s(row, col): + return row*ncol + col + + #def inc(row, col, a): + def intended_destination(row, col, a): + if a == LEFT: + col = max(col-1,0) + elif a == DOWN: + row = min(row+1,nrow-1) + elif a == RIGHT: + col = min(col+1,ncol-1) + elif a == UP: + row = max(row-1,0) + return (row, col) + + def construct_transition_for_intended(row, col, a, prob, li): + """ this constructs a transition to the "intended_destination(row, col, a)" + and adds it to the transition list (which could be for a different action b). + + """ + newrow, newcol = intended_destination(row, col, a) + newstate = convert_rc_to_s(newrow, newcol) + newletter = desc[newrow, newcol] + done = bytes(newletter) in b'G' + rew = REWARD if newletter == b'G' else SLEEP_DEPRIVATION_PENALTY + li.append( (prob, newstate, rew, done) ) + + + #THIS IS WHERE THE MATRIX OF TRANSITION PROBABILITIES IS COMPUTED. + for row in range(nrow): + for col in range(ncol): + # specify transitions for s=(row, col) + s = convert_rc_to_s(row, col) + letter = desc[row, col] + for a in range(4): + # specify transitions for action a + li = P[s][a] + if letter in b'G': + # We are at the goal ('G').... + # This is a strange case: + # - conceptually, we can think of this as: + # always transition to a 'terminated' state where we willget 0 reward. + # + # - But in gym, in practie, this case should not be happening at all!!! + # Gym will alreay have returned 'done' when transitioning TO the goal state (not from it). + # So we will never use the transition probabilities *from* the goal state. + # So, from gym's perspective we could specify anything we like here. E.g.,: + # li.append((1.0, 59, 42000000, True)) + # + # However, if we want to be able to use the transition matrix to do value iteration, it is important + # that we get 0 reward ever after. + li.append((1.0, s, 0, True)) + + if letter in b'H': + #We are at a pothole ('H') + #when we are at a pothole, we trip with prob. POTHOLE_PROB + li.append((POTHOLE_PROB, s, BROKEN_LEG_PENALTY, True)) + construct_transition_for_intended(row, col, a, 1.0 - POTHOLE_PROB, li) + + else: + # We are at normal pavement (.) + # with prob. 0.8 we move as intended: + construct_transition_for_intended(row, col, a, 0.8, li) + # but with prob. 0.1 we move sideways to intended: + for b in [(a-1)%4, (a+1)%4]: + construct_transition_for_intended(row, col, b, 0.1, li) + + super(DrunkenWalkEnv, self).__init__(nS, nA, P, isd) + + def action_to_string(self, action_index): + s ="{}".format(["Left","Down","Right","Up"][action_index]) + return s + + def render(self, mode='human'): + outfile = StringIO() if mode == 'ansi' else sys.stdout + + row, col = self.s // self.ncol, self.s % self.ncol + desc = self.desc.tolist() + desc = [[c.decode('utf-8') for c in line] for line in desc] + desc[row][col] = utils.colorize(desc[row][col], "red", highlight=True) + if self.lastaction is not None: + outfile.write(" (last action was '{action}')\n".format( action=self.action_to_string(self.lastaction) ) ) + else: + outfile.write("\n") + outfile.write("\n".join(''.join(line) for line in desc)+"\n") + + if mode != 'human': + with closing(outfile): + return outfile.getvalue() +if __name__ == "__main__": + # env = DrunkenWalkEnv(map_name="walkInThePark") + env = DrunkenWalkEnv(map_name="theAlley") + n_states = env.observation_space.n + n_actions = env.action_space.n \ No newline at end of file diff --git a/notebooks/envs/track.txt b/notebooks/envs/track.txt new file mode 100644 index 0000000..4bbe230 --- /dev/null +++ b/notebooks/envs/track.txt @@ -0,0 +1,15 @@ +1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 1 1 1 1 1 1 1 0 0 0 0 0 3 3 3 3 3 1 +1 1 1 1 1 1 0 0 0 0 0 0 0 3 3 3 3 3 1 +1 1 1 1 1 0 0 0 0 0 0 0 0 3 3 3 3 3 1 +1 1 1 1 0 0 0 0 0 0 0 0 0 3 3 3 3 3 1 +1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 +1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 +1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 +1 1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 +1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \ No newline at end of file diff --git a/notebooks/figs/duelingdqn_model.png b/notebooks/figs/duelingdqn_model.png new file mode 100644 index 0000000000000000000000000000000000000000..2529311589a3cd28f90f482b59e3c206eddeb72e GIT binary patch literal 123703 zcmeFY`8$+v{5GzI%2sJYwn}0wA=%gLObiBNUz4V>?~J8I5<>PQ>zIbd*au^+BwMoY zAzO?+23h-Fy+7a2^A|inK64xnGaTx^uj_T4uk$=#=N)AT*Jh&Upr@gsVbaynK+w?8 z>Cw=fB%VD9ezMd$cpH2>;e*gtqbdH*MFAg9KUCFMrJ*T{XE=1A1)tA(>R9;D&@eau z`#RC;QQ$;F^B1S9p=uInyK+PcxM6|e*=N~O?7pMx$)EJCu)Lf=z?Z*IwM<>Tc~B%= z5?nNYzEyjw`){7uj=;gb=y+n9E2;iF85v-uWHOwb?j#|XMDsEz>*7lq-X{m{r)!fZ zqzYbeo!#6smF7HmnpgGOg@Y&={}o~&;?R>BT+n|n`&2>v-}C?bNxZ^v?%)0Vdp${y zw*KGu z;#>dkzxaO(^?$dbAO_J_;T|VHK4jO$Di5#wD0XkthFy!!jU%;ym%RwovDLD+a~p!h>WUZ6iN%_Bg&rwLK}h z2m%y?ppkmZD4N}Qb#t$o+G;Rrl542P2LAksnWpkhWJk(9@}tzBwMVwqGF*%;xll15 zDZvz2EE3zltjCI-c!bxOW(o>Vc+&2uRsjBpa86V7N%tKt=8QpSvSB;Uo7@>fGI1Ho zNa`;=sU(?L{NtQC4p!J}$TP^%B@&N0T)QiI!RA%Xk$dELF_M7q1ULGzQ-&vgJl3Cx zz+X$y{q>;*O)|k<`?M|V1&x|X5%m^?(8nU1_dU}Yk##MzyQe=lZm5m0ZI0P6ha0Kb z0L=K=aTnbA9V78oKl0J}Z0>dLg*z>lWPWB1a+T)au2}qna|y)X+4MFZQT|u5=m*a0 z!1}3oF`-@-AZ`AkM-y^Ql znQ%OkAh;14R&_}edC`Srxs7S)r%*9Ua-DsbOoc8JTc|A>T$Q) zPg{qrnv#~bCBvMtT9zY@WpDKOF-+O}CH=;WcDauO#Mvb?y3nK#hJt#mv%e-{52hLy zc4}Wa-)MM3=>w3q(MJtFvP~Ng_1JCBRzk~+S>xBUdf=sfy=T>6UZ!=X}H8 z2G(Xf(zKk4J`E9o@?3y14^U>vW2VioR%ez%XrAj5JZXI?AaX zf>DTXO7imii`e*%6p16hM>oQDiQ~P2l8RRmg(~Y0PJumRF#4V*cyA@N^zR~DydMX5 zL}XpSIwG~y044cWOyU)d)N&?VAg$BrU5;TwyOSl6wdE8>v?W}JPtEJu=W{JlmP9T6 zzZFrvsQlq&3i;W!9ydAo1$;lnn~a*q;c(_6tn?AkZy`uxY!)<{cm4|fJh zZOOv9n)Q0W;Gp}05C)E}um5eA*^{NehfT-v6n&b&I9bS@DAyUj^n3FM6UQ?%GeoOu ze}8|d_Wn^=e5?AE-f7P^x$XN%!XV1&QOWo!QYa-v*}$RF5NgOXA2jJ$cKYPgK*dHf zncUEzUzqG}{3ZX3E+J2#?_~0mM@p66YA)F49}J<;2MEY}b|JjOzHn|62O}LO@6eaG zi7ul{T29pk7a=%6UvEe>NfC;Gm)x=H;%PeAase!XWn`0t$Y^uw+FDVA{P`sAWC!D_e+Db7W`etMLC#|x_}PK|{!H(8uMZN8QeX2MFZS3y(v^cBe!chB z_u_rA7bnjx4@yBeW53#8TiljU8eOEyQrXi%M=xdpOh9?UkUfh#D|;Fmx4e0 zK1>EJa7X7u3+iS)?QOqa+a{xXXP$#)Xi1OUwYp|MY!T5?ymQD871MipHF)vY()Bde`7Yw9;OPn+A=Gz6?q z1~hJE{wrB$&$JW<3n4waW z-TRv~Ri7oEYT?8<^t1gY7^(*JG4NN?G?cnZkE5$8VM(KqSLNxf_7aIRgdkm8-h2aBqha9`Nk+uGWC*qx;mx=-EM5KnPn-@_zpL{b6nf(qc@X@WoZS-yoywmp56F=REQG zrtpzE#45NUORz>m)5e9q)c`$vt?Xvk%#35sMX7ul2e z$^La%9|koYuYGbpC@VGpnyOcxC9z}I5R*%47mQ$iZ>Xw5DWNX5x9eh!vW>ruX6}q2 z1{^E&?3BPoUViegNpR9P&o(5*%%1LMfLxsl+3M=*(kFKh_(s`XiPZ}Klw&S}U=RI! zwEK9!KYML;^?^jXbA|4s!R77ZqN4iWUpd$7x4y5ASI_>IrM0Hd^k&a2o*C{vqL%bD z&HKvVNNC&KlpsFM(iBsVYl7&FulhIG;s@@H%B1Td#Bl|%?mUru2KnqlC6S*+8(1(( z)WtwadW}<^ocB0xeSHb2b08)0VcMDa_}a{3S;+bi^45@*hmo;pb#Jz07US>9Reu9G zoJS?>a4Y-oVOrDS1Kxxj{;Y){%*^M{pTB?q{;wt@&tEMrE~X1t4RX8MdQOhc@S`|K zELcUpw#+J2d+_cWkw{bu-1xY@3oeh`rb&rly@o^Rt_`MiF9_Ngj^rHP^?Ih5ZHhXg zLUEbig^C=pnLOGdO70{p{Q3V=l(kRAWyciY@Aw3l(z~2HA|OzexWr@)ZS2KXuNKGO z05nG{9tH;oQ)Hak}sL2@r6 z-sM29x1OsW*S`{;B`hY^ou?!7VerE{=$yhM(g)p#qP3A~nz`oe@n7AWf*<&d{sMdm zVB&>;n3(yIA+oNuJ&CVHmM|#9MpkBi57E7;`(bz)qJC8gL+#H#PS%%8){EwON!4uCI#6gV= zU28x+WOy|0wewxuJ%j%h3|44C<*(e$=%l11Yf)_`8Pe=0d(Y6&Bde+Xp>dC<1`veLB*)Zyjt`VZ}x`JgQ}3) zl+OkI6iI!$&K$#o%R<%?7~U2~%X2r)CQd)lk0$fPx32FRTjI)RZ5Og^k*ILi*>w2lJ3BbLcNiasR9y!q%Vt8{OCTL-egi`1uP70jh`L9>nGZsAjY1AwoDm9D{E?M%F9`pBj;6} zC=V{k#e;sJ!K>Pvz6ot`rmv$~|EKV6)8`&7%~2?x;`!s=3HRbo4?vCca#G(SzJTs{ zFnjgyA8_Ia(BN!=X6q{|B2vFS^sj2F*M5-InHsEv_npK_yB#DsLY1#-o|MA@`aJEa z^ZVnxw^3jYEy|Q5R%>lU^DkG#yZQMCFgDOmQ}gFO8i?8#fqnAbpPPGbYujKe2BA+& zORH3~3>TaG&qpZc_>XmLX^O(4lg|p;@o;e|h8_L^bT)Yhy49Y>0$3`EM9R$M?kKUc zvZ~Bi)KOH@u-J)N=oNd3)IoJEwJT1Iwd-tA=>@CkPChk+YLv8swkWaL@(O~$wHL*F zaebgE(`c~!3VOf4|IzKe>);FpmML4zEp1~+ma9}MwLM9ouC5Mn1vWM|9O988Pp88y zSnPncAGr}`NaV9mIbF_Jq;1?KyASQ}BLoEuX>$A@i?f>urSzgS{>tAxO}>}Lb$Rgx z43~I`_DEfWr&ySaxl?_hzn>EI*{P2c28q>DFHY-KaR?Yay52O|MtAtOUY-v)PJu_j zGx_7&%|`Z>&+J~nKHsf~YHn`!m7k#aLI=s#qS3h?O-DOc9u0o$lMR82Yo4;Gz4#LC zz(S~DpNdA=$n5X7S(k6!-TiL#g^;@x+JHKn+Uo(cyuR4}rI)9Sh`F)^skgB&^T9of zwF|^plPqI-zZ|SL{l#8ALV0+^v(Qec-y*d;(VspE#Kqs8>ZYTgpTfavuRHk$k;C{( zR_{4T2}FFh7k{pn>s%4!<#j!PI)oaTy94O+`flev7R$t$=STu+d=&sqP*9McpQ)&K zFBT$D(@v8^L@v+Lv)#6M<&W3*7~s^WtFolEia)#n+WGRcf9*WDu}zat7o1%Hdo!7c z!u*ly@^ZB+)X9cm>K&eVV|Ee{E*As}HwPmW_p-5R8c_O64Ymf;g9}?ma2$%zPl2XH z=e4nB88bpZ_>(a>BjI7#o_EFM%)uc_5$Q4jYl&G8paXDpU&(H+eAIRJcVIxkF4%Bz z!1hAI#MuoA+%YZEGBRL!??pL=hAOc{$#OB1D^h-Z=_Kr<7b#SO9u*B2EFXZ#ML1c7 z?MRpkjW`{otM(YzVseQp0=6~=Y?K`Q^vM(Zmlxrd8P*GVINGqD0x97L7|D9Is`lB( zW(L;q%0zC0}+Y)1*MgKZ#i2@gMwCJWq8KC^RvZ@A>>3WrVBCJ@Ai}9_1YW*;H zSN>X&KkXw!3WD@nG+(Tbgveaqf<=5rNf(f)84il4L4hm%EAZgi-)|QFAhDrA3Cdv@ z%+5-^<%iy*j&@g#WCg*6)s>YWO^^SAJtq(dn-=;Q6vD2S#Q`36^SSMv++@H{vXw)} zGW1TY`6}?nTx{sQ7S$IhnHMPk^GqhP8g^aEILEH4f02<+9m7jJK`RC@zr;P%_%O<*xWmiWoBtOuNFUu-frDOt43&GRBQA{5qgY7;3@zYM)Z>Ue8d2ev0Mb`ZjHrP4$R- z)xAA$(G-JByDIcbpC%6WK%7I8gM^IKWd}Y?WAq7?#j3i(iq079b6KYwbc}T2aJ;$< z6?63U>(_sLVQ1Xq@q)rsdUkd|-Nb-xQ$6f8l7RcdtD6YJ0V8eHwd$WH34%#bON=dZ zXy3<#allkJIZ%7OsLG}$J1Ar^jA-lPV{R&Rb9i~T)*3q`;(QMx&_R}%ct2%{#fsdMDw)(KDa4dDJD*!rgj@#rw*6gU-B1Wr z>ZX%=g}3D>c?-|hFsJ~woUSpdqqnTqGIbSmEZ7ib$34&jeT<~ zm0=!T*0C*1Uzn^vZ^`rh3*eL?sR@!mm6H%hn}?g!(a{P4?I^59gZ0%|Eowpcf|Z2@ z8IUJ%-oQCn1uZKG6*Mo*)!5-Gy^Co;5;Uvlmv07T4KHttrp4Gcvjts=PBo zaha>+njeOUSza04n>=%%9V`G;VV7ma)WS`p#I*d4UG2wI?Z+Eu9$#RNtd)ct_50S>A8-cR;zesYc7GUzTu@w>*hlvP&xf~o_`e);MV_OV9w zsiz+aC7ydBjc~ki$*^1;K&DLt%uRqZR9KsDZ}(0}f=gJ?aq#0m6Wim0(!FA8 zWw}$!TlGE5J4-2AYZ7+fAY18*!<60wY;QrV^C_i-JlX~a-&0XwGi+rc-bNWZ)Yq1O43fBJN2{xj)xuQjicK6)t%!CJ{$%xxlu0vLvEg3?j zXeDmE!wH(7Ux5Lb2d&~*U3suJ1NGYYvq1&&HNkD*t?TAY@8Ybn25;A zm8nw>-B$%c6Q)&%PnRw9cTfN3W5%K5$|Pprrb1)_V!Q2s+Bu8@tN zPp#(?hwrE>liD<^r7UCHU41d{KA~QFqs3X?Ftb$U+z&uq!9_DY5_@=O z|GXC{k49xs9&`yBk7T)!(J2F?^X>ipN7`qiW}U7ZFILv|8G2(fbIm=shdOqSh`6pA zvBg{S9WAa2S|3=%9mh** zMlU@E$8pw$uSHEdN$`pr%$hr2qA1beloZ$9z7k93G5dBo2@k~k`S{&9K}(Z+gSL_V z6hC-;ILD8!U{1@1D%P;)FtR#laND4^DI zO#t^+(vs;`I085_A>2^!Pul{KMyb>Linwk)iC}<-f$L6xu@6(!QW9B}+{KsF%X((U zJ`YWFt)8h~l%BssUqp=@@;r*M{?PtKS2|{Vf%*ASu6Yl-dXY&!`fZZD%j9dU3tESkdei^!J(LJDGsJz4yS3JxBw|&>|J1r26m(8?wjMb zqfg_psfb*03;l$Mjs5Rq`>RqgNN&XI<_Fz)hKFYs22g$dC2#{#wJu50Fz~cvKiT)7 zBnv{YDg&}lrQySiz-R*AR^#H~34R{hi$MWVRbzMVBIxqJ{#9+Vl@?@+Q zycVqDTaDm~Jv*qB7Ad37g0j;2~a6P;j;iyO!4QJAL_FIaE#{O&B+RviZ zOSHBqDa&-HwZp}kQEc;8bBts0z$z7b$9$C)_=+`+HAi2EHnkM1AU-wR@(pX7yrH0g z=~>AGXp(ISo=sh4c^jjg?NL1*tJN%}8op9!!|NVL&23b-0C#e3MG@N_p z@^Z5$P;#wOK0@zy(7TZR>5Bd%WBRuwZ{qMgm5w{&7Ay}8pN6W;(xhh~^&-d^t^f!evDA3-t#OJyhyP0JM%IGh4sf~lFDvh%n@kLfr|t@y zxC~&zCn;W~C+@O+b}w;}pecB9yxk5xR&VSUio#jTWeXyTQ8EhDwRSVrFyw*+I5Z1j zm_JO<8SEk=RUFe*V1e(`Ua#A(ecw*s>mU1<4@Rd9E!{;r2q zLpJq-!Wm%$5vi=Kfy|=Ifc7jUcBdLyX+`Btpp5f$vfeYBM=XmxPR9oqc-^shC0Zg} z1+i(WXsjng?5wDNCg`xLYXc%B3&3An)C9yWrseb2p{MMMuRPGKeJ3Y2!2Ba#n}~Fg zbmjZA5Sq!G2E*lPsOEN3yfEReLRv9hpPl`YLX@NTv|p|VH)oKXZ`$Q*^r9>GL&Nw2 z&S%$SH(%N;jsOED`xHPEW$5*7j5W?sKhuUsSy>)~NmSHL@y7XAsFOR;6&kY%u?n2a z;{@SqDz5Wy2llA*^XKyM{M`wfb(83IlLD>yC{gD}-9!Yc;zO+GB1VlOWohzu>B zDv;i!s0mtqFkNbJ_u$ioX!*%=D}~nn^P&i7zS!DKTat-_imb{Hr98#giu%ZC)7)-h zQ=y@&A#M(C!G5#fEkl&n&hNRwGvN3mC(eKt&`cybVn;8oj(&vZ1moI3{*Da)ln z?1GVP4Yh^~CuyD-s3kBsPogBR2x7%NZQ@R%0Jf^s=jdR9vfe9dT-PP^%l+_wJknHO zR_PTG>hM6hmYpP5WJ&y0A!L18v)CX{Qg@wQX~I>itXgs|VDBBofJrMHQE2!fc~*C- zSh-c^Ll*#s0x9_}=Bb5N>}@c4A}@xw5%&KGfb(Md5#ymRf632sVu{a)OGQa;RHci* z9Eixx7n3>oUt;AKEGH~2Cao>U%;_}_2bd9ge+DXK&6?UYOIn>IfJSky7)40}-?DCk z^|XUHdtifYTBjz1;@`J+<_Rv|xAMQ|WPDp$*`#e?u5Na$M)_Gve>)L#rpQCNb=zeg zLo&z4V+T>j(n$(FMg{D;EE8FD=X_Vdve*H_?ws|JAr^fH5a(6ytIBfnDvI59zcNTe zKLU$nmckQ$cIJe4a1(@$Rl|5 zeTh`!Gl`=)L)FDfc>rKl(9WapzzMFyL&32Wxn=J&Gjdm=rF&NNj^Qe-|9t*s+^a2Q)db3~Hp4 z_{Arrx*t0vlr8#BSpln(wm?BtNpeNYHw-yf)8#$=v(LNSKq5o3&ReXqqK}oEK5IJT zK#g>uBrQc!Es4l~-ZoDQ-Tvy!33oh%PfVSmDW8{(m_3vJsQ|z6Yp3>yay6J(HI>KN z2uVk)JfQai_e<6ySqPderN|Gj_H%aD`sgN~wRrcZh9H|@2Hb6#3(?l%Nqk02m9;Id zl)%5#jrQL5<460vHiUu5QweH`;|qC=wN(wZejYv!ev@oe%aNYV?6ChSkD*xYJ?&1E9?1lIK7m(IDJJjE(YxZa08vxe z<43ontkXLA%JJRbnX|ZfR(Tc>WG$lZ?YsD4TI|ynl4kTJ&VZr&_l(fPdd@eb%$9x8lZ>DCx_Z`dQ7@jxs-~r7Y8n@s zf_RNMdmp}ecb|IuvP6X1dk};H-2Eo~zR6tijNQg5a7>oZXo|kM;`;u^BaN~b+mj!p zq5b*YVg@?~mjuq$PCW7hV^i8|9v?5oYNyJ~g22aKN>KcinjR zDloZJBZRh3|L|4!7;y3BfZ;Z;pP=oB6Z#9Jfsy zQf{taPHnRhJrgVhy?Z@0ZiyYClP~zn+YpgpD4hw9oRy7faTI6&=3D_%2`$krGo8T6 zY?8R;o&HKXa&Xm0L6JFT&{f>%UH=CXngqj{Ku2D^Cc=rJIlm=3XDoZq80M>BdtXj^ z)~Zs}!m6A8EP!q^Oan^gj#l5xWv^}T@L1u$bBlrNe`aJYL{0wKX7iBhT(>&Qbk~Wo zDa3huKKp<%KnfAtm;3pmt?iN!xdW&H{+Q8KzldMqjXA^fUg_VoTHZZVhUJPe3T$^+ zl2hxxrEIwle`g~}$nIb6PbM`&`= z_AsPRe&k+M(Vz=Os^3uu0#42upnP#jZpHXnxH=PU zwdGRQ%nD5_zdT_Z>+&ZXQmSfKwSqwnC(s<_euPC{1)HP)Wav&7=Z&nBG#`gQv9tt= zY`BU#cbrdgycv`T0N&soUm88Kn%S0=45F`w{c$KW&!@FjO^E3sAoQKdx6@<& z@e|YjJqG)RfOH}8*O%Ho&p&Y<>jAtm(C+1y- zH4Nu4Mk5X>rM=uCMmch5kWV%0Cn)Lp{X25*?%R+O;BmYq|eRez`4t+Ue6$ z)QkGO+M~ZuADXFg+v*?Es5NU;jJj5jyDI8uU1g4>ijpVX<7Rn)l_?Zs-K1J*SgzqP zFb*|(UO&C}TIMH7-qn(5>F6UKciJ|`x)+VeD{x92h2@SFNJV}&Y_Ihd^mVP(qM@nz z4wyXw#TTm)#dLbShy=hvI=xO7-jl5-VJwJjoh|Ei@(g!<98qN5_<_04Xy= zy<*S&2Xhy1HU83O1oK2DaH8f7S6*ujl?WuYWhp7B1cn6G1i#aNz&ZH7hYebHn)evA zXiz3qYwllC?*seJRjTvUr^b)@&v=JBv2U&0QT8dYG?kT@7A(A^*-5Iu_lxH>1a8{4@nFr#$dG4yXp%l+`J`8>z3UcV4H00L5+I4or$J8Z1COgtorHzf6pwqQ$gsJ zjZ<4rHQ@lyGG(gGJcuGi-|IqL%Q;e^wmqZC79!pkVa8N>eg33R_F#s)sTY$6?aNGo z&9AH!O}O_vmf+g9ITvphN(v>7&h3!Z%dSPxS9d?CdXpk_Gju<+Sd2N+y4tQpdNXYg zQEdH<)xyg-ac<2Xwx9nmOHgC`uS^^P`_aB%+)7#^dgmtAeY4@Z$s*9+8RL81IQdHg z67N^Dnv3!b3kvh{Q*Nwce^u5y&%}S~W{U39WzDY;2-%h=I$0a?AT7 z2z5Noop1*>G%)Q|K+a$gjYC8&1X=zfv61A zQSL|Z-$(ojf^5P^qIg5-M3|Wf&uDEm>B!y%F-hNH%-vAW0WiCy&8b`{I+r!0h1;I( z)gN``v{udCp70q@sOPhfUmq+dZ_S6iH|$7Ro|m6cj|Z8JFBVm_Ip0A8?50!&4be7b^>c5aHOd zMdO^G`$f&Ntp+dF-o82^@9ZN_F!?}%ouILQ4~8=({cpU#1X_PL8!^$Y(>4erXDBv^ zIK?C@LO;m=5P4NRWjh{JT2Xm1zU78L-bTOFVfNjZs6yAyxi&&Qqi0DBKU9b zr{9ymDaRJKt(K~SeP-nvjILUo_4r{kRbS_|e2j#$Rw}r9=e<$hn}0*evVK0p`hX6T z1|`O7VYRTm6yNvpHtoE_TM!@m6s-s1i`?$1P{(^gD3o~hB+S<~RVfDsRf{04>!bdcjji%*(d2R8Yn@k5HMgs|sHTEXaR zPfJyRO<`{Pvg8&*+%G7TH6y~0|L>SFcc>~@0aog?kZF z{Z<5I(e5%Z(iII1KJu$2!kfDLe+{f}2Xn_Qd!16v*^uYyF0|9V4N$@s+irfQS+tIZ z2$qhq4wODQ~yIof0ON;{Sji|7U+@W=svrx*1Wgm6X8o)~v^L0mLR2ZFte7 zw=)*l-k-AYL_YGJG?_)41`?=(`I`dWHEIyp(52N`jqC9I%||^DeX^CJ*QHh%xj`goVPWx8q26H{ z>5`oxA0 zW{*;y^Hf0H$klGi)ycj%yc{szz@bppe!08_gM*(-;lYi-1d(#-++2X}5T-pxmOaUx zhrcJ=r`LW@&tmm>)uS9`As_>$GGjGrIayN?wlEEM6@=-ZBV7~PCe$&y4aHbXpkws; zFWoGIMP)-$I0N0o0-cg}W49$suxnY;6b5tb6o z(&EIURW?pBdJT1oj_}QWbIZ#H&Z5mh1R?eEI}h1Yd1&le|DBKTci9aw1u4rAEsJ$x z5?@4>Qe=W6K}eeed^RVNx$ zJ*wV_AS)(iDT5Cr-VmL!>Bo6yLXcVWpoG**n%9kUUa7`|CH_xc&A9xI7>w8mfnM0o5aG{^ zvk8*1=@j--ingY{RcSJzA)DlRa-lV5LpUk^>o^wAb@AQQ8>{B>P1hhBWJn!x&2AZEAfNx}* z36If#9S|1ydoHa`p!<7bYda>LX|FKzTTylW#i_8;hQt2p<`(VDH;@feqw zYuG~}hC}(d_72_1V@0O6bcqqYnX<*tPC9q&=w{9T; zAs2J_`{tPx3_?V~y-JtAh+-;mkSsGU2MyLyYMCmJ+?WY0ZiP3%75x1$t4MtRlBbgY z?UUml__rm3NFdO%-P;(d=(uoa#PiIk$z=yEk-#5D5+$ajV)efC0gTOoV3{dQjaZOLEEX?E zY@{=71$L)F?ANab4u%Z^x`ifrhS%B1e7Z}!`##Zf7y?P2IQSLwt(~F!!rpG4y}jg> zcRUZpSs2BhPq^}E5n#B~I;I^t=@$KpArYtOJ%Ag+q@`P9*DT&jEm6puu(``XUoJ-g zmJyf;W%{EEMgm-~8+Gis1TG1*`|=u>NY{wsWfmvG3<9rL)>N@)Qzrqii-4dsaB;PWm^>d@&<9#a6p2s-jz9jUPr=TE!yqqq)KP zy(o7@f$X{LVlW;meg(J^7h}dYc$kR%jtb@x3A)amdlJL5zI2)WvoA%S3mTR7DyHS- zqI%ZKmzm`K`R{ut?E7k#wEGEpU&N@ywD3kmtL5H(%pKo4(AGC`Ll;pvIIxMRI2dDy zu{$wtc-%;+nY8cYWW->jx;~;v>A*%@W$NY&)?I%lU~OXQ|QW@MhKUITyvCP@PntVPHN)nwks^M~%kCvteF?SC_7ERN2?#{|w4K00K6AYpvoP+$U zeS(UCrzSy*&Gc9SBQt$1#SQjXuBX2ejCE?AHAN9nh_a~nMYMcN?#PE~Fu&@Y&386? z*weMYu2W)1=(lurHu!ky6|H(%j!c{Mtq7RhBEvKB*9KXjtK>640)!)khG$VOIIg@Q zwC&OJpFlT(CoX@s+8I>MR<-|L!usU>CXsogqn+GI{r@XW4Um|~F0TDR14 z+Ip`rK0eBCr4J4GXas%cQ~l4VvbTcpk<6-gb|=d*n4mD+*#@%6y;v1Y#1Jf8O5)8iVjZfKiq{QvQfvc$;?CTknT5QHSaA-Wcb}n$nB?bV- zTIkl=Oh^6rdfCXxh_0F35?Bi?KiM+37sbfm(Cl_z<7BS6I6G7M2+`WVrE5|9HA2#2>wEGgmIRT84WwneQQ^u(|TpGINM+lfsCJ z4jg#XVUX@dk1Xip-1f(JvF&KHeufCGFlT6We^t*hNL^>J28yFnIAZAmSnSm0l-iFB zm8ysW@wcxkj-yV|eB%OTLHIAL;%!r$EL`D3)Q;L}-s;@)l{0gfwj3xJ=c=+7sj1|# zo3zfdOFyp_?w;LgFNyLqTeDsk0IShIr*@fp$MENS72pCMzxn1`BbwH&X*7s(ZV`EU z^<}t2T33SPir=WG&9*nu$fXY?Hf67vo&tfnCuXXR5@kki&Mc!_*qARyynd-2c!n;^ zn9UdMu8dlz2BL4dePJ{EbtC3t+VG?DH@+BuFRoPr-i7Q~9FWktyz4qKC27?)feiR~ zKF}R8YD8E(KOq+r?i1R_cUDiq|B)nmY_bxQD!j;6sj$jS58*lE7D??veR(mBr?%~m zD!u}EVdOT@x$R$ZgGxL0;?b3=&%^S5vNRv{!DAmGe!yaO3u@@g5yybRD&@=paC!$3 z#NkyVE4bTZSGg*$;MFymbx}7F+WV@6X5M%m`OxD*;Q5eLN0Y-IBn{5}t`lh0xs4xh z|2mC;*6_%1y`)wQul2sqxHrFe39nuhR&9`*iYT%q!bvIwdnRsUZ zsqs45+BO^3TH;!uVwHK<@yo}{YhQ^6)k6V8Adr~Rj}|YTu147@g&wE)HpEy@NAzS& zh1&a=XGo!C$hK*h{-{>>_j7JPE&aRS<)|naAUJ@&oH05&%cvO+aSv538FV)-G@W@p zqmgY>JF+}Xh_#lt(_yP948e~&pV}gfRE$V5-eCzpLF3E@_{Mx2_TvsY3}@cOUjZH~ zstEV#@N97{Gb)T<_yvuk<2}Z0x6BjgTLxP|4(HMadlwxMsm^rB*uo8H2U99+KF-E9 zgo%hO$+T9rFCDw(o;^PAH_&*fU}G`726h`kId7;|Beg=UiN$!Zax-=Qk-GJh)Bl( zz_`>hIK}x7JXGe!>+2kR#*$$XAgsvgwm(2upELNV&=lAGl4&SxRbI3gseP4q{zNSD z&Xvl01R07xtF(2R%+K6xi1=av+ZlDQwwcrO?e2BJ|NGD)G*3UY>?Vk%UFASbO|W%G%2@1oPgzMTy-z652QGV)GV8_bMIed793Ni( z-8H4!3F>WgZ{@X4t~dviG+ye$PHXCY0IqVQFioR8x0-Rv@6fEzsOwhW_{(vM0K55^75ih!#L^c|Q()twFumxzN=Z>*eZUMdj+|+2j`pIlHwgpatTU&Cwp)|2lR3q#xIisdWiy zOk^@gfSut>s$*p@Ancfz>kO_mJv_s10go6!?gW^T*s&GA#UqFNI|KnX6*v;ajKx?$ zp+p!m;$9+41_~3D6%^Hs$U6!61GjF0x*gixCTp~QEBBCG^R?=33N9PNKH7! zZ1$I22?|fX6k*x&D_{sUxCz~^yizyHp5u=l)#=p9`{MHq8tqzB?2Jbin??^}$djv7 z5X!zwM9zwEfQ-gdUbe&Lk;~D2FY_LPX}6N>RPZ|GII?>)El4_uSEXmEax&+km*4dF z=1gL6Mhs!AF(-{95KVk2-wr6Mx*;EqW@(2Uep~wd{lM#bk8%2DSx*xdBH)C34wBiT zAnX_N{%!!QPshVvy&I8#^FJ_QYu>H_;b(u(owhnNa-#FJ=5cz1_P{!}qx~Sq%Rjfj_`&2e(EgL1gV=&v-~*pW zv)?fxez(~f#%!d+d+!E2t0_<@md;)JP;a0a_f8>PBxejE&p!o9&S1Fab)sW9h-1^` z!lp8LQSau?r9v0eaCYg(i@x$nEpxsKiYMa57D)=LD~?(b&&r?k#g0I?C&I8pMUW3* zRV`e+Y~olV6tSO+JcIxtU;sxZ2%5lpr{#;T_j)+KZhh6p)=4M=mc0z}upN>KEgRo6 z#>YK=^KLuW{j5{>3+A3+VveR}2ne~of(^!(zE)m{Ktfw*A|3e~_!dN?k za0Nto;gj^yxvwWH*9SSNNzXpHW{cNd*A%VQZ#VSl>GjYKj4Mg~Fu|HpHR5`kHt)o( zy14aP{i;8EU>Ry2l(SDLo1v7y)JAtlQcCD?&#KNyA0FD@9arHz$7h_Qk)S_6I;@(w zXyLkuk*cHd{+CesBLRwI3b^NEU2u}QE|BXsE-(K6MboC*ivN|r=C{i`1JXM`V%Fc3zF&jz6&~B zQF+iP-q!D*q=j10x6O*umXi%za%CHkY~e06AG@RzwS0SQZ<+S9rB{S+g=)3(*wf2U5p?1{|JvN57%rn4eXckHi48;-Nh@EDdr z;%l6Vk=u|JpvvJzR_ydZ%G$Amir6hkxe124mO$3;f?YD09M{jv_fFfhO~cZDLnetW zPSn?xZG9zfj}x{!Z)Y@j6dTmX+4O+2n1&|yy>Ju1!sV_l&hb*Dyl~luhiyW))m1GU zXr$s+sSjOh@82|it6*SSx@81Ru9RL^FiVEO=C}2RfL5w7%zLdNO%o)YqA;ca!rMQ4 z>kKw2A%saD<`

IGg1@t&oFQ;(^B$hzTo&RfmMm_>H+u7Vxt5E>%*^yr4T{O2w@K zZ!O9-zV0(*B#m8fg^en^Q7&v zo1B|*sx({p%j0tk_I;=HAfU#uBy=;E!S)3*x3>&(K&x-iM&OB%^_^36P?`j${)?Va z&2xHs`BwV}d=B;tiqDkW@j|K>HpfnNun2I1}O-l%k`Ju!fcfB#2L`zQYng78kUC6y)oh+YYlE3->ew~(PGoxvY^Y}QTrh>nTVUw`lBUc4gn<(cr zUVdxnmycQ$QiP$;>V|Tk3t#W2iLA_=UW>9!L1qVLt%N?CyCcS4C(PPDM^5{bTA& zB4}3jE-UDS$Y?%x=c6U6zfZ4L)jDg=^;9)kz7kQq<^S790ziUa4kqgzF2+v~S6;9a z7-_m?XHMTgXoZoMh%!uW0`MzwT?%1dugWt%Fy^<H14CAF=4ZOiHI9DHHxtpX_UA>4{cZQ>F8 z9sZ84j{Z0#_UeAJvK4(r4zmhflo%y3bPhw#C5~g*f4?Dr5%gb?swnJdHT4F9v$gpd z<9w|GJwIgnonLQwX-TW=c?z(%f@QvDeYbkINZjpL_KuUPtj#We(8+UNg9zzxExwju z!tYv4I}C4)@|ZOrUeF|q$w=>wa%+_J{;WD|RJk{^2iNv5LT<-z=iWZ+b{d!$__!oB zHAad9xqbbE*bl<0vU8Ev{hr;xoO}AHH#`J3Bz%nRI%rm5yy=xf( zYL7iDPQ|SvXAX^|Uxjv8B2lsha&X>L)bC%^m4yA;!GF&XGy)Ls#Nd_fDPi@bB?9I(>B(75O6Q3eQE=E$_4`5Pg!(4yIk?ug=RG- zqgI@C14Y2irtYV}J9nc+MTM_!0yvELXcdQ1DU~%XZ}~tIqJ#QH?^#aab(Wg34(Pbr z*_pz@hWq=xq44@RZ$j(fgo$ysU1x6WyMHQJX>*K zXyos%TQn8+g?7jxF(b0#&YAu_I3w)UYn2N6ue}yaZ4H}UeS(+j9cmFtp7}(UtONf-;4P3*~aErXK(zj^5VzNzTJ&R=&tB_FE`93RG14KRGJI?MDkHL-}yD zp36il9W$fCtx>oRg*?xP_PW0=a_Dg=$0MQ!eI$mK@Fa>2tyAwL{6Z>U@vaoo zVa$7d)9>^Vgc4_}u;%@XXAsRIp%MWkWT@FD(OZ-5dpd zXcXTT_4jS}#f}DF*^FgEg>0Hg-(KpQ6ls-b$gm=&?Svn7B{GgVRmNdxi zFXf$^7FX#=bo$-AN=MK|UD=w_Re6`;-*`5g46h)c(w!EmBg_7~RsQ89smRtjU{{U= zJ+b$77j3MZcM+ejK2ikfkvflCDNhfA`>64k)Q_akfJh(;wJSeF$snKNSh&OVSAFqL zz2Z4&yLo!%m@_b@!fDi@9X=>2-u7brX2!R?v)^rZFX`vQVmLG?ITZUIKN89VM%p@m!&ymuvIgIp|&3o<23s57| z7T-QfWHr9%E;=r_xp;=4n8TH=(lAZ7mhW0`T=(}b7R^GTuPtx9JjR|`+uqi2?4C`F z3Qc&&Iw6#-ZdbH##S)PUY8&*N#@pDr^UrD6qTM8;S0?=eYx`$hb^6|K2~R(L$PsTB z_02{IN)2GwKqZ9eH65TEl#c%Q+}kl=Mm)AMZrfb8_@-|_c_-p3evIN*4Z%bXd~Gp$ zO+RP!q`=S&lv(??+&7lvzs#e@l%tF@zH{oS#I;eTkaHJte;za35jv+WEk0z|%l;_U z2T8ARiV|s8KM-CBrO!NU#%9cyr1P|Ce9hp|i~`=oTc!;D|dXnSvF zcptX~^o^PBJ0lmMTlMV?S%`3=rL1`rVsjUrD93%HXFba9;XLt{N}3RrW;0S(gXPKd zp8KW@KNiIrep-}O2Rgw@9nbHuy%#0h!GG>Np`SDR+|Z9Ll~Tla%F*u18zhRc9|mpa zT@mNR8-#?duJUJ(oF@=I7hyD%7{D%5HqvEe$sV#IEhZu@(t~pA_KW-z3d1&~!_L&s zQF143iYV^3-%?2}4rUL_GcUbA9a#R`A^NBSZQ)T1N}=!9H)@X@=q?D-yZUlvU{*Z+ zK_>WyJ$^I6?YX)l%c;uI0)2f5`a!Du;;5h!Q|`f^F+9=R(Qui7xx!39P0xCHs$2Ck zh!5>4*;br+oVm{53Myy?%LnazrMId%S{&T^_r~Yww`P4L{v5neDax)=uvZB-jf1WLqH%tG<)h=L_%DP;QQlGJu6-!Mr3Ik;-aXJ@gL9+VyjIusA@j9 zDWb*-g)f9m`h4|M?~Mb0vY28SG&P`rJ_#%bOkQ6cn#uhbg*+8m5+s3e=I^Bu^`uCb zCcN;0d6{7=aTctL1jA1ID*dxpq#2(t;R{uFJrsnYQsy6FV&D-UdO|~e@h}r=_RXQC zZGb<42|E~dYu-b9*8!iVQ!oI!irG)K4Ln3tJTd*2cYh3Us$9eu_kB|wA4JsXKcG21 zJ#+l0OQkVqvqfUhePh-DkFe&7mjLGR(?!jGb5GM}&0v3jorR2vkwNsC~uhySX+FJnSO<{V)YF2g-Z9YuA}e` zdqpZPiwz)?H47hG$wtp$cTfL2l*FQvWDUxib?gkH!6XXBO~M#9E+OKct%8}62XvPL zWvqK2E-A|VvJ}#we!;8O5~ie;uSa=vnI~0x**f@zNdcCFd_`F_(X)BlXa7s$#*9v} zT1|GpL;q2PsE`(&xNDe-0D+MbU{zNOcLtwrjV+dowK=?!9l*5gO|EE5rRDmFF-1kO zgbb~|;tDemN)lRilApTb+}l~4tW##ro@@Vn4#wHM=fp4A_Zs4sWzXdf%@F&MvNR|b zXy?aI-4$2nB!er;kaMU2g+OVccq>HSz4vB}nYn3|n^w<~10B4N>-6&=!o$qb#F7s@ z>5L}tS2FHs#D;p9-}pq_&806i-vXkvAA|gYoRgt%x^3l>)<9#R%2M?h(J(mqxhe&x zh`PBZTQ{K1u7}U;aImD|&YsP^jyQx4#1>?vKgT%pa$K(WN+W>uU4wtU_{GQvNkrnmy+gpa2(u(%t z^5=L?&rxH$83!_Z0VZhEWMp1`u>nenSRo>fS{c82I*Urx$ugTWiz1B3^~k#%rNox? z+5MB9(9=G!-BQ$IavV&>d*(dpgc8)zGhFU%^tneb+az8StYvFw)0VQY?PGLT4%Y%G zIHJq)9U2fc`}O)Io8d>q_QX{y&W^t^?@Xh8&oPy?eI>-#uWt?na8TByD;Zv_@GF15 zKqBV5>#H1F&120^-z^lWf*iECykGKs%w#_-rCTwnXNK6fmDn7ZZvyn}YveB{Z3HNM zKyceXYVxDh*Lj|hk-hgQr9K_>7D@9BCXqmc*nyNVXw9Wn8k=$n{03x*gk3Z5lfehEC zz8}WH8d&$WL-(lAz@SvcJf4h@CD#PT)nY=KN{>%UOp{^WIH5{c#+1GMN4~fpXwV6= zGa#|`^3kZdmD;uK|6Vpr0HJpLhPRTz7-4EOYVy?6SBUA&tL-OwE`iWYr7JbnMT`hX zfill4B@Iy{b*YpQU_A9KuuMxz1)L?1YIx^Lj@Fg6-h+JM`FY7)=e*xl zk&RPDim79JI*q@U@cV^NXd)@I*>pZ;W|VW9na;ji@B_FUsFC;7CNRpM)Nc8&?M|$9 zT$w=!h>d@&V$bb!b-VE=ce>QqIxx_hn<7T!H+UiTjED*#OiAE*sIU)9yasT|LD2uO z7&L>JE3RB%{6tFLg;zvIcKeizD^_jx+3_Rh|%Z5gV@S>7U(_^^8a1NICjN(HPvx~%F)?#ueQHizR zUo(uQv@XzzC`YI+;YE&OK^AXG>{jFZsRP*pw4E*;kZ8$B{t3E&Q!nS#y5IgIVy{o{|i8#b)4U>Xl_imB0DVPD?#J`ZEoDW>gZ zx^I%ez%?y+j=(4ob`h-$8i0FW zm+he}DoP(zDZ~GkEiYy*)DjR#MM)g$SLk*#e{T10_rETo{+@YrK{gki_~8o9<*fP1 z$WOXE5eeNhHWJG&;&?^LF!5a-t?7N;@=LZXw{yULp=y9i!E4`3f^IW#%t27xh)h?{ zlVUd0@2jkYR<2q-VN@wxPGrTM^|- zmI}9q=cM!3(#e1Fwgbon9rajd`=nbh(`FPi z4;PX}%I5zvb4#EJZ>+=z^%;y>l!-`^aUQidq7nN#_MZJ@Q@3q@&Fyz1U_LEmr{2ih zJ7#u2gZyavF-^(3Wv!yei$f2g1w^n0_ZQ?*=8x}ioQ7rdLyuk6*8+7g4T9|^lv(C z`1_7FEY`lT>#6Led4q#%p0vbuFFyvwvRBz>m)Lkz0!-&U{oyIUVV~yR+_HlaX>|LO z5x<33A3Lo7A#iyLJ-tE)%@vZDGN~Z=0gKqqP5d5OVNpQuJGEg{r6RI&gquky(UQ5b z@RVgd0b6THS>y8n_fW}X#gXw2*m=RSxQj9NN^MmXe$5gxmf3#|FDCRg43T1F zuT>%h(}P?r&i&{)ALag`8JJg?Fhty@*2I`|03<7XnX!&+SEdeAoUoW|nMm5?`Mz4D z-bRy$~;cItmT-sp>07Zl!);>5#!PrN;h9I`>Utuh_ryc zIt+bcXf8@$o z!gO9hJV7?pi*B#;>>b_O@br9PI^8%-?SMyL?{BPu zvWlzaDdcka{n)grp%KV;cf`%6CCzmd|GVy zVWt?RUm*O+_ITpX+g1W%DnG`+X#DfAIk~ZCNwT4eN{?N+$P~P=x1{FW>T5g zRbdLQLZd6BdHIW5dJfc7RDzByWy+!pyaIt|>uucfU_^*-s~X`J%I$WzdyV^)>HA97 z*%Dh9&p|~@RisfMlb_v>b8!piNk7hbvhX65sIs`@LIgQ6fr&5-;1gTS?yDcnD5Ts% zw@kHyAJATB0CJFlNKS>I#l{Q-M@wU~u&qmdzDm}JXrrtuxXam2R}0_O>AUK9V7ffr z39a||w7BJedYmK4!YLU4XjlNWa~ovfY2SaT0EdE`Orc1lRb%Y)!wLcy$x@!lB0w27 z!7^bT0NREr+1mU5&(`0O9>Azdzsf*()xn{ulq!XM6zkRcL3J13v34u-`o)Sv8YP{xyHl*JRt_3<1LmmANSRENJ5h>H_*36Ag-cJ9x4i&qn!{bR(hXA7B)CNq z8imKnDX=7S({KQQ4lAg0F&1xRge4&;N&BO`-nyXfqppa&LXT)1o$?D5%2KXSzL1Tv z1oEQRy^;ZYb`L~;!j4EDDoc9OS7^2zQIw;`XMDc?pI=rd1HrpXCtJe7N>y@My%|TC zjKGtF@ucf1+|q}WcsAr*x_i^*DckS6C|Kk#!5CE8c60(Ox?)-CFoALN0Iu&{OVpc-Rs`VHgg>le?( zVSMK3s{k}F{k`O6aW!zu#`??V*_lZEcDSBDNZVak63a z1-fy*y}bzU31G7al_!&3uwY5gw9_5PM1_fh5_?0PuuG-W}d$s~^ohB)cB=I zX^hxEX4aS4^3pOJ^TCr&oO|674+-k* z+7_CobaaLKbDK`3?vDiEPddAG@CokVdp)u^Z^f=n@k1ecukPS%$V0`hl$go3M5YqpBgt zoxJ2_O|d|&IAw7Zxb*54=(67>A!;r(n{!8934A+qM)K72TI8*W#_YpAw=A{re8RXf z$!p-!2@*=ro76F2pBy=meQ(|-=DG8JXGkYi(~Xgf19XCpQB&xDj|Z1Nv)JCa2s2bV z-Vv<<1gW57KWZ{zS43CKEmKY(bg!RNhP8}Yeo*<9CFq=|C-=~}%eoe#k8JZ46(Yag z{xI>4vwIp4J5^#o=-k#N2%y4;ex!WNJ2dUe;hFxE`Ch16sZpM;YK0$Atp!sJmNn~I z2v?UX>(cah0Gp5oOB!JzK#Mlu>d@*YeY1tV4gIW)D9tY2nXM`|LATEf45OFSM%U`$13gTXO8g zMcOsCkh%ab2##S;xm8kPs~dt=Q@x=(u`w_!HGGt`_G*D+Vg~p!s##X;K!{ZfgBfVJ z^0}ZJK!d1f7ZNuTitOe$CNmMOEYa%9XV<0O@}dcixX(uo(nOD!*#maprtSjLnAYE; z-ynF2s*u>X?5Av~Y(8J|>q3*TnPr^cHJSY;h^As&zNo<`*=Udwc+>;X&t9J zO|752GQ|aor2~x3LrU8+QO*%XWXn~Teq;%Y&xBi>K}4l)7B9ZG0f@1qZ1w~!l0lIe z3f#^BT|%1^_&97N;3h*qNiPf2Zi%>WAtu}us;$^;z_pxRzjIGT)Rcz?V^*4G1&Rci zEl_95@j5q8UGk}yA;-Q`!`j@{;IYYWxXeh=xpd}P!83~UjC=h%wV>p zNkC3n7K8tj9rshsv@itd;#I@HPKIjTpm;M!nE~?tVgj$wY-T}@D34q2zKI&?sCh4d z6TG6Mt}|+RAZPV?W!=2wiPXF(f+C0RY4 znO7rrVbf!UU(-KWY_?n!*JAT5)&|^9f}To!rgg1lk3r<=Wim&oUNWIED!w>Gf>X0e z%1(YQ<}7ecT_5^z;8H^I_&I05>29)m`RLm)i>98cR7M%Io-JXELe>j-%&O`*_AGO+|@EM#hgG8UM?z(7I`!+OJ~j zE>tT)h!2=?sri#6==iamEEM0!CnnH2qc+Bd^i&uxarpY_?CD5hsNi*y8NF{+>TshLDe9@sr0i4M>bk+ z#UlMk#v^;+S{pgXt5=9|<6cOd@fKiOCv0%aNcB?r#Y9Rd*Vx`K^>M(#fM@{BxVoqd zP>c6z`=VcY@(+{+QhGfkD0%n$PW{lrOn>NR$R>6t1KcOzJR+hB$bg!Lx_yXxwb3)& zYioV0x_wS4h19N_sv&QZ1&+r8?E=gV{IVZILacF=p{{(TXR<`v(v6PSOz!xI8ZqTwzN%9|M>sPly9 z1~Vd~GuX4XYozFpa?y4JqaN?L*Up9-2$@stzdu_Kb_qH`pe%!4mg4+O#IMH)GAg{_ zhZ09Vy7#75G^{+uT=IXegpZn6Aj-wK8`DdG|7+Uv;km`5K>aMB)JrT7|8aS+nyymB zZ>T1AE|vXV;@ga~B}s?AfeajMs=e1kv^8tKINTd$&>y*t&dt#;ur*MWdBG3uEzF** z3&wy7fwKyi`UACLmc_<67>o<+6`-ZC(%sDN@vRL^tKb$|^ZBzy8OEcQQ}S9`y>O<% zgK_U#8Ktxi%Z-VN`}r2*i)$7lbTMi)fyv-H@VJ@@jNGoW<~NYkpmwexiURuIaALCw!Y2ez$x2^4~?*n zA$ypcZ=0u8z$K&#TIL`ZdytbX79{{zzA^oGPk-|^*Vh>$ZMUcyg{ zE+`>OStm*#aW7vaqTfr9&yq#zFOm9%cQXCEYnw~?n8XlA4K5ALKpNaQH#CWe(!XnH z@x=ncuqL@@cawlKSJ-IrQA7WWcUVP>@Nni+WP^#`LYB z$;ru;m15buO8(A5iNJ!uPbOVbD5g=SR1l+c&`qi7WN1r?M9Ob4C#cS(Yz;o6nJ4I@ z+192o9y5wA;Z>Z{t{PYGcqXJTCM7Q(H~<43VItg%c#b>gwThxiFBb^+op^ZUsU5K8 zj+%QSNEIb3^v;=o-|MuP|GVwt_?`YR zx5&2Ha-?<%*{i#yH(aLPpZ%=$ykv3!z-j}JK+%0hF9s>~KjyJlWFfb6)?{hu1PY-rU2LYVgKOO){MY%;DtO*QOWwUB~oMprSqV3iRA9jBk}R-hWZ-$ z;0m!q#W?MIqNIYx#01R=GL94qnktDKzaz=2Bxy-`9KU)qIgFnSO752h26IYWhvO)g z8HS|b3BWxteRa8CkD%EA=C|{-jV6v-c|IFsV@Oj8OrUd;tO78|Tm7-jx&T|{mP}%+ zR=6C$E!5e%kC4RiaOb(SY{^BvP3(SaVLb8(fibGAbC^Qs=@(na)qHj3&)^|>+2WyH z{qa$bR_V2S7&c=oWVbo7{2?&6feY8Tjyu?C@;q4)c4|*V3gsqHNy+AW_`dHnRCNwm8WWe^9Sd2lmr;5JD~R;gGg=~oviqXRKhnIO!jQnb$#-tF zX{Ts4;AC`sSBZScYw*y#32n(h76zOIJ!j?Hm)eI3Oox1;S2qVNw!lY<_jsg{%+$%^XD+IS3 zFhwQ_TYgCobHo5h`U|8gKViHW;)P5Ts{?b0g$uzulkl>n{Jr$QQ;XwxaCHqbJtNzT zpmACIR<#Phmz?({XaLdwUM(Wv^S4QA``KbA;1JIf*)ij(Lt#ArxZz+httx1V-uVa_ z4rb1ep-=AuQ(8S0qk@ZTGp}dZx5XRq3Rb|mzJ83q{ez0NM?xh1aLg}(RsdR7+4H~u`SqDrjZm|>%+LN#W2Kn@y+0#QDsXz@;v3lCL}rT^Q(CpO zXMr*m(#B2=>}ovbCUMU7o3o=$M}uk3zfEc?{;bz+5ej{oz>EHm>1*2NBfvxw7KNCC zk}6#KU_SR`r{`}~P0mY~5XP+Hkd8zRgDi3U;K;c@-EZ@!-;HJ9cN39tlM~$2KexP6C|y{48rA+phPIpz7diD6+LL)~)6qv;6WvxChZ{nko2DO$#IE4mI-^@FMagz z2Su4w#P(Es3>5o0KT<}6rl>BV*jv=tM zRg*5_!{@K=dKuj{4QTJw31{oTA{4Ygixzs&3I;98WybgI3Zvp8%*&aVOv=f{s6buf=pB%T2pUgF} zj-Ti>MBJjml|2B|gq8mn|5FN#euKh+_;Z?n%_Nl|CK@gdOHdAXd6&=}&~l$k04Q%@O7?7X7|#;6}jON9tY!|Ii**iqdAHpLqt*IZ~&DC&h0cR9Qc+E zypEPOAR5I5bujY!e___`z4FI?dqIQP^pMLUbTYTpWx zgu9T1v$!1VWLPvPJm&Mn*Y|OdP38Oa^dLN13H%$KcneRh&cT3x@8&a21@Zf?Y$hfj zz)(+fNAqfX2M`?!g$^2|#^=K2ya@Hj^nMJ#Z^ln?B)=zRf}vQ(6z1z@niHIwG=Mm|K=^kI%M9c2%J0;rZ{QoJL^(1YF%2+h9OpdriqZsQ!Mm-@;Z|B~Lf=2fjK zUCSizO~Rku<%BdQ&?v?GENnwo7Q1TKK2IKmAKQRNGEi`y zvuk@Z4nuV+F^RRPdGE4zzJ_RCZqH79jFX1r!xeF6N;Yl0tuzq({nOGT^7K4&#&sjj4A;QQu*9|pfMuTYtq281cz17wEuamUGSUDMI3^jP4kt=QYF zYGrXDpyiie3EpiGZaVUJ9uGcX!g^KX=DA1-%D@+US~<4+CF^*S>7&*^=E%#idu z?8JU`{fzjiEv^yX9=p3=qIbx=9idb>sK)#G9e3JthLqnrh)n5hseq@eM|2}S;Q zBrx~^LJnPw2v#FON5OQifjnJDf7MgO)`O}EE!=C_B>qHvOjDuhJR^l$ocvo&8XM=s z$df%DTogMETIP?Q)VuT59VRO?5gzit3M-;_qNNWpNUI9=SIB45mm}M_s3Xze#e6>& zPsd-|SSd8(0qfiVDN_hEDT!r4;#(9OeULgyIxDl|@Uhvp>Xmc;;sSUl803E~#;XM-c7l`*( zf|pDJ0?{kw^d>ttf@=x@eI|Xt+E_oVi971gy}r_4N{GE`7%}Ge#2zecC9Y?y@$eFs zblQ)vH?oxrTVboiTAiv4i}W$2<~K|3Edr~+ev}gw=ZqS40k$*vO9Z?Zc?=H4Oq|{p zAU;B50W6Z0#;ROe&fiWuM+ZCOK?gW3wrRH-whrT#&Kw)lZ~HFmhb=8F$H!6?f0UGz z9M(RaSt2V!+YH~}Ep4WE9yc6AREj&41ggpVD8mFL^;N9VB7WnKh|Gawt;~U)3hFd= z2@)&kE5Z5eXq&1hr<^=@9N=Q`!GQ>uqh)JpK#Ahj4V<{geXGkp)q+$%X5GR$I-u6Y z*Gst_0V1WccifZ;jeFhBI+R)T8o6BLVDJUQ*+ZKZ&6*7oFkK9fLe5i?n#iCuDo(T+)e|5(f1X2afWs>eIZ zSMrcUr;%ItB3wCM+?Hm$6LPYoPv%YzPY$I|$Z>6-FNhbO0 zrcxkK=1P5*V1hXNcDQ22+a|8lvSO>KxL680^QTYSmbOy5t%TBg6QtcT3zbXaOt>4Y z{Ei@!L|=j_*I%s2Nhra7aQNSdeuYWG`AXId{|1G2j`;iYZ1(o{oU|lAy7yJ1Zn-5a zLaI>kI!*986gO+u(gzp}=Gq<71`{xUUmb5cIgR&_-fbZdn)42_e)2>vTCv|+H%LHjC~7);@Wn&)8NG6rZm;)OoI4hH1D`A8lZ^mQt^@-hjr5$4 zs1Xw5%ii1#-xybk<)4T5CMt#pF~tCt?FfRa{sOedlqfJ!Efn_0G0C29*4uQ8Gzu&> z{Z4I{X@`913fi;g_Ts=s^{ak_P)M*kk;{U`xJOnTk>oFs@u=yT%hV(f^;xS z<)p+!CJCQU)zuGn@M742+Fqyf>EzUjFaWObH6S+;BfAtTOMYGI!#S#q9_tE3{*~bT z(XtyCyRF=VgHM`Hc215@UvL2AIo?Zt4Nlq|^La6ik55BV)=q=cP9yg84Gh@n0)eUD zN{Av0Z`#i`rj{o&S8Ml6}*FM^WJNPl?nWAkiu zfK&XW8BpBL2W7r{NJ~PP)cI6^E;pvZ(k(`|0wGCDGSAoHR0XMw$1AJHE960IA;J5a zCkt>UK|JeB_CjCA^YjND@>1e#5fno+)l94wh|D*c~sAQeR_}spuV4wtDpTH~oSHuVoLu2j=`{$yeP0= zqg-X{VlQ4p@!)T<$Mk8AxTATvC|>=B@1N#9wwE@(m$n)(C*ESFMW-y$zEk_#h2N5k zpji-1Sc&VKJ*%_$J|OK!Y&(^PPQUzbyjEpSj?(3qPLce=#hbN{ApwaoymwBDDP|^{ zmC;rGx_`&;mFf=pllMk>kURouaFiTDOI1OUZf%h83u;bjp9!TNl;y2pQg(G1?k{b- zvQrai=j##1frTt6{=0eGU$ZmF|?M{XO<+)4sULUm19*{0@khxFc*^zl^i zcF!@UHJtoODJ?E#p{-2HW=eG5b3Q3s(S4r*xcv$@BeHK?bhAM={P9>7PMyvP4lggm>wGeuM10r%8uv6H8y#>dZ1Ug?p!+m z@6g2Q>gL!tX4Ae5cZ_+ZI1||w4uay8B%^6MWx2}W)RhUF7?(D07yJeZAw&%CJD+Sj zpTN4}Ir=>|Mn)KN-Soaj)5U|pus^hW6a>Yn^+yz_4ihJ}3j^f_@vXn{=*My;@3+U? z`sI>SgLwCS6M8C|iIv)Ko-=3j4va;9=NwJ9ZAHq}g@%TDkNJknwyhqGtzzrEc^Swa z{{2=GCxVvky4h@`cTN)lbHK~a#DI<3$jA^MT2EJ$W8%mlA*GgP3`+RD7qJW3Yai?3 z@KaR~x7;_rh|Ls%(;nhHT3Z)d30wq?!m-`N*8ItkM$%%Ic|?;u297TTYj;lLsAbSE zqSr5T5SUP;_E-K*A6O#0O47H{$V^Dv!khsiESq5;|ABOQ)86BKi?%G6dI4d{F-njV9JY&X<)&l$nW5A zLc%lX@y{f`v@s9BH>w*UhVAsHpC#w&vJcQzjLspjCa-uD95t5A_}DBXljVgx6N~j0 zWB=_?2CbCn-^fU?98Up99iEtbpD#nS=T>+CQE2u%ZmFQ14j>{9O?}N0In9nQzWslH zy4Oa~szCJeI=3^=h3qrPj$vDG-sr0f@;PtVy%1^ZUp;K!G5)m{_oxH^TgX$AUmsdb zzz+pAnHK5Cby#L;&2Ra&-n1I{ry7z`|MwT$x6OXyF5>0kYCn6W31dM=)QVS_J!(4O zOZ@>LW`t3hjR=EKYIkI0B!ueD!5A`4!+O8@pT9Y_4Lf58;zHYAA!}LYds+``JdqM4?}84Ug^N&$lX*~awh0N{!uL_TYccwCff8Yha{o$=fJUhn+tNlp0 z#XWk$uLt=+=HkV(V(w>t3qW+>>1Q_!T9z4}(vB>cD;e$?s{IYsVm-(O55v(FvJ13j zwu$(IBlzr+A#mBnIzf22#~g%5dWbE6F+xXt=TpegEiHviSFju6Nm6B|s6aRhd^!J- zKp2es|NiwZr0nrTQHobhE;g(e`J;X0^K~Iy28it7q092tQFyd}#*Es9A?Y;QUH``A zi{Y()4M7r2sXgVNnBC>n;#D8k%_O`ryxEM9vVcr($mu`BJaj^yiZGGWMrg@R7jr-ej=+# zP@VXH7nN%6&|_R8m@Le-RPxTJ()Y~V3x!@mQ_S6y@QYb3gOMKe9Ps8(of9RQVv6(& zFb;{#>}eV&)2!0I`*?ON1f9eARrTpprhWnBr$O7ruV zKVEod50d%+ebY*?m(?iQBy0e1CF@imLv_L8u0d`616Iw4-G1)OQ7)pRdV{M_?x=~S zt$5XKynF>2n!CHZ^Yd&;ooG|YN{8jgOaY#b90@-x!I(d*t*vcfKrgZlHWQ3C!Dd^Y zQwE-{J^6pXbM~+Nk& zJv|+K7;~~d-2p+H5MI0uY2faGfoV>iot!MU-hMxgs6N|&F#5Oib`0l(FK0BVYS-HBYcj2i_f)Zua&|Rlx^U zCo@flNsy3QHHy3Ly?geVJtR{7@0DHw4l_7_e?xW}c6ueLGejiF-f@lX%5kf3OPh1K zIXZCbBAn-W19osm&27R4MCs(CZQg6l_4VmUFzp<`c_Naag0^U#blER|1-r=2t#84D zflP^+;<2G2QV=ej1QkK!v;WUAtN5nGBa$m@wJA`TmiVLKqDEb+=G;T;q*rm4b(nOX z3kGsc<2^HOz|af|3UYVvhuF$A{LMuVvD|*!G7J!3>Zj+BZFs*U8Y5Z)E4u%-{B1T$ zB9w})`=fK{<}VwEUw+hgIDjiJ#&Y{`qCTE?N33CTVo2T_05U6wI;>ls2&8rm zaz;Jpd&hI3Bo*UeVrW?BKKHY)FLr1Nj>P^8EZ?Tq!TuqGBS9tq>vL`bzTy9!t<9v_ zy6k#(3H?*Ax!bbW|COG8n6C=~CB9z1elGf)L*bxqeCaxGDjlUb1#?5Dm^KTvT}6|2 zM=bNJDG_bTg_|#;5d`=DI}B14va}xI5&^9=jNmEe?t|Xp0mGg2plZ{ug!xLgSJ3!v zL89~iD@|OUAOl$)mgnfh`RTh0x#R@Rq+yJI&t!t%TtuO=D1C5lF%zhUc1;@GfX(>0 z<~Tdzrhy_4DmIdxm&ZmWaT1Btd%sK&M?p;*#Zw157q6+!zhGOk5e-VZdinVqG=rC`2Ea(tm+qg7Cl1=X4A9 z)L>q>e*dA4L!kA*ls9Mm4}D~EU03c;p0a#~p(Rb4&;rZTqZ*>5dwO~dixS6IcYGx5 zD*X2O2!5OWcgK*TwAdgV!$Gum(@gyGwtYEW`V?4)w4vMDT(kQZ)sjLAECuLZWj`ty zh>nR#?Y3g0+&DNo{ojzD^Y@!L@wL4N)tL{&`c_*7PA|2eWli?xL$&wJ?)l)BN_#P6 zA=X9k*U}bv;lr_wwy~@lmCJh5IRmW7|L5IA8kgtk8y3!@qIQ3VI9By=lcIDQ--~Ei zorVN_+1Xpjb`gX_VQ0*Lb$S}8NZ<+%XpDy#I*yp&|K4Uuc1ofIm8TVkN9N;y7QY;- zblLEGAkx0N{_!{|L=t#N z{nCUd(oCZjs9Twu3{g6QAEN-+n!--$BPC-M;XbGps7FvoK7~AarkGSUmXMZ-j8BLn zxIi9uK60u$07Rf1$dLrXU{?G0#SpwkAh!u6ft3p3Mf7WSTO;63Rqq{8?GIT^^4bhB zz~hkQqVD|hLq&oKE-}IoKw*3(nBqEM=R?q9MNQ2sNN@hXrA~9aY!)9a9;Tg3;swWV zOr3j)4>RLS-Y=&C85Yd;P8pEaMOpaxLtmv0__LQ}&|WtD0RZc|6wDg9Fn zQHp=-4HnIZHJx9cUC(^IvDiVylRkGLL^JpV!ccWNa9*iWB@4y`F0KF7^J}TUI4Z{S zc6KH0#S01yIjst6Mpy1=#?mO!v>D}(uE4Osn9@YbuSzspTw3}hwP`Ok<8Yc4il8{p zVqFe}m=zojioO5eXHu$!j%9lLF>CN?yv?X29@|mV9ur0VwB9 zN|MxAPW!WMtoL}4E{8)?Zt_HIG>Y-t|gQ6 z7IPD32c?+|o6-YrMAtHQU>F>pN(&G-> z3%uvO0|E{K;iBoU3!3>0Z!BZVK*2V#|KC=C-&0Ok*U9wyJhlETWE+Jjk2`wzknw@c<6deZ}O7fgm2>`t{(~zzWlCd&fD8N_;@qpq-5^>`}Y@Lyy>u)Scsa6`UJca(ZJV8@gM@ui$r%?@)zj?AUD<+ zc+f38epocVUle@YbF$YI@Do~dxC=%`My{W%U)NmSPmtb=lm7p>dh38Fx9)q~0%;Wq zL8JshT3S+RX=$lJq@=q;r39oUMg#-|1RM|$a7Yy?>1If2>6V7yp8I~@*ZckbeXq>( zJm;Lf*IsMweb8=81Fo>Be*c9M>t3$7Myz1HiVA+h5ZaWX#cG{!urdB%imBiFb7&v~ z{EpYm19G1lW3HqnR}ufZ06#xJAD=_u(%@3%x%znyE-py3`oDk^i&@)m{IOfRTeB8$ zdI&)U?lAdZ6?SG%j3C%l^^T>B9(Eqg+DFV-)Q0Ei2cgmy_@Jeu=KjK8UH!RR9fjc@ zl^yRIjBSq{MA(Xverq?8)D!GxI$d)C4)uK0w5qD=$rSgARPDUvaqj7MQow#vXlN+d zkiNQs-S0nJUh-asdNOJ*IAMS9Ad`CrW{DXlvCk>OJ-isLsHKvYL&veHR-S7_aMMJd z78FTwOi1Nh;F#6O`<;e3nxd3EUQnYG_x>z;KLTSbc>glVrAxCu*d0N4y4MsYV+xbQ zzO4T5kcMJQ2i566=!#W)E{Dc;9lpVZ?2ewiUM-1K2chAc_>`Qrp1_MPFE1Y*y|wQ` zJSwWhe-P)HcIm=7EJJ#NxO%#XI4%g-ayV(PI~hDZP&=7XoADVK7#Lm=+5VKc;YEQ# z>tt|@POhES5-0)2G|c*uiS$G~c*haEG$gP}fbRyEpy(oNSU7*x8J{Co;b=Wn@<=WH zv4g{xvPGdq6uR)VXgfI`GC?8dV<=wOd?G$N3uh;=hZW^o0L96ooJWY2CML^>cgVd^o0O z8X@uEEz`yCF((9wbfyRJSb187D3qO@-6M`fcs|!UeU!1D-d>>OUf}5ppRI#KfLI9S znWIz8;o7NSA)mt$g*P+7*>m&?&&ZdJYLv>ETF0D}svlH$jE^%N9v;_??&sLP5yF_= z5JES|*2HHHiH41z&Gb0uEAjQK_vgZV3I^jf`Yr0Vw^Ycl0`rFRCO<9i1sVojmcnBQ zy6o%|#F(L&m2cA}R3Y@#T0l$!=2mib7V0H^JR2=Z8__Ep;Q`nUsvV^A036<)9>!RO zpX{~I&N0S*$jOmAB+k#zw~C2~Q3=LHWB(xh)frV*t<8?-s+t})Zjo{A7EM`Bp_sdO zc~?r%Tl>D~%Vza)XKz>sK#OM)O*d*AzAh*K3?va>Gd4V1-S3t`KdFVqcDv`I`fiG=hk)x=-^BL{cI-Ll)mG?(Db~wOS&aKDMDQR6qBXP?P4|y(F>X zpuu$?55o^@_MaUfwVJ4P3&pn>*&dQpE|-w=rYv~21TDw)Nz?1EmqF}|U`aaJ^woY3c=5URxr~emOeqzfPyoN zQf|zB&D-e}Y*E@*hFldTCC;-y6B-(1>n73_vwyPVF(kbD`z-#G8(xfI9}4eJRMq4T zsJG5$?82v7w%&`WgVrIyhxW^oEkK<3h4 z{-BkglXJ^9Sgp1?A_W3^u^ybI>L*PkwuC4Y3TiN<@~~}rY;3G1EU3889|&;9MM5d< zJvgs|vtehjy8TSrUm)7*aY=*Gbk8~6h3zz%7uiSGo| zep3rL=uI;AehQ5hxPckvKg@XT#wyDS3s-F}qK9k+(>ooktcD;UZcI0&d(9zhYbC%@ z@*QsX_VnDFj+Q)`mpt`a=wYrHf&0851A8e+H8;xrFKli4nRLu+Jk3uTz8=YmYnPhH z{i}(wcov%eISj9Yn^3eZd16*2fW8roU2Gpb+wp;g#XTBzdCDQR~HXI zzw7$1Z}7{|=AtHg8ILKxr6=u#(w7owH2TXxYh`tRu^B7`cM&M@brltqN*Z~udl!D# zOLBfA8t*Zx#KY|UU8-6ZTS0>ijcW!(#GH)>ay5F4in%@PF6>W|nvQ8tA%Z1xPq6rv zf&~LM-}8I)w9zc2VOIQaly5n_)eoL+Bc7JrpShabi|On8{G=&Lp3d)cQBhG&j)kA! z*!6~@l$tAGmh@{%@u8yfm9&g9qlrOh~A+^?o!7m1vQj?SSerH9iz7@VBCT3fT zSzj{^MbyNLGnh@kyU+C>Ac41k0^y!ET6a)yu%@i4@F8UInXTY=LSOhx#f0wA851Y9 z#&Q}A3=RS{-4H?9nJW4ZT{IF*NZA2t>-fN}y4{R7L*42z+!A?-M!0KmkmWMoN1dhI zbbs%aVF9?B-IPW3ZE{M=VdA&jbK4?ZN$jx-)YR1F_G1S_Poi%~`d3#}=%RFObe{nV~JE%dB)h_U>w@$UHDDdcL|;I+?<@L!cJ3D z4H52Der9GfD-{!vp=uK%?%|w!4wpWt(gqxDVBZ1`W^ONF$GVB=fYqLCB~49D*KS6J z>ok8O+iqn2B%bW|oIj1vjgE&!h$9*ZisY8rNm?^;dObNFa>*-Z8Hv%Vf%s8TL3h{L z%*qOka32c`8%^)b6|MuFlc)7_Z5N&>tikj(2JHfBV@!)#+gzK!Jx)qHMVO38Dv6Kh za&c4C4bc$f@UXrwVvi-Rh3RC$R*>>h;A${-w8bq3dC0jYjzUn zg+(ybh*F1(pt!bPG}xE3Wa3kcqp8w6iwX;C?=%NrVxb}73p7jyx;ISb`}`K_<3|Oi zIM{V7L&ejL^n-SfOEKr3Lx8d!DJMR>>%INE(5PzLTm0mF3C0#Ag!wIuvS0~ySV$J6 zMs;7UGve&eVj^Gsjh1IkiX)~C!>zq+bZt5Z>=VjGQd&efI?x+lN$up1B4%xY}&);u?OLi4?ySy;@B~F-T)4m85P^WKfdvKbD`1V1F5dj(@w~zG&S{WNfp$T^uLPX~j?~%E`WAB+ z`xF?uR=h-6q!y`cko2+Gkt0EQlAXOPvJ%hh^4}Oh%R`%P8Po4j~^C)|4fAd$1+ zdDrNVqvat(CbH~^U*VUs$OwpW>%RqFjJ_dS?y)vrUM^Uy*Tx3>7kMyt*CRO01~rM7$2_OOw5q(>(cAC#V@F zB>!fg5_E$i)U9RC$y+n5&wGPH zEoGHf4d}CLL2v8TO%VQp^74+qJX=LFW8JBu0)RS`uv$bBvopt^fnq)w_N*^ zmWDFgTkX>)4{Z$#%7o86*b%K7*}>6?6j!~J_&#nys`g%|G1H7h#^0TDPnaf3**Lr3 z23A>L6bhMTg*ygCS0YNfc`(;oj4t{qo$(T_s6|}6b)#3T_UGB z{cH7ky&CQEM0Y{KU^w%XtH?BuXra-y8fWjl%{=yUa|1SHrV=GSTJ2v8a9J>vlZ;SX zU;Bx{6BnO&jch#w0~d^8qE|%y6w$sk+SY#SZ5#7tJdlkbfHh4ct5p2!PJIsF>2V~= zuyqeS)fY**=yA#QlAC}B|6t#Mf_aY~f2~*ruc)A?lbf@Xcgs^3)PZ!1CvVb7A7whJ zv*h2(&Q{p>Y*D!}{3|P~LS38w2GKW%x|W5VZ7OYm7o}=F`%TfmrNgyBqrsw3ENh7^ zXiw29P(aty{;WEzg{%-O)7LfpX{jqJHPqd9Ow`PlcYVKFi+9DzyQxSu?c~?;PV197 z93`_dPk~wKQ*qKwzs$cM+!1n|R5siyNUeW;o7g*6=Cv{tXGD2|SH$2#g#7gWQGGxQ zv>t1)CBRRLI?puUj23g=6MS3`)DnRDHJ1+&^|R|ZN7SjqePhFziSg31g6z^q6Y4C9 z;d~3PM&{noAm7|bF?jpPIr&DzlA2PkD~i(ULqv?vv%gy~FiwFPWyG0!e1p0M!k4AS z)989pQ3*@qPw$~-V%Q|cy?8NTzZJ1MiZ1n39NP6)q--WDImkHxfFqxFSL{=1XO|v# zqM|eMZSUgSFCuQU+x-#g2z{hb6XS;REzR+e%g&VlT65Ogm?Bg!|7Yq~?YIeYWwo`m z1R+qRB{GlXOTJb$|4sDH;W0n;C0enezP{~ya$oMTQh;j^N(&&9QqSK&jdAWox)GEy zrnJEM%tp@U+3;<}M-0dobj|`#g;7o{gl%pAuXR?32v$GGnon*Nn3{ULLXZIe)Z5T_ zB(A;0Y6I!q@?qXOqn@^>vsLnY$N!LqGe=EeT zH|nm&PuBjPFIbG&?TYirzrH0uN$AbQZ~<=>`2cwr`O^1_q{K~$7Kw=#NylmTcoW~B zy`qOebk0Z2-%pru5aR$VN&En{>#^wJB?%`Jlfh@j4SLK;7QK&P#a;aV^t7;3O4fZA zvyA#ESBf$8;*)CT{8wV>0!l8aDdD!ciXAa52X*S3)>&M?0{7DTYLkshU*xv5r%U0^ z4wgl+#dj&!=b$h!H2kc`0S*N)<0^h4Xjlg$ikhnG@X8-zA8XjyqI!O9LF?UwBA z*6x(;mI;&#EE0+MHWWOMvBL-o-I0{MQzu+H1JU@nAkVBaX5wXT?v;`|f76QAnGA(@ z19`v@0@?RZKEm-UxT?zn32&-<4=O8ZL9)2cc@XnKvxjMbW~2e{>L)$dYIY@#w|o2h z`)viU-@gCcRV1}_*22O9NVYn|FOFw}h4$=FLp0_0SU=eG?XLYEIc`?1rdA>DVSC`u zxwd=ZR*?$g;AnFl9gE)BZ??XceqP-8S&V_q|G=fjSt$5r*z&sbQifAtqa&-WIa9WT ztAR}%TgE%k9UK_=DN9GN=fW8KvUOJ9*ti^Ho2SJ_5y8p9k=#B9(XZbqYOvY=JT3%e1fokgO9vmOWj^YVoe9S@9;87`D z^O>hiSQ2gZ=<`&oN@M(fnXi|RRI||EYA^4a_GbP-Aq60va#eORLKn=(kyY9{-p7wV zS@2;(p&?rN*7S}y*n_wcwPJ#TPe-z>PHUr>ZJtYXGR4br#yA zA0&qMcthra{-=i?+W-+JAR`QPSRgeLTgmCFg@x_}Y-}lca;kFTR)3=z%Z`Xy`^)!g z-0}2HE75;w^TBS_>ig@~>4q$)rIN8qTR@t{3d>fzrs=Tksj1)(?I8mliGKhF zrU^>B)F?12HUcCER@>a)`D{^wS83Cvx#~hDuq>Npe~%cOoYP)NS$3ryrV3SsYGTsV zLd|a8M|3@Q=TPPJO0D%hVL*RSVIrl9Yy>7HPfMSbERH$3#f%p!c_8pXRp?&?xJ4U1 zzv1~wCR+p2s3O&5B^A_i;X!3`M!N&6Q%02}Yqs_dakpppzQacE9keV=yMcB-SX|y4 zwWik+Gml>Fk!>FQo2m1d;3%_FSX&E(%pCw+O(=hZe!M@`76*F^r#{c@fI+yIB~`V` zkPCh$QchP_7nmzbO3Ek2daPt`Qc?{5vDvVm*Ruh_$KFGX7EDMtZ{AGeGOBc({JtNz zu<+DE+pF$6IlzAf=6-8)qbEjCtwE5HM;HXQuofj+_B={&wS4rsL#<5>kv0ICtbkmZ#El@iaE>%VTJ0_~=owK1y!~VAup$tLQ)nojAqf zSFn_AZ8Xt!c66B5Z~6-f0<0j#x3TUAD7GtBX|puWpjq*t@b&!G{xj|`JTjNTb@UNNxxAW+;r(Cw_5F7+R={6KcmObts6FH$$NND76O|gIoBc2xWiXXyOWMXZ zO#@cW>K+;xfFdgi=%iS@oHl*5Vbm;jacAe5kcm;rltJ2!6d=JXii9Da z>Dx!bPQd${+q9T66!eU;`1$*RDek9s6_XfT`x9-13Fgq3-4Gg6vv~09pxx=5Ni(a~amHW3uzQ7v6Cv zE9TI?aM{H}`}|FkTfp%HqO?$MiY84-onv%Z>jMpx(O6BGapA|n81q!EMwu(bsv z74OC`SwPDWJsAYZ$l9E4vt^p!ziAh3m+m~>ruIc;+-rujtIQQ;giOAXQpz==bDqI_ zoe?whuQQ*l{II`oV93h)gTU|iybHtn<4@fp4X>4PjzG=LED_@1=U1c7DwEX>9XSz{ z+-XpbTbBt63GMFgvXc>HsK0#5K_Tk%XSu&X7y2er+6S!5^rBQq!!8J_<@RQ%6AKFqAyjevsBSS^{QdhYnFIK{I_C-DtAYwrZOnb*2&RVw#a2<2^4{h3 zP!})52MIFS4=35}*X*v3ig$HSJTxepCWPX+&)lU`jZ@hu1)DgGKgsCaTT_u+*!EIk=bb-)9vamAfbjaWHX+H+4?0$mR7UG80d63WWyN|#TYEIy-hSHJ z5U&!{KnyEm(~N$4T3k~_hrtZkXxQ`{(h8B`ad&bcsyvU|k zNQgauhF~rN;TWX4MdC68Jp-xd>pwqY%1w7g{K7m-3=5?`>3xKx=qduiw5hQXq`9W1 zrun%!@HHJB9nC_iYFzy?7$`(PKcfuwYmstrrYgXl#m>$SuMG>;VEQqCyOrFb(W2B# zEKP<8V~%pW2n0W6=Ym_8s4|k_if4Mzyn;+3twJT)CVii=^}8Q!#W#Uljx| z{be1(n*cnD*`w}PxOJL5F*u)&s19#0F)QQ5EL+H%321QX-X#tD0Z)bGvmE!DPsMuK zekQO#dGZ9pJkT)SOQ?#IKNWSyQ22jwUFZR+^eD;&l|KkqiL7JgIB)^D*Wg)sB;?f%q!QqkL55r41mPu&V+>b*lr&Bbeh}TDvYD1eR;IC*d8)?~pl5 zORok{Cbh1ttx5Xstwa2BUmG9m?ak`9h65;=VqS^?+5T2Mbeh7=@{w}#a&l7}p7Qe0 z%vT>WR9)Q^ig&{LkLYKvh%7W78F(`6Z(?v7Rohq|!iMHgRX!X&0YM;aGOsna5MluU z5-mpU@#L7$zx%dX`UUr|Rx)1c_zVZ1qVW&)q(!|#?&jYs%_4#_k**=Pb*{WtoCS*q zP~G6y7NBki&fWO7*JLnd6rJSw!~{ZHyJ6OO-?vtQi8P`Cm{AiR*t`Y0MYrM~kbNjB z3SgE0Vt;>tmbkH>(+3PYNF9yhar{;9tBsAiFeE zw(yKaovWgFGWs$>Fz6^Bz`s84j7B1n3kwVP=wlR^OpEpYp|`=a=IQC_?@z0w?hmw` zY4IMMEbzAJz5G5aF0s6x?ec}DSnHz}yMC2{2i^GHFP5KN-btgh$v1=7t%u5OuUGLp zo%BY4AHqn`qe0vyK4$H2-LQE%zdPTjVuv3|{hAFYqCH%G8s2JX_D*!KE?03eXb;7D z9|xBzAZ*~%>mFJe$(Pae@Ago_5K=Rz_F4Yq)z0iS>p zb1Oj+EON#1Xf(RrrF)7P;CY@7f0=;&7~fuVFHn( zxV9DM>C7qbvB3Cm(LR(Sx-(v(ff&{JO+2s+ckJMx5_}L;DW#kv|EYov?QcF#NGo7X zP~7qMgLWaTBs%KSiPaon@E=*WGv#j{;tI=AK<~7-`3>1uxZ$rJe1SmWUA;Td%Dpvtlwc1-D39BeCrhg zDSWtr-e89vX~RJZKnE{wGx7gX;IWT>RjHxTqP{EbENrO;)BT#~!FjTW;WvK~<_I0p z>w@D5tLpk6EI@b5pY81rT5Rx4M9yyR?j%G+wquoUAPPgm2Yehu=wnho2F^=D?&?nt z6Sc6j+r^q2rZ;3rA8Hy*16rzB84>wnb8q4uWq1%$t8sc89#QOcp`n=lYGRM<$A9HNwTzb8)Jr6_&Y-Ys55Gk1K`UK~7=z-Spf4GbzzJ1C^kH8tyW+TCvy8PXKZ0 zshbLs+FgzgGcjbV-H(*0t^Fe);Q@+KMASWv0dE6X%g}}$Z@=y^i_xxu5;tgHivh_N zDWx;`Zf$I!ba!Yx%}yL-hy9?#61EL&rQV*6bb2qhq}2}!)1XL zD=|x*6j*_)oH4yuMUf;ZD3tdu>#p%Y^qQnKoXWI**uSvE$13-!tno zJ#8fuR~2r>*`Nie7a7T)|K%_>O;jiE@DE;ErTSpgwS`ly%r@ zzft>(28;fIrOJz<|EMuypp_m-56F&8wUJsl-xW!>ak($1@SYTk4V!l^BefZ;s4*40 zNNd!a`dK-hn{zm=L$e!8NsUSKI@PKOei~r%TooxX&3_9HK|-){K&m#yZfrO@cBx>3 z_y?nqkA#oSZ{}*`IX^6UO3$Weo2bsgFL)i-{m+`0>mZx~usFoZd`@gVG_2iVzX}_U zO2P-_*@zHU6nf8co#MX|qsF(ce(>Rd!vLv_t0_|d!j}b0y@M$#1dv?K{m^|qra2x_ zl#*al`;BO()&4vYybdT=J9`D}$)B}z$px3IK3TM1ndly=%PK&%4lYkz0}ZAY}O4 z*!jb#RjOgWm-Mke-=l3i<~Q3TJJSzmzC-GVFRbI2Q8t?T1D|2{(tqE*B*VP)QQgEE zhzMLsRX;#X#$qyXfJ|+Csh`v{Hcm@V2j)m`spbI(1v}YqT#=bp&==I1w6t0yQF59d zaFY_)b0m@ip1Lj-e3da&&4_npsE9$8!A^*NvCLb=Y$L(lzUJ*8>oZf^arMi3JE5c-G8;Pf zt~-pFYybOn#O+Hv{_Ec^)}8DWonjro3u*!1x4{YSxz#SjZB$7{gqx~5zrQuFmL?Xq zz>@C!Vm6?v<@awZk<^?MmVJF-U$P$xlnDux3;td#I~Pk&5yq*^sT!$_z6EJ?rKbAoW6IOnX&yW*#L9Kb@+YB&~X4P1XCJjw>*8vDJTl64;TQvFH&!dOB?w_ zuVS1`u1~#JJ@VVz_H0SJO!Kn66 zZ|X0rsm(7^vClf^OX(J|bRd9QZEEenmLc&z3|QJc6_XwossG$U3skh1@|5ui@Crzx zpRI}i!vB%AF;z;LSI%&W?C(~}C}^490MY?4{t1}Uu>G1)uViGLtyztYy%OEjJ2GlehHlxA3ds2X^8H5><{%=L?y zLzSB%J&Uq3d*mrOJpvC$icph~D`lzixSAKK%un6$+RLEZ8Ewc!`Yk=ME(+M20w%_= zm+cs`8`fN*?1?Yk+=jmy`Bl+k(8pf|fz;Ky^~j(V!qnE)t@#tL$)CvBhK1~BLNE1L zjk_N-pT{zx_~Hx&xQS% zn#ydQB_#-^j?5{1UtUg8ko=s}wIS9*I91iPBX8tEE&h}YN>d=28Z3P%<5tRb)7UR= zE#>^BWb3#ZVOstxqG=W}t#hWa$(<`eXE7E$6fD@2}mnmtS7c-efD535qT>+|CGbh;N<#SujhCA_lq)1RXnZJG^VziqFf= zA{^~a{pSwaM)#_{zD*VT{M6<4caoy>`sBC`lUYLQCmpDrg0C_}Yc}@&>TE-J0QH}_m-2Mc` zoS(9F_c=%_I538S9%6~jl$+;b&wMhtFb^iGoSdAPRmMTtA3Ex%RPv+4!_+-)brX`J zq7i|3R6fEqbDLk_Lj)@_Bq(j56O*VLe&QSh(`5o{ z;>yGh3%@L5V@~;3`=kD?FZwHOp|l3gw`N^{A;_#Oh8qZ_Ih=^WNvQ3lV$}_D^9mn^ zGiO?HgmX~VEEN~uQO?cDS*OTbYYaVA#XU*cKuCaJG8oL~b!p%nFY}I6zRgZDlc1_M zq6PAT^22P04|Z#IOVq!AeC{^;A=EMH4EK!KVI;&w_&{h9t6DCpl>X+(7Mn@i9@yY| z_Xf#D{fnQ;X0w^Cbh;d&EKNut-`4KNmwj?2qTy4ua~GFa!+A?$9ZDT()_7k5vKvCYo~sDlcC8)4j+A1b32JvX-#xuLp3-^edZ&t=1K|& z?pIcd$gBa1@Az2Bsas?$J49b6!~U}31BVRbmCX+Dgo1k$@x^fxN+qPSg`J&>{&!m( zFh~JZK0ZEv8@Jgrf^G1>=_*cpX^zfovCE}M;%2O3vUZTKHe;gaq1sv+o2)-bC5%{~ zl$nlpq0ofyRr&kEG>u0alu^gO`YqAbDo##k&tBk@qJAE^uZ!>_XMo;fq&7L!U$l38 zS4Z!*Rk)?39WV64v1?;1iS_fJ>Z=Nnh4sTr`bHRLq}FJyzfrhS@kc-zLxZpg{eK+_;g>((q`tzj@lAZI)z9+A@p*^2fX z`0^kxcvtKI=}A(0lOnt!3mgQcS6ADX>354{_BKEZ_e)@c!BTRM z{+VfHWF#>$aklcWj+9PtM+R~I3Gw1@#2Zsw{uR5X!j&Se(JJE)Wg{b9J40!{bH+yF z!>>oq{lon|n2F*C_E(k8e0vomXYvHRcytVYLXy|TSgm9(*9)c)Z?Q!Z2%z-~EOcTc z+p0~F>3SyL9iYCS^k^a$*$jnK-1nqe?sC0-#q|en4h}`CxmP0^tT4z84vWiYV=PSW zI$!#z|L76&%^Pr&(@;}Ol{_4uzVWRt0=sX9ML4A%KIF8719iq_slt?FRErd&MXQnc@?UY}CTR+KqQc?M~xlMXfofm21f>A8X?Cu)^eqLy?z^tc=?%W5% zmuI!C_QDHhwD$^`wM}I@4h|?dj9Ta7!nC@sx0#iodsIS;FONYNS52+?jfQ0L7>6s5 zBHytuy6y864K8*2j*9WRu_yQX$4WvHh9rW)JmMz+ai;6_uPSM!D`7I9+~EMmMrlI| zMl2m1i0F_L-~ys>BrD+a`cnEsCsWIqRL~<-pcA;hrW?fWF@XZ z>)0ztY=6;A2E%1MYisM*ip-lAw~fC~@*GV5u6YYaaInapq&qy5!1Wd#dJhdRwd4mC zpcDFO`e_92o)mLXZCwpy`mjAQd6C(!zN?P71SJR4VHI2oHP$dB@f!||*t51Jth+dIt( zydO;!NiT%y=dS)<6W-hN_mzP5mwo{#Q-hB(g7dN`T?SQa1H8RmL%d#|EyYJqfN=bxV$IQQm(GBh^*dk}ee)AS?ITf2xCumDSA(cxw=EHDTb3OqVWC75OJg^=xuAoOB*i~*=YGNiGJ znqwx`R{R251qmsU+-N**QIo^{}f=aNiC#c-SPVYCC9ORRP(eW83-yd_Y6&2?v( z%}X1qY(GsS7avV|gpa6kjU708lFN6?$aAls^bb7w9^kbhNqahb{>I)_k%I`rNEEJY znH2r#E05`eTi{4$Ot7-HS$C^|uoz*#Vl7ZkElc{CF%jYr;Z?$|_=Y6AmQ}ZdPnW-) zpIvD=e*Tm0_@^F6BmdRCH(i$+lo?|kMN;9;2|hl)WSIV8#UE}88hEPelSb2G<)qcr ziZ5SYmi>;@8BnJji(k^|7Do%F__(PRs!8n6?ADzg15ssDR1@-ZD)5rTudRJ(QiFhb zzk$f}G5$M8iFEnM>8<@wh8z??D_$oGk*D>Vu`m3V{vq4H7W)g@QZGZzr=&!fNiBZW?8E9_APmZ4BYnofREV6?Te`~BMih?T5?eBdx{r9Su(A78HtXnK5p)0_|8@jMC` zac~Uj`)vr$3|;#9UK7c2lEfBb<PN#G|^h|UoIUbH_SaQ>R@m*UE zZc0XkUg&pkkp$IS8fP88uKnR|=iu(($R=IT;$@E4ePBi^tttLJtGmy{_6}LVG&c_Z zetuOQi*CtDx{60@>`L42^R8AU!F>{w_l$YMqaCQXnpi`Ea1znNUV3uerpzUM2|V@J=< zWNU}BrQRRx8`m1dTF~M)UiU7RaOi>95B@ici-}+C?5l~3LbifmDBmu~L*?0YvFFbU zbvT0$$eCj>58R>G^{>AXeFG}^aHR_Q2CrMiR9$%Khgu?=r+Hz|B9(57GRBf~(+%A1Z!=jkA|dE3lpIFrg8~d$%HL{|wu7itoOK zL18IYSi*0{!jOyd_%i5$QK9|T;$E9fF4Bc{0fEqwz#RWTk)?SB#03rHXK?bAmKkI} zEY>r~ocz$csQ=d3IXM;MDo7p1)xj~6xU!%nr_X$czrR0`ON+z!r+odrloSOft$eZ- zKf8-`lAor(mKQ!J0e_YaA$v8oF;Xb{ZJqmKAfM((mP()*lV_57x7P@9@a6?nI;acKy6tMTYWxW_~#=$_j(2% zTbO^59IKcOk&piJ%+~(UX(IG5VL0NtWf;F5u^p=D(qZ4+O!L0!FGpdRV}xu~hTah* z-FU3Uk7*|}64;)s^`jpMk#gE$`Y5m(SCz7>G+TtE@uYV?u}Ae=S$7RA=^2yE`9%@YD_c(S9V3^EY83uu4^sR0n*Y1irL!V`ymTC9dhyr}&YkIz|#$B!_e4RZZ|70Zvn2GIQ+A+1V-Y81!zF)?CMf?aoGZ5 z9@LQiB!vGyQ1RX%a=R}NJ%kuHPRLO4s=)$3_?)(i+x$JO?IuAg@f8b7seC^y7#-%d zRgGC$|B<=D`H>USu8nR)p{l{7)W^;Ua))!x!G{Jn>_a^W$7=|2SD0;OKL`#oTG7DB7I_L2+Y0_=bG=tn7kwMzSYdEPM^}A zSpkM~T}z>G=C;@51F3t$C3#-kGcSD(~{}ILn?#!i&Bs5^Fk&Sys@~Ub2u?WxaOdhq;$A$O4v4z&(xqCNE8?I|w zaIG}t;^1D3h%soKbpr1MDr2B;%-U8Eui?9%u)XmoVN{{A$W2Wxus$c*t0JnMDX1L4 zvuRJdj+ zb~MGDCOOqjKkoyXo^NKr6^MaP65utm$;mWTIAF^Pn0%>TF;irZ% z2>jHu&UY*66v#cZQ~Wd4fH>Iq^;c0*f%%(Iq*7!y@j_VAX6-aBZnNMMFF}r;g-KV_ zTV(y4Ap;?Dnt_@6-)5b9A?nBKbAMDa?>WG&kwer|t}l>Y*iU z-wdFsw8CM%Lv#(8ldQrFpMRS4FT^N7UWGZX@h$5E^ILF^w)M_na1NM2UBtG@jg0{_ zNFF8=<6u$%$l4@6JDVA%8X8@3u97i*=%-mz+yD+&CXG8TjT9;Mg>gztZx;LX1zyD5 ze$cGTe6{5nOS1C&pKEp6x8gT^&e4h*6?)FAZ$-#triyx;9L-AxtdtGH6c;*TA|mKp zR0W1_w7c%(W;QOi}b}zyFv=NKm@9S!UJZas>zT2S9=`-Oo-b|c^GLt zIx!LbxeQ7zwyXKG8*xx5rg!f4`{Gb_0;3LzI-FNn4}^Iy9ER)oB~dWC2TWh!<0MzsS;x567h_r+B*g&Q)-Jv`H_WfJvcg-q5JzzD;w_2@EKL<~yo5k%e#i1S zBevzxGG#^yE@_x~c<~agt*tG`+KZTxGGl0W6O0E|4&z$*$(TBj^3%CD91a=4jbO38@Y+4H{(UbjZnCw}2zI&}?)sQO` z`qy7@PX)&{(fYKR@bKW!o+B4*4h|Q%jQ3>>9H7VjO10hG`nT`vhna$<%Dw8wig;~9 z(VslXLiiV6fNKc6-eAQv%f?gaD0zy4Kc#7_Kf*!qjz1IVjte*qoSp) z1s@k^LAp9RFi~Q3lxEIO&_EC6h?Lpl!mXUfv8R z^}Pefj*yVBfsU%=Q7Pt?;nmshN0~=)VtQb(goz56c{m(Bqoc3(WUhgqSmt&^3&d^Uy&z~9Vcs<2uv;15FwE4#2ar4uz zYgr3Bo?>m9Mn8k`FxQ;XH2K&%agq7~UZwjiIWx#8gGC5=+^|6nwVzuE$EsCMQ{bQT1!FfAl~>gaFe&$oO0i$?87_BvXO>5heP^~(l4`mHT>`ZTOFVx1YfyNZXZm}1^ltq8l z-2dIZ%$B!!@3h!rlXH5Xg6siZJDzJVzR_EI+D6SG z?`FJ-xrigc!)C@rI^UTt>9I-^M=ZmkLHM2y+<;O!FMY4XWYZ&LDjCTLswyjEf<9MN z++6y~@N5>`s@mer3^VrhmP0V*1N?5ON>+wF@+$}Mh4ZV z%QU$KOVB8C=exIHd}IjYAM&b^If&0-chL0Fv<&d^aY!jNj-V&<3VO*QvJ zwDaU>4<;9(l zcMbw>Jy@cCA3uHo*#mvMwMxE10K@AC z19NU%Kj&h6=J?Y+S~4xh4;(S}j1t}EQVKAYPK&EqKK81z{TZN9 zeF*$C0Hf9EDf2j#D^9UZn|n=?(E1LpdeClow!U4YJ33wqkavre{%T#8c}C~)IEGp_c$(!IKSxL|AOoD?HVBksMuw=oT4POD$WthMU< zbEf_b3cM1ES#a`%{;z8N@$o0rL;oL3=N*sb{{QhvBC<#JmSmF^;Wk6rBYUUpy~)bT z-bq$=NLF@2ZhI$L*(+pa^LyXt`#XQ1$KxE=eO;f=d%RxH*Z5p(RYgvX6g|nuQ=R8s zt0}8}Y4;ux#(w{T<(17$6!EkWco)A~1FkB~yWWG-ZFbfuUmfrZ10dC+1;xM#bQ1om zLFj$v%5jkr|9(Pq?6%yjS#ayl5+aPw@B&n5wM4!P$LMiVv|^r)@PGmEN0YO^ItY4v zQEI%32^+zTct11j0tGqX!2<6Bw6gK9fPc(1EaOnpWP@no?&B_p7Fh#>v*b=lr6j%N zGPv$$>>=l%^$Nsdxvd83KQh+nm}wE?qGm5zp{X3{o1AZxG-H_))j)5*fZ0-8RpBX}9$+hx6bR}E8M#;Y~N zx79QMIX+zYHFb3v$^{@K&l?UuxPFhRps1ZN7faKEQUO8G9d5KTKo0Af%=C08(M%T? z7c5(uha<^=bbR_;DDGjwz)_PJ?{(#n?Nr{G2SEE3z!FTxj{u&(*men1v^Jw!Wra25PCU~+Z6!N2AMetLlNz}8qR zt&0ezk3(ct96j0QJ@~P~C*Y#NLQfXbBY*<<9x;KjAq4Q#F`I$Nask zO9f6)QBgpsQAd+GTuC91@L$lqT!({vYziq2cX~rZ13^1?%Q53VMiF#n80@)8j}h?G zp=dDwrW}~Cr4ASq;YsoLTnwoJ$o7~9&qa}41%4IP zGBA5>*sc|iNDqSSn1jrm_Bv3KjzBTrmYSr%{P!7f0uM6D$jRfm7e-SRnAwv{^7Ac0 z8>*5-E#ZF-zlFTw-+wTC?;>I@ShEM;NTu%i6Js8Rqw5;RJZWf$8yhcOkCPQyQtsfs zhF_2t2J|plQXVo}sqCVacDQxH)*&b;HPi8?CiO@`fyG2mTOb{-OHX}c<5*E@!wc9; za)1Rzugu-iF|N1{&GZUrAADh7QMVc>18D#Pdc*OJrr$CzQ;4raS_zeg1wCxENxvvC zzfDgEzKyH`ymueS6nIpl`QzUt1sC_BImCz1*Fr$pdTQkN6^0kZpF8twN)ZrnNddqRvBR0lVN;e zYui!X6xE{^A8epN{9oTDSr<0AnnzqyUF`}EUwkDP$P=$LT=V69S_qVGamwhYDk}U_ z=={@?NYo??J2Q*sq5Je&J`=hFt`G0?MxND|Gq_4=E;rMjU=^ztWkJ;`m?7I<4Dnux zOrM}8hF)M0Fdy8a2o>dhR*O>IQpiIeqKZu1a0y_k~Ip@caW<^m7 zjx0j3bUNOmGHUQ>Y{TZ%{QyX9;1~oAp_8{=?>`W_XUA^KDjb5sSa}bc!j?+CXw&) zN4h{&{vV)JV-Jq7yw(s`RF4R4&AKZkRqi5Ci{W|X@Yf@ciu3cAVOKug=;6Tfe&aFH z5SB?rJ^*;udjejk4e-t6md3K+gaVe5`5koyh{Jmrvj%?~p*0Cf~9;ZX~}S_V%F>itD)7cVl3HvsT4ETN{~ z9ajxL(tq|0?qw)vPeG*f0xFIN+mlscUYE--WgU)1@WI-GSJpqGpD7+H>#yZK4_TJZ z)NPMjg&m^e`kAr@0cGymta_2#bqGwb=$IH#3_-F0C?)oP)z}n`z;y_(aQgH2QoWS0 zS+CURNU;_Gx2Nh0bA8R<%i!#%=Xs2kOKAF{ZVK2)9;XK{GWuUj!tbFH9|jE)-0E-Q zuvacG{h4XO9tdQiYj`10rXb}hHQ>S4VLzCMc^hcuo9kx1aSrc-z47X+*xo$Y4>l(% z0zd}Xw+HLWf&Tv6`1q|r2kcA8U@)ufS$0l7QbN}0^_GG2nX7ba2fM=@TQG{VB88mp z!%yA2M1K9^7_eMc;25E@IrI2O`F68jY`a84K#14Du=;fRQl`nb1(aUtdsP z%4QqHb-@G+_X9;58pbKuZ6J;B%wlwml1%u?uuL9+#? z&p#;EvkNT0fBQtOaSX+XoSYoUE~gpC48hxL=K&%r3yyBHswDP$n7#>ZI7~-xTEX?k zMl?qG65P!c`ftENK!VGu%>6bh*x=EhzzsrECrgPys1RK^fu7(A zOPYx5TATrwhiGP&-#-fCKJd~C*~iHs#lcjr8t~|7+6Bt01tlRVN*EwbPfnhIY>@}` zkwNgmA4;QBv}>!f%b?f~uH<-Pk_fUA(uMVCOaPF1%BgNDb=R z;W4&kQtr{ql*EUs>SbCK`nYz@c9e#<6}_q7+mM&*r`WDrh^F=?_YxwIei{_P2C#O{ zS7%7JpiK_1{+yqm52`{t5wcut!1h9+eet}z#%2O4E_gnI?-4n#1Zl<3_s&K{xOEZF zDHFo56HGu*{D^e_jmSZNE$lSxTXGO3Q)g2~kX#pt># z9L>NT4v6$b#bZXZpneU2gh9|=*J8cnJUVe7F)^{LC1ZV^1>Ynv&QU5qP}S}g7ry^S z@|SErOjsaY85ny0xu^jlbV1Om%EwSs+_@v^$Y}cgS6iDDN0%>5%7f~gj1etu@D!n! z;Cuh6LYN~e#Z!Qxn21XM4J4Ev#?esfW>{N%m|p`L`TV5SIZY zyn%Bq%>*FVjUUkIYM%)5g#avj&$}6(2K=4Uw|3z`Y~CMu2$KVR%wX{Bz}IiO-QWh) zNNWKo-Ou4;0#OLrWG94*tf)DcTX=i_THQyTOG2==v2X19Y>jgRQM4*!mZM(wk^je! zu^(6=bqAl!Eo*XteK9-McZCwd@=ccN0TInS(6j-8(Tr zFt&S8_*mjPLow%j8x$57H=05%uu=YNd^|i__Vvxp(hm7+abftMN8n)XIKX5zi+5!_ ze3zA_!c5e+2RTs?!@+dla@HT)9kJ>a9~n%NLNSQA#(yYC{JrlYLN&`p_#Ied3ub3q z16m>B7rrjc{d{H&-ZypO&kOM6izdd#pu5S$UV(2SUO{s~c#+T#Q2iG17z$1tDlGz~EU~+M zS&^oGS`V}dg(JllqM1D(cxQyU&yPO*rAuv-SL-vfHi;24AQ%+Ji2vT#*M~w|+?Mg` zY!BM+y*k_9`{VcfbNwnS*~0Kba5O-L;?V(pZ8csdZ4>=(YH=5~7(naDt@%#UFZR|^ zV9UC7*rdyhw=Zv(>r(N7P*|vEl-;n+#`-!oX7Eo4N&ubF?CxmeuF9J?Z+JYSFo zSU}|EN|ClFHKCct{*LWh^nG+SFo374t1G$2H%RXA(ne;@Os9_>(ZZez(uP6)c<@?= zBEj!wu04|igkCHRSR5@}$t~qI3|LjIndRilndC*llDkuEftn}w_6>BjjV<^z$EJkk zR2={pz<1VUemvns!n1|2(NTIH&=q|%D=~~Vh=L*d>vz-_jd=97o}y0W6B9*=v=E& z*Lry)-4Y_;eZAzh3*Q6fxC}m?!8iI0XBH{+ABNNA#m+7+mzS4e?PeuX#qf=47bx{f zik4mzb-|eRNV|HSU;`|X4*rG<_{PI6`smZtsF>cv>p=Y1+SrLCdls_~v;hn=YHTEc zRW7Q00slc_4+&)G7ug?exSf2DvAmCww+NOL5a1ikrF2lMWJ*Z?35!yskeFhP|#=Tyz?9a@P(H}GHIz1;rQwsFMLS&Jl zKOw2**x->sTcsl|j!S)wi~wO&2P}+%-vDm&)Ph~TZ+$&YCxNYweP-aRXxy@|=&hr~ zvQ(!ypZ9bU{$sY^cDiTMRuF_GRTVCJn}+3UUs>zlX#G^%G$~i#Rr=KSb;+oRB7T7h zrR9-~qy5Z^nm>AvjCJQe8&Riz{K>s(blaKXu2gQ&U|`qc{8ltRhA~qLN|I+NYawsV znzsB(?j{9Z%roCt;U|sfxG&;1spb1+qOcCY`Z;<2e)!e?2*lA4 zq0%JFyMzWqXvjd3AB}ke!^GPl4s$ySHYg$?2vZOsOo7jTt?v5%B0HZZb0bpK$J_f8 zK`5aK)^A91VEQ#|jQD6j(?B|ZD^0!A>o%1ou!&n|#Y;2Ol1)`l+#zoeSMJ#6l9J5DY$J009sizjMEui`TnY7D#`*JdL5SmxpE?Bq3G2K-y!zBDvYI)S}E_P2!N?`!)^GWz;cP(P_= zF;z+R(ZQtc@ZaUd8R3!wT_xGR@GVsbek~6#j}S5XwK3k-N`_ZzVLMZG_*z0l_%io2 zN|~;=>07WW6OCwrg0UxWPrfI-{~k7jN9?)@eaaq-vMTTcz#7l9XpnXSyJ=ntF)=X- z2}qM5j=-qmRLsQ>wtqci-&IQzxs>sd{Ksf_5}>&`bQyEl!rIHqi+@lZ0*zVGsPi4B zvp#@7_1q1cYXN6aIZ2-o`Qx*Vl*5pzQ+Z#y^d*l^CMQuiiF0U)UTC#fuw}r7bl*MAPt@V^cVDkHT9H*^f7Vnb$X-p= zbH;g(o4swyK(KB@Ka)EBa>T!7-|evP@1c_U(^8xVv{kG9xSZd>Wi9^TLGryBwd$q= zectDunPOfe^NvgG``?F96Kytt78EhU=jHtbNuK`YibzxF82#@9`nPJd`!Efs##>ZE z@MrZ~-QV40AdRM=ubZ?*3WHiLYHT0&D!xFtfbsI^IvCEVSJJx}o~Wqg0l5kzg4}U#<4}A$?yD|^I&Wbt_V*3tpNSahxcoTX~XdfBx z>uFua`0CnP+K28?IQl`)0IPJ=hy|DyFx?(flSdyv^+}#yRKMXtCI(fe^_2#9FS*ZF|-Hp9L z96P${|qcp>#<%XSm@imrrg1FnvTY85`*y}R(UE`^K(hbvCVZpC4fu0it+}VSx@vf zGA;Q8UW%LwVts=d7|0(D>zyrKU0uDsDW4U9JER0;4Ij}v%G8TxenomU&d_3E*a}YV z?K$(@u_#y7g#u0)x=&5?0-f*Yj{@(_ny~}+K*XH0z^wAl4NxD(gzA3uB)t}cuKAlb z7FP1}U)$I|ELt9Wzw@X(eQEz?e^dkV9%Cg>Vh?yvff@j|9^iPR z)^{)+7=sz{{-5uEVOT#eu>u<}f7k}b(uy~L?;RxOFD>0z(v0G1W~f_)E@NrJ%mPkwvUX`1CzK+63ff++EXw8K=c6}l`Wn{Sh(+<&B2 zEo>a*&$u+P=Lv0GQ)F;q8i~p{r=BtQrN8#2HPWu+jgPY*HsuS~%XsZvhAvYAyf7$R z@vev95Gh(UUAt0cCIZzxXn_JHfgVjFNA#+!$EW@Yl2Z=yR5H3}<`QwxA_O4k4U(>x zQn3{BhCKn+K07}=ZY`Tq-X-QG^@FXwJ-!%vjy9*9(HT3-htfw& zzdE)r-y0YwD6^{N=NU@oy>g{i>&NBF{svO@El1lM`s$*=6!gro<$Y`w^1Pj5prJQSc=8;QH{(x5IR}*4^MI)NmU77K<-voZ zwe8FAaAV6PQFMpdye9{B6loWds57ThH-Umxi6x;}Q#4T-uyoXx`3#>Hev`jk zr!qGRMXXo8*4I6bTV*Bp<&wBeX{^6H0m}%r7kOxiTOosFY0Jk+Ll(YU;`M1s*ZXg` za8Q5vxn%E8lS4H)$1Wqun%GwUH-{;3xoM9bjQ&oQ^#igmcwng6ylAW~?rV!N})W&?RE>9MGw7?6`Q8igjL+iN9 z&V3Lc*9rUbzklc3*&@V9HC9$*_WT`)QDv+16(}2cVY>(NA$f&7JbBvSPvlq_YYDQ9 zgdyGlaiY|$uCX?7YBG5Y?uM5R9RXhC9+8;!f>l0`kfBWk;}2cvyqQVCeS(cmU!pe7 zbRo&Sm?imSV2PpVFLaM_A#1J;51$ghh$}_RB*Oo30*HV>JOaC-f7fc*yd%=2R?&*N zy=98#cw`B@n~gMQis~w-Z3WGVLs$~AnfNLh;D3`_YV^$`l2aT0yeb91VVzY+ktYSO zSN;_MFHg2+;r(=j55NKV1*vY!SFQgU0H6rW?|rkOe5zT~kr$=qIPbbv;`D(HIl>#; z{_=tDdHvh=MaU`PvrN`yT-g&`JgFDLM}a{eL0l0qYs+Rt$DV>b1bJL@L&laX6mJ# zRqY5*Dz5(D?b!2LZ|~vx++dm?xo4gxrxW!&S{5n5aFx%N)SDwXK9J~8&wwVzA6pu8NO;;t6Ilx zZq5`+arsIrFgn?0uLl1LOYb5NmZMSPsnBFsWBHFZ2>P|ZDvLg{y1$KE7ahXk7tio< zW+i8Trb!3BInrA%Z;gTSX9gS_C^gJJ7Blrflwu(x!`%Os?DH33CCki(A+pTQ-rgPz zTz*|Uh>zUbqOrUNLwEb$3#ugqRRntjWKY488xrZ5BHBnE@Nd|S{S+R$c3UKdWNhl# zWB9Y#I89cd&vj^0td4x+a3U}^EMz!bf;d;wJFa*2_O}|*kHu#*y&>$wdI9kn$kwWt z)Ykw1rpa( zzv=|SbwknD&=?RsQ@-R$7_OP+#;pTOKAoi(w>D2|#1Q4eoQ9mbVqWYS?E;BC7V7I3 z>t^kmjLG3F3;CM_i^C(2b>ls&Eo(;Su3cNCdMqQQDS+2$FmeZ5HcDD2aHvFrvy$qLEIpQAv(Gk7YjnQe2<(CMy)F^1luqwCUlm8dXme4QQ< zf$eJ+uYe&H!*w@>A7naxR#gx-F)dXd*|$g7Cj1UK2C5>A1?eXnL@Ne&3h2h6B%PQD zdnKtI$U)qE&sTcckYKM_lBU_n_uOu`<<~2UCbxP6SPi~^_s&(A8s;G|A8sF8cg;Of zW+o~MuO!_s1(8}OJ4ctcD(rxgu`{ayln1LytS+(BtD=-rMf`SIoE}_f(}L1c8_=F= zK~|$sPqrk`X$3Jq_#p+Z@#l^Nlf?V*wCf|~Tt#WVQKe%O#a>=s!q(XYboK=E9*Il| z{a`qwe+L9~H9E$~G+LTbSs5!p77{uXaS~dkN!7lR$@Q#JDozcrTbrU+1<6Xh;9aFy zDYl)|I3kO}wT8T#w0|*)cQIlIHC~js9f}%eYO@ig-~b!bmWx7(o{})VNNjk4=}qsZ zpdhuSFeV!R@y9eO9@By*Z({QjCQa_T8#E^lbONRuTt@472g`Q$ll{-b9y6QOXy^YZ z9;ei*(JNN%-c8Wy1#75!x~2gO*<%^A2nG73MZix~+7%mFR{fo;Z81WUJ0xpubdZL9 zA1TH)>b78~;GWIBuPt`OPKzxo9ms=6NByvqze(|V;QaDEJU3GLFVraue^c!8T@9BK z`kPd#2lcq3Er9AV@T6}rmb)*ezuzD$lQQ#tlc2c28+yfNYFC9ZWk!}kc&K^boU>3| zmVl7Zq6$zAAl|j!0-BEfwaD*^M?{Bb7k$o{DS0Y-vn_mTEdT-t+Mpu6Mf7ATsYnV1 zys9T-_gE^10VFt^rr~2%JH*AqyZn7q0%U<6=H_`Y*4TQ3n_O?-3j{%zKVjbTD3Ste zNFQ1z!3Sa_#;f&jyur`<26s?vJm~!{e&{~0NmA+$f|KRnnf`0`Ylq^R^(~+B)9geJ-mfv5;{a~ahPwFF+ zr+#$H>Hy=WS-I!p-bWHp`_|ZJtA^azci4jOF>?YcCSE70>F+m`^nQ8kKCxQ{cD=EBewaH` zAta@NrodsCo$T22yJxHgth-Ak*GP?ZMQ2W}tpWj^ir`?SU-`=II zSLug{Krb@dM-6)~Kb!g%S9}<@IrTWeBMU1!#q>DjzYdx)fCHSlADH}VEGzWzQJITb zP#*lT4KR3ss;S<90*VXk5Rk+ z-L|_F`~bG1F%-1W`w$Xa~i_$JrPN#63>d@QVjs`E}ySH>z z+s~J_FKxgrY`bl353xg}VU@~u;+=tI;D{}68(7HxS-apl`L+BKSWUr=XJPL6cv}?H zwE@;$ZFcY>&0Qb|#O2+0#6SDY4U3<}ZizekUgdP*Q+w}yoiD@_-#f@*8hqq^P%j^Q z`FnVAkk044v+KR*$#J5DFLebV3(Jbj?p^VE1fGa2)xNgWVjo8V@D`%DK~a>KQ=GKB zmZ7ylPu>D50df@Yj_21UA`o+|`*pj_dbGZI_FK-YTbd;{1a(MZ+5A;U$UNEIbpnkj ziL`d)2`m91!HO@P#N)zR1R+Sd!e+7^r7X^+?nLkvP9n57Vj&`PwM{{BXVcFi4MLAFB-4`U)48q?P(C_vADILpViN zZylcl-f7T@0j>CzUND*A#mgFJmszdMX|ifRECzv~y3lnBKcB`3bR?15v*fyZ%bz7p zQ6t#Fws;Um=%}QVv3J}_jt-FH@D4sPXvc!6R+esqtO$ZhVcazya7pcjY7m4AlPEvx+~w9Bq)<3u@chWVBl;9+4YIP5JIo(p z1xQP&tQ~Ue95&Lh^S;N;@_~rwv4Su)B+!ER2}B`DphJNl16!ptso9)d#X;QV&Z17l&dq3>@*{3TkY~iLjUcV z8CUkj&!{k+_BO24L0R&dF+0Rui|eLc!*rPMO-(7GrzFj8MMEtDl!q+VD#ImExIX+T zQk%PStOSMRWyak33fR(*9b1;oTPYq%`^sBu%m!RtfP<90OvOufx#%~4JxCWPHen(F za{v9kavKz_zb7RQtI?bu=9=lyDNO9y7|3l@zy{Tw#Y>?tL|hMe^KK$$Byl4 zXSb-<4cE)?_hw1P8t!Fly+U`k38|j3r=z8{qLmG(+7nDFh`Swu{nUa6YX)?q%nWH# zPt}c{Ae&!@piKtB;7!hy=MImo{VQg;_5orH=lcf)GZF8;0%x4RNeg6<0^|~e8V>R1 zx@Foj_gppy_x!tAUn_DDKEY^4%j(@ZIv!>uS6SrS0BNY!o?l5$_IVii4No~i z%8)W(lhcW#2*Q^A{LoHJ;lsE|XPNe`4#EuK`cFQRRRn@5>^b6{7kOF_rMQyb$mN0D z`Z)6bZbFnI%@VNKjt?L?essObdHGgLy$R3p_#!9;u+SpB$&w$qB%67yU$xvN-xp@q zTinQO~)v6$}O`DLc$6+e|z`#N>ZE znuUT2SUko3pUM*~y~ubbpjWd2FU(bR230Y6y1SE2-Vkg9kUC4oPjAzi9c;jU-4qKn z5WGti_0sjFA6D;)=S%NP#r%*~u0c;A?6xtM zb$M`?gv-Ib7rX;Ok>yPfKSyXSfnrMuLebz&2imxN(4?(cy&cOsa&H;JK(dO5JlqY-3|& z!1m<*t2py=-41;Yph>^9v4LtF{05*J0NsqqiW)3w%s4+|CCR5lr@%36Es!>nZou4{ z0y8P2R0l7A77~ujfe#~^R2jElmMQ9KHMLS{yosv-s9Rt36ktRc(|Pp!s$8n-j^Dmd zhrWcGjxH-LO)@XyU`OdL8E>$`u(hj~7ljvnBy0c%zv;LiKH;tyYz(cDWh3h$;cJPD z{oc@I^SN8|Z@PhXQ#u(i0=pKSTyx_rwHN$`k?rj93O~2pU47zIzeRhKWimo;G$7t! zP|HBkNhGreaMG`<`ylv(Yys6fG-tXTufKj@K{@f*Y9F)cK@fJu)oBIjPQu#fr=O57 z`A2E8yIr220K^Y6)7Uk<%N0;hP~EnvoKGG3S3;v|bwQ-fI`tlt`}z%rKe9F0mW#xC8(A}yZ_H^Bbb(7>jvu6%5E9jC_RPQlzDn14oJo3uXz<*mG0LRV zou_Y-5oW=x>+~sWVuTF3MxVKiHa0(Y>#UxYe_ zJG1+clVA(f#_sMZ^-uUtVO`x91~1*5pvaKir%|J;d!65S@iGj{v|lRWM3JB&q$^1-QNayISd-Mu z8?gAN9H$52wss)t*(2wX;N^wzuOWOxBO@+u&U!e9elU{C3)MFHF~8$VI_ml|9r=Jp1xB;- zFxl&;`95R;*e-af+7&ZSj%WY90l~3!KfN3qD?7j977H+jL)F$nJ}YpI zJvp+Rn?5A&HUwtE*{{mBbm$!)f`J~$Z5RMWGnEWihEfL+=!zRGqF?74(AE{y7SuPZ z<%2!3^L3mW5dYI(=5J%a;SM-)v}X9KK#wT&xy=<~In&6qrhY<~v(o&q(jv^pzTG zqSiLeDSHc7Z_0adI1YFc6`0dDZ>$yHf(xb7X$eWFNu5?)QL*#q4+ut<9fd)W@SoNb zq`s{OBT8vr5H82-2mWkTv>e=*WSVSXX$C!L_y%M%3uXYgkj1r77lActGO}I`6hp2u z=qq4LqFqV~D`r6E*)kW)yc}=caPtPLCtp0&_cfS?`YIU+*}-Y%rTJ>N%^#>3@z&!` z?#qk&U<%4IAJ>`4bvgZIQz5?FLA=(Ua-{x(-80Un+4Y_SSY`bwV!L)}z_cIRWiFVp zn_?d+MJo(Tgim8B?;SNYG)6~8f(QV{--m4gg%u3OAxT`@iq;0~{VtnaeRZ%gLpiEg z|9pU{Z*T7z0J*`<3+`=D3;r7;=Lwkq2GJd_Yv2HZTLt8WU}Nli4KFj27i0}_4m`2p zU{F?Nhou&&T6AB?Hj6yg@g!Cn zv04ZfPC)?-Ws`IQ_-(`Y;H`vU3UBZdf?{OJ`6T*o0)e^{n0>C`V*sW3zC^%&#vG5% znfWDOGgnJ8K9u<$9B?V1Kg~m|F=9)#%)2+Ly2bZxAGhpmSr2F$%?#nH}fC5#GjeExj}exDX3+;QB~}bhO6HTen)^>O4K`rVkjXx5 z@H_jrH$nt+$mK2U$s!2D=;;CPM7#pCPy#`48-%sPF9=o@h$tmzS(=5Z#!l1zKn1wp zQMTfM2Fup7nH>n}HiiXtD2&<5tc6!T3H#X_v)vh3-Dj*+(66vtw}$y%4-4RZOi_Ls z>zs5O3;^ALK3y^Y<%<`vgasHuS=o~^ZP0vvcn`Ac#O@(KUikN=KrY8w=r)6C4>H z4y34>w5`|eFaVenobfb`F^HD6_0YkZe>zoNs zb#-;POfFP=uyjyHsgaea5(rT60WufT$A*S8sLp**9hD4CzZyN-l6Z z57pO;kSG<7CYcc-kk?IX^dvwRKRi6F%i$hX$A%DkQy(}3+Rf)#en6M*y$@FOh27(C z-_VJ052)hZV80IvFZ%0JLx5XnW_WcDiMk_ZmB2ZnU^qhTetdU$sK6Y=arBE5W~i=- zU!L5jjZWp#JP1SY#39Y+D~8{UVn>*VMq(mwPQT#}RVOu^8qmPEJt8;Uai&<{giJWC?W{;J8D2_0{Fh z6+~chaI;ukH~CHu{lLn~3OLLX;y}m>iY45Tu0@y?&6fdfc*4ok^UiKow}n0LAMAQk ztU^T2Z&y(XFemNZuCs4LB2lkQ6qR71Do?do-GY;6Vgz$ouUgTPUi0@M18xnHoja1? zNXWVc3n3i4x~b<@RvctXjPcemii8<$dHIT?umW2kXm3a&K?$8Voc6TPPLOI}gZ*sT<%hd@xf#GWUXF17{Kvfp-ndEC zB;5OboXx$ZO2E=FHqIKhmPvu0mdm)Msi{d>Con&h#jjmTi&^wquo#Cp00Zg6!%uAj-aR$!y)6Vro)fb2y)ryI{ zYX$aoK0rnQS1lYp-4+S{Pgw9VyoJ|j;QOG4y*09I5>)cg6by~HtYI@Op&^KZZc#tO zNQi?t7of_GjPMByhf_;)kTGqtrQUDT=aBJ7nT5vY0k!-X2@Y&{OMtBeaDi>mbJ50z z@su`Lf~AMM_1xLm*w~BQ!UgMQJ4g#>7eXWNLEQ6?;u>!N)5Ig0mx)5+`WZ6%`BK}G z&(iBmfHguC!JMq9WwxRIIM@J=AAoPkd|o^Be!@Bm#}u4EEvM}yzx=sU0W#F+F!$&~ z&Z8{+46qGbK^I0AHLuigsAPpzualN#^zh-sc*~S5w*y14YUcm@=N=+-@kC#FPjayScZ z3kO4-(N$f*8N^o9jdmMkC=RuX3RV7g_jIm*r^{YmHu2)%Eu~?!E+bbeeTXey(Rq9& zh(l_o2b*pHCXqRT!qwz{<$XQ0Co~(DrQ;BmHKIC$%B*!$G#fwy z4bkG~M*&wyR1QsT@6e-9pu#7v5&aPp9nFhF!4_O2jN#bClR><94Th#LJCa$So;DDm z+*(`v2?j+aC4hg)wCHjjkiwk=22=>R7k139t^Kj=+z(CyWo1t>+LDp(OsSCBp0LL;ZP{ za!ynVaEeHAI0BJ;fN=r9OM<3%IG-1N+B6C8IUp!Ay~c(;5RVUvKau8t_%H%Fob>OZ zxVzdHGX8oF4|DZo#oZR(FwZh-c)$kEZ@rw=aH4P44h{jpvPTtIyw4w9E#dU( za{$$6f|rx~0$tE+qqq<%#U3Aqr8dG_p|FHP(#6Tr<4Zj#S7kf)y)0t}o1$*sFfJ}` z_M@&^qyRa7xr?dEtQiS{+bwwFN{}F+F#d_$Z@cBqHp8 zeoU+)1`&PtQhQsMsmoEn1<1FjrlQV?rnYCBsfyX%bz$&%bff0_MmVfy^jq(ee;$GF z9SRiE+q|(Rmz}V4+c92+D*uE#;6zEecSi|@Gnz2+*$O2$vVQU6-cD%TP2h3}K6tPN zN`hw{fY5-Qn=)%-r%X`2wG%j6Z%Q1a0mSj42b{bb@Wb~(eHJanB}0#1TwcBnjxm{0(1?~_9ovA;mfu=>4Spo7YNZBTK^`~ z_geg>V&`tQJhuPD02_=x8r!Ex@xWUPwc(u$7iULIymmG=_kq}SOA~KxDp1t8OdH@< z7=HYb0edFAXx$d{=z+iSK4U=%J5JhIAn}Ko@ufFG6zJ9Y;1z5h15CLT zP=3_oskzI4sLRC)#oOV*96 zrQs7Wo8eP#&}qsP#j9FgY_OsNE!2WDg`K|H*QG`!_ypF^#&uUZWXk19yi=S%2x9oA| z$CU+nG%TYqYY;|`o0kk17hf{q-$8uBI7B(#uTCdgb9>n5qHC7mna!Y*rGUHvqMhv= zDvvRx>| z^oLZrl3vGZ_q4ilz-r0Szc55kog~KzE zsNWaN3iX4l_jgL2hv>-}j>!3up?%jM;3S$tyfHk6qI1_D4(>4FhO_T4)Vjc7nWOAShW^yF4)RVN-0Hv!8I(28ov2_K}^enB`QJ`uE*(Sf|l}9aeo!4D|fkdV%N0S}uU4SkCsPF6o zW**?LEY^J46+;7S0$8fg+*zW6+4xTjQ`31^GQ55F?!%d*_<`AQTKgZ@sTl||isKIN zV0>ctB)Ge1q~u3kQiTrV657a*7v8TM4!%RMOy9gSBm`-)0$6uPv}u2mPU7NEY?k*w z=*K<95A*KgQP0gi_<2vKr)MhhVZz|*Fli^Q-t7XnpS5=S^`$3s?uAi zgpg_DqGxfh87G!fX+^S>S=~fuK(-!}l)dmJ@R@TJC?`-pScT`r5i$_06D#gL#>E?#B-+0ZN=uL<7bNrXaAfQBVl@2dWnK ziIWoz>EM{fp0&5Z?Q_FYnNVC*kGT6=(S6H18*RqSf+(X8Ry30n0fS1RBga$|uY z426hjSfHfI|AxJdz9)Pxk0#)X8N52lx;oi3zB)x6J86)LOo=mN@4<8D9k^ee7BC8w z<@1}2_de-zlY~i02M$3T*3^8rrOWt(9!Ry;3y$epto-TP>b3WZG+~Yx&krnL+ zQ;oUS#(&%&x;PP4P2DaBj>X@~?~A+8AFHy3IBb&T@CbtAE_tskE)3gQ1A`#}e~cr1 z7N~KLDDnL16Uxj2dTYkxQU7( zd9RAY9GW+*ddy#obiR#?zV^UNfU>!YnK@lqdq^eQLRxBba4gLCk#UYHeI~dpk!;j> zU44CTAYRJ;6$kk~4BeWK!Q*=)Noo#|qKyXSkjM%g((F3vU;}(Q-@;-U_TRVlQf&QI zUe$!=mlO-S)x8AgBq`-XdVJM&lJY}kQL5Xr;BlGYjuj~@hoxK@yHQa%+ZOE~^%t5& z1#GH2iBRm3VbF2EjfHGttDyDB+^Pt!RTOK$?`Q^!^pN#Pv&hSJs9|2mu#aL}zKM-B zzgzT@oh8xK@CY~c`A#sz6V9IOW7o|@pMc8$RN`_`VtX&)sqdHLHHeahB$}67dm}qR zOVV#hlEfJsYv zIo|LY*o62??W2GdH`{GsrV2!V!yI=>n)&?`Fp2*?G8`{&!G`=AKyq>l(2j_Y`?kQ!m{eGVxiG{1dhTq-51?3fDhKGM9mM;H=* z4%YaDXKr1PLZIfB$1XSS7xftT)OONVn=w9nc6)vO9(S{bL(2(k3_5jin#AR|O1h>~ zj#POe!&wdjkcMIiuE6w8D+G|L&$VZ`EYQO(#y0xI$$FJqaTqBcBmbuucI>)3I6oIN zyA#2>GS%>8@bX|iro|m)o_!?Yv@s)*rO**Ie*^<;hI4yyXM2UhQ3c$zYP1tcz=$Zb zM#<&DV#&#gkme5P3w|Zn7xQRz@o6kkA@6_PIWpI`_=XgU!=7{E!z~&lj7&3Yaq!_z zh z*U`eHy*giqNjre)+rk24)PP}Xa&9XNN7r&>BZZfi=qBWXPQ%D1h-!f$o(F6-;NysZEOq<*06ubv8q{@?edQXwKML`f=H*;$oP_Bu(Y6Oz!ejuEmN zLROOOkYpS};y831BOyEEka3KVdF+|+y-)8?{eJ!1<8hqxdOgQ|U)ObC*N#xsfq=F* zKvPO9OoU`3gr!gF*u4eYBK8`#I`P8Mt}TfARnK{R#6EOpEI9VLRO8&)7V(|A*2coM z$BjRe6HT988Hsap+Sw@pq~;}Rg}7ePaen+YA=7)YsYN6AsU-bZ+NT%j!gN0P7R-(O zTASPXf$=RUm8Ipe|3DKZa#8haFRxImTdP~k`OK;9@|>KuXhSfgvN=_j%$+cm-62El z$kZdY67-W2R6J&10~#euKBAym@q4k6N=7W6U~?Q`qCc2#UZGdv_25DLC!G;rUo{*u z94SXHWP2msu=(}tVg=EDA^De|lEg>@^LkHX&Lq6+Z9Mv$pB;Csv&6toRWUv(DSc~w z%MUG|mD4e|R%-p^(?ZIx&P;H(fn1!V?MbVPM6c{TP`ZN=BVu5BC7U#b_wSCd^7c;5 z7Q>kr%_J=vkccB@9K8F8j!sKIIj%2ZPpHYnOdZEhJ|`~J@=zVs0PMsf-X5MRxwn1M zE#%gX8>z+|tYTf}TLFB*@hW4fN-7N_o9v+ykkc!t~Q-fR>&)Czy!Vy7}&)(c6YU+!YR@o29 zR$VH_A07CFYrb|tA=h|?P*~1O)DntvE_61O1AwIi`&9=P(Jx`I^AxHMB zvpv0;5sg~b&QCXZYNlO69@vGh#tOHe5KW|5XNLe})VF6d;z{kWMVzKJ-lQ0-{aSnc zq)~8Fa*3GO_g?#yArPXCy~!i+J))gDkcg#^rq(F?^?^EdxHi zb#v>Glv#1>1ObU-$CZzG{1xYCfEZ1>fvF|1K$+VhoOx&ZjOV*{=F3ybo=?2e+`1$Z zn;EOWOrQ84{FzL$d`?Ffd4<*UiK7Q`2aCgtot^Qx$Q!msvmTl52n0!?M zU0&~Y>;nf=)l>Jqjx!zqZqr$EJ%@ym??>Zi+zDXN-<4{XZ|qi5Sa`XvOikbc&^%bm zo0ZOAhtM}BPRcpog~vbCJFQCYAf~}oJ>Vmox-Aar9+Mt?fSwEdta1^j+1RwdHLNkZ-8*yP52TO4R}Ejebi!NIsF>@3hAWo0!)95CJX3!!u`h5}Bj(}3xLu@HPx*ze zd@;Ii)pXU3FY`~0a_3t&#g!Hwb&QW9bDi&%$Yq^Hig5T>9TUZ5(jXyUb-~le^(ld$ zJ9g=92fgyD7tvmJlWOk{zBEAPCG*whO$_Ilx`9}!5RyvD9F_~(v?l^aZqdwyZckWq zbUruGzSP+H%s`?+h8H{{06**e_{}T3sk5P@0h|rMvhV~{t)Nn&WB+O;+3)7kDHy)S zfcb8)r0vXjzZFpGTFPP&RsA#RW{V%bm`bk+eNXE+Pj_b@fT5=`YIg$_H7J=d7FTbD z(hAMdbIKPin%`x9;2WTQis#R3I`1d)rj&;Gn##n>|FWu@5qFIERK&P}pq3Z2)jkMcbLXlTdM6VTq zgU{i>#q-YHyJMS!JKJFCQ{gjxa}bclSli(rHK7ZhueoF06m-KG*drqc1_`oO4;PDJ>3k@ea0AwHJxg3%A>rejJ9u><%?hcx>Z;nlw3BH z>=yim|27;DcYs9jij39*Z(7VP!w?Osn+N2?r~Dp01+N`!K%woSk`UYO*Ovj*s0!zi z%OWH+j=gO=Eyu2`OmQb%bs=9~t~=Q|46Z&^eKGY`CCq_g9(yozhPfjjbAGX)Q9?pO z+~FD!_AC^&$>nPfCXIwnHBvCYtYT z?mL?8Z_O#LUxkwMO>*EgPiy@Nwn1Ldy6O+`MP60okL#nTc&~~GB?t8_FPuuY;R;M( z#v&kVBI}pormBMiNkf4is%?_aY(@xZ|BA|riloaw-hJ8yE-c0!mt{br_>FHOV0m#N z?*hG!5;K22G0xM^)io-?F}powvws|%Xse4G`D@3Q+RjH$iQ@YFcIuMevL0^bxAAcP z@gRhOdc87GX<2~9sz@Yeb?4iHtkhex!N;aqzUs?TP$xOTb9<=r%hJ9*0a%iYC~Jsg z|926q?>9I5$i-3P97!rcM!8Clx`i!&Y>YhGbd+S*&c9_oc!NR1zfF&zjXNj7FTeEl zUiUj=r}hF))QRf*JSy8?mO9zfFO=&Dbxg0YL3$6}R6IZyIHaz!@l=qJj@~Up)va%M z!rOky)cM3um7P54gL=xeQx^tqR6hwGcVgJO58)HQo}9pkPwm+oYh8F`_lesVp!I<4 zQ#S>ylM}uV`^&IURkWtFlkHk#ordl3a1j6YmxovEO5h-ek{Z%Q^GAjZ(&%-@)q|=R zhWwd7hA%q2**y$a%4YeoE%_rvntmrl)B#*Q+wX9@DTg=5T&%5Ytt4+Rve1;=RLIp6 zi`K4d53n!jnElFTlt!AES8$^fHGkAoGPM0B+f>ZN(tDvf@n)OBdt}~$0NT*%ABn3? zDG4|Q5!J{;gOam6(B?~Um0+8I0^KW7RBJ13)cR^V2y9r>*wV{vuD_CPqYe16yr{@0 z=*EAvL913he&iIsYHsb}q_+86=0yoVRg5RVmpv1KgPr9DSCSMqI;&HoJIk|3={~*PMXR&Y)nqoih-M4*FD^rR;hRUUDq4z=zyytzp@|BqPk{2MzC&Cf(c#N!emVUK}UWi4e~$a>m~5 zDU`#wbrmnZWlo$s+$brtL-?pje;&>3i9DeSsr~nGNVp17<`)bKd!!Sa*$m3f?U-pW zn{g@~=%SDfBYW`}UF%I>jofRcTaJkx!cmRuPu7U7LY2g7vi3O^J^O*)kl9+TfR7f^ zfsImQ@yh2N?%$|kJy**$D@FefTX80;KI^O&Ls202K4krU^-@Mo&UVb$LuPhJ7&6I; zrseWFAI<9|&&bs5oxc9^NNR<++-OdS$osrLWXv z-7O^=A0LXlVxqM;qRA#CS0m92s}R*9H747mOMCp~e$2yHi(}0<`);1?8>U<>HOP3; zI$V(QaHhXg^Mk>aDD6wPUAc-=b<*1TrI z8ao|bHO0JO2)hn$snnNW87ePbT-be0J>+s0x2r#f8a}|?-N}4e=E$Y}@P#_Vinu8V zL3ZX-*<*6XX4)kuo01d%x?G_3%dT-&tala7pue@8ZN4JP%tF>JMWg96PO} zzY4ky@W#@8=M1{nd1UXarvln=qDCkr{ejOL9AGkFBTC$Nl3F{~-4&;y*$loN2R1{O z&g1&}*JFEndSF<_xnH580#N+MPPd0YrBWaham065{{_^im?wv(E*ss=NB}Vf)%4EU zck3b|YG*xSXB`6Lo-OVg8hH~niII4J4V~Ido^X6mvOi0rA1taHF3=o%d0;jB1S)I) zX0A~-ot!(=(f-q^J{cD?wL`02R)?iJLXGL7%!KcpvOmJP_q%wIP`&y-9q*@>YV_xz z-WOzrMOj4U#rkHMgWTBKB=L(5MS)$hTIta6c`6M+#pE=yMN3nu3>^(mIGqg0!{7JV z1GhE0^Z@;$v^Jijq$>_N=^;lhf-GeSTLZ|{vf!%(qs(HzONCh|QwL{qYR%d7&KH)d3dP`cF+doNrg-+7bF5u`41-b(6c zCCj(z)$DY%a16b})6a^L@Y7ByhLUIE7x!@d=EzhRj_+_ZV)fKO#P;r<% zTm|XO8Uz~ssyOlIF;-kDUkG>d0h!dONqHs}DuWnuo*R{vBe2jT9r55+dnC{hi@+kL zs0O>#66trxg{{Ng$97V7mL6`eI_<1N-7$wfINnv3NyWB-qNTVeu1XDvS8l)k)D1?Q zxiO|98A$3-nc<eyX2e#wyx)NrKNsvL1LD=+!c~<{|c+OM)^U+>u6DrwMjPHVXo@E zYxTFaTu5k~R=R3<32bbw^rFgJzuWC)T}x4*jjbDD^KuzXFxmqn2Uu72{B%o1+~u3j zWxHr*BHRfOE1Y$y%T^kWHSXJamoj8JlTWb*gJj7iKIzRX9*R+ZH<-y~c5D#c6Z;ef z&Qz99uWhm!8f?9r_ZKcy6Brgg<$#vvj@J=lqfa+FV=aA;^V;?7YD5%PN!0b^dDNjN z4U9DW^%!|x34e`TmcGzB_d7+$*bay?6*k}PI06;ntGYS~vF{hsE(MTuln(QT4>zQ{ zc3zX~3FE8qMh`gMM@9?py=M4&X2|cn^g)5W&pS`R_yl-rjw~p_AUn0=*%{T}9%V3J z{|t3RK~WJzZbOFfg{Amb%#yhh*h+#0tJg$o(Dp>c_OmV@&`@plem$kKZ~(6S$3o8) zXdZdzlF(x=rDpk=9g}*=N*kXU#C@n29o@#pc*=!`+djt*!I{}<(2+phuT*&#|AWy; zfc5}ai%B->XvX#J4DPJ$7-|-nHr2iQgh^T6^bNUqnhE4xQBg1ovLP72kI=@tP%l`- zJva!Jw}<(+kLLnQ#EE4xwo+Y*N3ZnB#2etiHJetaWiJhX4MqZ-pQDXVa)+G!9BiGI z-hO(kFiNb#_{sSQi$R&GW`xL56m#CK!Dn+PKT-0k-kHl2B#6=uu05Sd(jMmfth1Sy zqekDZO9Glzcq2p{RA3%ohA{?p!Jm|i+UM59#l=Aj0CK>VrY6|$AZ%j|rb{ce=yzO$ zvLzSnO*@T$3}@emr;~4%?<#d1nmBZjuSyCO*zR$^Ho)xKUKWJ5UJyy?==eMV@U?rw z8i^&IWLs%E+FeM^d@v2`Kg8vTr`depM*({=%K{L}W-%Ejy_0}&RpWP;NH0x{)W@D2 z%9AvH^Vv78R)WzX{aFBmYE}z_hMW!W94F0?tQ&#oBb4&IV`s5h!&ro6I$VL!XZ?{I zYc3^5t>foS^1Gz!n_z!g&Q{xh3xymIk+CZwwJ#i>?Oif z9d$wyKh zJkOT7J1CbOo-I;9C!v3iE;qHm>YMAFl3C~2$Moc~0mDB3T>%lLsONlVG@#*!{@zOk zV6IR1r$Hv!$)W|_VkD28BZ~XRty{W+tWcWR*aXoUOi3CRSQiFwv(i+m*y8)Z{t1Tv z*UaDp7-xz~;N0vTrRuK1nLAp`kdOo+0CIBTW@T3?vbb@8IJ;*4%+SJ*iQ;~M{*4{W zJY3~jL9-c}ZJutF+JJ%-3qAk{(~Wv2-A-4&`St^R_aMzFryk)nd4@C!h`FoGYl7VA zy~h#wGis^VkMH00DB>y6pr9i+CVSzk0E=dEfiT^<%KbMp%D&}J78?E7*&E5J<+w8C)qwWaC^rL7wYL>he2 zd^`fVpR3^BF2ouPqHqFQ#tCmPg`I*z(-Yh?Mzo}Pvgs1MA7(r|7*2-e?zO? z*zYNZ{vA2`WHY^wV&w1+t+}upF3RYP5Mp`xHdTZHN?yP+5F~284BTY|>YY{Eppys! zOL#Ia_wPqf{ccW_1My~nH1&S&4^-)J>Pk%aIm4o7{j$d~GY4_@luemfg|={P7{ji9 zZ?Zc+PE_MbTlCo+MY}2!Vmjiikd06#XJ(cvwIF4rPz?3vy5Uu=;d=zK#!Cho3w|9P zo&9@g(FKr2>+ygS*9V1j7lfC?`3b4e7-#3Uk%e!@=%NFnO)V|S;N|>#V`1KsmFaiDad!9~&E6dhBUe z2j8zP6_S-;Db3J{Nq4VFHKAf2an7^5t>3g~>By$_ICf3QbP|qm(w4+RrTt!RDP9$G zf(^x-ac9yDpV^j^WM*SAFt>Offeagd;y-q%Q=R@G2`v*423R25m8li4yb);`nH9*= zqXre5ZzPHDw4{W6`+U9P7wN)g;RSDq$HJbiS&2OarRmIW=(MD{v8gH#x64|`M`~T+ z7WVoDI*!N$Tj+s;{Rk_51ad~^!(W*XwHkrU`%pKMx@BQ4RuXY~6o$k=^9K0yk3(Yh z>ZxC$=>)UfE9}u|k?T=C>vyaWv2~Ze0!NqfaLPC(0XpX-1Ko^cdj^YkRZ{F^kdaAO zZC&vu*x)a!IUSZBeMNNPIzlz}s1FywLIr0ON~v+Yh3qNA={C9qG|5aRAQ^Q;*PGo7 z4Pe}hS0w0-^XP&noSB(a<2?cy)H5ZIZ?V}bBnF z{Gh@1)`MSZ@k=LdK;&l#)>A04VTIrupf$XBK1n50=lICN16!RTGad(Id!Q` zYf8=Vi>B`>7#(+{6in5v!$bBLH5y>`U=od1}EPgdh+=|b_n7E@bsMV-@JOY zF73~K(3+q#amW;ff{C|fmk`t1J{lSogNi|M&W3okKtHGtr7RHK(TYPZ8?TMdBU!&Q zGgf!ztXN4um~PL-*-ayuYgi*m_f}eUTf|xwe3>G-hL7;71)U&YJ}wjx!KUU?FM_;m zcmn_O8!hJ*mw>@=Gxej{c-Pw_I2syEt3jd;r4YcQz*vqFp#(lGOGdPl92qt2k){hf zHo?)6t9#$8Jtf^Gp8jabYq!KghR~9^g8Znc1DsC*E5(~L(acu`R^QGf>#DsRPP&?o zh#%7B5~U;5?ufk;XE^#0jmeNnnHW4>^+=9cOJ zJL}<#s>D4s)PM39k>MuNTn8Ozy3QWNB7V#(^!vpc<&H9Z@BdYDsFK)b^9!-N5DS`6 zQgmZZ4a)G?p*VY?xgwk4<+4*l0Qil(rP;@vaP`lJJ=&cLaNJ@#LMcgi96dJm<;ww_ z9%WI%UMxrFc+EHKl1w`POZk0gIfWIcQ&*;Wu%_8$d*hly1yN|4wtF;lA14LbJqhyK zzmM}J>dz{G4iYfWETAbK7*wv|Qtq+Yc9)~oEE*ckF)3zi;JAjO0bcQ)_V&5DJt zW_wBP=_0RO#UV3!#krJ3#A$Zww`2eNS!+Fiie#8S8VsFt2+A2txGGpgaNw)Z&NT*Y z0wXxw1ZA6p5EjXaV$MaG={`N2tD!9tZTdPUKB@!0qJqDPAV(_e=c*t<&OcwT(idi( zjs)K8;$Fa5df4TgU^T~#Vp}JZR`_;xNky6&1UVANk$AR46>`T36YCUzSyxTV~F zg--97HdTUhQa-&sOM;)5mp&`wzaPAIq{BwC-d>RHtW_w{QC}#QyNNEe!}23!bGN|@ zAybE|w)}FD3=XpcWksxm+R|v<)T_3|3D)|0tw{+oaVwT^s#fpT6#MU$P)oy%kx6nc z(WqS7g3cwq-}ap8Q4Zn_@t9|I0W`C+vh}3tZsC>i#GBoI-l8m;F6T`W`#yQP-`?(g zjm)XNs4B1aVwCpJhm|qm}P(5%rb9z+%5 z2&Eod%{*-eMP?53dwu+GT<~_W9&UQlW_c)BT}kC79VYHg`G23-f1&y?-~h-xA%S4q z)5x5z8lzyl_Veebjqkl0k)-kHgEz)V*X(8I4T`yyoC30EVU<~y?Z880-grRsGEq?r15O!?JvBiFK>Q-5rt@qMKzv6NOh?r^jGHFwJ#$Vya& z`U&uWBY~;9%U>Oy;0uoAsT}SJHrt}e%xdggUh9~W>E{v)C5v!`?(tzf{ zeKppb_+qU9R`?Ztx_lKkZ8|mIv3eenrAd0)E&mux5 zYp{h8uZv6HLzW^tGn3-qwXoXv=!lyl86iR>78{Ep)C5xN(Jq^}kkmcAus(q$f>Q(J zptnyh161JHUlLhw1$O#I=YO(QIGqn1%_4U11U8;ryGYa7v3@G5zD?yhw#wo~ScYTSeODXNS7GUjxz7qQrNDHwf%o!^;9ZKN(reSwPe4?+q`U48 zY~wC^e14~%LE9a#D-eY#Ree;=^miF<0o}Gq_7hGXK=z1@hR{B)oGJqH7D)_DVmV;! zSHb*?0HZyCiWp%bTKu+B3^6j%Mfb~~s2rTb-=rXp z7R zyyF_k@k@{L9S+cOUg}!ynrfN->3GKc2gCa8qv`%Mo3akRY)@9K6^dyn>mqa!)PEKi z7=tbc-d>FVJ^ND(h-2S)l=a7iCif^fy0vRYT;`dUuK=BcLppf81F?x#lHQeRd~tE! za}>-&16c@jm0HklZ$V0;A8Z`kgASkEDZML^H}Q^uQjRS>aKv93uw}e{Dyqpo-yZJZ zs5Ul|T)5fDDj~K-OrFRTpmm(>HX|pm%vG0Nf4nqRmET>u!WS_P2q5#0&*)k6jRwy0`2a{qns!qtFx7cj z5Bmv#;|m*rH5%v9JfMO@zoE-nTRf4E%6clRs+d#NeDh|2{o}gv^Tg+cDe_>6*_n8d z^++wIs_oyk;AbnFknVFnvEigZJ+QCQ+Q7a#b!E1njvV&70K;A=F)%W=l7t&*^2{0@ z`ni<#FQ<}^Jb*+Ti0_n8Rt7W-UN}33KrUJYrRz`n7od6gks8GJv5(U47$M=vcwIK0 ze1kbq)&mG$=qig-RL1vk7U zo-0>_Xm~1mtAeoS^V~gY?kWq3cpb1(k8NCOQ4}uE?V~`trCB~4CMA)mk%M(cI8^AY zhDVpb-SzH5tVnKwLT)A>YPD4td6XkwwU&Li{L6nu0G_Vt&ET|+@y3uw)(g>g?%Ycw z%jd&5c4uh(ve@#2@gOF;-2k#Jcn(O_18D=yUw$`G=92L<--Sv`&Y{vY2Up$kt8Y_H z2|XtFu8F1G*_!Z6TDv7rBm0Dy7H|V?|8Dhz6xXU zFfQ4XQim>QX!DI>Ct4k!7yi_4iy_GZBivMf?<_J!X3&r`wa(F|Fs= z^{;9r1`E~m8$QtI#WwDxt@0!(GSc}2bbgu*QeAH5#(=R0$Z=jS{A3Y^(x9+s2Id$F zzM7r&S`L#$1(0*+SLB?&xZhcx1J#6-HbnmV&AkfB?l0l3H2hb;65FR&paGDL?j!e~ zS?w-?lc&=@~s7_dzTo`a@u-h8P(6|JH)8KYG$5&q? z0nKZ0jV0vxwpvM!;I8cLuu-7ssoebD*9#>o;2&PNJcBbcj(tt-MXv4lB&Mlvng8Eg zKHH3xifXcsy5VJySF{ZNJ|h90N)cUC?R`$T2OvDho_Cjz`YMY)_}IXrh^t99s>eF!%)p4)W6UPB-Y}!7kp?BmiWhlg0qnIvEzcSZ zG6u+FsFqm1da{oq8{K3j8Lal!B*$6&0xfKZzDbUybYkxO>|8CTK3X!TLxCtySs-L( z)U(f>)4x#368QHfCd=_M=`-q&8kLglrhBa1EiFIWp3@Q4YfHN-_?xIbHI$ZZk^@`^ zWRC&1w_OY{5Yrx7)nU))g)m-AU50$3fTIGWW!H&bnQOlJFbg!==u(b@>iOHNNX&^& zbTOM&scZXrnYk228N1>{eT)5^yccXu|2t1-%k^@Mg=3_G?R~@tvgFh)BkQdfTi2JZ zl_Od&znp%);zfip<%l|n{d!sd4i45Hd#D9$r6GI~esISmq$vUl2D)1>hynsI6KoAu zHhm-N(oAydyw5j5eVyNz!`28@u&t{&Ygm`?eXLG{*#Sj<%)Wl1M8mvSBdY51f!{v- zul)BVxyW#Y++~eNrmJu1 zqnZH73b&68{^;2YO(dHz@6D`Ve{LEYkB&!4ENFwT?EXB2Qbc**q%guIv-|ePcz`gj z3UJ5zM_d(-M&_CToPDGXjRTdbpC8oBkOZodLcEq8Y-YZ**lsm2zlb5P9LWxZ>& z9d*Bd)sP6FR@g{pwF5(b$HAtgn&#Ju`_MK{ry3peCr}$X5CDH7dzp%yhe^ z*(C$uB8o@2%ky&Q)&@wqS`!{Tk$W8abv8~T4FvQ*Tuk9NwqDrzeJ4Ws=ZY8LXR*Tq zdYMbq@gmTv?{Gd`;M{Q?g`7NB+%-V z@X^mb)!uk{vC_JPmSNXmQMaW{9Y%NFfG}iw`G2LzkfSgaCa6Lvk|1dH;r{IN&OfA6t>XXR0xmhvZ_MnOrER=C``RJo}p_rm6TRRJL$hWI|w z*haXLZpSTTN5W{`bYe41U-0HDj85=N@-j}7yrkI}@&ewb+8)3D4mZPZ2wFa~d^s~2 zpr4Geh*A_EBi+cgApU9z=!V7?r*a$5PI_i^Q|j3yv#)3JE6L!v46;U*RJ^NOobNrl z!~FLzMdWl-U~l>e^OM7)>C=M`A67^clbDmcp-Y=evviWIUSqic!%Cn;gA1Sx4XQn; zGVg-OdvGq|`cdS}p}eX`XoTmfkN54)@`kZV2JEV~T}i+OU?&3}_1w0u!yJ$ZWEiTr zWc*)kJMVm7k!+OuT6f&24S_=?0&>Hz=}!P7dvj>2Uw25c4%ncHSt=B<|py&W3IwD}sfyp83kaUY@TGLo*U zM9tm*gw7R~;Eyv)_*km3gn?qX()-fiJ#ps`@ zQh4ht2T(b(@eZ9ls*#lzUEY~QjT`{_EJ~W|Iw|hZj=`WE)hL5M0`iZ%Yof;1Y7(M3SD{Xl)qb$?PF&8li0$|RK^N`oX&-Cc45~?z2&mT{#>`fK$o{Nu9rjbs^JQMQFx<)g{@OPam zo)h%HU24GO7zhg|lYA|kec(()&F#puR$!7_U814_Mrb6ougV~#+$Qs$f3WyYFBANp zU?LruY1ZJU$-n?Z_FE}xcEOX+Z+*D#3ee7w(BP&p;(OGdtS85!={VRs(ATS7)1GU6 zGxe2z^Crkwp*xR8p80YugodB)%KrcEhNIk!`=IeC;m}fxB0FBs>DCjad#@L2AoAr| zA_2mtOhsZ~rn?o!cFm7Gfa$nqYp|@y2!JUZ_=ZsX!*DRzeY7n?AUm}&5|8+n1I)By zBkA@xM_jdHWOR-l;imV7Tk@n7GR<*#=JStI^+M`_xIw#Ja+;=$`QNdome%!buEw|k zfijulrNYpgZgj||Bmr*6VhC@_wjCo zTVg3IpcdJJ>+#{nSnQzZNVty*#K}0p$bD(4W@DAbJgnv$H*bOf13VBLDbKP_C;E2K+iT+(0tH9^Z@3MbC~l)$faWFLu^DLT{H#1`U4i z-{liwEzh<3iD;Bp)To#8YHIBl(qHz&p$`NHRhA68io|uFay0=cCxC_mb`NBXW@ctx zlWrWLV_;4Rler}HwH%UPMSk}*Cnq$ka7J}^|0fuM$?Fv_WscDFj!Dac?~eGoO=YeL zhs=@qB$5S2l`)mz-JF~pAi!l01bhZ>sBjHXJV8nWMl+8uO3$kJx(6V$1!U8-0k{wV zPj6&??dC}VkH6Eb&qHY|9sa@)LuuIS+^`TAh-!rcY#~p*q6X}x65ng2YgLWkcAqCe z*AF(V_OjlPulQ$Pnd)GWb3I=RQbbI7Lu)|CYzs2ahcML+ZFMlQC? zKut-Eo(BJ~m59hN!BQLo(g+3CX<&b0_Fa_^)W zm42(8U7cbgrF-GTqO?!hT+z(a1kW~>VD*u9&^7&A`M03)Hnd}Nt??9$Y-Nj6Njqno z$wAAMfBD##nIVsqi^o6@0i-e*NM-_wn(s%kGvA~h0l={;Eq}WVr6gDu6Vl$oL_@IO z!(YO^USL?*>hn_yMiaZSWq>wnrH?qQwPGYh*c&1(-0bdpkNmX88n6bdJ63ov%slbv zwJYMTF$x=|ExG)!V9E2to9A=^<|y!5WK7Gy>S9j!`nZrNQ>ekS$*5VC#}|*qHj*9J zsFpyVzk&*Zn_we1yG8OH%a>2?~3Y9ADimiGdd-WtdrFoX)|AX8x1aveK6blE` z`*MqQj=Or!n8aR7GuD3h<8X=I0-ps}2HEk7KqU1ci4&{w8rvWyu=DU(gJnY1D98@X zGyPGQQ4Kx75g*><2$_5x>ROY$n$;h0gP*-_vK0U1;xUXT?^5Qtkd3cNrh49s2w2)j z|6SqL2kR~1d#)C*T2iI^HA1CjOoYa4gR`J3jR=}0k?X=+wK6-v%;a~CA~nlt2Y#~Z z*~7tKU{&Yjmn%@e#R7nU?b_n7tU^~^2bWOG%(s8(oHKvhP*}*y6f8o#h;a<>KCu!GoZ0MwtY=gfD z5Dmvy3E?Iu%q#ghpAf?9MgUbvY+jwOX5Ojd|6K*N{2HV-`z=PLP;Cm9my2L%z>7## zp20S^J^R4#X^1jJZ^J5AO?`2}g+B_lJ1{9I=aqO}bv*?)R2$yxQXmkm=^!=@<27@y z>V8xPgwS~G`wPPG12Q0s4kzYfq}hPj2hx;hUcQVeURCJOe!sa4KTL!KV+R`dvVIh% zAjHhdJSW@J(YQ|~CGs$?!hZ?Q=e12l;MNCj5CA~#Ffb}t-BRj$fZXu;^r4Wi?04c> ztZB$Vc9s49CVjo;O(4y}^_0c-(eU&9`wCWnZVEJ(`+!DNq@ZYyv~cX;J=Ys|UCx+O zCs_uL{IQaPaZBN7xVW^^KM&7?DHOmyN_^uBo-pGEmVq6UP@aP!gDH+wz$l~B=^P{anvx_9S0vALd%G_@^G{O#&D_`Y?vxIUWthPwZ~p-aeS6XE3N zL5FKl1$~ntCoPjS$CKUSDMG2H@?v||GzjFMfsR|$acF9xHRn6$4ZXKUDXO@SLLE7P zL^k`v9-vgfiHBN|JX{ZYxK60pBvfo9R&2m{;uiSl78zk7`qlXHLiy^gOcM5$aMjAU z8guiIxte`V7t^|-L56EWO1lF|v_>(}%(DKiKL)xn@^JCiUlr!lLug&ImN3X>7fP(3 zDw<$aczjVpY~Pv&=xGqb;KKzzdeB9{a80~UVCy){2!kYM9>xH?h<*}WfH9HDw}dfZ zX}H9f_nqhv5nwMbAfuJL9{s| zT{V2WtiH*voE362STfmu=F zN(%k@);1vN7dB@K`;T&6Si$O3w;Sxgx0b@Ba;CT+wHT7{ij@d^Z~rYqvDsG+fNTfe zt+ncTWfC1Lw6TWIwRczE3iu0zdE3eL6%aiIxv;OYml5fP3GanMJKjp615}%8ar}^8 zuO?t99PLHirlj5+ahMy~7UGWw*?uu7lJR~IoITF=JL1xff_og3k&Ghd^7o44Cn@AX zkNudZe~tCECYd*!+8d)?${$@2qhDhMyF~f`Xk)Pm zm&^EC9;W17iqGsWUORb2o8mxm=>Oi7xda2~Htic3#O0Bs#jN|nRxncWk8$=J#8kG( znTy4wc`sN=_uRYBCR}4%j=}4Q9p$9;+!uH|t3~Z{L1@LNqC!4&XQFDsH;XR)=6x;7 z?p?FRy7SZybwKrRd$)FV*yG{JeGfBaLmQYIJv~CHqf^;*n zvB4}W>&3!Gi2=)Y;x4HPcS61GV!K@|{RpOnRuW(#s~!tf=lE`Oq}{eBKreLGE-uNp`E6s2eV zoq%~>i_vXa_vtXpHS<4*qS^c>PS^>$9fwYj(H;j?go^RR+Al5KXC4gU)Gf(Ud({3% zQdUlxae7vH<$ey(@}9fS%@o+b?7*z@po-#Ai1$}BVY8_Cx4?In30po2DbEBMdQ>yX zkqv@$g;n;MJCgwd!zG9MnSryiu^IpAP~tpN3j-7I4{~U<)7#fqJYYB!L{tSfu^2ik~iE7nINTJPjv+w;ixvH!t8ZP?Jxy>Q1D_(G2N*U+rkFS7-N zEwS87XIVo%ecay6W_l`ZFE)zrr1Z^KQ0X{0>=LQd9;d+g6*@uqd+grvKP=+3$Eft} z)=v$wq&atQ*7z@n=atq+cW>WFxhkOQ#bA*#{Nlg++Tvi`rNRM`ac!)ra8#3fpK__H z_1bq{GlEh25W{+$$>jFiiVG>NoMp_t4H8gp(+5>oSwIFJ9Qs9l6u*iKep_T{v2KRL zX+F>wY@biD`VsF)(2o9c7^C0fsk|$qB`XaNDC&EV^Uu8^{3S zrDSBL`vwZiN#WS%3{_hr7)SpZ?m}*$Ji(6O-^WL6WX? zPRZ~qhtsW3I6vPLN44dqMN_X%ET8A|{9X2NAm5HYI2ZzTR_biZe}zD55tJIHU@*$B!ZN0Cfe4}d`%thT`{ue5@0Tco$~&N% z`OgA*P5_~euJws3z!PWgdqd8VP3Mgy6A++8f~si9&thNC!Jr=dRb1qsj^~eO>(7_o2O+F3$u_k8_Yi%aKaBah9PeJ36p{e~4U$o` z_)wy~5DX~VeABXG1!CzC>wZSdn=#t&Dm9Ndy4FznR-#n|aB$|O8{~A``cM6yd#_CsE z=}<0Bx=}@P@TXzq13JVjScJ;X?AQp=dj5g36*XzADG?{GogghPn3 zYlS1Dgh8t{nX=}c(Jz!^C;)_^&*U3kZy>au}&ks zY0FW!1SuP@AebRRJtP(jxTs1Bl(UN)O4SnK8Ykj)K)PSpqm!6L!_HIj^Un0zFOo~H zp#xLgV;I5!)tm>qcIv}v1bve6X+#hyr$do(T7Owy`cG6ct zfqHA=naGf%W(17d%q!&h_RU-}3y5sCMg1Q|G67SN38e$jk#s3}J zmCj$5fu z#OkmE_B%z;v_8v)G%FB44Gcr^?}R%R6{&= zJoLza|K9`J3`8_(17B_EC#mXW_ugB^yGF-4}?IRqHM$s|x zK?g#W3Y) z!0eGi*(lpXTaG#tTc7SBA;w6vdhqYd4g;}{b*0tIcnXQ4njwGg+--?zWn;dh-l=cd zIEDGFl=vc4j!_4s>VemX$*qOoU%`iI3u^nlw7VefKKflm^aa&1rzNp?fR8|BSUn6s z*R0&po%Y!B<=BTCvA{$=yu<)r=1uU1W5Yj5!FD1TEP!d&C(i|N z_f9tl6L7c{>v}|KW={P*JxaLXGE)Utht`abB$x1HVUku(^$(^JcHzB3NQEKT$5b(x zlkfCRs!0npNEJS?XEyOH$aQ$g+IF_e4qM7#bjw|_?JL1(oNF?&unxjLD(b5ya7hNd zAawNg31mmua~z>{>br(4{=L%BVT`HpD}k!3ve7x$?BJNv3U2_`$CoL6>V%Fy)0(;x z9~D5ZSYUw{_kggk(9@Y8!p9i&^l0*>0!1KpeO zIH1}fp#k$%NpZp<$H&JZE`m@}lGSEAfsbh1Rr&aDna<0=Sp7jW&&u8VZf4xs15bT& z8YPL+=~5G(K71}m_Hp=119asI4gx#BVcL>frtGXg(@Rm=s^Xu8OACY#j`+d3P&I*H zw}8a}!?%%_s1a2f4A%xO>H-9)Qwf?zo0iw$fnh`f%; zt5&R0%~r*UVJ2xh$9XuPq)osLNyQ>3oh_}(R*%B5ZI;ixhZbxFCzgN(|8iI#a0EMC z?}9arywcyx??m3Z>fj$|PLcU|mNPfy9~E>LoN9oCqxl&TwVUFvX%ew5!>Ip zvSKd@zVFf8>D71Skl}!9i?9G$ZFr805e8fdl4p;nY)v1xTs7;2?c$vMEt3QTf<@wAuKPAp;LQYQEGQ1RQ3pFRQ7eJ+k+ zsN^py`aAxQIGhoVw;{J3qk4`+BlmeP9vB4pKhV5g( zfq|!0@7G#&xkc$BP2v24=WTI^D+4A>IwnD5YawBpLn;Y9G+EF+%}yTx2QeV?_Odx7 zG#u7$3NRWg77GKr{emq2-}isxg-Z_0kgNv~cFNt$D8AE5YGYjJJ{_fG4=IGXg|n@iYc1hd%`x)YNAAb(RG_D*DqkmIW|v7hRNLgngza zfXsjgC3y~j4q#~0+9p=K(ulN`|HO>EXJ8?MJmF_Ej87;!KOq`8yFaM4k^w&aFxQ}K z766%GFMb{D33tE;1$>kNgZ2X61wdAQcw&s47*z z5s;@|I6-wQkdu>}41m$OO2fZGO5QU>$9zM((T-A#1XA?c1E1tJH0bjft(8UZNG?_f z@I*zoj&JyY@QInuAIL)32*_NRcvnrW%x#5g-Aa-#qQeUb!sP1Vc`(_9+gcp>M)-CH zr=e8-Ge{4AZT0AXJFMczrq^%ga^${~dHB2TA=NB*1BfOden)@& z_|g9r3<}Ni`C+#9xxl|8Wk?JG#0l_)3d#5I3efCN6(Q|~h?=LsWn^q<9v&rAP&Fhq zK_5%fihzm~%EB=h5OKIEOh!^)a%Km(`4!#w^V^>3DWu9tZL2H`zBT?gE&P%`z_QGo zMn2^4+BxxrIB7k&GU9-%oSpujU`4 z1`=J>yg1FV?{@5o!24Pkar<`gB^d@Wb{{8E+#$mQt}NNa<>P-o$)3Lend?$oMna!s zOhX9k3Pn{9zql%hfYJJcL6^NW;S|}M)^;`ecG(r0e;Un4C*Hmi-`o8Jy7msV_FdLO zvQ;tnK@NY^8UENu)u7aeA;5~kozW<8V`gWiB-xv+B=g{qY*Hk9 zg(Ksb**j&FQs1ZRdS9R0?|1!i-LBhp>!#y%UgJ3)kNeXq-tsv>1hlyvxFKJL`kyRu z@D+;xBFkNn^^I=Qe$NNzjFVW;?itPMAr`lc4ckx@`#*Q|Ys*Uoz_BJcyI4ce2$M!8 z;k<#%7?gsLPk~CYaq6Ea5<+MIi!8#uQ8MyM5;6#g2VzeBw=+ILq+N}XPwj>dQkz+L zlX4#>Q~uh$`_J`e5pAtdyKr`L`VCa!KYxHB*9tS3hVr$5QC8=^*nRAjhfdVPU!xC? zO#Jea^HDb-bv6@vbp1SK7#ube6BCDgc&(xV4ZXv9Vs_=f6q&NgHa9t<02E#9rcn6e z!*yGWg4&=O89H7^DG6P<#I6>SJ&t*6Y+&JsMnWaTATT=P@_ERZAqnj< z0!D^ZMjs$oOQu}FWN(W5yz`D|w&=g`jj{q-hegug(v&5@L`4p5$6Q0GbAjs;U<%|S zLCbErRD-saF!bb~d=KDPa9i4hDvL5xI*h|R)MpEAfJ-^ws-REImDm;Z9_AtyE%@Fc za>M@@0EgWw9O)_~Pg8}YLuyUuU9fA_r2@KwUa4VXs(W>m|B_swu?9{7!5M&xfw{O2 zMlk_4`*=2komg61TN{`&VOD9f-KB!j^}#EGRADOUmnQc!h-N$g?-zmM&8_m!_xyK^ zTh!OfoDlN(q=9Sy71b58u`~*55NT3(J8)0^(Seh9Onz(%%#^x-#-xgEO z_5ugEBy_jOoq&7@f1%$TOly*1)-4>~^9%g{oh}sznRMqWBcAQjEzS?&x`nx)vH$ch zZwe%T^_AnSk0F8yorzr=-oJics3r7?^g^Tn;c>u|M~jdc)TXEQ16no785Hxaj1)DPy6Ne%PxxEJ_q=K z4i&p)NU6~fP{ToPwG=V{GXxBXgdp@l7eK_GhNHyfZ=cw+96OV^I_f4l~~h&mGu_4T)TXxe|B4$l3*Ox60IW`vQ}2xyNPbgI(@vD#~25v7!s z=o0E1svuBF0uwjbdL!Ym`U0dF02@bFs^qR+TRoOMR~{#0ILIfeMxYo&K>{NIE5{)o zf&vk&fPLC$n7Ol~dt#PHdHCM~U05&BEe?JyDn9^h!!u6*tQW{~N`W8FtQi_n6r=Ir zATBjthoL&h!E^mU;1-ay&2HTSKNN&exr3m3_VYX3UG-S*m;csz<(R1nBxj(HfZ1gf z#Q;PtsP_hfJu46Q==$}N5% z+?XDh=J=MY^^lhW?D4cv(^VR>)sO=9iDG>o7%d1&rISFDsu|+idU5LHqhPX26eKQH z^hoy;%n$ynHLwqtN`7e3;K(d8#>gq?<(gz{9=DA?V^>$9qC^UT6_l?8=<3b>c<-+r zK#`RXgvm4FZM@XsG-RhY!)mOO*qR5QUSa;{lTt>{-5uNX)CzT%xTMoI)C7V@6v*#O zfCQxlihF-9rP;6WZM?dG_I*#4dMs)=__gbBHFa8fib&?$e~+z7?#y;=`X=ffGpX8e zxOQz%f4gM0$l~tAKb;36B4(}sK7Gz0rs|9T{e9&&cj#}gMk9crS;KIXam3%En1qO^ z9js- zRwuC5>l`rtm&?2aEvOS;YDD4pRprWQ=mMid+F9HPX7J&g4O;2H=8Iv?cymGKY67?C z$Xbq;J8h&I{E`)_c}D#Ieev@y8YHcLxC`gnIb;WIn{xDdzL0@7)j}s%n+s-V2K^$;AUQ5zUP&U7r|y}6*Y@GG zywrX9zz1)AsmvZ6tx^414FkDC$}!{T_sE^2@F|BKADoa}twXbW+n6K+&sKGm$CrbG(=UD6bwvGa>U<#^Vcp>f8??B_ zp>xZntNqDOOvv-ATc6l3nfs5WTf_-EbcKtPSM2%~0&Hi{PG)8QDoxK&?yW$d7hGXa zt#$#Hm&Dfw3Lz%99-24z*@=R$Xab;FXdv_9?nYXe?%?Ao8^d)Yz=>Tx|JC=5Xd)b- zP>vks{7)I4puGoOB>eQHM;-mLO)*Emb^ous<_3)paPQFffDS+`eXXhy@AFOffmu+h zwot2x5RuG>qVPoiMX;293rz&6AjHM&y`p=lcD@0Wn=4y4 zGIqdk9Y6gWdqyvP^Ov7In~=#{^E$Jgx|YQVH@P`?H5n_ndX7nT_+R&mM;R;ho&24b z+fAiCR^M7lM6I`Q!*#_e)@Awk9xH#H*@fBuPX@!Ao+XQDFmz`d=ZoRBLb{A-%lshKFVm;*Tb&VRE6!9Tr?&cr7405}Wz-Wj z$4l@&%sB9Yh=B5>M7I)rbtRDN5b+oy4zNmXB&GwP7H+Oz+T0H0BY5FH`j|NW2 z_!Si&{5nG7(#~@4*Id~{1LXR4mMs__2OU3Bi+*tbiGea(0pImIiEH7>yAu+ z1SlLey4`7;f2wdl{ubx?vyig!oXt7Zj-7W7YaxWOGb!j~LTi0jSectGMg*Q~lw?M? zEp-~|okm|BD%bO8CSZQb;-bmn8Gak#wa~`Yi0? zKPozMHD#QVqYr#xm8yKe-+}Ln4VLWc`Lhd}kgMd_M>T-A9}Crqh6^WlpRPI&XB6@z z{$WSetL7MeV(|HA)#h}*=80iZZ8h$A>=OEY>yIPiu!+rDJ$V>`i8V&Ck*4~w@N-o7 z?$%e%)WTy6T@t`S5-3k0C>*O{EMZP-T*oqaKkAkHmoO({IQDyzy}4_csLDe5U^@wT z`fh-HUbDoi< z(@notsJ_9RZ0Yb1nup6pUKn^BXEoAicdXs9pI_2yeLMH5YE z%H|#1*iM=D056>?$IpNlpEdHVvXuB+M}#^k0=Lj1NUl^JZEXNbxyfi(r!&p?#I1iP zD4h+}gW6KO1}r`3qK0^q8LvJ*FO#qmw^7xYjFM#0f?U?SM9{DsWaxx#RBr!=b{Pc%dI@p!ZdaKad`uQ|nXlOV>5GE}!K(KuT% z2EV^BYrz&qNlN0?-}r9;-(C9A4cgcXp_)or);J}tY=7ueKsy2o0f}AK^=3=&+?i5k zHCA|XFF#@Op$k_nyYoH>9z-$?Rce4ENQ`S+h5MS(%${Ws2?^k0BSikwGgg~AgQ>s? zmGs#p@}BoSMbzw^R`=qaoW5VibQYv;8^j zC?9$=J3)+pz^^!^pBr`Z|BMZaA3bz*F+F6hXw;+9iQMkTkMu42^& zq+hz^uAYQDGL%p(5KDjiz#+7_Dp)w_h7Gsgi#$HC>J(`j1}X&SoTYzKMQ|olrVb}Q z&7Ly_4FJ??QXv~cvPnWs>6vo=rPQaVHj>%?tSLg=6zvz1@^@q4Pm~quqgl6^U&p{T z8lz8F1ckFqe@~7otiSNQpP^6y7Z|2S%GJen8XS(*$y&=`R&bs8^~sRx(2o1Q;b7}l z*vy}uhtT@R-p^GDrX)r%gFNjmsNMm~eOz?C=lUuCmetdslmZFAzB*zeW)awZBb%NX zdrM2W&7N{|(DX-R5)m5UndFFv{lBjpdZsQzX&GHssA_rDD-IxPs$5dCeN+nfEdh6_ z&EDE}QXSN&ZgK|0qfS*3<6rVe%Sz2nbG6}4@jpML4(8D#+?8(F%d!7bAFL~-HAl)FF#vOc~D`a&(KjHCm**mAm z$Jc6i2F_e$>0pVo5Mebe1+=$N`9C_V=9Ick^tAJhTlEV1+%!cv;7U{Ia_vfZO83Pw`=*)l3n@CTVL_F z7loE0@U(KlJEBC*EV(55oOC}6m?{f#uu@+??19dDS`*WAf|-`0HSc2DrzICrQxKa09nD_! zA9)B*!n5|{xW%Pao~^45{BCUlycwPF_&Oo(l;fH9khQ~`K2%$i-yaVGzpQe^!3(05 za>9DmI0FWR(rWD_k&m)|k6`eOUYg0ukm6nCs8H3uAbz^wxyA$sY5Z%fFr9gOS z)zc`gNqNYEA+o3xFzNO};-Dxe+iTkx9z>5`x))gzXOt-3Wx$irExjIXo7L3uCFm&! z-k;kX5rsTM&UAKf{6fNf-xVV*=yn((X>S#bIG(d@YF!6IkQBWv1JBymxySKlwIR9; zyW9`Mot6*)Ze#>%x?hM`fE6g5+N_#zQXO5V zdU~p?&{G6p$Czh5q3-#&y7Jt?&=thDxaKC3IjaMRl<*`S2LtYi37IAXyDCOr>cw^= zwulzWuPtz*UM`i5IKej`;DeZ4G!J~rh;;eEC-`aDHdig$8mlj~7||9GKGExk8+7nl zsh-q5OUQh2iSH&TmvSWSSJmx4VRkX0nh%6so~ylgf%(TeUZlhv;m;VYF=cHiQ5@9j z=OZv&2W>YSM=XVnH^hH2M@X#WkT}o_e;-#C?O}!H3=kvTugOr3SmbCFL1jlolra9g zbi_gQb~IxaGD23CO-jQ(kOz?i6VgyQyAyhM-tV`2Awu+{0=MET;Yh*^0J;ZHa*y+j zG3j5a3y3J5uV8cl(raq}u%3b;&!Q$xl+?OTL@clImUjc*5w0)1o%r)TlE@Z&(PBxy zdQG9^8>-Z6=!(|HA_{~_7$wvVwpEYL+wL9_%a&FT=YNi!Xa-|!k)&p*d%Zp!E2m=q zI|a#LRT)^mA7Wb1hBhvy#lUn!6URL?PDzEuHx0#Q@>1%9=unX~;|P-7M8G=I%%aX1 zJG}Zdk_X`lh8NEygB!_6>`?I@64#%{bTw3x%wCRXhxR~895hkr%>VM{ph4qxRIF9nJ{Mfw69%%{9XThpx6=l)#V~L&*P-- zJPfYeN&H$9D)s3Nm`9U6ZWPj{aJ zvb{01HCW*tz{BUV&I*+8J(1HUhQp8jkhm(XkXEm=8#+}_}=o}I4~5rKgQGq`az}B@h-)M~NJuxoBS*r)X8Z#PqO9QT3<)Zl^x2&aENIG7e)bL)RO3rvl0g5uc;r?Ig@f&i!S#l3uTE7+lxS zg$G-}@7?av#8kzVF}TILH{ImDRst?=Ka9utt}TmX&W1fr+7rH<>&^ZCGJleZI!Y3f>($>Xh*&4}J^4K- ztfOqiF>Vf_`OniG!a1sb-QY@f&;0h?Xmm;I+P6k#m&WO$d|x9T>Nj@lGv=L!f+G-_ z@ukNQ=i+JeEUYRA^DcQl9!S)<>O>qNe$WC~4Q4%j%(*ivYY7GquO#-i@3)84d@gqd zazB~N2GrSNYm& zZB&iPXR~JdJ8hH!<}oddrCw zMgh{Sgy_OASoaDj*7`Ro#7eV6S)1qHJ&J{TN|NKX$Z{Sl@evP&;J2mv@=SD5EMNLo$OHkS#Fc)^#%xNkacz!=$= zpg(zIkX!b3$+We)*GT%FW;6#L9h!pP_!@SB?EZyVRtZ3liMC9w;|v_3(O?zBQkDGb z&vy$s>ImpAf|*h*K~v4p34n6B3Q}I$ACF5H_zX{g?r+u9bB$}2WwLsIO6hYJCjfHL z0(Y~AR*dWf_8sYyx@Cc8fB3o~wh$MhtyF1KZ*9NHcvbeU8M`4QKj@-8M(~4A9$j2{ zo?rLM7;C~`?U&5LXHhO?|A^)5%`#)2wU^1!#^r=Xmt=9J_rxYMSKMxU20s6udqJ2JZos*vl&MaXC^*gmO)GnV>MDL zIrnq8A7chTVO?4Z_Q{6JM*G2-lIfyyzJcqme;}rGf$UnSk5p}+?Ba`bs^09h4D%PH zy*dqC=J;!aX`W>HW^!wpFO^Q!o${PLf8x&dDeh`rXOYzvHxC`eR8Vb~EuOK;JwG$% z;|cK}Q)6Y6Ebk$HVHx;zf@zwx&}vn=1{!*eQ-8w4FK+bu1gsgoaah{f4i0?6IeKPA z{0Ntv1-M|(S2-^uiyK_qwH`%uVN|2#{r)>I9m?EyG1$-#JHHw6M}|cUG{J8?oOu?> zs+DmDSWmuCl+tMsM3#)(z7G^MA>j5`6uv~Gt1Sd?Lh-*Em5ZaPM2SXd?i`H-f>exI z)QKP_r)2)cxCw6SBBsn6Hi?5qPN`YL2&CeiDo28L#}IH(lK3Ia2cfxDm+z;PHV2TM zI@$RTwdp2r)|i?bugzW3_RB}!*nFYNcOm@Aq_*iwCefs*P}SYSEk+$uzC=USoJ%?+ zh;-7VtSYVi&sfM+>=R_`H3afnGblH0Ls+KUbVw&kD^DQv^@Zs97nSQ##i-6f2d^^} zDxxGu>hG<7|C+T>PFR;8{8=>RluDiqpeyiNR%urUV%PzoY4awn$atR9efPf&(-_6* z0+9prlnm@^!|YG1UiyX_O{$NA2jT|J6Cp2YLJM1y?Z~g)kMAxCX}6-_=gC&fO+??dN_sl*W2E-{8+nVstRMMHfqr z_`Q&r4yS)u`iedn??1bf8$(q++izq9{3>I}H1al{DB+ou!iZ;CEvd@FFP?mNUEl(L zk~@M=&^wZ_?XK6bA;fh0lKXz71bedeHvQn1CjlDtH#)>*<-{|`2r-=X849VGDlZvk zvL{Yl=~lEZf8F%pi3uXBw-QU3u$Y3|(Wr}-ukFit=ug8+vgFJUvmg*s{%_MvNvy3@ z(2JmmZ?qH{am9D%L&=mYwR>SBIuVbkHZIRmuTPK<6%TyMVIVbk6I)HlvTag38qma| z_>ADbZ$fQX5ojvk$hM`H{Q{n!41O%&a7B5QPuiY8Em}QcP(P~JQ-CHmbRL>eELw)r zb!aRESC~3ZRE1_PK4aIouuXDxm)Hy+@9oRtUE8iHw~g@cm`X4}X;7@DXda?A+%2U1OvIKAot zv+lq?6FksACnH3re)fMia6>H*A1&GV?X{bX$z8VY;CG=SnCAsw7f9CUpMjL}&r3B% z!F>zcaDcOFsU~3Ui;b}riQYS0MdDqB9t!V9C+@)3$wAUSZz#_7;_ z?E>3>oZCpy zZM3@BP!y(qEFwRCi5hC_3?*X+Ea;n~H>tJSV7C;<@!cd_lSXYDIDWGCWW<_jMhCs` zn4T{s*e=IA*N$DVNJin3glRqUHL=S4{#inerqe5m#3znB7;Zdn;?4$C#RjfM5y=5H zaW|~L`0uQ^L?KKD?+P?9>9r@U`XaLXQ;TE=?```iIbV=1tRBDXGj0}C=+nJUT4$~R zZ_ia|n!FD?8Om@#lc2RDK ztzo&5G6*3 zTlCPcbgjq$vkXAH$%*lItHwogJA&ekok0!>XvL}Mwteayx6Jf-WVMoMM`Ob5=K(g5 zYHTBKy7+kbfPx^RFy9^9UzDXNul~!D`+=&p|FOpB-!*98XM8aKpi$Loa3#q4)nFAP zsu~GeV+uO?tnCqW^{o%K9CeN{4V$_p<1SL^BdF@TKcv#3a{jKWIkOO}tmTb7wAAHioj?V^f-O_#pM!mmYLCbFYV2_x^Be4_T+1p59gK%cu@nOzpGnUY4cp&DUYDFK2-MSxe8Mj+YmTFZ#d&M zi?A2Y5>MV7u;(F);S-|16wAhTZu=G6YSHPtu7gEMl^);IAYM-6I2Y3O63@d)Em}?1 zWbuAY)UZsqH%RcfCYZFX*;W@1g zewYm(fBbfSU8QlEK^^daIa+SXF$*th(S%c8dMZrwI_p->d3uo`W_X4IKk9JLZ101# zMJhQu)G8;ssV^hLaa6j-#d)(d3^gd>C0UY>2HNkXrwTB)Rp(J^>-zIdTUSHLhko93 zyT2ErVn083;)2-Gr1Ph8FB_FxX@zCG{X4-l<$^&+Kqfj4EoSVa&5c3JH&mobElLY> z0&0gH6Kyjl(#(!+xT{Ytol~p4A=Ra}ex^701NGMOYi^fgd9z3=%9B&dz4#e;Cdw zJN4!DrCyTim_E#)osQ1g?51XWxp+B-znVlcWkr&+A1ETu)d|qHFN<1@jc*DPKur?o7AQ;NJeeE%5f{LlIz5If(0$n6LHMOQ;H z+P+zSwaR~k2Bl$x;`;TvKO zj^ZgaB$_5=`p!*6z+^X=XVJ2E-Ye{jf4C=yVK+UN$crmf`GV|lih*54hPpTsFdk?A z#TTx6ya}lh@Jlwnnpk-;-R(+E-MgzXE<|;KPKio_9rjP?Wlh<#rOBjJX-s%VXq;BG zr4mORDi8w5N+qm;W=`fH?21zd!^Ui^vzWYIh`}HScN}dYX=FO!?A+tol?SjoMo;)s~(u! zlHH-q>oK0G5Z1FSF|Gr-A`cCqOxE`ZI^L|&=wtW&mpRqrI#L_ixN_y-tCM&Jy4T;m zE55tH@U(3(tW1)(p7?bKXLOtlxw*sD3iO}F?zQ$lL9#zqbG}fAdSO{P{Yv-3o;Y0P z{dtv*r2r(@9l}py$J@le1HQu(Z^}#ueOHsNaov;dpNZTK^!+)`pM@T`a=ys(T?l$7 zm|dIazapxT-latV+oTN3lJeicz{vFl^u^PLN* z32wpIhbhNTB!;eCPAASaWh=49R3my|4@tDs$-A*Ca@r2A|`6;5h$o9>i?Q}+rH}Oe@ zEF~JgP-M9jp%?C;t(w~#wpj+;Cf%VNQs32zlyVDV8?QM5M5kjIf(O}Ga*2gYWm8t% zI6K4dyG${D6M(Q2`Zj4n$nm(7I}HX0L-Idum65h#x3MU2)rkJzT_PVL3kBWk%3O-n zu2m026J=wEuDMOPs&)p%@@ghH+sKS6ewG2%$AdpCI9Ov$v^Mh0@g^zVd2bCCU}7Dd z9-mYGE0So?mi&uQFsT8)%;a0o$ShrjOE4a)%?xYdsBe>d>Ney(eE^|YBlRtyFN7fu zf-lUUr&9sv1yD(@L;NF}6*M6=M6(Ka6V2pa=zpZ-9A&JcYfNieKkYwN)oL#p<4JT|L6Rhnd)xrJtvRxQfPQPj4&Mc zkS zF}=UPDg;3Bn#6U&d_>IF7rBW!*!}&PvnH&?ugQ6P`@%G$tn27jUGzXf1s6aEf-Mo7 zF4bm&*5ue*2*xPXM!b$qPn%}twDloH#=Gph+r2W=-{ajf6U{u)c^yA20yfwDJf)30 zX`^jJd?r*1<%&6XmF73ROaCjLTzS^#WeInxYyTbnwwVRJ)dS>^IX_KJ!W%_LhsWYcF++Py=R-O_ZY3&|04ai zjQn!C=R0|OEso^ZAvK@Q5CxwKe|7T1bcz9&fx}JwPG!B*3tsPOp~%+K5l4_22M^d~ zs7p1CM#7?A7F6ddc`Am9gnI!jXq9)6De&0Psg)ymL+WXqU+7ZAx8qDBS ze!Bek5=IEvn|_|%8SrK7UR#j}t0deH`QKw3b2{PzuM@OTXr88TZd{Fql*(EhWyX;b z!R;#-A*@Hi4SdIvK>>Pxn1%JOLpM8KYZ)qTwXGy}_!(B6lb&XeAqbg0qBx^c%-ZKy z8OJ|lNll7;?3l9$f(U78;I0qqOLR@^XE&wsdN~ypav5rP&8O9vLB|hj18{*FMjB2B z6Siuga*~X^ns@^nqAshb5O#@(`NoE{^~ra)I1I3~ewEWpRTJ{w(BN?rci2ORqI8{E z)UML_9&^JR4a+M$c=N1QKU#2H&_(58FAgw`TgYsvPXU7S~o3_ah$XPBW<|kWaT;%*k56 zkGF-GzIDVNDB7L^Ea%#kGa8}92jQys=f@TD`}@z5t@3X>?)zDA4K zfhifc(_bjcZ)YD2+bNy7!txYUc!+eZ7nD4}=$U<;>mA!KMn)^^l{(%p6$mxmtqR9I z#$*3Zr0>OxAuX>7n___lQ%)w`$z})`8-o<5E%3nZI5S`=vh}7cBMg155Fyb!+V=DpA%`l2 z0OI?~mWDEWD69NF|7Xj>k%C*5al8euuyBng_NIKxhyL~U-h!K!@kDwL`89TIk=7Mq@oAo#)hJFn zLxGmvw7EDIZh}h;SS9T1^=e9BP8C`iT+gQcJp6z*POR`U5*(;v6a7|Qt_E}ob<=B5gB_%SMG zHmo8W6k@p-Oq(of378sk;IYL6*LGZ%6O~kR%mqa%8?1%gj2MB6X&ZJ1j)tUP^mxm( zXYa+Y+I?r>k@<&$cd$+3j2)vGwVzJgDJLe9SsU9P;aQ8*8bK#pdQ#nP>{!}GKr0{B zM`;7TOgxczuIs2@mIYLb>G@Vw)0_N6(_uKkBt5BF@w0toyNV-ZsEU-|zLw3WExfu8 zL&7&oH_eVV_uO-|+3*Wdu0KB{v{~lp{pM+laQpSYLM;93kiQQ$=yNwN(~w<%K!m2&QvqLRd?nKBO6n;!4v|r9Rg4&v9+8QHH5Jy52mMc>nE;3Ka3?pRS3t zEke;xTT(7QI&{o`+VFafpK}%mxCPwYCG1O3rJiV~Q2IzUbjZ^fdYHj>Z9WUmh`B8{ z;hT=XL-aVXASB)MwK=KhOdW}WeXI(9Ea-eaeKJkCc*HTvIHdKS&rfrjpy#C|)hSj~ zq`%ZAz7mVyJ)E*=oB~eQPXT|s*cA)8cl2z59r`)X^9Dp{{N3g{PB=Nl+9i}c=dU=G zE$y9~b18Pf1d{~O2Gpm>l22aftoSeYzbjW0`GK-NAxo)M^+Lh%#JsVt*U9cV8rS3J zzkVcrda~gE6i)V>2i_izTHmG#c6R3I0?L8zGc)G+sJSKXjL2 zE$CB+j^dtXmY)s`sJjrez4>IktH#*p@p=v%vW)%;Lwxnv`1+5N`%;uNpG}!<8$0Gm z>yE?|4I@wdoy;R_*VH3JYO46sGW*;H@89>0JqhDjAEDcJoO1Y1!_CoW4T=?uu<6pm zf}0>F`KZhqt9Zz`rTTsVC^Beh0n!icXp1HEeiVnQqJg7+qmHx8W^_}BAVYL({-q~O z(_ZH%rsq=@tgbZAiLhu5zlXV5HiowkpY>6G$A7@@exM2bGVkv8`+t|K(2qbG8kA?J zE;B#%apWG}#Gg6kTw9OZm}KBP?N3!lDz&mv(K^^zO~&L?V72Niqid;Cp%3K`8hcdH z6&h5W->r~qVAm2MYgw%rw>OR$(N1V$^l^2JRoH@g^-R*W-qJo7 zX{4x#3c!T*$62mgiAfKQ*rQ-QQLy`18!zUd$OY;(t*D`!e6&!|XU zVu?;-pcuO?uKOvX)k6`=4lxw_jy4gRBpc5Jiz{}!YBHSH&O#B`NsK9$lcQy2YiYWF zjdBmk(Q+17o-+RP4hh8-8nPlgxVWN?bKzY4GM{$1bJs;oq(Ppe?SRDPQ_5qODmC?U z9KJ-svLc$AI{GT$LO~k(tm1UZkMtj+N=Cbr$-<2UXh`eVna{LZfB*+f^x9CO}+(=ocM9G z@+_d?cdtd{Zt?xsA>;ctftU7oba6btY``Dc_F+^^+R=BwB{|sr7T+#$l%_ zo|RtCN{A9K=q?OxG&S?SWiqdnY@ugP7a)S@7iK2xI>fl-#O1!zf8M}+%rYJ2nI?1I zXm1VImNV>5&G6c<$pI2xz5$9@Me;Y4R)--hArDF&xN)LsI?u4EsPSscOF=k27`YlP z4&x$Pzbmq3lXK8~gK&D+_Q>~fA!)?*F*7s?YSJ0r-K0RS85f-JxQqC&S%1YM63`)a^Zd?Bt(E z6%@T1`rNz6;x>3_T&<-tl=kL3W^G8!RXrMqO|-m z6#-fpRyO#17kTVlP6LTAF1{<@szO6U^jUDzl=$gOFz?0~NB?F6Jdd6V*@8wr)j&&H zf9=!18oM>E!R>=k*T4SZ&q?o(*Bo~VTjBFS2o^bYSUL2-dv6WRkx-ga>^Zcn{a{6V zZTH%k|LfVj2XFsZqZg`EIe8+x;n4lGtV3#_4S;Xy!rJai@g$Kw(&(gIw*u=``P3S| zBpL=mN9BQb2Ju3WR+HvFDxk~4rx{G9zjs)vEVS>MZQhdxjyF-*C(@#WcFWp#L*gK+ z6g2U0I-d{~cF~irGynUdRsM*RL6TU@y+XF8!kJo@Y)+HHVXVm-#Qb24$qz{TAg9+H z`0Y1!pafqv^|JmkU-~#mbK~Y=&f_uUq~kSm-|D%E*{UWHq`wn!bz?y_;Do;^@~P!S zwAAUOG;6MGUSKLCs|Ot_3~i%?IMzjv6hd=OJw4J*jufNn^a+F*#Z6_O^~DBrZLX5( zly~k(skFNIN7^B%G^NA5HCUmkiAdty3jMcny!etm-9`X}jAif@Ei?>jn|jxTEO`FP zddHA$*RAr9qjE~MqK6Pt1NIOinae!NvpWy)Vurs;hl+Q(vbwCQWO@;~x>#dqafKUw zpcJ7$TgQL#7tIq10$_47x|fE2YI7J0jv|*IQy%Ri%%wCPybk4E*2)H(a<(x%?g0sA zFh3%(cgtnVxtxUeaYA>#;rBm@%c&B6(fXV+mvdMq)&EyKBHyB94b3|F2VT>!H?8_!E5{aU-qK7P+7;ufQZ-CK@ui_QxC^rac&li%K5p#ZIdkO? zOp^(Q`J6`1>3hZsSpa2+1!}2g`ulgkf43etuYK_G-8Q)r^<Y2ai3S{mnk z!|m>y^~qqMr}`Q9p64buLNTv^OVW$~W?GcQxnRux=uUpOB4-VOT z=X!8LRWNa7B7q`qKu19V%!;-_((h~V#M9vtvsn@+(@dcM48)uLu0$Z;dPO5l6Oh| z=&H7DOpJVKeRS)^1P$iiS7Q91$woP$dYUZ7kL^NX!!jE}$cJBC=C z>#%U7E_iJYRyOj{Wd?eOE4NB*(|SYuy$fu)3zrI)VtRW8`}%|j)R%KTg%+rOPW@J@ zHZ7&gjkn8COdMbWYrh`R->ww0kG5X*S<}I(x(XfK9Y;!RN6v-s|4N1RVHT4au$;Wg z6ClI8$^TZwQz}hoyMTXVvv?%g4;b)FIV{96?>p=-+hScE)uKHKqj^b8fDALOv{&6LER8aF&P| z247mhNYfO|PwgP#7g4zF(mS``{~3%fVKZwC`ib0F+Mn*X01i}Av1i1q(e+aA4B?e| zy{Rv|@zq!OxlLjey_^<5e*67xV_}2y#>LtJ8=tWi51BP?SRSISQ0tHu`_~asdz{K# zg;!vI4SzQnV*m4cV9q_EA?}Knp>uWmCOY4^lg=>QD1e`pFs8f3>9GovBH6EApQ1qa zvmJJ|N4B0{;4p~4VN>hkG+h?}&7VPkHLLk>JH4metx}EWMt_|m{l6tKP~z)wk|Kc4 zVsw+-PbEIiPNWc1nXt=wQ&k%E3Zo*J%J);7y(yzCrR42|xysG9Cw!|Po_-*GJFzK6 zs4!;W*&Dc!lgJ3N4HllQM3rFR^^9D~B)N6lJ7B(B57d}gAaw$P`Y?VBJ@kVQTaKks$# zs+Gvyqxop2RM)kS^t)iz5Bd_$U38yQft51{=Du>ozl;rZE!AT4kMW2;v+9XlKS6X! z3=Uu{`PB3Ha<13DN7G-4J1#G!*tT*aPALqfOLWF-aQqyjqZg<12({+OdUn-Y$~#Y` z5G#eHy7QeUU^~`QUo~!B{L$|H!YPAwjMDR(l~b?p?|mN88Z9&X;d|75xU|O$fzRZ|7BVAD})>9Q%t_4`M=tHT{JEV;2A8Ue~0%C4@i+Z!97IxOt)YOg#QFYbr^ z_C)3G5fM=^oOOTHaYCK`WA!PzlF;4!j^+LEQU=}HR^HFbZzgb3jmi7nmyA^mdfMDY zO?tUJsxdlPK2H91O%kX71BMY0s!bzpFj#F7$pBU6su%mpEh=(ul_#vOy zP*<2sIXk!eNR8DdKf6jc&anqAHIk-jOl@7$+cINL#Dyb&X#@{7cntf z_N>isbsHb5)Y$lblHy-bgQ;C@QIc@BipIA&3dk- zEnu}fG}d8b%d4^K!Efw6!^%XL_XK-YDIvFvF+YKtcYWm7JsUb=+3o=NZ~JlA$5p?u zOu#z4(=As>(JhR&o!?dV4B*p#DF5{LhqFYK;;@th6lv~}N%@L2&!4||2EP__+S1MD zDcyt|z&%ZEeO1-p(=B=n8};*l1j@rBu7N9oE=W-nUB(r1_icoX>a)pvuoad z(LtGQBcUq+5^@atByyCgSwRRhHn2R-y26@K_>VJ7#SXB%IIGjA+b^IyAf)}hIy%TA zW$>;9L?8W%GZ<-_YE;?6&`;R#EbrVD-Zdt|71Wk=E@vTufo$I;UlC@JjPdJ&Y$u80$22!KIaeF6e+YW;;DNVyiUKF_dI<6# zAy5V%)MSGffA#<&^K)o&Xs74L&HID5qduP^60yGAd0K%<<0Q4a?#QZlTzX!H@T^xI zGpF<>Wk#PRJ-_%jv__V$36?BF@7=9ly7dvirqA|Y<%&6UETS8_$=-}6eo6TBV#zT0 z@@T7C|I}ck=KE?)J-R#f+qklybY*Q*2RB8=&JW|qABrZ%m)(j4$iS>Ecdp9oII zwF4}SRLECv<*YniFn*6%OpPuS;O@INukT|D1P`k|{cKhF2@eF3%-G5wG28>Eo#-_LM)~Ep08YXODM%LIbFH7SXsq1x|?rm zWCXEn@v`6ZH;&14RI%ZKeux?J;+?o#owQ<&4vdchKOf6%eoL<5y6Z&I-{-SAi8_lB z^&D8)!_QA(jQp?zOw5!bTyAB_@nShy_4{=(TIiUI2@oxs$hNgT#8LPyg`g)NxsPs( zTsnt#C2Ed)beaAV9b7bb2J9>2x|y@dJkH+pcDJ(qFn`dUXP%|oID#oTS6zm8c&^R$ zBccYr`lMTb8^@hiL!r_}x%o2tByl~fkW-&y4M-FGgjr^^CmY^9ILc)*>AzDS^mD1b z+7zEK-S^2srKzBbz>+)I`3R@shH=4I+5{~we4D`Ls_Wr|a4c!JGge*tRzD`J?|+~8bnyd0@?u)d*U)I8Ftd~jD4OaxOC*D^lr~`p9@_s`-dVpz z*}MxJMFk{8x)f=t1yKP3Q5u#KBqRhuL~^C21SLdLYN=&Gnx&TR1w?8=y1Rv?I|a`0 ze$RQ&b)A3VJik47$@6f}?Ci{a&wM_&4W>C&BbAq|7Xh)EX?0(P=H;6CS_>SXabd-| zCiE+4Wq5*+oQusBjJCu$|l!L^Pd zk-5Adpl|>H2{0aj9Hh<(rzsTwD2^n;;%J#NcNQzC*>y$m_cDZYdN>DC$C>1!fSZXBU(hPtZ4eFKLOBrp7~o8-2Q3$(Zvm4`=iIf%0O--v?+^0(EgR3r zsBM~Cq_e|Et;+V@kyxAZS5IW;?8FpbUvD{^4YYG*rAi_ZZ_>7TL}l6f=?(e9NmI{e zLCT|LQocXRRZd1p6wz`+MrFM=j}eJh;Plt-RUO;ggT+DD8tR_6sZ)PwSlahcF^?kj zh!5dR8#R4kmlt_q*$uiVo`n06XT|vZY|h{xe_DjBGKw42HNyFKBtZE=d9j0o%tOPt zWYi|zdyL#XGbP+9*pO$b1~6l9c^}D$C0C5E@64pN-I0QbVTVJjCLjzyzdtKG_#2x{ z8b&}WkIw{|F&g+fmYus<|7qjwV;6jP5sHFNUw7+G{n?NVFtzmC6-jl6laNo_j6Uv| z4PrNS2}jfYrk&q&r5&r%e#DAyhiQC944TBr4!8gLRG??@oA7Df7IFCux=B2EB*vG+qegT1Q+^tZ3BgzmS9O@?jFA66s76iqpP zADhM`@YHgbJ9eIFMqtzVxK-mW_i zaDdnX&yl;0l?2Ady<+oGQfvk8XxgY(*yY<9ZC#=e4KQ$aPc@ zY~8d#(KytqN;7v$4A-|HYSXin&_%VTCQf7?+bYMrb_@rT*l2+T$13ES_%DADED;ba z4S)Gp46+@~Hv`)Mfv0=HFM;mnvm!( z-Q;PBpe!lZn)-=g?P|U#!`PN}=_t_i^%vP2FC+~+4%*e2_TX^%92dKDT1+o7xs5>j z@N7)xZ$ZyC?p+&Iky>m&^Nzw2CyM^UJ?z<}` z_F&5;&bJDmwJj36r#beP^(&}9^A3`C3sY(Ec{)+3Ncn|JEp*JxcksD%MZy52Zzd?l zr9@5~B`s2r&4h~NXWt!TTAEuPrb8EDbvYcGf&`%HnNq~+iv8Y2&Bo+o(bR6p`M5B) z`o3oM;_!NMb_)K#m>JdFqaZtX@!-7h$gG^@R@Nx}rZiFFBq{Xp(*YGbCWZMZ{IDPN zIOpE}c$FhRd_f)%Trxt5au<&vO##~WV-?BdS>>gmx#}vbj7%+fwdMz5SE`DdHKY30 z?k8Pm>D_;&l7HcT$k+74D#k4aN?*C1MBjCd^EH&nABN?U8Z}3@f9;!DybYJHdIgTW ztc|pnyakTY`-2SJ^nLURmdc_fHZF+%`2iIJukT=#bu%pG=I}YVWR^8t$>@;!+%^88 zZug`<85NydT2)wBSX!zDgaM~NQ~~RdYh~6>bbyPT@aW77cbpnIKm?}=mb-}OTmm$b zL96{nf8t9`C&ai;g}=87^|JeEk*B96%q=E8dhN#D>r9N)_UwJ;S}Ce-`N=coXDeMd z-yes6T28tvgBVcTa{s}!YFe*dGkF`vS5VsY?rUi!~x;Uzp=zgGy%51D$G-b(ZEdj#E{h&uCjo5Abr)q_-A4=@ zw^?6)?1eBWEp9VEgG2p|wyGSL6m|2^=$9Q}k&pJ;?I7meb%{k9)q>cI{Z(2yNMOB^ z`1=b-h^|dlq`q!uO)8DBIkt0LlCL*(xSZxZPnZDX&N?aXk$(c?EpTLe??X%aRw!Gz z(72c8ne3y;@Q2Gv!?;cw6X3Ie+r1$&riR;$XVG+8%4O&=p!wK|<$gdbODns0G|>Hl z%ludwT+7ObJw#Oz7es}Mx)&;qJY3!@Zsf$z-zHz{8#``5LC22JbYx~W7}Z=m;d z^R%NAwp_T&s>!e03ZPe8M|;kslEDi4=&4HpQhvLltM=3RWUx~vk1n-q!xv?gWxav?MJBxUSDii(L(Jq{*76Lcqcn>_?H=aDFd`t$Z@ z-F#h&0bxVbd$acJQJIsLZ8zSIV}%bYs~M6vK}S|+!Zud9o-2UTKWwb-aSrjf|?ff2^lz~zWATkRW3U(*?BKgqhKIiX79UhZQGScixWa)O0=Eku3&WNg z=7NR-K5B@JcGdCQciuZiiOy0pN1ylKu;kNAvCY}N!$P7rXH>qLeg+-Nn1GY6${a<;%dg8`^LP{Pq^}e_=ygi%oawQF zUa~_xuhquG+Y*!tCuU-8s?`aOaw*Eqef66<=oo1D^0eXlRhd2YInu1p(fy}BMm4{Z zl-^}CJ`HEb@uF*Y=7I&lRxpa_^vBHKGd=IG-E#P}ZCtn2xrwn6q-TU;jB-25ZlhQq z#`cQ8To}>G(B$LQ&Onv(>6FCN{wUoU`$ooy;UdeLTy%D;g~bl9Z&$s(8{0n*FyV2* zmo})4xs?oS+KW@)PDY@qE#gvtc0A$OolmH!xYfhm^_SPjCfN`I)D=N;3?aOII^l6IWL2?I2~y3^l!cBAB?)c;!+co+Cy9e5O$2f-3Qe1{lP3sf=?dW z?+vUt8oLWq5m{kwku$NFqNzPlBQniNyc#56XliA!Aq&whUZ9yGNA%gqos{rSYMZ`H zZ%VyL+z47_ouuB6MGWXE>Xe%n1qUZ(3_o6OHubrIiQuAgQ;V26{jwdTjOlIqBbj7R zMQS)pV8Jgzq(n#=V?TpQ^|mRW^Qi$hO6fHeO2w6pw{V-RO=Z5{Y_8&c1vBLa7U|z_ ziLk8HG8G27_Xi!E1(GJlr^d&XH04m?aatCSvbGV6fv*k_rSkyD>H!$0$H&Jg6gT*O ztQcQ>5RiN(RX|&Ra2$JaC^GO>QM)`A%U)8Y6$7L!E;qinV>}-oz0tCaVrKH`{ zGZ1V)I#-O`5M#P%leXnQ_*RgtLP`RnEmG|z8)=!JhG=cJlNi$JcVJ*34u=CgU^tvw zEH4CUseXY<86L7KTONJ(ck5R$tw7Qxy`HS#)*s2pSoB*Y5Oxb~tRc~%=u>I@)0`S@ed=;MJ?F*& z?{Vaw7^cnP-NyU+ISztDL}B`B(COZ~ZZYE_Em2`prqYet<(EzBD82l+@fO}*C|Yd@ zSCXz*&}8JredaaidggN9Z|n6Y1{ z50zh>Q_w`XpNy<0esCsyUz!f{0z4{jVB!TVSt~usa;LfY`Sj}L_tC5DI#6mJJ-K~% zVL*K-9cL2OGwF|MUEHZQyqh(?#7VvC^dvnovh{LYYMA~JEdWl~+&Vv*1sQ@;#GSJ^ zFB6m5wg@)0BAe6@ZOhlEJtO%!RzU7cR6J?}&ceZ=L5=3SQUkt)ulSsp(8G*`*IHUz z0W;WgclIU)H+%b{10T)!)KpmO{NoIH=o^^jfun#Vrm&iv@HAgIcgTbA2W{SyLQ#C` znjA6PsX1>Zd8&tQrf3UO1bl+ZAhmH^q7{qE8?hXmD@a&{9_3hMReHUENVPp}HsZ0Q zH7Gg?Ti2h9yK^8xBu;&16r$DlEQxbK_+5?84uKDE@hyUMm~Q2QF~p;gq|uxs6}gk7 z3|oK+;iy>{%1HFIg4*L?A!KNb9vGCLUye*xvUczD1Z-aoUS%KS`q|N;T37KJeu88N9!#b>J>^k!g63~{Uk&bX zO3dSUg4&AfDUZOF`>`E4IqiSZDUw10Un{-?A?~u$14(-J-Q~d~5XC`VW4II~rr!Nd zAWxsV3jv}$yHwnkEVdu#px94SQy~G#8aMekwz!uj!2sfhckaz%2{PF>QzOtO7n}~a zcFv-evh8CA9s&(nug@v|@Q?war)u;tVT26j&&BzUj@Iu?PpX$mU7PCy@Gz7P8>(HR zeV+{C(ibvq<~&TIRz!+#1uxzAKZ80At?7QUhFjpq^IT&E4eaxs6-0Qd$MEG|=LIM} z6Ic3Cw;lA*gkH6lDP@9+!yvD+>xz7S#Og%OV@)h&dZQMH%BzGlC`733^fZ^;;k6TG zcOUxjWAD$~$zU%W!8H)2jptqU5qvq(ITzdLi{mcuvv>v|0bg0kncke9m;maVPEPf0 zTt?Bvn{eX0oxgwc5&l_Pdbcy&?FlOxWF?(+-R%@PB&Z_%K0SZySei1$jvZv!uCqzS zwk{r2D@kr!4~0g=G5n@zm$}T6%|x-Ja;-NF!ED|lWL_HtTA}nIF$mLRiTwT-(n6n| z$g~v?=t6G9wpM|JMKFMa9xpygi(r#19?$Yi*F}$0mgm;t2b1b_n)|-i^^G|b$;a3) z$qZzM_z>~8l5x4&t#hAHcbapEG~XSC%)1%hepdF=j83%hhRA`D-l*$4IJWSh!g0~% zDqpn*L6joCdN&uDazH(Q!3}CJDTkM}c)ff^Q^+&$suK4I9j@4U=Pa&#IA7lfGhbCJ z?CN&iUZ1kHwe_)Q-HZEent$3rM`D)+_Jr2?hyn;W^>TFbq6U=Z_U7MK+V0y~z@92D;L=(xm!Lpo0IPwQ)%>;V6|i{%*G65X2c(@KDxiHl|N{B&7q7dqG;jPn63zh(&x{& z*U9VMWTSo-$IPpuUF`pHW7h~GGh1KKVgifM@NBTZFO}OAON+vscy38D=rl&Ll>HXUcT4D$;->j-aevz zbW|_km(==qz2%-WFh8XrDp9zkE{^5u_Zc zl7P-hCQ{Zf&@!p2##DIE)0hlfRlHK@y>hJAjQDkUcBtTvgnc;R#ovTauq&=862z41 z?33zzvZfYLXoE}D4CPNtZDhchGAOLCZv8wxQLN)p6<()Q8$<7O!A^O>d)?*wPyc|A zZF=tp9G<(DYvxoUH!fAl#>eft6EG265^zS`r&>r*(E4+z0g25WUXKZa`9<)KJpeXZ?K@2EIa-oAb2Z_VQ_rRJ+i-cs|jV}ie{4Aq#Inh~I z`LY&OU6JllRsc4cgEhdn^*$GNv5jqzmsU&ku0a&O*zfpK2F=qSF})R|^4YomoHZFE z=&3{yfmEVt9fU}}BgIW>7lHhAra$Tw|5Hxnjew1gsc=j)8e?U;m7t7JxNV=R5K z=#Px0HS$BZDGyGX!^4P)allf2v+z8e`15Ihwuq$X#SVN|SGd4dCwQLoUVZR+!6y(e5amz8LHyI66@f zNk4>&<-@XSC|0SV!*Cn=wL7JUM^?=RMit&1QeDy<{2HeWhr?A1R?})_^$-s-vc_W- zR6+gv76TL1z4!*duZw6Q_?2LZ*>J}4w8HseIoPJ)UvD^JG!2{*B_$;SwOftYC@%aj zpU2lhMuRVFLl$CD35tV7MMZUWUSJ&u4s+0&F{!-K=cCCT6cZ7tC@i!C^KD?!=>w!z zCbFu-m(p`lNdOzU=uib@c9`8R@$vC-pf2!wx3RaIMWah=9;OmyHQ;`^vYFWe2CBj8 z6NIAFql=A9i*7zc-*Q!jP9Pr+O z<^a63gOv4^r#%*rz#gFFZUqHkJTrfY7UDnjf-dVVSEWY*9pw7jTB#VnFSgLdY9B|N zbW{E7Coi0)`u%bO!f4CXWBe=YOmZx2uF1@Ry(b1snJlyEx8~Ivm zuFiOeRpMj01zgIzZgn$t{_W)l2k#a!cP8(L`YPr)~P0Uu6G0{WFkmv<^?5bTCgvUEwa#cGOq0h8G%Q zZ^oV)n5pN)fdjT!zxapXNix^L{-D47z~|0dUc)#Z+Dd_P%?an#hEkVJSqK||n%eN4 z>KC+@s+zgLs$^PHje(%2DFfwG9bZN{Mn&~gaz2D;U0OC9=q%&%_vr$eFlw#V^j38| zMR_c`8<0)4ayi5ed=!~V66mLNJeMQFCU8kGK;ORSy*sVKUQU6Mt=25yfhXjEqG{NW zrA7E{NKMD=j%aIEOBUE|wv^UStPwnTl^#%Z|G8%HF27N{lXY^nxwUzlp=E~o+Hi1O zMiYUApn1~w=@`t+Nuw%%G|ZNY8-l#i`i>Z2-GjRSe_x{CK-d1C8$3MuyBL@Mh%x^8 zSwkCGzWndM(z$^*{@+`+TOeHjUT+q_g!|t+ybuX6rvH2UIRd1~{=LH!-1$FG1ugvV p)zEhNC;fZ