455 lines
67 KiB
Plaintext
455 lines
67 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 1、定义算法\n",
|
||
"强化学习算法的模式都比较固定，一般包括sample（即训练时采样动作），predict（测试时预测动作），update（算法更新）以及保存模型和加载模型等几个方法，其中对于每种算法samle和update的方式是不相同，而其他方法就大同小异。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 19,
|
||
"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, done):\n",
|
||
" Q_predict = self.Q_table[str(state)][action] \n",
|
||
" if done: # 终止状态\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, done, _ = env.step(action) # 与环境进行一次动作交互\n",
|
||
" agent.memory.push(state, action, reward, next_state, done) # 记录memory\n",
|
||
" agent.update(state, action, reward, next_state, done) # 算法更新\n",
|
||
" state = next_state # 更新状态\n",
|
||
" if done:\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```，然后会检查是否完成了这一回合的游戏，即```done==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": 20,
|
||
"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",
|
||
" while True:\n",
|
||
" action = agent.sample_action(state) # 根据算法采样一个动作\n",
|
||
" next_state, reward, done, _ = env.step(action) # 与环境进行一次动作交互\n",
|
||
" agent.update(state, action, reward, next_state, done) # Q学习算法更新\n",
|
||
" state = next_state # 更新状态\n",
|
||
" ep_reward += reward\n",
|
||
" if done:\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() # 重置环境, 重新开一局（即开始新的一个回合）\n",
|
||
" while True:\n",
|
||
" action = agent.predict_action(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",
|
||
"\n",
|
||
"OpenAI Gym中其实集成了很多强化学习环境，足够大家学习了，但是在做强化学习的应用中免不了要自己创建环境，比如在本项目中其实不太好找到Qlearning能学出来的环境，Qlearning实在是太弱了，需要足够简单的环境才行，因此本项目写了一个环境，大家感兴趣的话可以看一下，一般环境接口最关键的部分即使reset和step。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 21,
|
||
"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": 22,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import gym\n",
|
||
"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",
|
||
" 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": 23,
|
||
"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='Q-learning',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",
|
||
"curr_time = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\") # 获取当前时间\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(\"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(smooth(rewards), label='smoothed')\n",
|
||
" plt.legend()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 5、我准备好了！\n",
|
||
"\n",
|
||
"到现在我们真的可以像海绵宝宝那样大声说出来“我准备好了！“，跟着注释来看下效果吧～。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 24,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"开始训练！\n",
|
||
"环境:CliffWalking-v0, 算法:Q-learning, 设备:cpu\n",
|
||
"回合：20/400，奖励：-45.0，Epsilon：0.010\n",
|
||
"回合：40/400，奖励：-34.0，Epsilon：0.010\n",
|
||
"回合：60/400，奖励：-47.0，Epsilon：0.010\n",
|
||
"回合：80/400，奖励：-88.0，Epsilon：0.010\n",
|
||
"回合：100/400，奖励：-53.0，Epsilon：0.010\n",
|
||
"回合：120/400，奖励：-23.0，Epsilon：0.010\n",
|
||
"回合：140/400，奖励：-20.0，Epsilon：0.010\n",
|
||
"回合：160/400，奖励：-29.0，Epsilon：0.010\n",
|
||
"回合：180/400，奖励：-42.0，Epsilon：0.010\n",
|
||
"回合：200/400，奖励：-28.0，Epsilon：0.010\n",
|
||
"回合：220/400，奖励：-20.0，Epsilon：0.010\n",
|
||
"回合：240/400，奖励：-20.0，Epsilon：0.010\n",
|
||
"回合：260/400，奖励：-17.0，Epsilon：0.010\n",
|
||
"回合：280/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：300/400，奖励：-13.0，Epsilon：0.010\n",
|
||
"回合：320/400，奖励：-13.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，奖励：-14.0，Epsilon：0.010\n",
|
||
"完成训练！\n",
|
||
"开始测试！\n",
|
||
"环境：CliffWalking-v0, 算法：Q-learning, 设备：cpu\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"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEXCAYAAABCjVgAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABOu0lEQVR4nO3dd3gU5drA4d/MtmyyIYVsIKH3zlEISg8gQkJoFhQLqCjYRT0HCSgWMCJ8qKAiqOcoHtQDigKKICoKKCACIogKQqS3VNKTbfP9seySQAJJCNnIPvd1cZHMzs4882Z3nnnLvKNomqYhhBBCAKqvAxBCCFFzSFIQQgjhJUlBCCGElyQFIYQQXpIUhBBCeElSEEII4SVJ4Tw2b97M4MGDq2Vfc+bMYdmyZdWyL1G23NxcRo4cSUJCAqtXrz7n9d27d/PAAw8wcOBAhg0bxi233MI333xT5vY+/fRT7r333ksZsteTTz7Jxo0bq2RbFyqHili6dCk333wzw4YNY9CgQUyZMoXs7GwAXnvtNaZOnQrA2LFj2bdvHwDPPPMM/fr145VXXmHevHn06dOHUaNGcdVVV+Fyubzb/uc//0n79u3Jzc31LnvuueeYOXNmmfEU/14nJibyn//855x1quv7WFBQwD//+U/i4+MZOHDgeT9L1UXv6wCE2/jx430dggD++OMP0tPT+frrr8957ffff+eee+5h+vTpxMbGApCcnMz48eNJSUnh1ltvre5wS0hKSqqybZ2vHCpi/vz5rF+/nrlz5xIREYHdbueFF17gvvvu48MPPyyx7ttvv+39efHixaxdu5a6detyzTXXMGvWLDp16kS3bt3Ys2cPbdq0weFw8OOPP3L11Vfz/fffEx8fD8CmTZu8iaayquv7+NprrxEYGMiqVas4duwYN910E+3bt6du3brVsv/SSFIoJ5vNxqxZs9iyZQtOp5O2bdvy1FNPYbFY+O6773jzzTex2WxkZGQwfPhwHn30UTZv3kxSUhKBgYHk5+czYcIE5s6dS4MGDdi7dy82m42nn36arl27kpiYSIsWLbj77rvp0KED48aNY8OGDaSkpDB69GjuvPNOnE4nM2fO5NtvvyU4OJiOHTuSnJzMwoULz4n3zTffZOnSpej1eho1asSLL77I119/zerVq3nzzTcB91Ws5/fExEROnTrF4cOH6dGjB0uWLGH16tVYrVYAbrrpJh588EG6detWZjkUZ7fbefHFF9m0aRM6nY6OHTsyadIkLBYL/fr147rrrmPTpk0cP36c+Ph4nnjiiXOOYf/+/Tz99NNkZGSgqir3338/gwYNol+/fvTv35+tW7eSk5PDXXfdxa233srmzZuZNm0aK1asADjn9+K++eYbXn/9dZxOJxaLxRvb5MmTOXnyJMOGDWPx4sUEBAR43zN79mzGjh3rTQgAzZo1Y+bMmdx5553ccMMNmEymMj9DOTk5JCUl8eeff2K32+nWrRtPPPEEer2eJUuWsHjxYux2O1lZWYwdO5Zbb72VTz/9lCVLllBQUIDFYuG6667j66+/RlVVDh48iMFgYMaMGbRs2ZJRo0Zx22230b59e+68805iY2PZsWMHWVlZPPbYYwwaNIiCggKeeeYZduzYQXBwMM2bNwfgxRdf9Mb5119/nVMOP/zwwznl1bFjR1577TV++eUXUlJSaNWqFbNmzfJuJz8/3/s5jIiIAMBgMPDEE0/w9ddfY7PZSpRPv379mDNnDtOnT0fTNMaOHUt4eDgnT57kySefZPz48fTs2ZPNmzfTpk0btm3bRqtWrYiLi+Pbb78lPj6ekydPkp6eTqdOncr8XpZl+vTp7N69mzfeeINp06ZV2fdx//79jBw5ku+//x6j0YjT6aRv37688847fPPNN94yi46OpmfPnqxatYq77rqrzDgvNWk+Kqe33noLnU7Hp59+ymeffUZkZCSzZs1C0zTeeecdXnzxRT799FMWL17MW2+9RUZGBgB79+7lpZde4rPPPsNoNLJz507GjBnDsmXLuPHGG3n99dfP2ZfNZiMsLIxFixbx6quv8tJLL1FUVMTHH3/Mb7/9xooVK1i0aBGHDx8uNdY1a9Z4Y1mxYgX169fn/fffv+AxFhYW8sUXXzB58mSuvfZaPvvsM8B9NZyamkqvXr3KLIezzZs3j5SUFJYvX87y5ctxuVwlqvT5+fl8+OGHLFq0iPfff7/UY3n88ceJi4vjiy++4K233uLll1/2NhMUFhbyySefsHDhQl599VX27NlzwePzSE5O5plnnuG1117j888/55FHHuGBBx4gMjKS559/noYNG7J8+fISCQFg27ZtdOnS5ZzttW3bFkVRSE5OPu9+X3jhBdq1a8enn37KsmXLyMzM5N133yUvL4+PP/6Yt956i2XLlvHKK6/wf//3f9737du3j4ULF3pPNlu2bGHKlCmsWLGCTp06ldr8cfjwYXr27MmSJUv417/+5d3eG2+8gdPpZNWqVSxYsIDff//9nPc2bdq0RDkcPXq01PLy/C2OHj3K0qVLz/kc/PXXXwQEBNC4ceMSy81mM0OHDsVoNJZaTp4axHvvvcd7773n/YwNGjSI3r1789NPPwHw3Xff0adPH2JjY/n+++9xOp1s2rSJHj16oNPpzvu9LE7TNJ577jmOHj3K22+/TVBQUInXL/b72KRJE1q0aMG3334LwA8//EC9evVo3rw5x48fJyoqyrtunTp1OHHiRKnbqS5SUyintWvXkpOT422ztdvt1K5dG0VRmD9/PmvXrmXFihUkJyejaRoFBQUAREVFUa9ePe92oqOjadOmDeA+mSxdurTU/V1zzTUAtGvXDpvNRn5+PuvWrWPYsGHeq9Gbb7651FrCpk2biIuLIyQkBIBJkyYB7prB+XTu3Nn784gRI3juuee4++67+eSTT7j++utRVbXMcjjb+vXreeyxxzAYDACMGjWKBx988Jzjq1OnDrVr1yYrK4sGDRp4Xz916hS7d+9mxIgRgLsci7e33nrrrSiKQt26denVqxcbNmygXbt25z0+jx9//JGuXbt699etWzfCw8PZtWsXiqKUaxulcTqd53197dq1/PrrryxZsgRwJzaAoKAg5s+fz7p16zhw4AC7d+8mPz/f+75WrVqVqIm1a9fO27zQtm3bUpt4DAaDt0bTtm1bTp06BcC6deuYNGkSqqp6ax4XSqjnKy+AK664Ar3+3FOJqqol2v+rQq9evXjhhRdwuVx89913/Pvf/yYyMpLo6Gh27drFjz/+SJ8+fS74vSxuwYIFpKens2zZsjIT1cV8H8H9fVq6dClxcXF8+umn3s91abMMqapvr9UlKZSTy+Vi8uTJ3i9aXl4eRUVF5Ofnc91119G/f39iYmK44YYb+Oabb7x/7MDAwBLbKX71qShKqR8KwPtB85ykNE0754tX1odHp9OVOLllZ2eTnZ19zv7sdnuJ9xWPNSYmBofDwc6dO71XQucrh7OdfTJwuVwl9le8maW0cvAca/Hj+Ouvv4iOji7xumfbqqpe8Pg8SitzTdNwOBzeJFaaTp068dNPP9G+fXsAUlNTiYiIYM+ePdjtdlq2bMmTTz7pPVmOHDmyxHG6XC7mzJlDs2bNALx/kxMnTnDzzTdz00030blzZ+Li4vjuu++876vMZ8hgMHg/H8XLUK/Xl1i/PCeg85VXafF5NG/eHIfDwcGDB2nUqJF3eVFREQ899BDPP//8Bfd9tvDwcBo0aMBXX32FTqfzJqo+ffqwbds2fvrpJ5544okLfi+L69KlC506dWLSpEksXry41M9ARb6PJ0+eZNy4cd7lb731FnFxcUyfPp3k5GS2bNniba6LiooiNTXV20ybkpJC69atK1wuVUmaj8qpZ8+efPDBB9hsNlwuF1OmTOHll1/m4MGD5Obm8uijj9KvXz9++ukn7zpVLTY2ls8++wybzYbD4SizltG9e3e+/vprb/X+tddeY8GCBYSHh7N3716KiopwOBwlTjylGTFiBNOmTaNVq1bek3FZ5XC2Xr16sWjRIux2Oy6Xiw8++IAePXqU+1gtFgvt2rXzjgA5fvw4t9xyCzk5OQDe5ceOHWPDhg307t2b8PBwjh07Rnp6OpqmlTmSo2vXrmzYsMFb3ff0bfzjH/84b0yPP/4477zzDuvWrQPcV5jXX389EyZM4NFHH8VkMpGUlORtMrvllltKvL9nz54sWLAATdOw2Wzcf//9vP/+++zatYvw8HAeeOABevXq5f27XKjmURmxsbF88sknuFwuCgoKWLFixQVrR5UtL6PRyNixY5k8eTJpaWmAuynmhRdeoKCggDp16lTqGHr37s0bb7xBnz59vMv69OnD8uXLiYiIIDw8vELfy/bt23P77bcTHBxcanNuWcr6PtapU8f7GVi+fDl16tTBZDKRkJBAYmIiAwYMwGw2A+4ayOLFiwE4ceIE33//PX379q1UuVQVqSmU0wMPPMCMGTO47rrrcDqdtGnThsTERAIDA+nTpw/x8fHUqlWLhg0b0rx5cw4ePFhmVbSyrr/+evbv38/w4cMJDAykfv363g9XcbGxsezbt897UmrevDnTpk0jICCALl26EB8fj9Vq5eqrrz5v08Hw4cN5+eWXS5z0yyqHs91///3MmDGD4cOH43A46NixI1OmTKnQ8b700ks899xzLFy4EEVRSEpK8l5RHTlyhOuvv57CwkKeeuopmjZtCrivzm+44QasVmuJk0ZxzZs355lnnuGhhx7C6XQSEBDA/PnzCQ4OPm88bdq04d///jdz5szhhRdeQFVVgoKCCA8PZ8eOHRw7dsybPEvz5JNPkpSUxJAhQ7Db7XTv3p177rkHh8PBkiVLiIuLw2w207FjR++Jrarde++9TJ06lSFDhhAcHEzt2rXP6Ts5W2XLC+C+++7DbDZz9913A+5awlVXXcUbb7xR6WPo3bs3c+fOLfF56tChA2lpad4RYK1atarQ91JRFF544QWGDx9eYiDB+ZT3++gxYsQI3n//fZ599lnvsocffphnn32WhIQEnE4nEyZMoGHDhuUsiUtDkamz/z5++OEH0tPTGTZsGADPP/88JpOJCRMm+Diy6uUZpdKhQwdfh+K1bds2GjZs6E1aNdUXX3yBxWIhNjYWl8vFww8/TI8ePXw+nPbv6HL9Pkrz0d9IixYtWLZsGUOHDiUhIYHMzEzuu+8+X4clcHfS1/SEAO7P0Lx58xg2bBiDBw8mMjLS2+kpKuZy/T5KTUEIIYSX1BSEEEJ4SVIQQgjhJUlBCCGElyQFIYQQXpfFfQqZmXm4XBXvL69d20J6eu6FV6xmElfFSFwVU1Pjgpob2+UUl6oqhIUFlfn6ZZEUXC6tUknB896aSOKqGImrYmpqXFBzY/OXuKT5SAghhJckBSGEEF41Iil8/vnnDBo0iGuvvZYPPvjA1+EIIYTf8nmfwsmTJ3nllVf49NNPMRqNjBw5kquvvtr7RCghhBDVx+c1hY0bN9K1a1dCQ0MJDAxk4MCBfPnll74OSwgh/JLPawopKSklJhKLjIxk586dFdpG7dqWC69UBqv1wtP/+oLEVTF/x7g0TbuoJ71djOJxuVwaikKpsZQW4/nWL0tZx6ppGsVnX9M0jYgIC5rmHjpZfGSN5+1lzdamqmcegHO+9crLs3/PfqvyM1baiCFP/GWtp6pKqeVY1Z99nyeF0ubjq+gXJT09t1LDsqzWYFJTcyr8vkutvHFpmkahzYnZ5H6aVmpWIZGhZc/nrmka+45m0TS6FrrTT4nKyC4kI7uI5vVDSl2/+N/iQnEdTsnlj4OZXBtTv8T7zt7OkZRcTmTkE9M60rssO9/GkrXJ3NS3ORazwXtsGdmFhNcKwGzSs+6Xo9SzWmgWXcu7vbxCO0czCgkL1GMNNbPh1+MU2pxc07k+AOt+OUqjusE0rluL73ccIz27kHU7jjH59s6YTXq+3HyIQV0bsWRdMvuOnCI6IohOLa1c1cb9AJijaXkowJbdKeQXOogIDaB5vRDqhJn5dP1fGPU6+naqR0GRgyXrkunfuT6tG4bhcLo4lF5A87oWfv0rnf+u3kPXtnX4YedxhnRvTPcOUcz48Gc6NKnN3iOnCDIb6N+5PvlFDopsdnbuOU6LOibaNY3gg2/2YcvN4ubYRhxKLyI738Gf+47Qqq6JsCA9x09m4HC6UBUdDSICaGA1k1foxKlBoc3BwWNZmI0KuFw0rxfM5j3phF95DQaDkcycIr7ZdpimUbWICDUTGKCnXkQQLpfGik0HCQ7QUZSXQ+OoEJo0qsuGXSc4kZ5PiMVIs+ha/Hn4FC6XkxbhcCotDavZSXQtlfTMHELNCvl5+ZhUFwbFQdMWTVmf24QdyenoVY1GtU3k5eSiFmZRS80nRC3Aondg0TvAXkiwwYXmsKNXnBhwYtK50CsuFJcDHS50isv9P6eX63QUOnWgKCiKgtPpQgNUtNP/XCiK5v1d8SxXzvwMoKDhRGVbYC8+PxZJqJpPqJpPLTWfQMWGWbETqBYRqNgwKk70ihM9TvSKCwNnfvfs07P9PMXCV4FDOHGqEH3hKYKVAoLUIoKUIixKEYXW1qw9EUKhzUmnllZSTxVwOMV9D4Jep9KucRg7k9PR61UMOpVOraxMvOOqCp/DVFU574W0z2dJXbp0KVu3biUpKQmAuXPnomkaDz30ULm34S9JISvPxpvLd3FHfGvqhAWybU8Kc5fuYvLtnTmVW8Qby3Zx37B2dGxWm+9+Pkr/mProdSrLvt/Pjn1p9OgQxf/W7OWOuFZEhpoJqxXAtPe2UlDk4N9P9EVVFV7/9Ff+OpbFFS2sfL/jGK+O74XZpCflVAErfzzEkZQcbu7XnKAAA9/9fJR+nesRVdt9I8zkt37kRIb72cIdm9UmK8/GkO6Nee/L3YwZ1IYim4NVG/ZxKL2QYKWQBuFGBl0VTd3IML7afpLffnM/+H5g18YcTs3nr7+OEqLmU89ai/r1Ivhh+0FMioMgvZNW9WvRokUjvti0H3teNiF6O82iLew7cgqAxnWDURWFEyfScKGgoGFUnBhwYFCcGBQHmqZiUuw4dUZcTichivvE5EKhUAnAZgwlL7+QDUUt2W5rgooLi1Lo/SJH6HKIVLOx6GwEqnYMWhEBip0A1YlOAafLRba5HvNPXEmwWogOF1G6TCJ12dQyKQTYs7CohQSr7vLQK05MigMjdkq5aKxS7+f2YIutGaDRNtyGKfcYYWoeVkMBwVoOZsVOiJpPmJqHXnHh1BQ+yb8Kk8lEa0sWzuw09IqTuqYCLK4cVMr3pMG/7FZq6W2EKTnoyniPCwWnasKGAfRGXIoel6qnwK7gQEdAgAmXokNTVLTT/+fbNFIzczHgJDBAT2GRg1CLicAAPRoqKKdP+4qChgLK6bRw+n/P724K9hP7aG44UWZ8Dp0ZuxqAUzXgVPS40Ln/V/Sn/9fh8qYehfwiB81sfxCgOErdpqZBhsvCtKzrMCs2nJpKEQY6Ng2nqSWPg7t3s9PWkMDAAHp2iMLucNE0uhZD+rS4/JLCyZMnueWWW1iyZAlms5mRI0cybdo0OnbsWO5t+DIp5OTbKLI5iTjrCn3jruN8v+M4E2/r5F2WdqqAJ+Zv4snRnXnniz+4soWVG/s0K/G+QydziKpbC8PpP8uPv52gef0QIkLMfPjNn3yz9QgJ3RrRqmEoa7YeYUdyOs2ia9GsXghfbTlMWLCJzq2sfLP1CHfGt8Yaaub//re9xD46NqvtvuLQqTic7iua5vXDaBppYuP2AzTUp5PjCsCiFtE82kJGdgH5BTbCdIXUJhOjXiXNZcHgcF/pWIygx0mOTaG2moNFLaRIM2BQnDg0FbNix6zYCFDsqIqGU1PQKVX/sTvzETjdjAAUaQZAQ0PBqRgodKnYNT12dKhoFGl6TIoDk8lAnXrRHMnVcehYJoGqjTA17/TJP5c0pwWLWnjOl1pT9eS5jBRqRkLCQslz6knLdVLk1DBrhTTVlX5iAShSA8nSAgkJD+NYngFzYABh4SGgDyAoOJiMQoWvftyP2aQS37sdW/dmcio7n7TMPOJi2xJcKwRDgAmz2cyn65NpXj+E1o2tHEzJIzjQiEnvbv6whgeBquNoWj7vrd7LbY6PidDl8putHi2DsjHYi30HjIG4zKFkFukJsUYSEB7J0Vw9tj0/0ECf4V7HYOZooRmbS0fzVk3R1YpAsdRGDQxDCbCAMRBFb8Sl6tAZTCSfLOTPo9k4t3xEC/0JAq31iGzUmK37c7FGhNGseUOUwDCUwBCs9eqQlllU4dYCTdP4+c9UWjUMw2I24HS5vLXhykh8/VvaO3YRYDIxbGAnwuvXJ8tmRDEFgd5U4fh+2ZvG8mVraGs8SrPmjejYoQVKYAhKQDBKgIVlHyyhf9FXHHWEEa3PJM0ZzO/2evQKT0XNTwdgWX5nUkI78vCVedgP/Ixaqw4Nb3q8ypOCz5uP6tSpw2OPPcbo0aOx2+3ceOONFUoI1W3bnhQ++m4fSWO7otepPPn2ZnIL7LyT2M+7Tn6hg3+v+AMAu8OJQa8D4I+DmQB8s/UIx9PzOZ5+kOBAAxt3neCmfs1p3TCUZ9/dAsA7if347UAGb33+Oy3rh9C9QxTfbD0CwBebDvLFpjOPavzrWLb3Q3oqp5CN25JppU/nj03p/GUy0D/gIKFqPqdcgbQ0nIAUjYG1ijAqDoyKk1pKAeSBekAjPuysA87BfY49/Wx2pyGIoiIbgQY7DoOePM0IOiMFdo0og40sNYxUZxCqVoTNZUDFhc4azp40O00b1+XPY/nYCnLp2LElUXXD2bQ7nf2HUtG7bNRv3ACXpvDH/jSCAlTuGN6FQp2FJd/uJSzARe+YJnzw3UEGdGvBiVOFrFm3g8jawTz90ADSc138diCLPYdP0ffKeuh1KoEmHWYXLP9hP7FXRFMvPBC7w0VBkYMTGflEhASQX+RgZ3I618bUx6DX0VrT+PqTX/njYCZFdifWABu3GL4lTzMRFV0PS9PmaCYLOU4T1nr1UCwRBJ5ORnqdSjjQ4HTRrd52hC3rVxCly+SkMwQnKneMvAZD7XqgDyBYVYk4vW4E56oHXNM0h+BAIyHBJq5pz+nPlAuDvuQJ76bhZx4D2qa0jQENGoYy5roQvnt/B0MDfybaXIi5UXt00a3RRTZFtUSgGN0XN8UbE8OzC3luq4lmhpM0at2GofFXUyfXjtPlIjCk7OZKT4TNGwZxKt/JG/ldAHjwmg40bGWl51WlvMdgQlFsZW6zLIqi0LnVmebIi0kIAAZzEN+mtqdRSDA3Nu1CgDWYnIu4gLQEGjjotHKwwMqd9Vujb1jysa1HzS05mf8jDlR+M8fQMn873Ux7UcLaQYdBZG78hIEBOzHatlO02YUa0Qh9g/YXdYxl8XlSABgyZAhDhgzxdRjlsnD1HrLz7cxf/ht9rogmt8AO4L0yycwp4p9zN3jXn/3xTgZ0aYCmQYHN/SD2rNwi7+vrdxzjeHo+H3z1Jzf3OzMM94GX1xER4n527r6j2RxOzTsnFh1OYsyHCNZy0dIVRkUeItSRVnIlOxAIdk3FoLjI1EeSWaCRq5nJcxrRq5DisOBCoUF0BEcyCgmo25S/kg/RuFljoiND2bInlUOp+Tz3UH90pmDGzlyDAScv3N+b+qdPCr/+lc7/fbKTqXdfTZDNwfPvbeOW/i1oEGmhZYNQmp0uH0t6His2HqBBz9YYDTquaeMOs6DIQYBRh6IoWPem0jAyGENIAAbgrlvPPLP24TvcZdTc5SIlX6V7+yh0QSEo+Tm0b1qb9k1rn1NONxUrV4NexaA3UivI/ZzecKC+9cxVk6IoPHJjR5wuFycyCvhkbTKv7osjKEDPa8N6e9cLLLb9sr5EtYKMbCxqCcCEW67EGhqA8Twn0dI0rHNuJ+LZCaEijHqVbwvb8UNhS65o24B7+7W74HuCzAZyNDO/2BrTqFZdFEUlLNhUof16yhsgONBQ4birmyXAHaPFXDWnyGDzmWO2mM89ftVg4oWs4QBc06I+i35uQqFmYO49/XG5ND7+5ig3BW1in7EdVw+/CV1o2c8Cv1g1Iin8nRgNOsDOz3+m8vOfqd7lmdlFRISa2X0os8T6fxzM9NYQPFJOFXh/Pp6eT93wQE5k5LN0/V/e5YU2J0dS8wi1GDmVa6OgyMGYgU05vuNHik6lEBN4hDDXKQLVM1dVeaZ6pEVfA/oAAqObsvNAFllZebS9oh2vf/YnRhw8cXdf2oQEoNepHErJoW54IL/sSyPYbKRdk3Cu0jSWfr+f7TYdjSOa0LlbEzp2cccS3bAeqak5xHdtQvLRLMKLneA6NK3Nm//q462xvPaouy/Cw3PlFlU7iLFDzj0RFV/3yhYXfqylTlUZ0efS3cuiU1XqRQQRGOCOy/N/RdQKPHMitIYEEFHBhHApGA06NBSKMGIsZ3Ix6tXTTY0ugipRDlAyEfwtksLpE3dQKSfwSm0v8PxJwdOaABBey0SOZsZs0qHXqWiqxm/2+jxzagSdWlrpfgkTAkhSKOFUbhG5+XbqR7qvHH/87QQBJj1XNHfXx/MK7WVepe3an8Gew6fKdRWXkV1U4vcb+zTj9U9/5VBKLrVrmahlMbH/WDbgPtmmnzhORNYfdPx1Gf+wZUMgFFrq8UdWIxp3uYbpq7MwKXZm3hWH0XDmT3pt2zP7KFx+gEKMWEPN3hgb160FQNe2db3rKYpC/5j6nMzIp8+V9QD3B7ZJVK0S8ZameDtr8ZP835k3KZgqfnKoFXTmatpSQ06ExT+fxmInovNRFIUgs56sXFulT5LBgcZSf66pPMdZ2gm8MswmPaqi4NK0UpOiyXDm7+KphQWdrq0oioJRr2JzuDAaLv2tZZfHN7eKPDFvIw6n5u0feOvz3wF3+76maTw8+/sy3/vf1XvOu22dquAspTN84FUNaNs4jDA1l0xXEKEmmHB1Hhu/Ws9Ptmb0yvyROo4/IQh0Ya3JbjqaHw5qXBfXmd6nr76nNMjDbNKXSAhlKU/SqhVo5P7hl6a98u8m0FT5mkJwkPtLrdepmAzlOwFfasVPKoYKnGCCAgzupBBQuZNk8fKrTFlWN0sVJwVVUbCY9WTn20tNrJ6agqoohJxOmsX3bTTo3EnhIpoOy6vm/3UuIZdLI7/Q4f2QOpyem15Kjqt3OF04nRc3WubqtnXYuKvkSJQJI6+gVbiTglUv8mzoPvY7IrC6Cihal8eVRoXOpgM4CkwYOw1D3/Af6CKbEgjceFbrS3RE2XOjezx8fQfyCksfDifK5jkJVqr56HRNITjQ4LOb1M6mU1XvBUpFTjCeZqOgSraxq8WOX60hZXE+Vd18BGAJNJKTby+1Cc6TrA0GtdRaiudirry1u4vh10lh0dd7+N9Xe3h1fC90xQaGF9mdJa7sjp5u27+QmNaRxLSy8tF3+0o0EY0b0paOzWqXSAombIQdWU/e2tUA5GhmmujTyFJCibptKv+a9xMtdUep1z2e2JiWF32sV7a8cDu9ONeZ5qNK1BQCq/Zqs6oYDToKihyn+8fKx5McLZWsKfzdeJJfVf7tLGYDgQH6UkdGeU76Jr1aai3F87eqSO2usvw6KWw+fZJOzyqkyO70Lt+xL513V/3h/f2HX49775AF6P2PKBpH1eK/X7qbjJ4bcxU//5lKnyvrERJkZNn3+73rjh7Yiq7t3G32owe0JCr3NzJ3rqe14Ri63zV09doS0OsuZvxvN+E5ydRqfiVXNmrHKcNBvskPZ5zlTFu+qH4X09FsNunR65QalxRMRndSqMgoJs9J8mKunKNqB150jbu6VHXzEbj7CvIK7aW+5qkBGPQ6bxkXL2uTN2lITeGS8nT+5RXa2Xc0y7t83S9HsdnP3G25ZtsR7/BQgNohZnp1jCI710ZosIkGkRYaRJ4Z1uipCnZtW8fbWatpGt31v1G0+39EG6FQM6Be+yiBTdxtQQbTAXZlNqRPgHs/gQEGd/ujn1yZ1VTe5qNK1BQURSE40FhiOGZN4LnqrEg/x8WUg8fz91xd6fdWtxb1Q+natg7NoqvuomxEn2YlLj6L85wzjAZ3/1ObRmG0bBDqfd3gfV2SwiXlycT5hQ627k7xjg748/CZBHF3Qhv+88Uf/HYgw7ssJMiITlUZ2rNJqdv1VvVOZ3fNaadg9RycR3aha/APpvzaDB0ukhq08b7HbNSV+D/oIq5QRdU509FcueR8V3xrQis4pv9S84x0qUhNoVfHKOqEmUudtK28akq/SnlYzAbGDb3wPRwVEV4roMzXPH8Lz/8TbrmyxOtnahLSfHRJeaqGR9PyOJKaR58r67F2+1FcxWb+iAwzExlq5o8D7nsNruvdlJ4do867XVOxTiFNc1H43ds4j+zC1PVmDO36k7nDPYqpxPDA04kk4KyTkNQUfKt2SAD1IoJoHFW5mShLu5nO1zyftYp0NNezWqhnrfxsxOL8PCf9smoCnr9VdQxJ9fnzFHzJU1M4eXoSt6ZR51YVgwIMNImu5R1OGtPKesHRE2dqClD49Vwcf/2E8aqbMHaMR9Gd/yTvrSmYpaZQE5hNeqbdczXNos+dRfbvqnj7tagZvM1HZSTqM4lcmo8uKU9SSM8uBNx3EnqakDwsZgP1ig35LM9NWZ4aQIusH3GkbsN09c0YOsad9z2eNOPZfpDp4ttwhSiNyejpU/Dra8IaxVtTKOOkX501Bb8+4+h17gL2JAWzSY/FrCc4yMjR03MNBZn1JeZ5CTBeOFMrisJVxn00T92IvmkXDB3jSrSnXtOpPmlZBaW+17P9Ds1qU2hzeGMUoqqYDFJTqGnO7lM4m9QUqoln1nDPPQVmk55OrSKJqh3Ixl9PcPBkDjq15ORfFxqxoRXmEp/2HmGWFLKDGhLd995zOthuG3DufQeedTxNUx2b1aZjs5rXHi3+/irTpyAureKjjyrzelXy66RwNrNRx+iBrQDo2SGKvNMzoBZPChcaQVH083LCHCkAnGhwLfV0FSviv8cobvF3Vp0nGFE+F2o+Mlzg9ark15+Ksx8vFGA8cwI3m/TeB+eEWso3pNB16gT2374l2dyRKZk3UhhW/lk82zcNB6BOmO9n0hSXN6M0H9U4xgs0H5mkplA9tGLX5YpSdoGXd8bPos2LQW9gZ3BPsrXcCsXS98p6dGppLXcCEqKyPE2gUlOoOQwX+JsYqvE+Bf/+VBSrKZiN+ou6ucZxfA+Og9sxXjGYIp17PHdFHnSqKIokBFEtTNXYaSnKx3iBCe+aRtWiaXQtQqrh7ng/rymcodedPyG0bxJ+3pFAtu2fo5hrYewwAOXoviqKUIiq16l1JCfSci/4mRfVx2zSc9u1LflHGYNLmtcP4anRMdUSi38nhWJZodBW+pwkHo/ffEWZrznTD+E8sgtjlxtQ9EbvPQeadBuLGqhtk9pYyzHrr6hexSfd9CW/bj7SimUFm8N1njXPz/bLSjAEYGzrfjjPtV0aEBSgp0MNnOJACCHOR2oKF8mVnYrjr80YOgxEMbnvfG5YJ5jXHu19gXcKIUTN4981hSpo3rHt+goUFWOHgVUQkRBC+JZfJwW0M3MOVertLheO5M3oG12JGhRWZWEJIYSv+HfzEYACDw5vT53wwAq/33lyL1pBNvqmXao8NiGE8AX/TgqahoJC51aRlXq/468toDOgb9CxiiMTQgjf8O/mI9x3MleGprlw7N+KvkEHFKNMTSGEuDz4dVLQtMonBdfJZLT8U+ibVM8NJUIIUR38PCloVLar2b5/K6h69I2uqNKYhBDCl/w8KVSupqBpGo79W9HVb4dirHgHtRBC1FT+nRSoXD1By0lFy02XDmYhxGXHv5OCVrkbFZzH9wCgi2pdxREJIYRv+XVSAFAqkRUcx3ejBASjhkVfgoiEEMJ3/DopVLaf2Xn8T3R1W17U8xeEEKIm8u+kgFbhnODKTUfLSUUX1eqSxCSEEL7k10mBSow+OtOfIElBCHH58euk4G49qlhWcKbuB70JNbzBpQlKCCF8yL+TgkurcE3BlXYQtXYDFNWvi04IcZny6zNbRZ+moGkunOmH0NVueEniEUIIX/PvpKBpFRpBpOWkgb0QNaLRJYxKCCF8p8qTwrJly+jZsyfDhg1j2LBhvPLKKwAcO3aM2267jbi4OO6//37y8vIAyM7OZty4ccTHx3PbbbeRmppa1SGVqaI1BWfqfgB0khSEEJepKk8Kv/76K4mJiSxfvpzly5fz2GOPAfDcc89x66238uWXX9K+fXveeOMNAGbPnk1MTAyrVq1ixIgRJCUlVXVIZavg6CPnyWTQGaWTWQhx2bokSWHZsmUMHTqUf/3rX2RlZWG329myZQsDB7qfY3z99dfz5ZdfArB27VqGDBkCwODBg1m/fj12u72qwypVRe9dc6bsQxfZBEXVXaqQhBDCp6r8yWtWq5Vx48bRsWNHXn75ZaZOncrEiROxWCzo9XrvOidPngQgJSUFq9XqDkavx2KxkJGRQZ06dcq9z9q1LZWKVdM0VJ2K1Rp84XWdDnLSDxHSZRC1y7H+xSpPTL4gcVWMxFVxNTU2f4mr0klh1apVTJ8+vcSypk2bsmDBAu/v99xzD/379+eJJ5445/3n6+BVKzjcMz09F5eroj0EbppLIzU154LrOTOPgtNBkbluuda/GFZr8CXfR2VIXBUjcVVcTY3tcopLVZXzXkhXOinEx8cTHx9fYllOTg4LFizgzjvvBNxX4nq9nvDwcHJzc3E6neh0OlJTU4mMdD8XOTIykrS0NOrWrYvD4SA3N5fQ0NDKhlUhFXmegivjKABqeP1LGJEQQvhWlfYpBAYG8u9//5sdO3YA8P7773PttddiMBiIiYlh5cqVgHuEUu/evQGIjY1l2bJlAKxcuZKYmBgMBkNVhlWmigxJdWUeAUVBDal7iaMSQgjfqdI+BZ1Ox+zZs3n22WcpLCykcePGzJw5E4BnnnmGxMRE5s2bR1RUFC+//DIA48ePJzExkYSEBIKDg5k1a1ZVhnReWgVanFwZR1Br1UHRGy9dQEII4WNV3tEcExPD0qVLz1ler149Fi5ceM7y0NBQ5s+fX9VhlItG+aa50DQNZ+p+dHVbXvqghBDCh/z8jubyDUnVctPR8jLR1WlxyWMSQghf8uuk4HbhtOA88ScAurqSFIQQlze/TgrujuYLr+eeLtsoI4+EEJc9/04K5VzPlXkUNaye3MkshLjs+XVSQAO1HFUFV4Y7KQghxOXOr5OCqxw9za7CHLSCLHThkhSEEJc/v04KlGP0kSvzGIDUFIQQfsGvk4IGF5znwpV1AgA1JOrSBySEED7m30lB0y5YU9CyToKqQ7HUrpaYhBDCl/w7KXDhCfFcWSdRg60oFZy5VQgh/o78+0xXjjGpruwUlJDyP9tBCCH+zvw6KbjnPiq7qqBpGq7sk6i1JCkIIfyDfyeFC4w+0gqywWFDrWWttpiEEMKX/DopwPn7FLS8DPc60skshPATfp0U3I/wLDsruHLTAVAlKQgh/IRfJwW4QE0h11NTCK+maIQQwrf8OilcqE/BlZsOOgOKqeyHXAshxOXEv5PCBea50PIyUCy1y/0cZyGE+Lvz76SggXLePoUMVGk6EkL4Eb9OCsD5awq56ShB0skshPAffp0Uzjf3keZyoOVnSU1BCOFX/DspUPboIy0vE9Bk5JEQwq/4dVJAo8xOZNfp4ahyj4IQwp/4dVJwna/56PSNa0qQ1BSEEP7Dr5MC57mh2ZXnqSlIUhBC+A+/TgoaWplDUrXcDDAFoRgCqjkqIYTwHf9OCuerKeSmSy1BCOF3/DopQNm3KWh5GdKfIITwO36dFM4395H7bmYZeSSE8C/+nRTcY1LPXW4vhKI8uUdBCOF3/DspaKCWUlXw3qMgzUdCCD/j50lBK325PHFNCOGn/DwplH5Hs3uKC1CDwqo7JCGE8Cm/TgplcRVkAaCYQ3wciRBCVC+/TgqappU6IZ6WnwWGABSDqfqDEkIIH/LvpEDpQ1K1gmypJQgh/JJfJ4Wy5s7W8rNQAyUpCCH8j18nBffcR6UsL8hCMdeq9niEEMLX/DsplNF+5JLmIyGEn7ropDBnzhxee+017+/Z2dmMGzeO+Ph4brvtNlJTUwGw2WxMmDCB+Ph4rrvuOpKTkwF3Z++MGTOIi4tj0KBBbNu27WJDKjcNUM9qPtKcdvfdzNJ8JITwQ5VOCjk5OUyePJl33nmnxPLZs2cTExPDqlWrGDFiBElJSQAsXLgQs9nMqlWrmDx5MomJiQCsXr2a5ORkVq5cydy5c0lMTMThcFzEIZVfaTevaQXZANJ8JITwS5VOCmvWrKFx48bcddddJZavXbuWIUOGADB48GDWr1+P3W5n7dq1DB06FIAuXbqQmZnJsWPHWLduHYMGDUJVVZo0aUJ0dDTbt2+/iEMqv9ImxNMKcgBQzMHVEoMQQtQk+sq+cfjw4QAlmo4AUlJSsFqt7o3r9VgsFjIyMkosB7BarZw4cYKUlBQiIyPPWV4RtWtbKncQGphMBqzWMwkgP9tBPhAeVZcAq+8Sg9WH+z4fiatiJK6Kq6mx+UtcF0wKq1atYvr06SWWNW3alAULFpR7J6paeoVEVdVSm3DKWr8s6em5uFylz2N0PhoaNpuD1NQc7zL7iZMAZBXqyCm2vDpZrcElYqopJK6KkbgqrqbGdjnFparKeS+kL5gU4uPjiY+PL/cOIyMjSUtLo27dujgcDnJzcwkNDSUyMpLU1FQaNWoEQGpqKpGRkdSpU8fbGV18eXXQSpk5WyuUPgUhhP+q8iGpsbGxLFu2DICVK1cSExODwWAgNjaW5cuXA7B161ZMJhPR0dH07t2bzz//HKfTycGDBzlw4AAdOnSo6rDKTSvIAVUHBrPPYhBCCF+pdJ9CWcaPH09iYiIJCQkEBwcza9YsAEaNGsXTTz9NQkICRqORmTNnAhAXF8fOnTu9ndBJSUkEBARUdVilcs99VLKq4CrIQTHXKnX2VCGEuNxddFJ4+OGHS/weGhrK/Pnzz1nPZDIxY8aMc5YrisLEiROZOHHixYZSYaXdu6YVZqME1MwOJSGEuNT8/I7mc2dJ1QpzJCkIIfyWnycFzulp1k43HwkhhD/y+6RwbvOR1BSEEP7Lr5MClGw+0hw2sBdKTUEI4bf8Oimcfd+cVihTXAgh/Jt/JwUoMfTUM++RGiA1BSGEf/LrpMBZfQpn7maWmoIQwj/5dVLQzsoK3hlSpaNZCOGn/DspaKAUywoy75EQwt/5eVI4a/RRQQ6oejBUzzQbQghR0/h3UuDsPoUcFHOwzHskhPBb/p0UzsoKWlEeiinIZ/EIIYSv+XVSQNNK9ilIUhBC+Dm/TgoanFVTyEcxBvoqHCGE8Dn/Tgpn36dQlAdSUxBC+DG/TgrnzH1kk5qCEMK/+XVS0Iq1H2kup3syPKkpCCH8mH8nBUA9XVPQbPkAKCapKQgh/Jd/JwVNO/OQnaI8AKkpCCH8mp8nhTMdzVqR1BSEEMLvk4InK2iemoJRagpCCP/l10kBtGI1BXdSkCGpQgh/5tdJofgsqdLRLIQQ/p4U4Ezzka0AAMVo9lk8Qgjha36dFNxzH51mKwBFBzqjLyMSQgif8uukULKmkI9iNMu02UIIv+bfSUHTUBVPn0IBSNOREMLP+XlSKPazzHskhBB+nhQ4c0MztgLpZBZC+D3/TgpnDUmVpCCE8Hd+nRSKz3Ph7lOQ5iMhhH/z66RQ/BHNUlMQQgh/Twqns4KmucBWKElBCOH3/DopuOc+UsBe5P5Zmo+EEH7Or5OC53EKnnmP5D4FIYS/8/OkoJ1OCp55j6SmIITwb/6dFABQZDI8IYQ4zb+TgmdEqmfabEkKQgg/59dJASjRfCT3KQgh/J3+YjcwZ84cVFXl4YcfBmDLli089NBD1K1bF4C2bdsyffp0srOz+de//sXhw4cJDw9n9uzZWK1WbDYbTz75JLt27SIgIIBZs2bRrFmziw3rgrRiEx9pUlMQQgjgImoKOTk5TJ48mXfeeafE8l9//ZUxY8awfPlyli9fzvTp0wGYPXs2MTExrFq1ihEjRpCUlATAwoULMZvNrFq1ismTJ5OYmHgRh1N+npSgKIp0NAshxGmVTgpr1qyhcePG3HXXXSWW//rrr2zYsIHhw4dz3333cfz4cQDWrl3LkCFDABg8eDDr16/Hbrezdu1ahg4dCkCXLl3IzMzk2LFjlQ2r/E5nBXefQgEoKujlATtCCP9W6aQwfPhwxo0bh06nK7E8ODiY0aNHs2zZMmJjY3nssccASElJwWq1AqDX67FYLGRkZJRYDmC1Wjlx4kRlwyo3rVhW0Gz5IA/YEUKIC/cprFq1ytsE5NG0aVMWLFhQ6vpTp071/nzLLbfw0ksvkZOTU+q6qlp6TipreVlq17ZUaH0Ah9MFgMViwpTnQDMHYbUGV3g7l0pNiqU4iatiJK6Kq6mx+UtcF0wK8fHxxMfHl2tjLpeLN99885wahF6vJzIykrS0NOrWrYvD4SA3N5fQ0FAiIyNJTU2lUaNGAKSmphIZGVmhg0hPz8Xl0i68YjF2hzsp5OfZKMjOQtMFkJpaevKqblZrcI2JpTiJq2IkroqrqbFdTnGpqnLeC+kqHZKqqipff/01q1evBmDZsmX84x//wGw2Exsby7JlywBYuXIlMTExGAwGYmNjWb58OQBbt27FZDIRHR1dlWGV4fStawrygB0hhDjtooeknm3GjBlMmTKFuXPnEh4ezsyZMwEYP348iYmJJCQkEBwczKxZswAYNWoUTz/9NAkJCRiNRu/6l1rJR3EWoAZHVMt+hRCiJrvopOC5P8GjRYsWLFq06Jz1QkNDmT9//jnLTSYTM2bMuNgwKqzkkNR8mQxPCCHw5zuaiw1J1WwFKAZJCkII4bdJwTskFQ3s8oAdIYQAf04Kp3OCTnOC5gJjgG8DEkKIGsBvk4KHzlkEgGKQpCCEEH6bFDwT4hk0T1KQ5iMhhPDfpHD6f9Vlc/8gzUdCCOHHSeF0VtA7paYghBAefpsUPHSau6YgfQpCCOHHScHTp+CpKUjzkRBC+HNSOP2/ziXNR0II4eG3ScGTFXROaT4SQggPv00KZ9cUMJh8FosQQtQUfpsUPMOP9K4iMASgKP5bFEII4eG3Z0KXt/moSJqOhBDiNL9NCh6qyyZJQQghTvPbpOAZkqpzFsqzFIQQ4jS/TQoeOqfUFIQQwsNvk4J36myX9CkIIYSH/yaF04NSVWeRNB8JIcRpfpsUkNFHQghxDr2vA/AV79TZkhSE8Cmn00FmZioOh42UFBWXy+XrkM7xd41LrzcSFmZFpyv/qd6vk4IOJ6rmlOYjIXwoMzOVgIBAgoLqYjDocDhq3slXr1f/dnFpmkZeXjaZmalERESVe5t+23ykaRoBih2QeY+E8CWHw0ZQUC0URfF1KJcVRVEICqqFw2Gr0Pv8NimggcmTFKSmIIRPSUK4NCpTrn6bFDTw1hSQmoIQoga48cYhHD9+zKcx+G9SkOYjIYQ4h992NAOYFAcgzUdCiDN+/nkr8+a9itPpIioqCrM5kP37k3E6Xdx222j69buWYcPi+OijZQQGBnH//WPo0aM3t99+J998s5pfftnO/fc/xPTp00hNTSEtLZUrrriSp56ayvbt27zbbtq0GY888jhTp04hJeUkjRs3xWZzt//v27eXmTOTcDqdGI1GJk9+hgYNGlbL8fttUtA0CFBOd8BITUGIGuGHncdYt/3SNJ/07BhFjw7lG4Vz+PAhlixZwcKF7xIRYeXZZ6eRlZXNffeNoW3b9nTuHMP27T9z5ZWdOX78OL/88jO3334nP/64kWuuuZaNG3+gRYuWPP/8DOx2O7ffPoI9e3aX2LbFYuHll2fQsmVrZs16lV9++Zlvv/0agI8++pCRI2+nX7/+rFnzFb/99qskhUtNo1hNQZKCEKKYBg0aYbFY2Lr1J4qKClm58jM0DQoLC9m//y+6devJtm0/oaoKAwbEs2bNVzgcDnbs+IUJEyZjMpn4/fddfPTRhxw4sJ+srCwKCvJLbBtg+/ZtPPvsCwBccUUnoqPrAdCtWw9efnkmmzdvpHv3XvTpc021HbvfJgU0jQCkT0GImqRnx2i6tq3r6zAwmdxPYnS5nEyZMo127dricLjIyEinVq0QcnJyWLToA3Q6PZ07d+HQoQOsWLGMpk2bYjKZWLJkEWvXfsvQoddx441XsX9/sndmZs+2wT06qPjNZzqdDoC+ffvTvn1HNmz4no8//h8//riBiROfqpZj9+OOZjCcrinIoziFEKXp1KkLy5YtASAtLY077riFkydPEBYWhslkYsOG9XTseAWdOnVhwYL/0L17LwC2bNnM0KHXM2BAPKCwd++fpd55HBNzFV99tQqAP/74jaNHjwDw9NOT+P333xg+/Abuuec+b9NTdfDfpIC7+UhTVBTVfytMQoiyjRkzlqKiIm69dQTjx9/HAw88Qr169QF3E4/FEkxgYCCdO3chLS2V7t17AnDTTbfy7rtvMWbMbbz88gzat+9Y6lDTu+++l6NHj3D77Tfx/vsLvM1Ho0bdxcKF7zJmzG3MnTubhx9+rNqOWdE8dZq/sfT0XFyuih3GoZM57Fj8Br2C9hN69/xLFFnlWK3BpKbm+DqMc0hcFSNxlc+JEwepW7cR8PecTsKXyhNX8fIFUFWF2rUtZa7vtzUFACMONJ3R12EIIUSN4bdJQdPAqDhwSVIQQggvv00K4E4KmmrwdRhCCFFj+G1ScLhc7qQgNQUhhPDy26RQUOTAiANFhqMKIYSX3yaFwiInRsWBapCaghBCeFQ6KWzbto0bbriBYcOGcccdd3D06FEAsrOzGTduHPHx8dx2222kpqYCYLPZmDBhAvHx8Vx33XUkJycD7tlKZ8yYQVxcHIMGDWLbtm1VcFgXll/kwKA4UY1yN7MQQnhUOilMmDCBpKQkli9fzpAhQ3j++ecBmD17NjExMaxatYoRI0aQlJQEwMKFCzGbzaxatYrJkyeTmJgIwOrVq0lOTmblypXMnTuXxMREHA5HFRza+RUUOTApDvRGaT4SQlSvY8eOMn36VMA9K+tDD42r9LZWrvycpKRnqyiySiYFm83G+PHjad26NQCtWrXi+PHjAKxdu5YhQ4YAMHjwYNavX4/dbmft2rUMHToUgC5dupCZmcmxY8dYt24dgwYNQlVVmjRpQnR0NNu3b6+KYzuvgiIHBhzopKYghKhmJ04c905pUdNUan4Ho9HIsGHDAHC5XLz++uv0798fgJSUFKxWq3vjej0Wi4WMjIwSywGsVisnTpwgJSWFyMjIc5ZfavlFDoyKE1U6moUQp6WknGTq1CkUFBSgqgrjx0/g2Wcn07//AH744Xt0Oh333vsgixa9z5Ejh3nwwUe55pprychI58UXp3Hy5Al0Oh3jxj1I167dKSwsZMaM59m3709UVWXkyNuJjx/MnDmzOHbsKC+9NIO+fa/h1KlT/Otfj3D06BEaNmzEtGkzMBqNrFq1go8//h8ul0arVq15/PGJmEwmvvzyC9577z9YLBbq1KmL2RxYZWVwwaSwatUqpk+fXmJZ06ZNWbBgATabzdvcc++995a5DVUtvUKiqiqlzbJR1vplOd8t22XR0DAoToJCggmzBlf4/ZeatQbGBBJXRUlcF5aSoqLXu7/zRbt/wLZ7/SXZj7F1b0yte553nZUrP6Nnz17cfvsdbNu2ld9+2wG4L1YXLVrCtGnP8MEHC5g79y127tzB7NmzGDhwIHPmzCIm5ipuvfV2jh49wr33juG99/7Hhx8uJDQ0lP/9bwmnTmUyZsxoWrduzeOPP8G///0mEydOYtu2raSknODll+dQt24U99xzB9u3byEqKpoVK5bx9tsLMJlMvPHGayxe/AFDhgxj3rzX+O9//0dISAj//OcjBAYGecvwbKqqVujvfcGkEB8fT3x8/DnL8/LyuP/++wkNDWXevHkYDO6bwCIjI0lLS6Nu3bo4HA5yc3MJDQ0lMjKS1NRUGjVyz8GRmppKZGQkderU8XZGF19eEZWZ+yjnVC4A+TZw1KB5YKDmzU3jIXFVjMRVPi6Xq8T8PZdqOjaXS7vgPEGdOnXhySefYPfu3XTv3pPhw0fw8ceL6datBw6Hi8jIutSubQVUrNY6ZGdn43C42Lr1JyZMeBKHw0WdOtG0adOeX3/dydatW0hMnILD4cJiCaFnz95s3bqVZs2ao2nueJxOF82atSAyMgqXCxo2bExGRiZHjhzh8OHD3H33HQA4HHZatmzNL79sp337DoSEhKHXq1x7bTzbtm0p89hcLleJv/eF5j6q9PSgEyZMoFGjRkydOhVFUbzLY2NjWbZsGffddx8rV64kJiYGg8FAbGwsy5cvJyYmhq1bt2IymYiOjqZ379588sknDB48mCNHjnDgwAE6dOhQ2bDKzVFU4P5BL81HQtQUptY90TXv7rP9d+x4Be+//xEbN/7AmjVfsXLl5wDo9WdmPvA886C4cy9KNZxOJ5pW8kStaeB0njuQpvg2FUVB0zScThf9+vXn0UcnAJCfn4/T6WTbtp9K7K+0eC5GpTqaf//9d9asWcPPP//M8OHDGTZsGGPHjgVg/Pjx/PLLLyQkJPDhhx/y9NNPAzBq1ChsNhsJCQkkJSUxc+ZMAOLi4mjRogVDhw7lgQceICkpiYCAS9/567QVAqDo5T4FIYTbG2/MYfXqlcTHD+axxyby5597yvW+zp1jWLFiGQBHjx7h11930K5dRzp16sIXXywH4NSpU3z//VquvDIGnU6P0+k87zavvLIz69evJTMzA03TeOml6Xz00Yd07HgFv//+K6mpKbhcLu8jPKtKpWoKbdu2Zc+e0gsrNDSU+fPPnYraZDIxY8aMc5YrisLEiROZOHFiZUKpNKetEBSkpiCE8Lrhhpt57rmnWLlyBaqq8s9/JjJv3qsXfN+jj05g5swkVq78/PQ57SkiIiK46657eOmlGYwefTMul4vRo8fQqlVrsrJOkZubw7RpU0hIGFbqNlu0aMldd43lkUfuQ9M0WrRoxe2334nJZOLRRyfw6KMPYDabadSoSZWWgd8+T2HVG7Pood9F0IgkdGH1LlFklVPT2nw9JK6KkbjKR56nUHnyPIUq1EJ3jPQ6XWtcQhBCCF/y2+dQ1h81jah6VjIz830dihBC1Bh+W1MICAxCr6/aXnshhPi789ukIISoOS6Drs0aqTLlKklBCOFTer2RvLxsSQxVTNM08vKy0Vdw2L3f9ikIIWqGsDArmZmp5OaeQlVVXK6aN8rn7xqXXm8kLMxa5uulvudigxJCiIuh0+mJiIgCat5wWQ9/ikuaj4QQQnhJUhBCCOF1WTQfqapy4ZUuwXsvJYmrYiSuiqmpcUHNje1yietC618W01wIIYSoGtJ8JIQQwkuSghBCCC9JCkIIIbwkKQghhPCSpCCEEMJLkoIQQggvSQpCCCG8JCkIIYTwkqQghBDCyy+Twueff86gQYO49tpr+eCDD3way+jRo0lISGDYsGEMGzaMHTt2+DS+3NxcBg8ezJEjRwDYuHEjQ4YMYcCAAbzyyive9f744w9uuOEGBg4cyJNPPonD4ajWuCZNmsSAAQO85fb111+fN95L4fXXXychIYGEhARmzpx53v1Xd3mVFltNKLM5c+YwaNAgEhISePfdd8+7/+oss9Liqgnl5TFjxgwSExOBssvl2LFj3HbbbcTFxXH//feTl5dXuZ1pfubEiRNa3759tczMTC0vL08bMmSItnfvXp/E4nK5tB49emh2u71GxPfLL79ogwcP1tq1a6cdPnxYKygo0GJjY7VDhw5pdrtdGzNmjLZ27VpN0zQtISFB2759u6ZpmjZp0iTtgw8+qLa4NE3TBg8erJ08ebLEeueLt6pt2LBBu/nmm7WioiLNZrNpo0eP1j7//PMaUV6lxfbVV1/5vMw2b96sjRw5UrPb7VpBQYHWt29f7Y8//vB5mZUWV3Jyss/Ly2Pjxo3a1VdfrU2cOFHTtLLLZdy4cdqKFSs0TdO0119/XZs5c2al9ud3NYWNGzfStWtXQkNDCQwMZODAgXz55Zc+ieWvv/5CURTGjh3L0KFDef/9930a30cffcQzzzxDZGQkADt37qRRo0Y0aNAAvV7PkCFD+PLLLzl69CiFhYVcccUVAFx//fWXNMaz48rPz+fYsWNMmTKFIUOG8Oqrr+JyucqM91KwWq0kJiZiNBoxGAw0a9aMAwcO1IjyKi22Y8eO+bzMrrrqKv773/+i1+tJT0/H6XSSnZ3t8zIrLS6TyeTz8gI4deoUr7zyCvfddx9AmeVit9vZsmULAwcOLLG8Mi6LWVIrIiUlBav1zJOIIiMj2blzp09iyc7Oplu3bjz77LMUFhYyevRo4uPjfRZfUlJSid9LK6uTJ0+es9xqtXLy5Mlqiys9PZ2uXbsydepUAgMDuffee1myZAmBgYGlxnsptGjRwvvzgQMHWLlyJaNGjaoR5VVabB9++CE//fSTT8sMwGAw8Oqrr/LOO+8QFxdXYz5jZ8fldDp9/hkDePrpp3nsscc4fvw4cO530lMumZmZWCwW9Hp9ieWV4Xc1Ba2USWEVxTdT4l555ZXMnDmTwMBAwsPDufHGG3n11VfPWc9X8ZVVVr4uwwYNGjB37lxq166N2Wxm1KhRrFu3zidx7d27lzFjxjBx4kQaNmxY6v59VV7FY2vatGmNKbNHHnmETZs2cfz4cQ4cOFDq/n0d16ZNm3xeXh9//DFRUVF069bNu6w6vpN+V1OoU6cOW7du9f6ekpLibZaoblu3bsVut3v/6JqmUa9ePdLS0mpEfHXq1Ck1lrOXp6amVmuMe/bs4cCBA96qsqZp6PX6MuO9VLZt28YjjzzC5MmTSUhI4Keffqox5XV2bDWhzJKTk7HZbLRp0waz2cyAAQP48ssv0el05+y/OsustLhWrlxJaGioT8tr5cqVpKamMmzYMLKyssjPz0dRlFLLJTw8nNzcXJxOJzqd7qLKy+9qCt27d2fTpk1kZGRQUFDAV199Re/evX0SS05ODjNnzqSoqIjc3FyWLl3K//3f/9WY+P7xj3+wf/9+Dh48iNPpZMWKFfTu3Zt69ephMpnYtm0bAMuWLavWGDVN44UXXiArKwu73c7ixYu59tpry4z3Ujh+/DgPPvggs2bNIiEhAag55VVabDWhzI4cOcJTTz2FzWbDZrOxZs0aRo4c6fMyKy2uLl26+Ly83n33XVasWMHy5ct55JFH6NevH9OnTy+1XAwGAzExMaxcubLE8srwy5rCY489xujRo7Hb7dx444107NjRJ7H07duXHTt2MHz4cFwuF7feeiudO3euMfGZTCZefPFFHn74YYqKioiNjSUuLg6AWbNm8dRTT5GXl0fbtm0ZPXp0tcXVunVrxo0bxy233ILD4WDAgAEMHjwYoMx4q9p//vMfioqKePHFF73LRo4cWSPKq6zYfF1msbGx3s+7TqdjwIABJCQkEB4e7tMyKy2uhx56iLCwMJ+WV1nKKpdnnnmGxMRE5s2bR1RUFC+//HKlti9PXhNCCOHld81HQgghyiZJQQghhJckBSGEEF6SFIQQQnhJUhBCCOElSUGIKjB27Fj27dtXoffce++9fPrpp5coIiEqx+/uUxDiUnj77bd9HYIQVUKSgvBr3377LfPmzcNutxMQEMDEiRP54Ycf2Lt3L2lpaaSnp9O6dWuSkpKwWCx8+OGHLFq0CIPBgMlkYurUqTRv3px+/foxZ84cOnTowOLFi1m4cCGqqhIREcGUKVNo0qQJJ0+eJDExkZSUFKKjo0lPT/fGkZycTFJSEqdOncLpdDJq1ChuvPFG8vLymDRpEgcPHkRVVdq1a8fUqVNRVanki0ukUhNuC3EZ2L9/vzZ48GAtIyND0zRN+/PPP7UePXpoL774ota7d28tNTVVczqd2uOPP669+OKLmsPh0Nq1a+edY3/p0qXaokWLNE3TtL59+2o7d+7UNm7cqPXv319LT0/XNE3TPvnkEy0+Pl5zuVzaAw88oL3yyiuapmnagQMHtCuuuEL75JNPNLvdrg0aNEjbtWuXpmmalp2drcXHx2vbt2/Xli5dqo0ZM0bTNE1zOBzak08+qR04cKA6i0n4GakpCL+1YcMGUlJSuPPOO73LFEXh0KFDxMXFERERAcCNN97ICy+8wMSJE4mLi2PkyJH06dOHHj16MGTIkBLb/P777xk0aBDh4eGAe177pKQkjhw5wsaNG5k4cSIAjRo14uqrrwbc01sfOnSIyZMne7dTWFjI77//Tq9evXjllVcYNWoU3bt354477qBRo0aXsliEn5OkIPyWy+WiW7duzJ4927vs+PHjLF68GJvNVmI9T3PNrFmz+PPPP9m4cSNvv/02S5YsYd68ed51tVJmjdE0DYfDcc4Ux565751OJ7Vq1WL58uXe19LS0ggODsZkMvH111+zefNmfvzxR+666y6eeuqpap9vR/gPaZgUfqtr165s2LCB5ORkANatW8fQoUMpKipizZo15OTk4HK5+Oijj+jbty8ZGRnExsYSGhrKnXfeyaOPPsqePXtKbLNnz56sXLmSjIwMAD755BNCQ0Np1KgRvXr1YvHixYD7ebqbN28GoEmTJphMJm9SOH78OIMHD2bXrl18+OGHTJo0iZ49ezJhwgR69uzJ3r17q6uIhB+SCfGEX1u1ahXz58/3zpc/efJkNm3axI8//ojT6SQzM5MuXbrw1FNPERAQwKJFi/jvf/9LQEAAOp2Oxx57jO7du5foaP7ggw9YtGgRLpeL8PBwnn76aVq0aEFGRgaTJk3i0KFD1K1bF4fDwXXXXcf111/P7t27vR3NDoeD0aNHc8stt5Cfn8/kyZPZs2cPZrOZ6OhokpKSCAkJ8XXRicuUJAUhzvLaa6+RmZnJ008/7etQhKh20nwkhBDCS2oKQgghvKSmIIQQwkuSghBCCC9JCkIIIbwkKQghhPCSpCCEEMJLkoIQQgiv/wexkHIMKlrueAAAAABJRU5ErkJggg==",
|
||
"text/plain": [
|
||
"<Figure size 432x288 with 1 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 432x288 with 1 Axes>"
|
||
]
|
||
},
|
||
"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
|
||
}
|