diff --git a/paddle2.0_docs/Autoencoder/AutoEncoder.ipynb b/paddle2.0_docs/Autoencoder/AutoEncoder.ipynb index 1ec0eeab23e..211cebf3fc1 100644 --- a/paddle2.0_docs/Autoencoder/AutoEncoder.ipynb +++ b/paddle2.0_docs/Autoencoder/AutoEncoder.ipynb @@ -2,85 +2,60 @@ "cells": [ { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "# 通过AutoEncoder实现时序数据异常检测\n", "\n", "作者: [Reatris](https://github.com/Reatris)\n", "\n", - "日期:2020.10.11\n", + "日期:2020.11\n", "\n", "本示例教程将会演示如何使用飞桨PaddlePaddle2.0来完成时序异常检测任务。这是一个较为简单的示例,将会搭建一个AutoEncoder网络完成任务。" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 环境配置\n", "\n", - "本教程基于paddle-2.0-beta编写,如果您的环境不是本版本,请先安装paddle-2.0-beta版本。" + "本教程基于paddle-2.0-rc编写,如果您的环境不是本版本,请先安装paddle-2.0-rc版本。" ] }, { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "#安装Paddle-2.0-beta版本\r\n", - "!pip install paddlepaddle-gpu==2.0.0b0" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ - "#导入模块\r\n", - "import numpy as np\r\n", - "import pandas as pd\r\n", + "#导入模块\n", + "import numpy as np\n", + "import pandas as pd\n", "from matplotlib import pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, + "execution_count": 2, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.0.0-beta0\n" + "2.0.0-rc0\n" ] } ], "source": [ - "import paddle\r\n", - "import paddle.nn.functional as F\r\n", - "print(paddle.__version__)\r\n", - "\r\n", - "# 启动动态图训练模式\r\n", - "paddle.disable_static()" + "import paddle\n", + "import paddle.nn.functional as F\n", + "print(paddle.__version__)" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 加载数据集\n", "\n", @@ -95,23 +70,28 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/aistudio\n", + "unzip: cannot find or open data/data55385/artificialNoAnomaly.zip, data/data55385/artificialNoAnomaly.zip.zip or data/data55385/artificialNoAnomaly.zip.ZIP.\r\n" + ] + } + ], "source": [ - "#解压数据集\r\n", - "%cd ~/\r\n", + "#解压数据集\n", + "%cd ~/\n", "!unzip data/data55385/artificialNoAnomaly.zip && unzip data/data55385/artificialWithAnomaly.zip" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -135,37 +115,33 @@ } ], "source": [ - "#正常数据预览\r\n", - "df_small_noise_path = 'artificialNoAnomaly/art_daily_small_noise.csv'\r\n", - "df_small_noise = pd.read_csv(\r\n", - " df_small_noise_path, parse_dates=True, index_col=\"timestamp\"\r\n", - ")\r\n", - "\r\n", - "#异常数据预览\r\n", - "df_daily_jumpsup_path = 'artificialWithAnomaly/art_daily_jumpsup.csv'\r\n", - "df_daily_jumpsup = pd.read_csv(\r\n", - " df_daily_jumpsup_path, parse_dates=True, index_col=\"timestamp\"\r\n", - ")\r\n", - "print(df_small_noise.head())\r\n", - "\r\n", + "#正常数据预览\n", + "df_small_noise_path = 'artificialNoAnomaly/art_daily_small_noise.csv'\n", + "df_small_noise = pd.read_csv(\n", + " df_small_noise_path, parse_dates=True, index_col=\"timestamp\"\n", + ")\n", + "\n", + "#异常数据预览\n", + "df_daily_jumpsup_path = 'artificialWithAnomaly/art_daily_jumpsup.csv'\n", + "df_daily_jumpsup = pd.read_csv(\n", + " df_daily_jumpsup_path, parse_dates=True, index_col=\"timestamp\"\n", + ")\n", + "print(df_small_noise.head())\n", + "\n", "print(df_daily_jumpsup.head())" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 数据可视化" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, + "execution_count": 5, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -189,17 +165,15 @@ } ], "source": [ - "#正常的时序数据可视化\r\n", - "fig, ax = plt.subplots()\r\n", - "df_small_noise.plot(legend=False, ax=ax)\r\n", - "plt.show()\r\n" + "#正常的时序数据可视化\n", + "fig, ax = plt.subplots()\n", + "df_small_noise.plot(legend=False, ax=ax)\n", + "plt.show()\n" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "**带有异常的时序数据如下:**\n", "\n", @@ -208,10 +182,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, + "execution_count": 6, + "metadata": {}, "outputs": [ { "data": { @@ -225,17 +197,15 @@ } ], "source": [ - "#异常的时序数据可视化\r\n", - "fig, ax = plt.subplots()\r\n", - "df_daily_jumpsup.plot(legend=False, ax=ax)\r\n", + "#异常的时序数据可视化\n", + "fig, ax = plt.subplots()\n", + "df_daily_jumpsup.plot(legend=False, ax=ax)\n", "plt.show()" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "# 训练数据预处理\n", "\n", @@ -247,10 +217,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, + "execution_count": 7, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -261,18 +229,16 @@ } ], "source": [ - "#初始化并保存我们得到的均值和方差,用于初始化数据。\r\n", - "training_mean = df_small_noise.mean()\r\n", - "training_std = df_small_noise.std()\r\n", - "df_training_value = (df_small_noise - training_mean) / training_std\r\n", + "#初始化并保存我们得到的均值和方差,用于初始化数据。\n", + "training_mean = df_small_noise.mean()\n", + "training_std = df_small_noise.std()\n", + "df_training_value = (df_small_noise - training_mean) / training_std\n", "print(\"训练数据总量:\", len(df_training_value))" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "# 创建序列\n", "\n", @@ -281,101 +247,93 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, + "execution_count": 8, + "metadata": {}, "outputs": [], "source": [ - "#时序步长\r\n", - "TIME_STEPS = 288 \r\n", - "\r\n", - "class MyDataset(paddle.io.Dataset):\r\n", - " \"\"\"\r\n", - " 步骤一:继承paddle.io.Dataset类\r\n", - " \"\"\"\r\n", - " def __init__(self,data,time_steps):\r\n", - " \"\"\"\r\n", - " 步骤二:实现构造函数,定义数据读取方式,划分训练和测试数据集\r\n", - " 注意:我们这个是不需要label的哦\r\n", - " \"\"\"\r\n", - " super(MyDataset, self).__init__()\r\n", - " self.time_steps = time_steps\r\n", - " self.data = paddle.to_tensor(self.transform(data),dtype='float32')\r\n", - "\r\n", - " def transform(self,data):\r\n", - " '''\r\n", - " 构造时序数据\r\n", - " '''\r\n", - " output = []\r\n", - " for i in range(len(data) - self.time_steps):\r\n", - " output.append(np.reshape(data[i : (i + self.time_steps)],(1,self.time_steps)))\r\n", - " return np.stack(output)\r\n", - "\r\n", - " def __getitem__(self, index):\r\n", - " \"\"\"\r\n", - " 步骤三:实现__getitem__方法,定义指定index时如何获取数据,并返回单条数据(训练数据)\r\n", - " \"\"\"\r\n", - " data = self.data[index]\r\n", - " label = self.data[index]\r\n", - " return data,label\r\n", - "\r\n", - " def __len__(self):\r\n", - " \"\"\"\r\n", - " 步骤四:实现__len__方法,返回数据集总数目\r\n", - " \"\"\"\r\n", - " return len(self.data)\r\n", - "\r\n", - "# 实例化数据集\r\n", - "train_dataset = MyDataset(df_training_value.values,TIME_STEPS)\r\n" + "#时序步长\n", + "TIME_STEPS = 288 \n", + "\n", + "class MyDataset(paddle.io.Dataset):\n", + " \"\"\"\n", + " 步骤一:继承paddle.io.Dataset类\n", + " \"\"\"\n", + " def __init__(self,data,time_steps):\n", + " \"\"\"\n", + " 步骤二:实现构造函数,定义数据读取方式,划分训练和测试数据集\n", + " 注意:我们这个是不需要label的哦\n", + " \"\"\"\n", + " super(MyDataset, self).__init__()\n", + " self.time_steps = time_steps\n", + " self.data = paddle.to_tensor(self.transform(data),dtype='float32')\n", + "\n", + " def transform(self,data):\n", + " '''\n", + " 构造时序数据\n", + " '''\n", + " output = []\n", + " for i in range(len(data) - self.time_steps):\n", + " output.append(np.reshape(data[i : (i + self.time_steps)],(1,self.time_steps)))\n", + " return np.stack(output)\n", + "\n", + " def __getitem__(self, index):\n", + " \"\"\"\n", + " 步骤三:实现__getitem__方法,定义指定index时如何获取数据,并返回单条数据(训练数据)\n", + " \"\"\"\n", + " data = self.data[index]\n", + " label = self.data[index]\n", + " return data,label\n", + "\n", + " def __len__(self):\n", + " \"\"\"\n", + " 步骤四:实现__len__方法,返回数据集总数目\n", + " \"\"\"\n", + " return len(self.data)\n", + "\n", + "# 实例化数据集\n", + "train_dataset = MyDataset(df_training_value.values,TIME_STEPS)\n" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 模型组网\n", "\n", - "用paddle.nn下的API,Layer,Conv1d、rlue完成网络的搭建。" + "用paddle.nn下的API,Layer,Conv1d、rlue完成网络的搭建,SubClass模式。" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ - "\r\n", - "class AutoEncoder(paddle.nn.Layer):\r\n", - " def __init__(self):\r\n", - " super(AutoEncoder, self).__init__()\r\n", - " self.conv0 = paddle.nn.Conv1d(in_channels=1,out_channels=32,kernel_size=7,stride=2)\r\n", - " self.conv1 = paddle.nn.Conv1d(in_channels=32,out_channels=16,kernel_size=7,stride=2)\r\n", - " self.convT0 = paddle.nn.ConvTranspose1d(in_channels=16,out_channels=32,kernel_size=7,stride=2)\r\n", - " self.convT1 = paddle.nn.ConvTranspose1d(in_channels=32,out_channels=1,kernel_size=7,stride=2)\r\n", - "\r\n", - " def forward(self, x):\r\n", - " x = self.conv0(x)\r\n", - " x = F.relu(x)\r\n", - " x = F.dropout(x,0.2)\r\n", - " x = self.conv1(x)\r\n", - " x = F.relu(x)\r\n", - " x = self.convT0(x)\r\n", - " x = F.relu(x)\r\n", - " x = F.dropout(x,0.2)\r\n", - " x = self.convT1(x)\r\n", + "\n", + "class AutoEncoder(paddle.nn.Layer):\n", + " def __init__(self):\n", + " super(AutoEncoder, self).__init__()\n", + " self.conv0 = paddle.nn.Conv1D(in_channels=1,out_channels=32,kernel_size=7,stride=2)\n", + " self.conv1 = paddle.nn.Conv1D(in_channels=32,out_channels=16,kernel_size=7,stride=2)\n", + " self.convT0 = paddle.nn.Conv1DTranspose(in_channels=16,out_channels=32,kernel_size=7,stride=2)\n", + " self.convT1 = paddle.nn.Conv1DTranspose(in_channels=32,out_channels=1,kernel_size=7,stride=2)\n", + "\n", + " def forward(self, x):\n", + " x = self.conv0(x)\n", + " x = F.relu(x)\n", + " x = F.dropout(x,0.2)\n", + " x = self.conv1(x)\n", + " x = F.relu(x)\n", + " x = self.convT0(x)\n", + " x = F.relu(x)\n", + " x = F.dropout(x,0.2)\n", + " x = self.convT1(x)\n", " return x" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 模型训练\n", "\n", @@ -390,10 +348,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, + "execution_count": 10, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -406,12 +362,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 200/200 [01:02<00:00, 3.22it/s]\n" + "100%|██████████| 200/200 [00:49<00:00, 4.03it/s]\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xt8nGWd9/HPb2ZyPjdJ0zZpm5S2YGmhlLYoQgVRBBXKUcH1oXhidxVd11UfdtkHFQ+7yq7ss8JrlX1AQUVgUbQKUlBEQBFaSksPUBp6THpImlOb8+n3/DF3ypAmmfQwM2nzfb9eeXXmnmsyv9yZzjfXdd33dZu7IyIiMpJQqgsQEZGxT2EhIiJxKSxERCQuhYWIiMSlsBARkbgUFiIiEpfCQkRE4lJYiIhIXAoLERGJK5LqAo6VkpISr6ysTHUZIiLHlZdeemmfu5fGa3fChEVlZSWrVq1KdRkiIscVM9s+mnYahhIRkbgUFiIiEpfCQkRE4jph5ixERI6Fnp4eampq6OzsTHUpx1RmZiYVFRWkpaUd0fMVFiIiMWpqasjLy6OyshIzS3U5x4S709DQQE1NDVVVVUf0PTQMJSISo7Ozk+Li4hMmKADMjOLi4qPqLSksREQGOZGCYsDR/kzjPizaunr57hObeHlHU6pLEREZs8Z9WHT19vOfT1XzSk1LqksREQEgNzc31SUcYtyHRTgU7Zr19nuKKxERGbvGfVhEBsKirz/FlYiIvJW786UvfYm5c+cyb948HnzwQQB2797NkiVLmD9/PnPnzuXZZ5+lr6+P66+//mDb22+//ZjWMu4PnY2E1bMQkaF97dcb2Lhr/zH9nnOm5POVS04dVdtf/OIXrFmzhrVr17Jv3z4WLVrEkiVLuP/++3nf+97HzTffTF9fH+3t7axZs4ba2lrWr18PQHNz8zGtO6E9CzO7yMw2mVm1md00xONLzGy1mfWa2VWDHptmZk+Y2atmttHMKhNRYyQU3QV9CgsRGWOee+45rr32WsLhMGVlZbzrXe9i5cqVLFq0iB/+8Id89atfZd26deTl5TFjxgy2bNnCZz/7WR5//HHy8/OPaS0J61mYWRi4E3gvUAOsNLPl7r4xptkO4Hrgi0N8i/uAb7r7k2aWCyRknCgYhdIwlIgcYrQ9gGRbsmQJzzzzDI8++ijXX389X/jCF7juuutYu3YtK1as4Pvf/z4PPfQQ99xzzzF7zUT2LBYD1e6+xd27gQeApbEN3H2bu7/CoCAwszlAxN2fDNq1unt7Ioo0M9LCpmEoERlzzj33XB588EH6+vqor6/nmWeeYfHixWzfvp2ysjI+9alP8clPfpLVq1ezb98++vv7ufLKK/nGN77B6tWrj2ktiZyzKAd2xtyvAc4a5XNnA81m9gugCvgdcJO79x3bEqPCIdMwlIiMOZdffjnPP/88p59+OmbGd77zHSZNmsS9997LbbfdRlpaGrm5udx3333U1tbysY99jP7+6N/e//Iv/3JMaxmrE9wR4FzgDKJDVQ8SHa66O7aRmd0A3AAwbdq0I3+xUIiePoWFiIwNra2tQHTk47bbbuO22257y+PLli1j2bJlhzzvWPcmYiVyGKoWmBpzvyLYNho1wJpgCKsX+CWwYHAjd7/L3Re6+8LS0rhXBRxWJGz09WvOQkRkOIkMi5XALDOrMrN04Bpg+WE8t9DMBhLg3cDGEdoflUhIcxYiIiNJWFgEPYIbgRXAq8BD7r7BzG41s0sBzGyRmdUAVwM/MLMNwXP7iB4h9XszWwcY8N+JqjUcMno1DCUiAfcT7/PgaH+mhM5ZuPtjwGODtt0Sc3sl0eGpoZ77JHBaIusbEAmF1LMQESB6kaCGhoYTapnygetZZGZmHvH3GKsT3EmlOQsRGVBRUUFNTQ319fWpLuWYGrhS3pFSWBAMQ6lnISJAWlraEV9N7kQ27hcShGCCW3MWIiLDUligOQsRkXgUFmjOQkQkHoUFmrMQEYlHYQGkhUKasxARGYHCAi0kKCISj8KC6JxFj+YsRESGpbAgeuisehYiIsNTWABhzVmIiIxIYcHAqrMahhIRGY7CguichQ6dFREZnsICzVmIiMSjsEBzFiIi8SgsgLSw5ixEREaisEAn5YmIxJPQsDCzi8xsk5lVm9lNQzy+xMxWm1mvmV01xOP5ZlZjZncksk5dg1tEZGQJCwszCwN3AhcDc4BrzWzOoGY7gOuB+4f5Nl8HnklUjQMiYc1ZiIiMJJE9i8VAtbtvcfdu4AFgaWwDd9/m7q8Ah0wYmNmZQBnwRAJrBHSehYhIPIkMi3JgZ8z9mmBbXGYWAv4d+GKcdjeY2SozW3U018vVnIWIyMjG6gT3p4HH3L1mpEbufpe7L3T3haWlpUf8YpFwiJ4+x12BISIylEgCv3ctMDXmfkWwbTTeAZxrZp8GcoF0M2t190MmyY+FSMgA6HcIWyJeQUTk+JbIsFgJzDKzKqIhcQ3wkdE80d3/auC2mV0PLExUUEB0GAqgt7+fcCicqJcRETluJWwYyt17gRuBFcCrwEPuvsHMbjWzSwHMbJGZ1QBXAz8wsw2JqmckaUF3QkdEiYgMLZE9C9z9MeCxQdtuibm9kujw1Ejf40fAjxJQ3kHhUDQzda6FiMjQxuoEd1INzFnoiCgRkaEpLIguUQ7Q26dzLUREhqKw4M2ehYahRESGprDgzTkLDUOJiAxNYcGbR0P1aBhKRGRICgvePM9CPQsRkaEpLNCchYhIPAoLNGchIhKPwoI3D53VnIWIyNAUFuikPBGReBQWxC4kqLAQERmKwgJICwdrQ2khQRGRISkseOsS5SIiciiFBZqzEBGJR2EBRIJDZ3s0DCUiMiSFBW8eOquehYjI0BIaFmZ2kZltMrNqMzvksqhmtsTMVptZr5ldFbN9vpk9b2YbzOwVM/twIuvUnIWIyMgSFhZmFgbuBC4G5gDXmtmcQc12ANcD9w/a3g5c5+6nAhcB/2FmhYmqNS2ko6FEREaSyMuqLgaq3X0LgJk9ACwFNg40cPdtwWNv+ZPe3V+Pub3LzOqAUqA5EYWGNQwlIjKiRA5DlQM7Y+7XBNsOi5ktBtKBN45RXYfQQoIiIiMb0xPcZjYZ+DHwMXc/ZELBzG4ws1Vmtqq+vv6IXyeiOQsRkRElMixqgakx9yuCbaNiZvnAo8DN7v6Xodq4+13uvtDdF5aWlh5xoRHNWYiIjCiRYbESmGVmVWaWDlwDLB/NE4P2jwD3ufvDCawR0JyFiEg8CQsLd+8FbgRWAK8CD7n7BjO71cwuBTCzRWZWA1wN/MDMNgRP/xCwBLjezNYEX/MTVevAMFSPhqFERIaUyKOhcPfHgMcGbbsl5vZKosNTg5/3E+Aniawt1sHlPjQMJSIypDE9wZ0sWqJcRGRkCgvAzIiETHMWIiLDUFgEwiHTnIWIyDAUFoFIyDRnISIyDIVFIBIOac5CRGQYCotAJGQ6g1tEZBgKi0BYE9wiIsNSWATSwiEt9yEiMgyFRSAcMs1ZiIgMQ2ERiCgsRESGpbAIRMJGnya4RUSGpLAIhEMhejRnISIyJIVFQMt9iIgMT2ER0AS3iMjwFBaBtLDR26c5CxGRoSgsAupZiIgMT2ERiIRCmrMQERlGQsPCzC4ys01mVm1mNw3x+BIzW21mvWZ21aDHlpnZ5uBrWSLrhOihs+pZiIgMLWFhYWZh4E7gYmAOcK2ZzRnUbAdwPXD/oOdOAL4CnAUsBr5iZkWJqhWCk/I0ZyEiMqRE9iwWA9XuvsXdu4EHgKWxDdx9m7u/Agz+lH4f8KS7N7p7E/AkcFECa9VCgiIiI0hkWJQDO2Pu1wTbEv3cI6LrWYiIDO+4nuA2sxvMbJWZraqvrz+q76VhKBGR4SUyLGqBqTH3K4Jtx+y57n6Xuy9094WlpaVHXCjo0FkRkZEkMixWArPMrMrM0oFrgOWjfO4K4EIzKwomti8MtiVMmg6dFREZVsLCwt17gRuJfsi/Cjzk7hvM7FYzuxTAzBaZWQ1wNfADM9sQPLcR+DrRwFkJ3BpsS5hw2LSQoIjIMCKJ/Obu/hjw2KBtt8TcXkl0iGmo594D3JPI+mJFFxLUnIWIyFBG1bMws5PMLCO4fZ6Zfc7MChNbWnJFtES5iMiwRjsM9XOgz8xmAncRnXy+f+SnHF9K8tJp7eqltas31aWIiIw5ow2L/mAO4nLge+7+JWBy4spKvhklOQBs29eW4kpERMae0YZFj5ldCywDfhNsS0tMSalRVZILwFaFhYjIIUYbFh8D3gF80923mlkV8OPElZV804uzMVNYiIgMZVRHQ7n7RuBzAMF5D3nu/u1EFpZsmWlhphRkKSxERIYw2qOhnjaz/GA12NXAf5vZdxNbWvJVleSwRWEhInKI0Q5DFbj7fuAK4D53Pwt4T+LKSo2qkhy21rfirkNoRURijTYsImY2GfgQb05wn3CqSnLY39lLY1t3qksRERlTRhsWtxJdtuMNd19pZjOAzYkrKzWqSqOHz2reQkTkrUYVFu7+P+5+mrv/bXB/i7tfmdjSkm/gXAuFhYjIW412grvCzB4xs7rg6+dmNuSaTsez8sIswiFje0N7qksRERlTRjsM9UOiy4tPCb5+HWw7oUTCISblZ7KruSPVpYiIjCmjDYtSd/+hu/cGXz8Cju5qQ2NUeWEWtQoLEZG3GG1YNJjZR80sHHx9FGhIZGGpMqUwk10tCgsRkVijDYuPEz1sdg+wG7gKuD5BNaXUlMIsdjd36qp5IiIxRns01HZ3v9TdS919ortfBsQ9GsrMLjKzTWZWbWY3DfF4hpk9GDz+gplVBtvTzOxeM1tnZq+a2T8e5s91xKYUZtHb79Qf6ErWS4qIjHlHc1nVL4z0oJmFgTuBi4E5wLVmNmdQs08ATe4+E7gdGFhv6mogw93nAWcCfz0QJIlWXpgFoHkLEZEYRxMWFufxxUB1cE5GN/AAsHRQm6XAvcHth4ELzMwAB3LMLAJkAd3A/qOoddTKi6JhoSOiRETedDRhEW9QvxzYGXO/Jtg2ZJvg4kotQDHR4GgjOj+yA/g3d288ilpHbXJBJqCehYhIrBGXKDezAwwdCkb0L/5EWQz0ET2nowh41sx+5+5bBtV3A3ADwLRp047JC+dlppGfGVHPQkQkxog9C3fPc/f8Ib7y3D3etTBqiV6re0BFsG3INsGQUwHRQ3I/Ajzu7j3uXgf8CVg4RH13uftCd19YWnrsTvuYUpilsBARiXE0w1DxrARmmVmVmaUD1xA9CzzWcqKXaoXo4bhPeXR98B3AuwHMLAd4O/BaAmt9i/LCLGqaFBYiIgMSFhbBHMSNRFerfRV4yN03mNmtZnZp0OxuoNjMqokeXTVweO2dQK6ZbSAaOj9091cSVetg5UXqWYiIxBrVZVWPlLs/Bjw2aNstMbc7iR4mO/h5rUNtT5bJBVns7+ylrauXnIyE7iIRkeNCIoehjltl+RkA7N3fmeJKRETGBoXFECblRw+f3aOwEBEBFBZDmhiERd1+LfkhIgIKiyFNKlDPQkQklsJiCLkZEXLSw5qzEBEJKCyGUVaQqbAQEQkoLIYxKT+TvZqzEBEBFBbDKsvPZE+LehYiIqCwGFZZfiZ1BzqJrj4iIjK+KSyGUZafQU+f09jWnepSRERSTmExjIET8zRvISKisBjWxINhoXkLERGFxTB0Yp6IyJsUFsMozY0uJqgjokREFBbDSo+EmFyQyc7G9lSXIiKScgqLEZxUmssb9a2pLkNEJOUUFiM4qTSHN+rbdK6FiIx7CQ0LM7vIzDaZWbWZ3TTE4xlm9mDw+AtmVhnz2Glm9ryZbTCzdWaWmchahzKjNJfWrl7qD+jwWREZ3xIWFmYWJnot7YuBOcC1ZjZnULNPAE3uPhO4Hfh28NwI8BPgb9z9VOA8oCdRtQ7npNJcAKo1FCUi41wiexaLgWp33+Lu3cADwNJBbZYC9wa3HwYuMDMDLgRecfe1AO7e4O59Cax1SCdNzAHgjfq2ZL+0iMiYksiwKAd2xtyvCbYN2cbde4EWoBiYDbiZrTCz1Wb25QTWOaxJ+Zlkp4fZop6FiIxzkVQXMIwIcA6wCGgHfm9mL7n772MbmdkNwA0A06ZNO+ZFmBkzgkluEZHxLJE9i1pgasz9imDbkG2CeYoCoIFoL+QZd9/n7u3AY8CCwS/g7ne5+0J3X1haWpqAHyE4fLZOPQsRGd8SGRYrgVlmVmVm6cA1wPJBbZYDy4LbVwFPefQ41RXAPDPLDkLkXcDGBNY6rJNKc9nV0kFHd9KnTERExoyEhUUwB3Ej0Q/+V4GH3H2Dmd1qZpcGze4Gis2sGvgCcFPw3Cbgu0QDZw2w2t0fTVStI5lRmoM7bN2noSgRGb8SOmfh7o8RHUKK3XZLzO1O4OphnvsToofPptTA4bNv1LcyZ0p+iqsREUkNncEdR1VJDmawRZPcIjKOKSziyEwLU16YpTWiRGRcU1iMghYUFJHxTmExCieV5rKlvo3+fi0oKCLjk8JiFE6amENHT5+umici45bCYhRmlLx5RJSIyHiksBiFgQUFdUSUiIxXCotRKM3NIC8zwmt7DqS6FBGRlFBYjIKZcVZVMc9urtdV80RkXFJYjNJ5J5dS09ShFWhFZFxSWIzSeSdHV7V9elNdiisREUk+hcUoVRRlM7sslz8oLERkHFJYHIbzT57Ii1sbaelI+uXARURSSmFxGC45fQo9fc5PX9ie6lJERJJKYXEY5pYXsGR2KXc/u1UXQxKRcUVhcZg+c95JNLR189CqnakuRUQkaRQWh2lx1QROn1rIz17ckepSRESSJqFhYWYXmdkmM6s2s5uGeDzDzB4MHn/BzCoHPT7NzFrN7IuJrPNwmBlXnFHOa3sOsElndIvIOJGwsDCzMHAncDEwB7jWzOYMavYJoMndZwK3A98e9Ph3gd8mqsYj9YHTJhMOGb9aU5vqUkREkiKRPYvFQLW7b3H3buABYOmgNkuBe4PbDwMXmJkBmNllwFZgQwJrPCIluRmcM7OEX63ZpeU/RGRcSGRYlAOxs8A1wbYh27h7L9ACFJtZLvC/ga+N9AJmdoOZrTKzVfX19ces8NFYOn8Ktc0dvLC1MamvKyKSCmN1gvurwO3uPuIFJNz9Lndf6O4LS0tLk1NZ4OK5k8nLjGiiW0TGhUSGRS0wNeZ+RbBtyDZmFgEKgAbgLOA7ZrYN+DzwT2Z2YwJrPWxZ6WGuOKOc367bQ2Nbd6rLERFJqESGxUpglplVmVk6cA2wfFCb5cCy4PZVwFMeda67V7p7JfAfwLfc/Y4E1npErj1rGt19/fzbE5tYV9OS6nJERBImYWERzEHcCKwAXgUecvcNZnarmV0aNLub6BxFNfAF4JDDa8eyUybl8563TeT+F3ZwyR3P8buNe1NdkohIQtiJcjTPwoULfdWqVUl/3b5+p6apnf9194tMyEnnkU+fTXBAl4jImGdmL7n7wnjtxuoE93EjHDKmF+dww5IZrNnZrKOjROSEpLA4Rq46s4KS3Ay+8ehGmjThLSInGIXFMZKZFuZbl8/l9b2tXPlff2bzXi0FIiInDoXFMXThqZP46SfPoqWjhw987zkeXKlzMETkxKCwOMYWVU7g8c8vYVFlETc/sl6LDYrICUFhkQCleRl879oF5GZG+OdfrqNufyddvbpYkogcvxQWCTIhJ51/uvhtrNzWxOJv/Z7zb3uaXc0dqS5LROSIKCwS6KozK/j+RxfwlUvmcKCzl4//aCWtXb0APP9Gw8HbIiJjXSTVBZzIQiHjormTATipNJeP/Wgl19/zIufOKuX2373ONYum8q9XnpbiKkVE4lPPIkmWzC7le9eewcs7m7n9d6+Tlxnhl2tqaW7XORkiMvapZ5FE7583may0MCu3NXLx3Mlccsdz/M+qGj61ZEaqSxMRGZHCIsnOP2Ui558yEYDFlRO469ktmME7Tirm5LI8ImF19kRk7FFYpNA/vv8Ubvr5Or7x6KsAFGSl8bkLZnHdO6aTptAQkTFEq86OATsb21m9o4mHX6rh2c37WFw1gf+3bCH5mWmpLk1ETnCjXXVWYTGGuDuPvFzLlx9+hZNKc/no26dx8bzJlORmpLo0ETlBKSyOY09vquMryzewvaGdnPQwHzxtCi9sbWDqhGy++6H5lOYpPETk2BgT17Mws4vMbJOZVZvZIVfBM7MMM3swePwFM6sMtr/XzF4ys3XBv+9OZJ1jzXknT+TpL57His8v4dxZpTz00k7K8jNZua2RpXc8x29e2UV//4kR8iJyfEhYz8LMwsDrwHuBGqLX5L7W3TfGtPk0cJq7/42ZXQNc7u4fNrMzgL3uvsvM5gIr3L18pNc7kXoWg/X29RMJh1hX08LfP7SG6rpWphdnc+npU5g2IZvTpxYyuywv1WWKyHFotD2LRB4NtRiodvctQUEPAEuBjTFtlgJfDW4/DNxhZubuL8e02QBkmVmGu3clsN4xa+Bw2nkVBaz4/BIeW7ebn724gzv+UI07RELGVy49lb9aPI32nj5e3tHE/KmF5GmCXESOkUSGRTmwM+Z+DXDWcG3cvdfMWoBiYF9MmyuB1eM1KAYLh4xLTp/CJadP4UBnD/UHurj1Nxv5P79czzcf3Yg7dPX2c8qkPO77+GIm5mfS3+8c6OylIFvhISJHZkyfZ2FmpwLfBi4c5vEbgBsApk2blsTKxoa8zDTyMtO4e9kifr12F6/UtGAGMyfm8vXfbOSyO//EVy49lfue38ZftjTygXmT+YcLZzO9OCfVpYvIcSaRYVELTI25XxFsG6pNjZlFgAKgAcDMKoBHgOvc/Y2hXsDd7wLuguicxTGt/jgSDhmXnVHOZWe8Oa1z6pR8Pvezl/nrH79EeiTE0vlTWLF+D09vquPLF53C1n1tLKosOrjQoYjISBI5wR0hOsF9AdFQWAl8xN03xLT5DDAvZoL7Cnf/kJkVAn8EvubuvxjN653IE9xHqr27l/ue3845M0uYW17AzsZ2PnnvKjbtPUDIoN/holMnsXH3fgqz0/jo26dz/skTMYNXd++nobWbxrZuWjp6iISMBdOLeOfMkoPff39nD3kZEcwshT+liByNMXGehZm9H/gPIAzc4+7fNLNbgVXuvtzMMoEfA2cAjcA17r7FzP4Z+Edgc8y3u9Dd64Z7LYXF6LR39/Lq7gPMLsvlthWbeGDlTt4+o5hdzR1U17WO+Fwz+Nqlp5KTHuHhl2p4fksDH144lW9dMY+G1i6KctK1TInIcWZMhEUyKSyOTH+/EwoZ7s7amhZe3NoAwNzyAiblZ1KUnU5+VhqdPX185v7VPL2pHoDpxdnMnVLAo+t2M6Ugk10tnZQXZrHs7OnMLsujuq6Vjbv3kxEJc8qkPN59ykSmTsg++Lq/f3UvuRkRzppRDEBHdx9ra5qZP7WQzLRw8neEyDilsJBjrqu3j/tf2MHc8gIWTi/CzPj+H99gxYY9nH/yRP6wqY6XdzQfbD8pP5Puvn4a26LX7Jg1MZeFlRNobOtixYa9RELG1y+by/aGdh5YuYPm9h7eNjmfmy4+hfzMCLPL8giHjPW1LUydkE1uRoQXtjYwMS+TacXZbNvXRlVJDrkZEVZs2MsfX6+jobWbv3vPLE6dUkB13QHufm4b3b39vHdOGRe8baJ6PiKDKCwk6dydPfs72dHQTsWEbMoLswDYuq+Np16r4+lNdayrbaG9q49Pn38Sz23ex6rtTYQM3nfqJM6eWcLtT75+MFzCISMtbHT29APR80l6B525XpyTzpwp+Ty7eR8FWWmEDFq7eplUkMnOxg4y00JkRMK0dPRQlp/Bde+o5MOLprJ1XxuNbd1MKchiy75WOrr7mFtewOPr97C9sZ2lp0/hzOlF0e8ZenNOZmdjO83tPUzITT/484kczxQWMmYNnJHe1tXLL9fU8q7ZpVQURYeomtu7WV+7n/buXl6paaGtu5ezqiawvaGdxvZuzp1ZSkNbFzVNHVQUZfHTv+xgzc5m/uHC2Xzy3Bns7+jh357YRFN7N2dMLeKKBeUUZKXx7OZ93POnrTy7ed+ItZlBYVYaTe09AGSlhZkzJZ+i7DR2NXeycff+g23PPqmYqpIc9rV2sWBaEcW5GWypb+XFrY30u7NgWhGhkJEZCTG5MIvfrt/D3pZOLnjbRN4/bzKF2Wn8eu1uzCAnI8Lu5g5yMiLMKMlhbnkBT2+q47nqfSyZXcoH50055DyZ1Tua2NXcwbtmlx5yAubWfW3c9cwW5kzO4+qFU4cc2uvrd8IhHZww3iksZFxwd9q7+8jJGN1R4Jv2HOC363dzclkeUwqz2NXcwfTiHNIjIdbsbObM6UVUFGXx3OZ9bGtoY0djOxt27aetq5fcjAjvnVNGZXEOr9cd4Kd/2UFrVy+F2Wlsb2gHor2heeUFhEPGKzXNhENGd28//R4dlqssyWbltib6hljba7ieU0NbN+nhEGfNmEBHdx9FOekUZafx0KoaANLCRlVJDm+bnM/8qYVs2nOAX7xci7vT0+ekhY2JeZn0u5ObEeG6syv546Z6nnptL7Mm5nHGtELmTMnHHXY0trOnpZNzZ5WwZV8bj76ym3NmlnD+KaVkRMJEwkZ7dx+1TR3UNndQmJXGx86pYl1NCy9tb2RSQRbra1uoaergrKoJLJldyrQJ2aze0URBVhpzJucTChm1zR08vKqG56rrKcnN4DPnzyQnI8Jru/eztqaFnPRoSJ93cvRCYf3upIVDtHf38vreVvrdKcpOZ3JB5iFB6O7Ut3aRn5k2qvmvzp4+Vm1r4vSpBeNy1QOFhUgSuDtmxt79nbR39zGlMJOMSPgtj3X29FHT1EFlcTaRcIjGtm6e3LiHfa3dLJ0/hYKsNNq6+ijNy6Czp4/Nda2s3dnMzIm5nH1SMetr9/PIy7X8+Y19FGanUdPUQU1TB9e9YzofmDeZP75ez+t7W1lb00z9gS7yMiK899Qybrr4FLbWt/H06/XsbekkFDJe27Of9bX7yUoLc/XCCnY0tvPyjmZaOqI9qYxIiKLsdPbs7yRk8PYZxaze0XRwKDBWVlqYjp4+cjMitHb1HtyeEQkxqSCqlkKdAAAJl0lEQVTzYICawcDHTGF2GpPyM9lcF/3An1dewNb6Ng7EPD82NCflZ3KgswcH3jmzhBe3Nh6sFaJBeeb0Ilq7eqlp6qCqJIeapg7qD0QXfJhckMmC6UUsmFbEmp3NrNiwhyWzSrhiQQVVJTn8as2ug/NlFUVZXHDKRB7fsIeFlRO46swKahrb+cvWRnY3d7C4qpgzphUyKT+TbQ1tPPJyLS9tb+KiUycxuywv6AUXs7nuAL9eu4s5k/NZML2Ioux06g50sa6mmZd3NjNtQjbzpxZSVZJDZ08/3X19TMzLpCw/g9K8THIzIvzu1b2sr23hygUVVBRl0dzRQ3FOOmt2NvOH1+p418kTmZiXwdqaZjp7+inKTuOCt5Ud0XtYYSFygnJ3Onr6yE6PHLJ9V0snZXkZw16e191Ztb2JiqIsJhdE51z6+519rV2YGUXZaYRDxoZd+8nLjDC9OIf9nT3saGint9/p6esnIxKioiibouw0Xt7ZzN3PbmX+1EI+tHAq9a2dlBdmk5UeZldzx8Ee2qLKCTS2dbNqeyN1+7uYOTGX686upLwwi6a2bh7fsIeMSIjpxTmcVlFAX7/z1Gt1/PLlWiYVZNLT189Tr9Uxf2ohl59RTkZamKa2bl7bc4A/vxGdr5o2IZst9W2U5mVw5vQi2rv7eG3PAVZvb6K2uYPs9DAXzinjuep97GuNzouFDC6cM4n3zCnjjqc2s7Opg3NmlrByWyPt3X1ANLAmF2ayrqblLT2/iXkZLK6awFOv1R1sO2DWxFx2NrW/JWSz0sLMqyhgR0M7e/Z3Dvv7jQ3LkEV7qz19Tl5mhAOdvUM+5/SphfzqM+8c9nuORGEhIhLY09JJdkaY/Mw0unv7Wb+rhc17D/DOmSUH58t6+vrp6OkjPzONfa1dvL7nANNLcphSkImZ0d7dy6Y9B6g70MXUomxmleWSFg7R0d1Hd18/4ZDx3OZo7++sqgl09fZT09ROY1sPpXkZlBdmkR4J4e40tnWzraGd7PQw6ZEQ9Qe62Lu/k7r9XdS3dnF6RSFnTi/iZy/uoLuvn5LcDN6ob6WyOJvLzijn6dfq6ejp48zpRcFwW4iJ+ZlHtG8UFiIiEteYuPiRiIicGBQWIiISl8JCRETiUliIiEhcCgsREYlLYSEiInEpLEREJC6FhYiIxHXCnJRnZvXA9qP4FiXAyEuSpobqOjxjtS4Yu7WprsMzVuuCI6tturuXxmt0woTF0TKzVaM5izHZVNfhGat1wditTXUdnrFaFyS2Ng1DiYhIXAoLERGJS2HxprtSXcAwVNfhGat1wditTXUdnrFaFySwNs1ZiIhIXOpZiIhIXOM+LMzsIjPbZGbVZnZTCuuYamZ/MLONZrbBzP4u2P5VM6s1szXB1/tTVN82M1sX1LAq2DbBzJ40s83Bv0VJrunkmP2yxsz2m9nnU7HPzOweM6szs/Ux24bcPxb1n8F77hUzW5Dkum4zs9eC137EzAqD7ZVm1hGz376fqLpGqG3Y352Z/WOwzzaZ2fuSXNeDMTVtM7M1wfak7bMRPiOS8z5z93H7BYSBN4AZQDqwFpiTolomAwuC23nA68Ac4KvAF8fAvtoGlAza9h3gpuD2TcC3U/y73ANMT8U+A5YAC4D18fYP8H7gt4ABbwdeSHJdFwKR4Pa3Y+qqjG2Xon025O8u+L+wFsgAqoL/t+Fk1TXo8X8Hbkn2PhvhMyIp77Px3rNYDFS7+xZ37wYeAJamohB33+3uq4PbB4BXgfJU1HIYlgL3BrfvBS5LYS0XAG+4+9GcmHnE3P0ZoHHQ5uH2z1LgPo/6C1BoZpOTVZe7P+HuAxdz/gtQkYjXjmeYfTacpcAD7t7l7luBaqL/f5Nal5kZ8CHgZ4l47ZGM8BmRlPfZeA+LcmBnzP0axsAHtJlVAmcALwSbbgy6kfcke6gnhgNPmNlLZnZDsK3M3XcHt/cAZakpDYBreOt/4LGwz4bbP2Ppffdxon99Dqgys5fN7I9mdm6KahrqdzdW9tm5wF533xyzLen7bNBnRFLeZ+M9LMYcM8sFfg583t33A/8FnATMB3YT7QKnwjnuvgC4GPiMmS2JfdCj/d6UHFpnZunApcD/BJvGyj47KJX7ZzhmdjPQC/w02LQbmObuZwBfAO43s/wklzXmfneDXMtb/yhJ+j4b4jPioES+z8Z7WNQCU2PuVwTbUsLM0oi+CX7q7r8AcPe97t7n7v3Af5Ogrnc87l4b/FsHPBLUsXegWxv8W5eK2ogG2Gp33xvUOCb2GcPvn5S/78zseuCDwF8FHzAEQzwNwe2XiM4LzE5mXSP87sbCPosAVwAPDmxL9j4b6jOCJL3PxntYrARmmVlV8NfpNcDyVBQSjIXeDbzq7t+N2R47xng5sH7wc5NQW46Z5Q3cJjpBup7ovloWNFsG/CrZtQXe8tfeWNhngeH2z3LguuBolbcDLTHDCAlnZhcBXwYudff2mO2lZhYObs8AZgFbklVX8LrD/e6WA9eYWYaZVQW1vZjM2oD3AK+5e83AhmTus+E+I0jW+ywZs/hj+YvoEQOvE/2L4OYU1nEO0e7jK8Ca4Ov9wI+BdcH25cDkFNQ2g+iRKGuBDQP7CSgGfg9sBn4HTEhBbTlAA1AQsy3p+4xoWO0GeoiODX9iuP1D9OiUO4P33DpgYZLrqiY6lj3wPvt+0PbK4Pe7BlgNXJKCfTbs7w64Odhnm4CLk1lXsP1HwN8Mapu0fTbCZ0RS3mc6g1tEROIa78NQIiIyCgoLERGJS2EhIiJxKSxERCQuhYWIiMSlsBA5Cmb25+DfSjP7SKrrEUkUhYXIUXD3s4OblcBhhUVwRrDIcUFhIXIUzKw1uPmvwLnBNQ3+3szCFr1uxMpgUby/DtqfZ2bPmtlyYGNwdvyjZrbWzNab2YdT9sOIjEB/2YgcGzcRvQ7DBwGClXlb3H2RmWUAfzKzJ4K2C4C57r7VzK4Edrn7B4LnFaSieJF41LMQSYwLia7Ls4boMtLFRNcNAnjRo9dkgOgyDO81s2+b2bnu3pKCWkXiUliIJIYBn3X3+cFXlbsP9CzaBhq5++tEexrrgG+Y2S0pqFUkLoWFyLFxgOilLgesAP42WFIaM5sdrNj7FmY2BWh3958AtxENDpExR3MWIsfGK0Cfma0lujrp/yV6hNTqYGnpeoa+7Ow84DYz6ye6yunfJqVakcOkVWdFRCQuDUOJiEhcCgsREYlLYSEiInEpLEREJC6FhYiIxKWwEBGRuBQWIiISl8JCRETi+v/jLsZ+AMse+wAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -421,59 +377,57 @@ } ], "source": [ - "import tqdm\r\n", - "#参数设置\r\n", - "epoch_num = 200\r\n", - "batch_size = 128\r\n", - "learning_rate = 0.001\r\n", - "\r\n", - "def train():\r\n", - " print('训练开始')\r\n", - " #实例化模型\r\n", - " model = AutoEncoder()\r\n", - " #将模型转换为训练模式\r\n", - " model.train()\r\n", - " #设置优化器,学习率,并且把模型参数给优化器\r\n", - " opt = paddle.optimizer.Adam(learning_rate=learning_rate,parameters=model.parameters())\r\n", - " #设置损失函数\r\n", - " mse_loss = paddle.nn.loss.MSELoss()\r\n", - " #设置数据读取器\r\n", - " data_reader = paddle.io.DataLoader(train_dataset,\r\n", - " places=[paddle.CPUPlace()],\r\n", - " batch_size=batch_size,\r\n", - " shuffle=True,\r\n", - " drop_last=True,\r\n", - " num_workers=0)\r\n", - " history_loss = []\r\n", - " iter_epoch = []\r\n", - " for epoch in tqdm.tqdm(range(epoch_num)):\r\n", - " for batch_id, data in enumerate(data_reader()): \r\n", - " x = data[0]\r\n", - " y = data[1]\r\n", - " out = model(x)\r\n", - " avg_loss = mse_loss(out,(y[:,:,:-1])) #输输入的数据进过卷积会丢掉最后一个数据所以只剩287\r\n", - " avg_loss.backward()\r\n", - " opt.step()\r\n", - " opt.clear_grad()\r\n", - " iter_epoch.append(epoch)\r\n", - " history_loss.append(avg_loss.numpy()[0])\r\n", - " #绘制loss\r\n", - " plt.plot(iter_epoch,history_loss, label = 'loss')\r\n", - " plt.legend()\r\n", - " plt.xlabel('iters')\r\n", - " plt.ylabel('Loss')\r\n", - " plt.show()\r\n", - " #保存模型参数\r\n", - " paddle.save(model.state_dict(),'model')\r\n", - "\r\n", + "import tqdm\n", + "#参数设置\n", + "epoch_num = 200\n", + "batch_size = 128\n", + "learning_rate = 0.001\n", + "\n", + "def train():\n", + " print('训练开始')\n", + " #实例化模型\n", + " model = AutoEncoder()\n", + " #将模型转换为训练模式\n", + " model.train()\n", + " #设置优化器,学习率,并且把模型参数给优化器\n", + " opt = paddle.optimizer.Adam(learning_rate=learning_rate,parameters=model.parameters())\n", + " #设置损失函数\n", + " mse_loss = paddle.nn.loss.MSELoss()\n", + " #设置数据读取器\n", + " data_reader = paddle.io.DataLoader(train_dataset,\n", + " places=[paddle.CPUPlace()],\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " drop_last=True,\n", + " num_workers=0)\n", + " history_loss = []\n", + " iter_epoch = []\n", + " for epoch in tqdm.tqdm(range(epoch_num)):\n", + " for batch_id, data in enumerate(data_reader()): \n", + " x = data[0]\n", + " y = data[1]\n", + " out = model(x)\n", + " avg_loss = mse_loss(out,(y[:,:,:-1])) #输输入的数据进过卷积会丢掉最后一个数据所以只剩287\n", + " avg_loss.backward()\n", + " opt.step()\n", + " opt.clear_grad()\n", + " iter_epoch.append(epoch)\n", + " history_loss.append(avg_loss.numpy()[0])\n", + " #绘制loss\n", + " plt.plot(iter_epoch,history_loss, label = 'loss')\n", + " plt.legend()\n", + " plt.xlabel('iters')\n", + " plt.ylabel('Loss')\n", + " plt.show()\n", + " #保存模型参数\n", + " paddle.save(model.state_dict(),'model')\n", + "\n", "train()" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 探测异常时序\n", "\n", @@ -487,14 +441,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, + "execution_count": 11, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEKCAYAAAA4t9PUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAHmJJREFUeJzt3Xu4HHWd5/H3x4SEi1zD0WUS4ASIOgEvA0fQHXRUFgjewiiMcXkEHZZ4y6iPi2NcRxYZ3cfMrLDDiBeQmygSBofxzBCNCjisjMacYIQEDB5CeEhkJVzkKpfAd/+oX5Oi7XO6zqlT3dXnfF7PU09X/epX1d+qru5v1+1XigjMzMzG6wXdDsDMzHqbE4mZmZXiRGJmZqU4kZiZWSlOJGZmVooTiZmZleJEYmZmpTiRmJlZKU4kZmZWyvRuB9AJe++9d/T393c7DDOznrJmzZr7IqKvXb0pkUj6+/sZGhrqdhhmZj1F0l1F6vnQlpmZleJEYmZmpTiRmJlZKU4kZmZWihOJmZmV4kRiZmalOJGYmVkpTiRmZlaKE4mZmZXiRGJmZqU4kZiZWSlOJGZmVooTiZmZleJEYmZmpTiRmJlZKZUmEkkLJG2QNCxpaYvxMyUtT+NXSepP5YdLWpu6X0r686LzNDOzzqoskUiaBpwHHAfMB94taX5TtVOBByPiIOAcYFkqXwcMRMSrgAXA1yRNLzhPMzProCr3SA4HhiNiY0Q8BVwBLGyqsxC4NPVfBRwlSRHxeERsS+U7AjGGeZqZWQdVmUhmA3fnhjenspZ1UuJ4CJgFIOkISeuBW4APpPFF5mlmZh1U25PtEbEqIg4GXg18StKOY5le0mJJQ5KGtm7dWk2QZmZWaSLZAuybG56TylrWkTQd2B24P18hIm4DHgUOKTjPxnTnR8RARAz09fWVWAwzMxtNlYlkNTBP0lxJM4BFwGBTnUHglNR/AnBdRESaZjqApP2BlwGbCs7TzMw6aHpVM46IbZKWACuBacBFEbFe0lnAUEQMAhcCl0kaBh4gSwwARwJLJT0NPAt8KCLuA2g1z6qWwczM2lNEtK/V4wYGBmJoaKjbYZiZ9RRJayJioF292p5sNzOz3uBEYmZmpTiRmJlZKU4kZmZWihOJmZmV4kRiZmalOJGYmVkpTiRmZlaKE4mZmZXiRGJmZqU4kZiZWSlOJGZmVooTiZmZleJEYmZmpTiRmJlZKU4kZmZWihOJmZmV4kRiZmalOJGYmVkpTiRmZlaKE4mZmZXiRGJmZqU4kZiZWSlOJGZmVkqliUTSAkkbJA1LWtpi/ExJy9P4VZL6U/nRktZIuiW9vik3zY/TPNem7kVVLoOZmY1uelUzljQNOA84GtgMrJY0GBG35qqdCjwYEQdJWgQsA94F3Ae8LSJ+I+kQYCUwOzfdSRExVFXsZmZWXJV7JIcDwxGxMSKeAq4AFjbVWQhcmvqvAo6SpIj4RUT8JpWvB3aSNLPCWM3MbJyqTCSzgbtzw5t5/l7F8+pExDbgIWBWU513AjdFxJO5sovTYa3PSFKrN5e0WNKQpKGtW7eWWQ4zMxtFrU+2SzqY7HDX+3PFJ0XEy4HXpe49raaNiPMjYiAiBvr6+qoP1sxsiqoykWwB9s0Nz0llLetImg7sDtyfhucAVwMnR8QdjQkiYkt6fQS4nOwQmpmZdUmViWQ1ME/SXEkzgEXAYFOdQeCU1H8CcF1EhKQ9gGuApRFxY6OypOmS9k79OwBvBdZVuAxmZtZGZYkknfNYQnbF1W3AlRGxXtJZkt6eql0IzJI0DHwcaFwivAQ4CDij6TLfmcBKSTcDa8n2aC6oahnMzKw9RUS3Y6jcwMBADA35amEzs7GQtCYiBtrVq/XJdjMzqz8nEjMzK8WJxMzMSnEiMTOzUtomEkm7SHpB6n+JpLenS2/NzMwK7ZHcAOwoaTbwA7I7yS+pMigzM+sdRRKJIuJx4B3AlyPiRODgasMyM7NeUSiRSHotcBLZ3eYA06oLycx6Uf/Sa9pXskmpSCL5GPAp4Op0Z/oBwPXVhmVmZr2i7YOtIuLfgX8HSCfd74uIj1QdmJmZ9YYiV21dLmk3SbuQNZB4q6RPVB+amZn1giKHtuZHxMPA8cD3gLmM8AwQMzObeookkh3SfSPHA4MR8TQw+Vt6NDOzQookkq8Bm4BdgBsk7Q88XGVQtp2vhDGzuitysv1c4Nxc0V2S3lhdSGZm1kuKnGzfXdLZkoZS90WyvRMzM7NCh7YuAh4B/iJ1DwMXVxmUmZn1jraHtoADI+KdueHPSlpbVUBmZtZbiuyR/F7SkY0BSX8K/L66kMzMrJcU2SP5IHCppN0BAQ8A760yKDMz6x1FrtpaC7xS0m5p2Jf+mpnZc0ZMJJI+PkI5ABFxdkUxmZlZDxntHMmubTozs57jm3wn3oh7JBHx2U4GYmZmvanIVVvjJmmBpA2ShiUtbTF+pqTlafwqSf2p/GhJayTdkl7flJvmsFQ+LOlcNY61mZlZV1SWSCRNA84DjgPmA++WNL+p2qnAgxFxEHAOsCyV3we8LSJeDpwCXJab5ivAacC81C2oahnMzKy9KvdIDgeGI2JjRDwFXAEsbKqzELg09V8FHCVJEfGLiPhNKl8P7JT2XvYBdouIn0VEAN8ga5XYzCY5n9uor7aX/0qaCbwT6M/Xj4iz2kw6G7g7N7wZOGKkOhGxTdJDwCyyPZKGdwI3RcSTkman+eTnOXuEuBcDiwH222+/NqGamdl4Fdkj+S7ZnsM24LFcVzlJB5Md7nr/WKeNiPMjYiAiBvr6+iY+ODMzA4rd2T4nIsZzHmILsG9+PqmsVZ3NkqYDuwP3A0iaA1wNnBwRd+Tqz2kzTzMz66AieyT/Ienl45j3amCepLmSZgCLgMGmOoNkJ9MBTgCui4iQtAdwDbA0Im5sVI6Ie4CHJb0mXa11Mtkek5mZdUmRRHIksCZdxntzuvT25nYTRcQ2YAmwErgNuDIi1ks6S9LbU7ULgVmShoGPA41LhJcABwFnSFqbuhelcR8Cvg4MA3eQPUfezMy6pMihrePGO/OIWAGsaCo7I9f/BHBii+k+B3xuhHkOAYeMNyYzM5tYbfdIIuIuYA/gbanbI5WZmZkVetTuR4FvAS9K3Tcl/VXVgZmZWW8ocmjrVOCIiHgMQNIy4KfAP1YZmJmZ9YYiJ9sFPJMbfiaVmZmZFdojuRhYJenqNHw82dVWZmZmhU62nw28j+wRuw8A74uI/1N1YNY9btPIzMZitCck7hYRD0vaC9iUusa4vSLigerDMzOzuhttj+Ty9LoGGMp1jWGz0rz3Y9b7RntC4lvT69zOhWNmZr2myH0k1xYpMzOzqWm0cyQ7AjsDe0vak+2X/O7GCM8AMTOzqWe0PZL3k50PeVl6bXTfBb5UfWhm5fj8i1lnjJhIIuIf0vmR0yPigIiYm7pXRoQTiU1pTlJm2xW5s/3Z9HwQACTtKelDFcZkNqU5SVmvKZJITouI3zUGIuJB4LTqQjIzs15SJJFMS08jBEDSNGBGdSFZp/ifr5lNhCKJ5PvAcklHSToK+HYqs0lutETjJGRmDUUSySeB64EPpu5a4K+rDMrMxs9J3jqtbeu/EfEs8JXU2RThHyMzK6rIne13StrY3HUiOLOpoKqkPRn/DEzGZZoMihzaGgBenbrXAecC36wyKDOzXtKc4KZawivyPJL7c92W9CySt3Qgtp4w1TYYq5a3J+tFRQ5tHZrrBiR9gGJPVjQzswrV5Y9HkYTwxVz/NuBO4C+qCcfMzHrNqHskkl4AfDUi3pi6oyNicURsKDJzSQskbZA0LGlpi/EzJS1P41dJ6k/lsyRdL+lRSV9qmubHaZ5rU/eiwktrtVKXf1M2Nv7crNmoiSRd+vuJ8cw43QF/HnAcMB94t6T5TdVOBR6MiIOAc4BlqfwJ4DPA6SPM/qSIeFXq7h1PfGZmNjGKXLX1I0mnS9pX0l6NrsB0hwPDEbExIp4CrgAWNtVZCFya+q8CjpKkiHgsIn5CllDMrMa8h9JZdVzfRRLJu4APAzew/ZkkRZ7ZPhu4Oze8mT98INZzdSJiG/AQMKvAvC9Oh7U+k28HLE/SYklDkoa2bt1aYJZTWx03TjPrDUUSyR/nnkUyNz2jpPkQVSedFBEvJ7un5XXAe1pViojzI2IgIgb6+vo6GqB1x0QlQydVs7Epkkj+o2BZsy3AvrnhOamsZR1J04HdgftHm2lEbEmvjwCXkx1CM5tUnMysl4z2zPb/RHboaSdJf8Lzn9m+c4F5rwbmSZpLljAWAf+1qc4gcArwU+AE4LqIiFFimg7sERH3SdoBeCvwowKxmJlZRUa7j+RY4L1kexJfZHsieQT4H+1mHBHbJC0BVgLTgIsiYr2ks4ChiBgELgQukzQMPECWbACQtIksac2QdDxwDHAXsDIlkWlkSeSCwkvbAf1Lr2HTFzp343+n38/MrNmIiSQiLgUulfTOiPjOeGYeESuAFU1lZ+T6nwBOHGHa/hFme9h4YjGzcvynxUZS5BzJHEm7KfN1STdJOqbyyKwWfKx+Yng9Tl39S6+Z9J9/kUTylxHxMNmhpVlkV0l9odKozKyW6vSDWKdYproiiaRxbuTNwDciYn2uzEbgjXxy8ec5+fgznThFEskaST8gSyQrJe0KPFttWGbV8Q9Id3i9T15FEsmpwFLg1RHxODADeF+lUdmk4x8Rs8mr0DPbJf0WmJ/u4zAzM3tOkQdbLQNuBP6GrCXgTzByq7xmk4L3oOplKnwevbyMRfYwjgdeGhFPVh2MdUcVG3D+noNe/oKYWXtFzpFsBHaoOhCz8XCSMuu+IonkcWCtpK9JOrfRVR2Y2Uiak0fZZNKtZOQkaJNFkUQyCPwtWYu/a3KdddBk+dGZLMtRVqfXQy+u96oOuXZz+ol637p9nm0TSWpz69tsTyCXpzLrorptSGYTwdt1bypy1dYbgF+TPX/9y8Dtkl5fcVxm/lExy6nz96HIVVtfBI6JiA0Akl5CtofiVnjNzKzQOZIdGkkEICJuZ4pexVXnfwRmE63O23uvnuuYrIokkqHUfPwbUncBMFR1YJNBfmP1hjv1jOUz7/b20e33t4nRrc+xSCL5IHAr8JHU3ZrKrMP8Ze+sqbi+p+IyN0zlZS+rSCKZDvxDRLwjIt4BnEv2mFubIN6ARzfSg4G6vd66/f5TRZXr2Z/hxCiSSK4FdsoN70T2rHQbgTfO7pvqn0G3l7/o+3c7zk6brMtbJJHsGBGPNgZS/87VhWQ2dnX9gk70eZKxLmfz3lzRx752c32Wee+6bgcwuW9CLZJIHpN0aGNA0mHA76sLyWxyqvOP3HjV/Y5r64wiieRjwD9J+r+SfgIsB5ZUG5bl+cu5Xbt14XXVe3r9M/PVmcWaSFkNvIzsSq0PAH8cEW5rq4vGs7EWPaQx1UymdVKXZWnEUZd4rHpFmkjZGfgk8NGIWAf0S3prkZlLWiBpg6RhSUtbjJ8paXkav0pSfyqfJel6SY9K+lLTNIdJuiVNc64kFYnFMnX9ctc1LusM32DY24oc2roYeAp4bRreAnyu3USSppG1z3UcMB94t6T5TdVOBR6MiIOAc4BlqfwJ4DO0fhLjV4DTgHmpW1BgGSZUL220vRTrWEzW5bKJ522lekUSyYER8XfA0wAR8ThQZC/gcGA4IjZGxFPAFcDCpjoLgUZLwlcBR0lSRDwWET8hSyjPkbQPsFtE/CwiAvgG2RMcrYf4iz02Xl8Tw+uxOkUSyVOSdgICQNKBQJHH7s4G7s4Nb05lLetExDbgIWBWm3lubjPPCVfVBugNu156+UR+L15aWuf1aWNTJJH8T+D7wL6SvkV2g+JfVxrVBJC0WNKQpKGtW7d2O5xC/MXqDf6cyvH6m3xGTSTpRPavgHcA7yVrPn4gIn5cYN5bgH1zw3NSWcs6kqYDuwP3t5nnnDbzBCAizo+IgYgY6OvrKxBu7+rkFVkjvU/db3LrlKmwjLadj1ZkRk0k6TzEioi4PyKuiYh/i4j7Cs57NTBP0lxJM4BFZI/tzRsETkn9JwDXpfccKZ57gIclvSYluZOB7xaMp+f02sbUUOe46xybTR0TuR3W4abQIoe2bpL06rHOOJ3zWAKsBG4DroyI9ZLOkvT2VO1CYJakYeDjwHOXCEvaBJwNvFfS5twVXx8Cvg4MA3cA3xtrbL2gLs+Gtqmjjp/9eGMq28xKJ9dFHdf7WBV5QuIRwEmS7gIeI7tiKyLiFe0mjIgVwIqmsjNy/U8AJ44wbf8I5UPAIQXiNjPrmv6l17DpC2+ZdO/VSpE9kmOBA4E3AW8D3ppebZx67R+I/51Nbf5MuqdX1n2RJlLuatV1IjizTuuVL651lreL0RXZI7EJ5A3SzCYbJxIrrJdv2GvWS7E2a5wM7uVl6BSvo85wIrFJr0xrtJMpebbihJSp0zqoUyxFOZGUUMWT3Hrp6XC+GcumgoneHidqfnX6njiRTJA6faidNtqyT+X1YiPr5RvyvE3/IScSs5J69fnmZhPFiaSNsXxR/aW2VvwoVpvsnEgmGTeeaDZx/EeyGCcSmxKm8pe8m9wqwujq0ODiRHAimaJ6dYPtBVWeSJ5I3gZsojiRmJm14ERbnBPJJOYvQud4XY/O62dycyLpAH+JzGyseul3w4mkoF76UHuV1/HovH6srpxIusw/Dma9yd/d7ZxIxsgbj5nZ8zmRTEJOdmbWSU4kVktOhvXiz8NG40RiZmalOJGYmVkpTiRWig95mJkTiZmZlVJpIpG0QNIGScOSlrYYP1PS8jR+laT+3LhPpfINko7NlW+SdIuktZKGqozfzMzam17VjCVNA84DjgY2A6slDUbErblqpwIPRsRBkhYBy4B3SZoPLAIOBv4I+JGkl0TEM2m6N0bEfVXFbmZmxVW5R3I4MBwRGyPiKeAKYGFTnYXApan/KuAoSUrlV0TEkxFxJzCc5mdmZjVTZSKZDdydG96cylrWiYhtwEPArDbTBvADSWskLa4gbjMzG4PKDm1V6MiI2CLpRcAPJf0qIm5orpSSzGKA/fbbr9MxmplNGVXukWwB9s0Nz0llLetImg7sDtw/2rQR0Xi9F7iaEQ55RcT5ETEQEQN9fX2lF8bMzFqrMpGsBuZJmitpBtnJ88GmOoPAKan/BOC6iIhUvihd1TUXmAf8XNIuknYFkLQLcAywrsJlMDOzNio7tBUR2yQtAVYC04CLImK9pLOAoYgYBC4ELpM0DDxAlmxI9a4EbgW2AR+OiGckvRi4Ojsfz3Tg8oj4flXLYGZm7VV6jiQiVgArmsrOyPU/AZw4wrSfBz7fVLYReOXER2pmZuPlO9vNzKwUJxIzMyvFicTMzEpxIjEzs1KcSMzMrBQnEjMzK8WJxMzMSnEiMTOzUpxIzMysFCcSMzMrxYnEzMxKcSIxM7NSnEjMzKwUJxIzMyvFicTMzEpxIjEzs1KcSMzMrBQnEjMzK8WJxMzMSnEiMTOzUpxIzMysFCcSMzMrxYnEzMxKcSIxM7NSKk0kkhZI2iBpWNLSFuNnSlqexq+S1J8b96lUvkHSsUXnaWZmnVVZIpE0DTgPOA6YD7xb0vymaqcCD0bEQcA5wLI07XxgEXAwsAD4sqRpBedpZmYdVOUeyeHAcERsjIingCuAhU11FgKXpv6rgKMkKZVfERFPRsSdwHCaX5F5mplZB1WZSGYDd+eGN6eylnUiYhvwEDBrlGmLzNPMzDpIEVHNjKUTgAUR8d/S8HuAIyJiSa7OulRncxq+AzgCOBP4WUR8M5VfCHwvTTbqPHPzXgwsToMvBTaMc1H2Bu4b57SdUvcY6x4fOMaJUPf4oP4x1i2+/SOir12l6RUGsAXYNzc8J5W1qrNZ0nRgd+D+NtO2mycAEXE+cP54g2+QNBQRA2XnU6W6x1j3+MAxToS6xwf1j7Hu8Y2kykNbq4F5kuZKmkF28nywqc4gcErqPwG4LrJdpEFgUbqqay4wD/h5wXmamVkHVbZHEhHbJC0BVgLTgIsiYr2ks4ChiBgELgQukzQMPECWGEj1rgRuBbYBH46IZwBazbOqZTAzs/aqPLRFRKwAVjSVnZHrfwI4cYRpPw98vsg8K1b68FgH1D3GuscHjnEi1D0+qH+MdY+vpcpOtpuZ2dTgJlLMzKwUJ5IR1KkpFkmbJN0iaa2koVS2l6QfSvp1et0zlUvSuSnumyUdWlFMF0m6N13C3Sgbc0ySTkn1fy3plFbvNYHxnSlpS1qPayW9OTeu403ySNpX0vWSbpW0XtJHU3kt1uMo8dVmPUraUdLPJf0yxfjZVD5XWbNLw8qaYZqRysfcLFOFMV4i6c7cenxVKu/496W0iHDX1JGdyL8DOACYAfwSmN/FeDYBezeV/R2wNPUvBZal/jeT3XMj4DXAqopiej1wKLBuvDEBewEb0+ueqX/PCuM7Ezi9Rd356TOeCcxNn/20qrcDYB/g0NS/K3B7iqUW63GU+GqzHtO6eGHq3wFYldbNlcCiVP5V4IOp/0PAV1P/ImD5aLFXHOMlwAkt6nf8+1K28x5Ja73QFEu+eZlLgeNz5d+IzM+APSTtM9FvHhE3kF1pVyamY4EfRsQDEfEg8EOyttWqim8kXWmSJyLuiYibUv8jwG1kLTXUYj2OEt9IOr4e07p4NA3ukLoA3kTW7BL84TocS7NMVcY4ko5/X8pyImmtbk2xBPADSWuU3bEP8OKIuCf1/z/gxam/m7GPNaZuxLokHS64qHHIqA7xpUMsf0L2b7V267EpPqjRelTWoOta4F6yH9c7gN9F1uxS8/uNtVmmSmKMiMZ6/Hxaj+dImtkcY1Msdftdeo4TSW84MiIOJWv1+MOSXp8fGdl+b60uv6tjTMBXgAOBVwH3AF/sbjgZSS8EvgN8LCIezo+rw3psEV+t1mNEPBMRryJr6eJw4GXdjKeV5hglHQJ8iizWV5MdrvpkF0MsxYmktSLNu3RMRGxJr/cCV5N9WX7bOGSVXu9N1bsZ+1hj6misEfHb9IV+FriA7YcuuhafpB3IfqS/FRH/nIprsx5bxVfH9Zji+h1wPfBassNBjfvk8u/3XCwq3ixTFTEuSIcOIyKeBC6mJutxPJxIWqtNUyySdpG0a6MfOAZYx/OblzkF+G7qHwROTld+vAZ4KHeYpGpjjWklcIykPdPhkWNSWSWazhX9Odl6bMTX8SZ50rH5C4HbIuLs3KharMeR4qvTepTUJ2mP1L8TcDTZuZzryZpdgj9ch2NplqmqGH+V+7MgsnM4+fXY9e/LmHTyzH4vdWRXTtxOdrz1012M4wCyq0l+CaxvxEJ2XPda4NfAj4C9UrnIHv51B3ALMFBRXN8mO6zxNNmx2lPHExPwl2QnNoeB91Uc32Xp/W8m+7Luk6v/6RTfBuC4TmwHwJFkh61uBtam7s11WY+jxFeb9Qi8AvhFimUdcEbue/PztD7+CZiZyndMw8Np/AHtYq8wxuvSelwHfJPtV3Z1/PtStvOd7WZmVooPbZmZWSlOJGZmVooTiZmZleJEYmZmpTiRmJlZKU4kZomyVm1Pb1PneEnzOxXTWEnqV67FY7NOcCIxG5vjyVqKNbPEicSmNEmflnS7pJ8AL82VnyZpdXqGxHck7SzpPwNvB/4+PT/iwFb1WrzHn2n7Myd+IWlXSS+UdK2km5Q9a2Zhqtsv6VfKnlVxu6RvSfovkm5U9gyKw1O9MyVdJumnqfy0Fu87TdLfp/hulvT+VL6PpBtSPOskva6i1WtTRbfviHTnrlsdcBjZncM7A7uR3S18eho3K1fvc8Bfpf5LyD1DYqR6Te/zr8Cfpv4XAtNTt1sq2zu9t4B+YBvwcrI/emuAi9K4hcC/pGnOJGvtYKc0/d3AH6Xp16U6i4G/Sf0zgSGyZ238d7a3kDAN2LXbn4W73u4ajZqZTUWvA66OiMcBJOXbfzpE0ueAPch+/Edq06hIvRuBsyV9C/jniNicGkP8X8pacn6WrDnwRnPxd0bELSmm9cC1ERGSbiFLFA3fjYjfA7+XdD1Zo39rc+OPAV4hqdHm1O5kbUitBi5KMfxLROSnMRszJxKz1i4Bjo+IX0p6L/CG8daLiC9IuoasvakblT3G9TVAH3BYRDwtaRNZO1AAT+YmfzY3/CzP/842t2/UPCyyPaQ/SG4pgb0FuETS2RHxjRGWz6wtnyOxqewG4HhJOylrYfltuXG7Avekf+0n5cofSePa1XuOpAMj4paIWEa2N/Aysr2De1MSeSOw/zjiX6jseeCzyBLY6qbxK4EPptiQ9BJlrUnvD/w2Ii4Avk72SGKzcfMeiU1ZEXGTpOVk5xru5fk/xJ8hexrg1vTaSB5XABdI+ghZM+Qj1cv7WEoWz5K14Py9VO9f0+GqIeBX41iEm8maS98b+NuI+I2yJxk2fJ3sUNhNqanyrWRXnb0B+ISkp4FHgZPH8d5mz3Hrv2Y9SNKZwKMR8b+7HYuZD22ZmVkp3iMxM7NSvEdiZmalOJGYmVkpTiRmZlaKE4mZmZXiRGJmZqU4kZiZWSn/H5w7pmSdwKuzAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -506,51 +458,49 @@ "name": "stdout", "output_type": "stream", "text": [ - "阀值: 0.028311959\n" + "阀值: 0.03150589\n" ] } ], "source": [ - "#计算阀值\r\n", - "\r\n", - "param_dict,_ = paddle.load('model.pdparams') #读取保存的参数\r\n", - "model = AutoEncoder() \r\n", - "model.load_dict(param_dict) #加载参数\r\n", - "model.eval() #预测\r\n", - "total_loss = []\r\n", - "datas = []\r\n", - "#预测所有正常时序\r\n", - "mse_loss = paddle.nn.loss.MSELoss()\r\n", - "#这里设置batch_size为1,单独求得每个数据的loss\r\n", - "data_reader = paddle.io.DataLoader(train_dataset,\r\n", - " places=[paddle.CPUPlace()],\r\n", - " batch_size=1,\r\n", - " shuffle=False,\r\n", - " drop_last=False,\r\n", - " num_workers=0)\r\n", - "for batch_id, data in enumerate(data_reader()):\r\n", - " x = data[0]\r\n", - " y = data[1]\r\n", - " out = model(x)\r\n", - " avg_loss = mse_loss(out,(y[:,:,:-1]))\r\n", - " total_loss.append(avg_loss.numpy()[0])\r\n", - " datas.append(batch_id)\r\n", - "\r\n", - "plt.bar(datas, total_loss)\r\n", - "plt.ylabel(\"reconstruction loss\")\r\n", - "plt.xlabel(\"data samples\")\r\n", - "plt.show()\r\n", - "\r\n", - "# 获取重建loss的阀值.\r\n", - "threshold = np.max(total_loss)\r\n", + "#计算阀值\n", + "\n", + "param_dict = paddle.load('model') #读取保存的参数\n", + "model = AutoEncoder() \n", + "model.load_dict(param_dict) #加载参数\n", + "model.eval() #预测\n", + "total_loss = []\n", + "datas = []\n", + "#预测所有正常时序\n", + "mse_loss = paddle.nn.loss.MSELoss()\n", + "#这里设置batch_size为1,单独求得每个数据的loss\n", + "data_reader = paddle.io.DataLoader(train_dataset,\n", + " places=[paddle.CPUPlace()],\n", + " batch_size=1,\n", + " shuffle=False,\n", + " drop_last=False,\n", + " num_workers=0)\n", + "for batch_id, data in enumerate(data_reader()):\n", + " x = data[0]\n", + " y = data[1]\n", + " out = model(x)\n", + " avg_loss = mse_loss(out,(y[:,:,:-1]))\n", + " total_loss.append(avg_loss.numpy()[0])\n", + " datas.append(batch_id)\n", + "\n", + "plt.bar(datas, total_loss)\n", + "plt.ylabel(\"reconstruction loss\")\n", + "plt.xlabel(\"data samples\")\n", + "plt.show()\n", + "\n", + "# 获取重建loss的阀值.\n", + "threshold = np.max(total_loss)\n", "print(\"阀值:\", threshold)" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## AutoEncoder 对异常数据的重构\n", "\n", @@ -560,13 +510,11 @@ { "cell_type": "code", "execution_count": 13, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -575,50 +523,321 @@ "output_type": "display_data" }, { - "ename": "SystemExit", - "evalue": "", - "output_type": "error", - "traceback": [ - "An exception has occurred, use %tb to see the full traceback.\n", - "\u001b[0;31mSystemExit\u001b[0m\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3273: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", - " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\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" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD8CAYAAACYebj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXeYHNWZr9/TOUwO0igHJIEkkkBEGzAmCYON413sa3sdWe9dh2Wd7bXXgV2Dd21snADbrBPYmIwNGJMzCCGUhbJGMyNNDj2du6vO/eNUp5lRgBlpZlrf+zx6urrqdNXpUfX51RfOd5TWGkEQBEEAcI13BwRBEISJg4iCIAiCkEdEQRAEQcgjoiAIgiDkEVEQBEEQ8ogoCIIgCHlEFARBEIQ8IgqCIAhCHhEFQRAEIY9nvDuwPxoaGvTcuXPHuxuCIAiTildeeaVba934Rj8/YUVh7ty5rFq1ary7IQiCMKlQSjWP5vPiPhIEQRDyiCgIgiAIeUQUBEEQhDwiCoIgCEIeEQVBEAQhj4iCIAiCkEdEQRAEQcgjoiAIgrD7OejcPN69mBCIKAiCIPz1anjquvHuxYRAREEQBCETh3R8vHsxIRBREARByCbNP0FEQRAEgUwSsqnx7sWEQERBEARBLIU8IgqCIBzd2BbYmbEThSe+B/d8amzONQ6IKAiCMPHRGppfMK9jTc5tNFai0Poy7HlxbM41DogoCIIw8WldBf+7wryONTkxyKbg1VvhxRv33zbWDT89Dbq37b9NJg7p6Nj28QgioiAIwsQn0Vv6OpbkRSEJ626HNX/Yf9veXdC9FTo27r9NOgqpwbHt4xFEREEQhIlPJuG8Hoa5BMWWQiZuMpFKjqeg5eXhbfdHOu4ErtNj39cjgIiCIAgTn9xgnBOHMT13UUwhHS9cI9ZjYgOb7oNfXwSDHWAdQvwhHXNeoxDtgm2Pjn2fDyMiCoIgTHxyFsLhtBS0DckByDqi8PIv4XdXQKIf0MZ1lXv6P6Cl4IhCKgKrboHb/g9YmbHv92HCM94dEARBOCiZw2gpFLuLEr2AMtvJiGM9OEHjdKw0/jASWkMmJwpRcz5tGRFxe8e+74cBsRQEQTisaK1Z19oPQEtvHF2UVvqHF5t5cWfPwU+Se3o/LO6jogE+Ezf/tC7szwWN01GwDmIpZJPG4sh9Lhk5cPsJiIiCIAj7JWPZ3LemrWQgf72s3NXLO376HE+v3YLvx4t5+ZmH88f+/d4NXHnzIeT05y2F0bmPEmlr+M5hA7Y2g39uf8oZ2FPRvFDo/VkKxUX1UoPGHQWTara0iIIgCPvl6a1dfO5Pa9i0L/KGz9EVNYPr3l1bmKr6STevBHh9QjMGlsLu7hjHf+thNu0d8l1GGrAziREshRi9A2a7vad/5IsUz09IRQqCIqIgCEI5EHOerGOpEZ6wD5G489n4oDPHILIXgFTWzrfpHDzIoPkGLAXb1vTHC2mhewcSWLamrX+IsIzk2skmyaSddjkXUDpKPG7iBcnkfvpR1L9Nu9sKloI1edJTRRQEQdgvaWfgTmZehyhk0xDvhYE2ePI6okmTeZOMmqdrb7wDgEiykJGzcejT+7Bzvj5LwbY17/z5c5z8nUfIWOY7pDIWF7heIZ3JjnzuYjJx2rr6ANApZ2BPR7EyRkD00LkMOXKZR8DfVm8nmxD3kSAIExmt4a5PwA3LYN0dB23+ekXBsjUDv3s/fH8ebP4LPPlfqEgbAJmYGWRDqU4ABpOFwXlj28CBT/w6s4/+8FIz61oHSq7j71zLr30/oKr9hdLGI1kKRaW0dbLgPtJFcxq2tA+Sypb+XVLxwkxmdybKYL8JomdShyFAfpgYE1FQSt2ilOpUSm3Yz/G3KKUGlFJrnH/fHIvrCoLwOsmmYP0d0LsTXvvLQZunnUGv2NVzIP774S1U73EmayWNZWA5g6rlPDXXZLsBiBaJwpaOg9QKyr4+99HWjsLgPJBwLBInNqCSQ+IBIz3FZxO4chPV8u6jGLYjTlY6weU/eYZ7Vrex4kdP86tndgLQ0d2dP0WVilOJ6W/6aBMF4DfAioO0eUZrfbLz7ztjdF1BEF4PVtFTcdfWgzdPx/i4+0GS6UPziTf3FNwnerAdADs3qDqDcqPuIZnOllgKsdQQl45DTzTFTU/tIJkw500lYiO2G0pxDCTiiIKV3k+pjBEthQRu2+y3nP7bycG8pWClE2QsTU8szc6uGLud793VWxCcReEEHmXENLO/GMQEZExEQWv9NHAYKlUJgjCm5Gbk+iqgZ/tBZ9o2db3AN7x/INw7QgG4R781rIRDMtqX37Yj+8yrYylUYAblgMrQ0dnOoBNTqPB79uue+vumDr730Gv0DxgrI5M4tEJzg8ksftIsUK352EXuKX/YWswjZh8lcdvmb+VKG1GIRfsLLqVMipmqk0QiSdqySWXM4N/bZ4ZB7atgSbjQ10xKYgojcZZSaq1S6iGl1NKRGiilrlJKrVJKrerq6jqCXROEowTHUuivPs4sLNO768DtHR++Tg15Qo91w7PXw63vKdldE92R30717XU+awbVnCsFoK+9mUHHOmis9O9XFHIWhHb6oUYKCu/nc38IfJ9H/V9iMBZ3zmEGZld2iCiMFDTOJvKi4Namb5l4NC8KoWwfj/m+yNy9fzXf1XGvDUSMpaAqm6jNdBYukT763EcHYzUwR2t9EvAT4N6RGmmtb9ZaL9daL29sbDxCXROEowhnULu/vcG8795ywObaERF7qCjsfhaAiKeuZPeUxM78tjVgLIWBfvP0XKkKg3G0aw+DySzf99zEP7geJ5kZOWaRSsY527UhLwquQ8ziiaUynMYmABJRY2Xo/VVa3Y+l4NGlbiUrNZhPLa3NduNXGbzxDk5TrxFImoyqZMyxDiqaINJauISIQila64jWOupsPwh4lVINR+LagiAU4Qxq6+3Z5n3Xawdun/O3Z0pFwdr1tPm4Z1rJ/lmZgiiEM07mTdxYClXE6aEGADuyl8FEmne4n+fN2RdIZke2FM7Y/mNu8/0X09O7AXDtz1KwMmAV4hIN8YIFlMyJgvNdhlkK2RQxAqX7MnG89pA4SiqKckSyChMY16kov/L9D2/t/bP5XskoWeWFYE1p947CQPMBUUo1KaWUs326c91DKHgiCMKY4ojCgA7T62mEnh3DmiQzFru7HRHIi8KQQW3XMwB4rcIAm0hbnM5GelUtAC7M039ImzaVKkGXp8lp3E821kdAZWjKtJHK2Fz70Gt8/s9rSy5TlWgpee+29mMp/PH98MDV+benpgqlM1Lx0rkCrqHfJZtkQIeH7fPq0niLysTyopDDlYlSreL4rBiWbYrhZVzB4aKwv3kNE5CxSkn9I/ACcKxSqlUp9XGl1KeUUrnVq98LbFBKrQVuAK7UoymmIgjCG8MJNKfx0uuqBydDqJhbntvFZTc8g2VrVE4UioOzWuPqMctRhizjLlm/ZiWrH/0Ti1xtrA6/ueR8YWUGxAoSRLwN2Fqh0oO4osblUptpJ5tJsa61n1XNpfkq8SFP8B47aeIZ182F1x4oHNj7aslqaMdYBbHLJEpLTbitUlHQmQQRHSr9I2TieCm1FDzZeCFNNffdMqa/HitBTyxFUCexvSGY86aSdlZ68ojCmJTO1lq//yDHfwr8dCyuJQjCKHAGtRReuqllgTMwF7OjM0YsbZHIWLjsEVwu2RQK80wXto0bZfb976XaNk/kOxveCtHCHIhlru2s8n+KBhXhWc+JxFUAlY7hwQiSG4uGbDvxdBV9sdKBOEaw0HWtcCsNz/8EEn3w8q/huMuMYMW7wWMExLY1c3QbCW81wewAlpOxlBM4zxAXlJVJksRLCh8+l42ys5CM4KL0udVrxXENKVdRY/WCC7x2is5IiqBKob0hWHhxSTtbZjQLgjAhcQbGtPbQpatHtBT2DZhBM57OopxBsCTrxxng+nQFQZKQjOQFoUtXkZx6asn5lqstNCjztJ71VpJQIdyZKP5kITtnWraNZMYiksyStQpB55j257f7qTAbz/3IvLp95nXACehGO0BrYskU81U73VUmyTGXEptz/XjsUlGwMwlS+EjhJUGAjPLmJ94VE9CJvEjmaMSk4PrsBB2RJGGSuPwVEC6ETFPai55EloKIgiCUOcWDbC6mkMbLPrumdDUxh30DZgBLpK28u8RdIgpmX6c2fnO980kArs1cyVXpz1NfW01Gu/PN3arwxG37jCh4M1HCyULa+Wza85PZ8jOQgeJK1/26ovSL9TnB5IE9zskzkOgj0bULv8owUHe82Z0y1kzuu3iHuY9SpLSXFF6S+Elqn7PaWilubPxWacB9ijLtfDpFRyRFgxrAHTIxFd51E+kl7yOJd/+lticgIgqCUMZsaR9k8Tf/NixwnMFDW7bK7IsVnti11uztz1kKFi4nA8djDbcUcqKQ2mzWR7jTOo9X9UKaqoPDs3ly5/dXkXSH8WSjVGS6iLsqSHkqmava6XMqmvbFC6JQHNjto7JwouPfa+ZY2HbBUgAYbCfbYdJsYw0nm3M45awLlkLpAK0zSVL4SGovCfwk8Q2zFJLarJoWypbuDyjTV59O0dPXz3GqBc+sU8zBk67EftdNpPHKIjuCIEwMdvfEyFialj4TE8jmavcoL21ZZ5AdLMQV+uKZ/ESseJGlUCoKjqWAk2W04xH22I10Uw3A1KoA0aJYQDFuf4iMO4TfjlOd7SHibSQWaGKq6iPumAXF5a6Ls436ii2FOWeb+MjgXugvylCKdqC7TfmOzNSTTP+cdFq38118Q0SBbIIUXlLaS0w7opDoK2nS6whSyB65zIZfJ/F1rcWrLNyzzyjs97hI4S0U0psEiCgIQhmTjXZzvfdn+Vz9tFNuoSIcpsN23BxFwea9RWsNJNIWLts8CZeKgtnu0ObzvngHa/UxAIR9bir8HmJ6ZEuh2u4j46kgYMWps3uI+xvRngCBokyfYkvBXeTDz7uPfBVQN99s9+6CgRas3FAW7cDVu4MeXYmvZjqW8uDJxkrO5R8mCikjCngZtH3EbR96iPuon6oRv08Ov05T2+uk0848Lb9fKUUaXyGLaxIgoiAIZUyo4xXe5X4Of5cZsLJOwLOyIpx3/xAtBJtz8QQwgWaPM5B6iwfSITEFgI32XKZXB6gJ+fB7XXn3Ubc2g+mWqrN52FrO3nn/h6y3goAdo4E+0sGpaHeAgCoShaIMpGJRiOMEnRsWFonCTuhvYStznO/SgTvWQYeuI+x3k3GHCdhxkhkrX7bCr4u+SzqOJ9XHoA6yV9fTateTwDtMFPo8hQoLg3q4FRQgxazoejo800uCzAAZ5Rs2v2EiMyYpqYIgTExyg1s2aZ6Wc4XZqivC9KDRKFSR+yiXeQSQyFhUOhO4SlwuTkwhZykAbNRz+fKlx9EXS+P3uIk6A2enrqVBRYhWL+SfOi/hppppaG+YCuIESDNQ2YQe7MdfNJe1r8h95LXT+UfXvdoZbJd9EKpngssD/c3ogRa2WLOZ7dpLaLAdd6KHbl3FXL+XrDdMRSpJTyydF7gSUdhwJ55snAetM9ig52Gj+K3vOlzJUvfRoL+JXOmmCCEqKQ1Wh0jRlG2jPbyAqUP+D7LKm3ddTQbEUhCEcsYpV20nTbA1ZylUV1aQxUM2UFfiPipeqjKetvA4T9c+PdxS6HFiCABt/mO44uQZfORN8/B7CpZCh2NNNE6bw+UnTuPUObVofyWVKoFXWXiqp4M3QICCyyjnPkpnbXxFbqW1+hiunnEbnPYJcLmd+kJ7YbCdfbqOTl1DZmAfvmQ33VQT9rtx+SoIk6S5pRWPdiwF0mBbZsGhlb+kv3IBK/VxxAkUso+GkAgVynkMDp3oBvhVhgo7QtpXPexY1uUblso6kRFREIQyRuXWAnCWicyVW6itMv75ZGg6dG7Kt9/Xn6QqYBwI8bSFx7EUSp6uHUshVFFwH3mrmvLbRhQcF0vVdACmz5rPTz9wCg0VfvAXsoj8tTPAEyyJKeQCzYm0ZQZwh6T2sU8XFeCrbIKODSg7Q4eupZNaUr1tBFI9dOtqwn4P3lAlK9wvc8bdZ9JkF03Uy8Rhy0PQvo4NMz8AqPyhBIW5EVlthkgVLriPIgwXBYB6Ili+4bGHrPLlXVeTAREFQShj3GmnGJyTq2+lk1ha0Vhtav3sm3YBtLwEfc3m/UCCBVOMYCTSWbzO03WguGKoYylUVxWygaZWFwLLHrcrX57CDhtniqdmRv648hcGznDDTJQviF8VWwpptrQPcv2jW/GToVlNZ7s9nWY9pXQFuMom6DCC1q7raNMNZNo34dUpunUVfo8LT9Bcy62zNOgil1A6Do9/F+oXsK7xspK/WXE67aAjAOFQmIjjEsuVxEgMsShcSmP7h4uC7faXiILWmtfaI0zUSj8iCoJQxrgzzjKXTrloK5MijZfGCvM0vG3q28zx9abK597+JLPrQnhcinjawpcTBVKFQcwpKFdXXcWH01/m0tT3OHlWaQG4hDID566as+CYt8KUxYU+BQuWQmXjTFzegqXgUsZ9dPfqVn7z/G4CpNntW8iF6f+hX1XlF7MxH54GzloHnbqGPXoKdcp83x5djVIK5R8y4S3HvrXGQjrr08QzquRQqy6yChwBCAaDRB2BiCkjqLmU3GJUYLj7yHL58264WCrLJT96mhU/eoZntnUPazsREFEQhDLGl3VKPDiiYGeSpPEwpcqIQqd7Ci2hxex66S9YtqYjkmRaTZCgz23cR46vP0Qq/5Sem51bU13J0/ZJbNZzOPuY+pLrdrinMqBD9FQvgQ/dU+Iyyj292yj8NdNx+QqiMLUqQH88TSSeJEgSv8rg9pon9LqQj1Rxie3KgsuqXdexx56Sf3/cgmOcP0DRhDdgIBcP2O6sGDfvXBJDFvgpPk/OUvD4AsQcoUu5jdD0uEq/M4AaUh0VQLt9+XjGA+v3sdVZj7p45vZEQkRBEMqYnCjkJnDZ2TRpvMa3D0STWXZkGvHEO+mOpsjamjnhLCd59hBPZ/E5ohBUaVJpU4Yitwh9ZbjwFL5sdulg+JDnAs5J/Qifb/h8BV/YPE33q2pwe3H7ggRVmloiLK1M0BfPsKzjTp72X02QNN6AGYwbKvyl7iMnXgHQhbEUcnxyxem5i5Vcu08bkdDbH4VwI9uzU+gdUoSvueg8OavA6w+ScJntjNd874hn+JIw7hFEwXb78264J14rzB63xX0kCMKY8eqt0Lb6oM0CTq2eXO0i7UzUqgp48XtcRFNZ2u0qau0+tneaJ9jlHXfy6+zXiMUT+IuyglJOBlMybs5ZLAp+T6HWEYDX6yNCBX7v8CHGFzIDZ7/bPGm7/WbQv877S74au5a+WJq6+C4a1QDVxJjVWMt333k8y2bXMJjM8v9ufYXX2iN5SyHurSODh0zVnMJFKpyBPVW6pnNEGVFQvTt4zXc8F17/NPe82kbQW+h/sy4klSYdq8DrC5J0me1B/1SS2kt7aCFQWrTPUzHcpaTdfjw6QzqV4umtXXmrSkRBEISx46Evw0s3HbRZwCnL4HEWw9HZNGntIehzUxnwEElm2ZupokIleeE1E2yus3vxk8aOdeEnQxYzYKYdMUglE9haUVUR5tZPnMHf/vWcYdf1e8zQEhgiFgABx1KI+Yzv3uMz7qHZqpPGbDtZW+NLmnkLLqXxB8N86Mw5BLxuBhIZHlzfzjt/9pyJKQADnnoq/B4qG2aSwgn+hpyn+MF9JdeOugqB4Fs7CyJSFy4EjbsoPO1nPDlLIUDKYwTF5QuzPPULttadD0CvKrT3jSAKePxUE8X+3kxmZXZx4WIjOvbIK5COOyIKgjDZyCQhPVgyE3l/hPKi4Cx8b5lAs9/jojropSeaotUpjLdp63YAKmyTxuqOdeEjQ9RlBsN0chDW3o412E4KL7VhP29a0MBxTcMzbnIWQsA7gihUGFFIBc3TvMexFOrVAOFsH6AJZQqZQh7HBVVsdSQzNgMe88Td626gOujle+85EVU3FwI14HEG+YZFANjaBJO7vMa6eMI6ibPeezXvWmayoopFweMqXEd7jGD5/EGyjtuo3p0kSoigk5I74CqIgr+idM1qAOUxlkSANL+ZcjtvPbbR6ZNYCoIgjAVxJ2tlhLUQhlKBEQVfbg0BK01WeVFKUV/hZ2d3LP9kHOlqJeh1482YNFZfspuAyhB3O2md+16Fe65iys57jCiEvPu9rs+dE4XhQ0y4upaMdmNXzQTAlQskM4hbZ6kiRh0D+fY599JQF9XbblqP5Q7SRT01IS+z6kL4piyCqkL6Kxd/F/2Jx9mkjVXQ55vO0uSv+WjmyxwzrZ6FUwsuMK9b4XYpaosEwuU1A7o/EKS50lRdtWvn4fO4mDXVWCNRT0EIgpXDLQWX25n34QrTNPAqod715jwiCoIgjAkxZx2CIa6RoehsmqCT1eO3C5aCpcxg3lDho7knRpcz63iK6ue0eXUop0JoZdpM9kp6zJO9r93EMNx2mhReakLDZ/7myA3gQwdyAH8gTNsVf+b4d33B7PAaSyC37kKDitCgCqIQDoWdcxWGq2veeTz9iQy/n/0d/ux/FzU5gVpxLbz314WLeYOomacSwZzD7QvkJ9Y1VQdYNMVYQW39CYJed76g3y3ZFXTqmrwoBIJBtjVewvmpH5Cc+1Ze/tqFXHjSXDp0DXuDJraQ1m7C4dJsJ4CKXrNM6K5Z7zZdiphS3/bE1AQRBUGYbPR3O2KQHMjPGRiJVKxQ1M3vTD5zWWmyLjOA1of9ZCydL2x3ekOWn7x/Wb5s9BTbZMpkAuZJOLTvxcK5tbcwEI9AwX008hAz95QLCVU5KZ2e0gJz01UPVarwvZRjSRSLwgdOn83iaVU8mDyB11IN1AQdgaqZVTInIkciZ+14C9eqCnhYNNUM4r2xNEFHEMJ+N9/JfpjTUz/H68/NUwhRGfCyS0/D53FRHfIS9Hk5J/VjXmp8HwARwoQDw/8mHUs/wQ57GlMu+Kz5urG9gFgKgiCMAVprfnDPc4UdB3AhJSImWJvFRZAk6ayNy05ju8wAWl9hXvuoQCs3HzkpSHXQmxeF6cp8Pj11GRntprpvY/7cGeXD697/8JEPNI8QUxiGtzRt9VjVUnrcWXu5+Fwul+KYxgpe2xehuTfO3IaRS0/kSHmNtePxF0RBKcXMWvPe61bGUvB7CPsKdUKPn238/+FQiEqn/EfO+gl43SiPn5pqI6qDhEb8m1xw6buZ8Y2NNM5aCJ4g7kFHFCaoqSCiIAiTiGgqiz9dVK7hAKKQsxT6VS0hkvn1Eay8KBjXiMaFFWo0i+3YlrFAgBnKxC68lVNYp44rOXfW5edAFNxHhzDEDLEUhomCIxq5c1X4zeC8YEoFkWQWy9acMnuErJ8iLH91ybV8zrlcLsVNHzqVBz57DgFHFHLnB6hc8CaYfz74q/L7c/1wuxR3/fPZfOy8RWS0m5gaefa0UsoImlJQNR131Fh6E1QTRBQEYTLRF8vQoCL599t3bhuxXXz7MzT9aQUAA95GQqSIpbO47TTaEYWGooAqFVNMtdRkwZefEwWX189rFYWFY8BMyDoQvlFYCks8raXHPbnsI3Ou3OB8zJTCxLShZTaGogPmeNQy56gv+u6XLG1i0dRKplQFmFYdyFtQAO5jzoUP3wsud95S8BUJ3fEzqqkP+0jgy09uOyDVMwqWgriPBEEYLX3xNHVESCozUK7esHnEdquefSS/Hfc3ElAZam9/BzOsVrTbiSlUFAZ2V/UM6NwM0cKM2xmO+8jlC7Bv6luwtMoviXkwUSi4j16/pbCQltJreEothbDfDOwLGk08YE59qOS7jMQZS0zZixPnmjTY4hTUHD/+h5O59t0ncuXps0c8R8FSKBU6j9tlSm67hweZh1E1E9dgGwDWBDUVRBQEYRLRG09TryK0u2eQwks43TViOx+mJMX/ZN5HT61Zqzi4byVgZthCIaZQ6ffgOvUfIdIKz98AQDxUKCHh9gYIzTqBs1I/5WFrudnpGXm5zRwHyj4axhBLIVcu26pbUHKtoe6jGbVBAl4Xyw5iJQBMnWomuuUmyo0kCrVhH9Uh735dUfMbKwh63cyqG77y2gO8mVfDZx+0H1RNR0U7cGMxQQ0FWXlNECYTfbE081WEHqpw6xrC6aJKm5F9ZiH7GafiteKktZufWu/i1tDG0pO4c+4jIw5VQS8sOh9mnQlrbgXA37QYdu51mgeYVxU2VUFDdZAG5T2IKDgWwkhlLoZRLDDKBdompv34q2ZA18a8aChlJqBVOG4ct0vxyw8vZ279Ibht5p0LZ/wzx51yDpfueo2vXjo8Q6mYV/79wpKlScHEMDZ/d8WI7W9w/yPLag4c1wCgegZKWzTSL+4jQRBGT188Qz0R2q1K+nQFQauots+zP4TbrgTAlY0TJ8B3r1jKghlTSk/iyYmBB49LmdRSpeCkK/NN3DNPzW8rj5+l06txuxQL58wy5/cOf1ou5nVlHxWLQrU5/w3We3GHa0qOx1PG+inODjpnYSOz6g6ceQRAsAYuvZZAMMwvPngqs+sP/Jn6Cj/HzxheBnt/+D0mSH1QnAl701UP1gQVBbEUBGES0RdLU6ci7MuEqVYhqopFIdFnJrZZWdyZKHECfOisubC5tMRzruyCmdXsM2moAMecX2i05B3w9PcBaKytIlAf4pV/v5CqTZ2wDabUHXjAnN9YwYyaIKFDCjQXCcwVP+PhTZ2sa5uBCtxt9jmiMMNJHz3v2MahZxh3PnXefOY37mfthmJC5v+iWsXK232klLoFuBzo1FofP8JxBfwYeBtm+euPaK0PXuJREIQSBqIxwipFv64gosI02XsLB9NxQEOyH3c2TsIJRg8N5PpUoRLbslm1zMk9NdfOLTRqLLhXAk7p6pqQD0LGRVJXdeCg6jtOms47Tpp+wDZ53F5QbrNgTtPxXDKvlksAnnjC6b/5HifOrOHZL5/PjJoDWynjwUfeNO/QGjqlvMMky36ewm+AkZ1thkuBhc6/q4BfjNF1BeGoIhU1cxQihIjoEJVECyuipZ1V1uI9eLJxkipYut+hJlvIMLrxQ6fy1bcV+dfnv8W8uj2msBytYoF0AAAgAElEQVSYATtH0PGbew6c7fO6yVkLxYviTF8G9QuhaDWzmbWhfGxhUuKIQkglJ6z7aExEQWv9NNB7gCZXAL/ThheBGqXUtLG4tiAcTeQmpA3qEBHCVBEnnnZWDnNWVyPeg8eKk8qJwqJLYPnH6b7sVwA0ZDuGnrbAB+6AL+822++6yQzS1TMLx3OicJCYwuvGEzAWjbvIeXHsCvjMqkLF03IgJwqkJuzktSMVU5gBFE9TbHX2lVT0UkpdhbEkmD175FxhQTiasXKiQIgBHSao0nTEYoT91ZA2FVGJ9+CzEqRcTvVObxAu/yEN6Rj6menUvO2b+7+Ax1cYhI9dAV8bMpEsZz0cDktBHQV5Lz4Td6hQyYKFN8GYUP8LWuubtdbLtdbLGxsnXjBJEMYb7cw4jugQEWf94MSgU/aiWBTsOCnXkAwbXxj1b5thwYVvvAPhRmMt1Mw5eNvXgycA/kMI1E52PD5weQmr1IRNST1SlkIbMKvo/UxnnyAIh4jWGlIR8BhLIaJzotALzB0iCkkyY+3iATNn4OpNB5289obOezRYCgC+MOFsioGjfOW1+4EPK8OZwIDW+sDF4AVBKCGZsQlpM/APEsqvEZCJOuG8fEyhl4BOkHEfQv7+G8EXAtcYDx2+ypKAclnjCxNm4rqPxiol9Y/AW4AGpVQr8B+AF0BrfSPwICYddTsmJfWjY3FdQTiasLSmCjPwF7uP0rE+s+BvThRiXfh1kqznMInC4eCSa0qznMoZX5iwSpa3+0hr/f6DHNfAv4zFtQThaMXWmkplBv4oQTI+82RtxfoLggAw0IYLjTWZRGHGqQdvUy74woRJYR3l7iNBEEaJtqGKOGl3GBsXoSqTHmon+wvxBID+PQCTSxSOJnwVhCawpSCiIAiTBFtrKomT9laa9VpqzMLxJPoLE9SUCwaMKNjeQygUJxx5fGFCEzimIKIgCJMES2uqVJyMp4IKv4eqyirS2o1KRfLuI6uyUFpCiyhMTBxRKOsZzYIgHH6KLYV/vXAR71s+i6gK404N5N1HL0abCh/wiShMSHxhghN4RrOIgiBMErSGShUn66nk42+exxnz64mpMJ7MYF4UnkktKHxARGFi4qsQ95EgCKPHdlJSM97CzN+YqxJfJpIXhVX2ovwxdTTMEJ6M+MIESWJN0PQjEQVBmCTYOUvBW5Xfl/BUE8gMkE6aQHMnhdW/XCIKExNvCDc2Ljs93j0ZEREFQZgk2JZNJYkSS8Hy1xCy+unrM/WPErpQqE5EYYLiFMXzWvGDNBwfRBQEYbKQTeJVFllPYbDXoXoq7UH6B0z11LgK8LfApQC4g1UjnkYYZ5xYjzcroiAIwiiwLbNGMW5vfp87XE+FStLb1Q7AwumN/FvsQyxL3ojXP/FWKBMoiIKdGOeOjIyIgiBMEmzbWUynqJqov8qUmE/37iGBnxNn1xHPQB9VBLzy856QOO4jn7iPBEEYDdp2LIUiUQjVGFEIJfaSdgWY11BIQw14jpICc5ONnKUgoiAIwmjILfTuKipbXVU3FYAZqhvtCTG3SBT8YilMTBxR8FniPhIEYRRonXMfFSyA6nojCtNVL3ZFE/OLRUEshYmJs0CRW0tKqiAIo8DOTXYqch95Khry296mxcyoCeJxKQACXhGFCYmzBrZb5ikIgjAadC7QXLzqWbAuv1kxcyket4vZ9aZktt8jP+8JidvMJXHrzDh3ZGTkrhGEyYJtLAVVvEKZN0DGZVJPVeNxAMyrNy4ksRQmKB5HFMRSEARhNFiOpaCGrI/srTQZSDSauke5DCQJNE9Q3BPbfTQmy3EKgnD40SPMUwAgVAvxHqiaCcDlJ01nMJml0i8/7wlJThR0dpw7MjJy1wjCZEGPbClQMxu8oXys4eRZNZw8q+ZI9044VJwZ6Z4Jmn0koiAIkwQ7H1MY8rN9+w2QsyKEiY9SpPHimaCBZhEFQZgkaEcUcFJO84TqhjcWJjRZ5cVtT0xRkEiUIEwScjGFkuwjYVKSUd4J6z4SURCEyULeUpCf7WQnqyau+0juLkGYJGjtxBRcYilMdizlnbDZRyIKgjBJsJ0qqUqpg7QUJjoZ5cVbzu4jpdQKpdQWpdR2pdRXRjj+EaVUl1JqjfPvE2NxXUE4msgFmsVSmPxYE9h9NOrsI2WiXj8DLgJagZeVUvdrrTcNaXq71vrTo72eIByt6Pw8BRGFyU5W+fCUcfbR6cB2rfVOrXUa+BNwxRicVxCEIrSznoJkH01+ssqLd4JaCmMhCjOAlqL3rc6+obxHKbVOKXWnUmrWGFxXEI4ucjEFyT6a9GSVFzdHd6D5L8BcrfWJwCPAb0dqpJS6Sim1Sim1qqur6wh1TRAmB3lLQdxHkx7LVd6WQhtQ/OQ/09mXR2vdo7VOOW9/BZw60om01jdrrZdrrZc3NjaOQdcEoYzYX+0jYdJhKR9eylcUXgYWKqXmKaV8wJXA/cUNlFLTit6+A9g8BtcVhKMKez+ls4XJx0S2FEadfaS1ziqlPg08DLiBW7TWG5VS3wFWaa3vBz6rlHoHkAV6gY+M9rqCcLSRn7w2tHS2MOmwlHfCWgpjUhBPa/0g8OCQfd8s2v4q8NWxuJYgHLXIjOayIevy4ZEZzYIgjIZcQTyXiMKkZyJbCiIKgjBZGGmNZmFSYru8+EQUBEEYDbmYAm752U52LJcP71E+T0EQhNHiWAriPpr82C4fbmywJp4wiCgIwmRB5imUDbbLZzas1IEbjgNydwnCJKEwT0EshcmO5fI6GxOvfLaIgiBMFnSuzIX8bCc7Vs5SyIooCILwRnHcRy7JPpr06LylIO4jQRDeKDJPoWywxVIQBGG0aMd9JKIw+bEk0CwIwqhx3EcyT2Hyo905URBLQRCEN4rMUygbxH0kCMLo0TlRkJ/tZEeL+0gQhNGipUpq2aDdJvtIZ0UUBEF4o2jJPioXbLffvIooCILwhrHFfVQu5OYpaIkpCILwhsnHFMZkbSxhHMlZCuI+EgThjZOPKcjPdrKTS0nVmeQ492Q4cncJwmRBqqSWDZYnBIBOx8e5J8ORu0sQJgvOjGak9tGkx/KEzUZqcHw7MgIiCoIwScivvKbkZzvZUW4vCe0TURAE4Y2jnIJ4IgqTH5eCKEERBUEQRoNYCuWC26UY1CIKgiCMBmeeAjJ5bdKjlDKWQjoy3l0ZhoiCIEwW8oFm+dlOdlxKEdVBVCo63l0ZhtxdgjBJULnS2UqNb0eEUeN2QYwgKi2iIAjCG0XbZOUnWxYopRgkiEqXaUxBKbVCKbVFKbVdKfWVEY77lVK3O8dfUkrNHYvrCsJRhbbRIgplQcF9VIaioJRyAz8DLgWWAO9XSi0Z0uzjQJ/WegFwPXDdaK8rCEcd2sJGXEflQC4l1VWm7qPTge1a651a6zTwJ+CKIW2uAH7rbN8JXKCUOEYF4fWgtI0WUSgL3C7HUrDTMMGK4o2FKMwAWoretzr7Rmyjtc4CA0D9GFxbEI4etMYS91FZYFJSA+bNBMtAmlB3mFLqKqXUKqXUqq6urvHujiBMLCSmUDa4FER10LxJTay5CmNxh7UBs4rez3T2jdhGKeUBqoGeoSfSWt+stV6utV7e2Ng4Bl0ThPJBYUtMoUxw5yavwYSb1TwWovAysFApNU8p5QOuBO4f0uZ+4B+d7fcCj2udm4kjCMKhoLSNLZZCWWBSUk357IkmCqNewklrnVVKfRp4GHADt2itNyqlvgOs0lrfD/wa+L1SajvQixEOQRBeD+I+KhtK3UdlJgoAWusHgQeH7Ptm0XYSeN9YXEsQjlq0jZakvbLA7Spv95EgCEcAcR+VD2bympN9NMFmNcsdJgiTBBNolp9sOaAUhZhCom98OzMEucMEYbIgk9fKBrdLkcRP1l8LA63j3Z0SRBQEYZKgJKZQNric/8dUxUzo3zPOvSlFREEQJgkmpiAL7JQDOW1PiigIgvDGEfdRueB2VCEZnmFEYQJN2xJREIRJgkvbaFl1rSxwuRxRCM2EbBKinePcowJyhwnCZEFSUssGRxNIhJ3aof3N49eZIcgdJgiTBIUW91GZkAs0x/OiMHHiCiIKgjBZEPdR2ZAXhdB0s6Nv9/h1ZghyhwnCJMEltY/KhpwoZF0hCFRDtGOce1SgPO8w2wYrO969EIQxxsYWS6EscDn/jbbWEG6E2MRZP6b87rC+3fDDxbDp3vHuiSCMKUpLTKFcyFkKBVHoHuceFSg/UaiebV5FFIQyw4UFYimUBQVRAMINYikcVlwuWPx22PYopGPj3RtBGDOkSmr54Bb30RFmyRWQTZDa/PB490QQxhAt2UdlgnIsBct2RCHem4+Ddg2myFj2uPWtLO+wWNPp9OkKdr9w93h3RRDGDJdUSS0bcu4jrTGigIZELwBfuWsdV/z0ufHr27hd+TCysyfJM/YJTO9+zmQiCUIZoLAlplAmuIsCza3psNkZ60Jrzast/SydXjVufSvLO2x71yBPWSdRme3lwcce5eXdvePdJUEYNUprqZJaJuSqpGYsm6893G7exLrY3ROnN5bmlDm149a3shSFHZ0xnrZPAGDbc3fxx5UTZwq5ILxRjKUg7qNyIFcQb29/krZshdkZ62Z1s1mF7ZTZIgpjyvbOKF3UstF1LJfYz5FIyUQ2YfLjQmY0lws591FzT4we7biKYt282tJHpd/DwikV49a3srzDdnRFAfhj6myOc7XQENs6zj0ShNGjpPZR2VAX9uF1K17a1csAYbK40LEuXtjRw8mza/KWxHhQdndY1rLZ3RNDKfiLdRZp7Wb54OPj3S1BGDVKUlLLBp/HxbyGMPsGkmhc9Ogqejpa2NEV4+KlTePat7K7w7qjaRor/BzXVMUAFbTpBmoyE6fYlCC8UVyIpVBOLJxamd9u13W0t+zCpeDS40UUxpSm6gDPf/UCPnnOPAAGCeG3ZGazMPlR2gaZp1A2HOuIgs/tokPX4ont46xj6mmo8I9rv8pOFHLUhX0ARHWQoC2iIEx+FDZaSUpqubBoqgkmnzyrhnZdR5Pq5YNnzBnnXpWxKNSHjdoOEiKo4+PcG0EYPRJTKC8WOZbCybONKNSoGBcvGr9JazlGdYcppeqUUo8opbY5ryMm1yqlLKXUGuff/aO55qFSV+FYCgQJiygIZYALcR+VE3Pqw1xx8nQuWTqV5ScuBcAdbR/nXo3eUvgK8JjWeiHwmPN+JBJa65Odf+8Y5TUPiXrHfRTRISqIm8JTgjCJcWkt7qMywu1S/PjKZZw6p463nnaS2RnZO76dYvSicAXwW2f7t8A7R3m+MSPgdTOtOoDlraCCBPFUZry7JAijQmY0lzFVM8xrGYjCVK31Pme7HZi6n3YBpdQqpdSLSqkjJhwPfe4cTlowC7fSJGODR+qygnBYkJTUMqZymnkdHH9R8BysgVLqUWCkxNmvF7/RWmul1P58NHO01m1KqfnA40qp9VrrHSNc6yrgKoDZs2cftPMHoybkwx2oBiAZ7YeG+lGfUxDGCxNoFvdRWeKvAH/VhLAUDioKWusL93dMKdWhlJqmtd6nlJoGdO7nHG3O606l1JPAMmCYKGitbwZuBli+fPmYBAFcQRPNT8X6x+J0gjBuuMR9VN40LIRdz5hy/67xswhHe+X7gX90tv8RuG9oA6VUrVLK72w3AG8CNo3yuodMThQyCREFYXKj0JRxFrlw+lXQtRm2/X1cuzHaO+xa4CKl1DbgQuc9SqnlSqlfOW0WA6uUUmuBJ4BrtdZHTBQ8oRoAsvGBI3VJQTgsuKUgXnlz/Hugaia8/KuDtz2MHNR9dCC01j3ABSPsXwV8wtl+HjhhNNcZDd6QiSlYich4dUEQxgRZea3McXth4UWw/k6wLXCNT/yo7O8wX9hYClpEQZjkuNAiCuXO7LMgPQidR8yZMoyyv8P8YWMp2EkRBWGCs+EuuOef93tYUlKPAmafYV73vDhuXSj7OyzoWAoqJaIgTGAyCbjzY7D2NkiPXMDRWAqSklrW1MyBiiYRhcNJMOAjqgO40oc2eS1j2TyyqYNU1jrMPZug2BZs/btJixOOHMXBxd6dIzaRmMJRgFIw5yxI9I1bF8r+DvN5XEQJ4UoPcu+rbfxp5R4ALFsTHbJ2cyyV5e0/eZZP/m4Vd69uG4/ujg+RfbDuz2Z769/gtvfB6t/A3jUiDkeCbY/CI/8BFU5BgP2IgrEUZJ5C2fOeX8OH7h63y5e9KABEVAWugWa+cMdabnra/OB++/xuzvv+EyUWwf1r2tjV3gPA7u5JtgZDMgKb7n/9g7htw12fgLs/CXtfhT0vmP1/vRpuPg/W3zH2fRVKeepaqJsHVz1l3vcMm9eJ1tqZvHZU/GSPbsYp6yh/+XG9+hHiUfc5HJ9ex2lsoC8SQWvNxrY+BmMxNu9z3Eq9u7j04fPYFPgYX656hJa+Qyi3nRyAlpWHt/OHgpWFP3/I/Hvu+kP/3Is3wnVzoflZ837VLeb7hBsLbdrXwbPXw4NfhM7NY9rtI8qrf4DBCbgsazICbathyTuhahqEp4xoKWhtLAUpcyEcbo4KUfiL/3L6dAV/9P0nt/BtoqksS9ru4Bn/51jT3M2+gQR/vvM2auw+OqpP4p/T/0tjx7MHP/HKX8ItK8bV/wfAmj/AzidhyhJ4/Bp48rpDsxh2PmGeSt70r7Dsg/DqrdDyEpx0JXylBaYshV1PwaPfgpU3wws/O9zf5PAw0Ab3/cuRmxSU6IN7/wX+920w0kz6NbdB+3qz3fw8aAvmnWve180fURRssRSEI8RRcYddePIxPHvKD2mbsYJTXNvpbd5IU3QzU1U/azZv5UO/XkmqdR1JFST4sb+QdIU5IfL0wU/ct9v8oDvGL6cYgF1PQ+V0+PgjsOQKePK/YPujB/9c7y6YczZc9G1487+Z7wIw83QIVEHjosLg5fLu19c94enZZl47Nh6Z6738ayPUzc9B26rSY1YW7v1nuPHN5v2up8Hth1lOKmL9MSOLgq1xK40ax5o4wtHBUXGHff7iY3n7Ff/AvjO/haUVev0d1GWNK2HPzi3s6Y1zxbReAjNOoLa6kn11y1lurx8WiGbnU7D9scL7QadqeMeGI/RN9sOeF01+s78Crvi5SVtseckc0xp++w4zS7IY2zaiVjvXvK8/Bj76EMx/S+GpteFY8+r2wdJ3Qc/2se33+jvh4a+bv6l9iNleT14Hq3/3+q7TnROFI/T/1LISgs4ihN1D/mb9zYXt3c+aFNR554I3YPbVH2PuqyHzamxtLD+ZpyAcbo6qO6yuaRYv2kuo3PEAM+kCYKarmxv+4WSq+rdA0/EAxKe/ibmuDtqbt/Ct+zfyyCZHQO76Ou13fD5/vnRfKwA69zS9H3706FYe3dTB3v4E7QPJkmORZIYntwwpLmtljMvmYGV0Yz2w7g6ItMGsM80+XwimLoW2V8z7VAR2PUV2+xOlnx3cC1bKuCtyzDkbPnwfBM3cDhoXmdemE0jWHQvRjmGD1f5o6R0ekxlIZMhYNmy8F/7wHrjr4/Diz+EP7zZuOH2QwrjJiLGC7v8MvPLbA7ctJidm/c2QGjk1eSCRYVvH8GOJ9P7Fam1LPxv3DqmpZdtGkI+7DPzV0LMNrTW/f2E3A4mMsc5y/O6dkE3BimsL+6aYZRmHxm/snGhKTEE4zBxVojC1KsCL9mLqE7uYpkyW0TVv9rGi/4+QGoCpRhQ8C88HYHDzY/zm+d38dZ0ZnL3xDmpTrfmnWqvfpK2m2tYVLhLZBzedB/vMPtvW/PzJHfz4sW18+JaVfPHOteYHv/NJAH7496185H9fpnOwSCx2PmWCuxvvGfmLND9v0hgfuBru/gQAm7xL+PhvXiaWypJqWkai+WUeWteGNWD63tI8JKMlNzjVzQOgfSDJI5s60Frz0s4eVu7qxa43opCZdgrfeCbhfG7/LqR4OsumvRHWtfZzzvef4JXm3vyxPT1x3v+dm/nZX1/AeuAL2HvXwjmfh6+2wtmfhdaVJHr28PSG4efvGYhiP/l9EyzOse72/fajmKxlFywFIP6TN9H11M3596v39PH4ax184Y61XHT90wzECyv0be+McsK3HmZty8gVdq++fQ3fuLfI+ti31gT7k/2sso9FNyyA7m1s7Yjyjfs2cu+rbdDr/D+c+0U48R/gytugYUHhHFMdUchZNQOt8KuL0H3GwlBiKQiHmVEVxJtshP0ednjMD9CjjDle9covIOsMeNNOBmDq/JOI6gADu1bzUfdWEh3LSGVOoNbuw68yDHbuorK2iaA1SEp7cHdt5q+3XMP5H/gSW+/4T5btW0Ny898JTDuR9kiSdNZmfZt5ouyLpdl3z3VUt7/I7899gvtebaGOCJv3DTKl0nEh5ErnDnXXPPJNdMtKaHkJ5fKAtqHhWFL+Wt5+Rz8Wg7y6p5/d+6bwQSvKf//xQezTg1wGeGL7Ss/VlxOF+bzS3Md7fvE8AN+9YinfuM/43i9b2sANx17GU77zWZtoAT+kO7bim37ysL/t1o5BLr7exGE+e8FCANa0DHDqnDrWtw7whdtf4Q7fNXStacCtu/hNwxf4yAXfMGtnH3sZ7udvYO8dX2J5+xO01b/KjGlmecLOSJJnf/B+3u0y587iZlv9+SzuXjesD3/bsI/P/WkN1UEvt3zkNGrDPq667hbuqFpPaObp0LqSULSZ0BNfJFU3Ff8JV3Dtg6/R1p/Il6//y7q9fPDMOQCsa+0na2tW7+mjO5rizPn1hP2efL92dscI+9xorVFKwVPfh9f+CsCXVwa4Y+kc6jpfyltNu3ti4NkJvgo4/+v5OQdrW/oZTGbpiaW4d/VebvFXoXLxjw13Q+tKXE6GmJZ5CsJh5qh77OiqOLZ0RzYBNbPhA3fAjFMAqAn72eOeRW3vOv7D+3uu6fsCLfvaCSjzFNm5a0M+nnCf9SYStpvL9/w3D9/5SxbsMb77tq2rYPXvaN+zreRyPbE0iY7thHSMB//+N96Xvpdn/J9j554WLFtz7YPraVl5r9O4SBRSUfQLv6B3zyZWhc8zwUk7C1fexs3zf4qFcSv89oXd/GpPEzYubvL9iL4tzwFQnTHuMrSG9g3GUnF5oGomd69uzV/mtpUtAHzmrQt4YGM39yz6PjdsrabPPwNbK7ZuXgOZBHY6YVxBDnesaslvP7mlk1mqg20dg9z6UjPv/Plz1MR3UaXiHKPN5MG/RBfxyKYOzvreY7z5f4177piOvxFSKbp2bqA3lub//upF7nv8Gd7tepoO3ywA1tvzeKinCWKdbPzlJ3jlJx/MX/eeV9uoDHjwuBQf+83LbFz9HA/4v0Yo1clT2aV0NZ7JNZn/S7M9hbbHbiJj2axr66c9kqQq4AXg9pdbiKdNLGlnl5mr8simDj7+21Xc8mzB9bNyt7GCYmmLtv4EZJKw4wmYdx6313ySHXo6WzJTINJGR3cPftI098ShZwfp6rkMJAvxqn+/dwNfunMt1z+ylSe2drMvcIxJBe7dSXTDAwC0bHNclOI+Eg4zR50otGSq6dKmSB6Nx5nX+efDootLZosOVi3kJJcx9W2t2LNnd+FY62b0gHEd3W2fy2mpXxDTfi7c/p9UqgQtTGVq53Nw/2eoXP0LAKZVB5hZGwQ0TVY7AN9Y3M5VwScIqxT2rmfZ+Ngf+OxLFzCLDpL4sIuClPbOJ1F2mk+nP837uj+J/fYbjAuiYQGvtQ8ypz7EjJogj2zqoEVNJ/m+21ioWnlnwsyMrCJG9JlfwA3L4MY3meJrDYvA7WFtaz+nza3F41Js3hdhdl2Iqy9cRMDr4tltXaxrHeBjb1lCq2s6VbseRP/yraz/weVcdsMzDCaNUK5p6WdeQxgA195XeMZ/NT2bn+br92zgzQsa+M0lBaN0p93EqwMV/PSJ7XjdLqY2NrBbF1Z8Hdy3lWe3d/Pc9h7WrzSxkG+rT5EN1POUfSKb0mbm7+K2O1nS/TA/eXQzP/z7Fp7b3sNFS5q49j0nkh3sYtu6Qv2YHzfP4YKuf+NX1mVscS8kPLiDLe2DJDM2lq3Z0m7iCevbBrjwB08xmMywy5nA+PwO42p8Zlt3/nwrdxVcY1s7Bk3QOBPDOvNfuKb/IkDxfH8dADO2/pYtgY8wtf0pdO8OHu+s4KRv/53ntnfTNZhifdsAeweSJDLGLflUXwO0vgw3LCO8zyQMdDa/Boj7SDj8HHV32Gnz6thgz0WjYLYTnM1l2xThbVqS327RU9i2vWiA7t5GpNP4eM855UQ+/pbFPOM6jSpirHKfzJa6t1Jhm4BsdefLuF2KR//tPG77xJk0ECGkUgAs3/dHGrJGIE5pv4PFL3ye7Xo6rad+iV9nV+Aa3Mu1963i5d29tK68j0EdJHDMmwDY1XQxvPXfAXitPcKxUytZMt2sMnfK7BpCSy+l0zuTClWIVVQ89hXwBml78/fYcvld8MG7SGYsXts3yGlz6zimsQKAJdOqcLkUC6ZU8PBG8xR/0qxqXlzwOWZndqE6N7Ek+Sr7Ojv593s3kLWMe+wtxzZSGfCwVO0GYHpiKwD/c66LYOvzZL0V/MU6kz9Z52Nr4zY5/7hGvnDxsWy0C2tyW9076epo40bv9bzNvZKE9vHwwGz+eOZ9/CT7LpqVcS250ARVmr899jg3PL6daCrLW45t5Iwt/83qwKdY0PskGdwMfGEfU5eeSySZpTroxTXlWBqtDtbuKgTys7bmXy9cyE/ev4y9A0me3dbNjq5oyT2xek9fXgRX7url3Ok2dUTY0h6FdbeTdQe58G7NYDLL3PoQt3bNo9/dwFtabwRgQewV6N/DdsuI2tW3r+GhDQW3XkckxSVLp/L37MkkPNWkZp2DQtOjK2lIO9acpKQKh5mj7g679t0ncOrlV6GOf48JLLs8MPfNw9pNXbAsv63Q7G01roMoYU7puIvqhz8LwIlLl/ClFcexuQVQou0AABFmSURBVPFtALw4/cMEZizNf7Yhtp3vhv5MePejzAomWe4zYpJuOtVMcqqdS3PVqSyz1hEnyHeqvs3Mt3+d3iojSl959QK23/Z5qnc/xGrPyXzxUrNe0Y1P7uCXT+8kmbHY1R3juGlVHD/dWEDnLDQzkvuqFw//A5zzeT61+UQ+9qgLXTmNjXsjZG3NybNqOG5aJUBeXBZNqcw/vS6dVs2sM9/L9zLv5w/ZC/Aqi28s6eKv6/axek8/ZBKcH25mXn2I+coMdPPVXi6YlqLx1otg3Z+wa+fzmcxnudl6e747i6dVccqcGtboY4lrP726Am+kmbod97HC/TIr3C/TU3kcFm5uW9uPrdyceMJJZHTBjfL/Fvbx1uOmEPC6OEetwf/KTQBcqFbR4Z5GdUWIFccbS+TEmdV4pi7GhWbjulfwuIx1eLHrZa7YfQ2XHt9EZcDDY691srsnRtDrxkeGmwM3cKzexYs7e0lmLLZ1Rvle+jp+F/wBnVteQq+/g9/bl7BrwPy9vn3F8cyYNp2Pxj9Dsz3F/A3VLpSdZbdu4puXL6FzMMU1D2wm5Ct8l7edMA216BIWR3/Bku3/xMX6p2yoOJt5qt25GcV9JBxejqpAM5hgM2d80PzLpmDeeVDZNKzd9IUFUahTg3gSXeCFVQ1XMKfzMXqopl3XcuIU4yLQCy/itD3V/NOis5le3Q7rYZM9hyWuZj6QvQfuegTlCXCjy7ggvO/5hSmT6/GTuu9aWPMK30h9kBmLzBPztPlLwUlAeX/6brLaRXjF11g01TzN3/GKeXLc2R3F1nBcUyW1IR9KwQWLzSBkTT0Ruh+h1TuHmRkjRt/fXMvGvQPY2mTX3L/GuMFOnlXDzu4Y963Zy5JpRhQWTjUiMasuSHXIy/K5tVzlfRcesnzA9xLnqjVY9hx+99hq/uS7hpOf3kFj6DT6lHG7HKP2MqdhC/SZ2IN3yeWE291MqwmyvdM8hS+eVkXI5+HVae/jLS1n8vPQjVQnW6hLF57im5acRcVLnrxr66LjZ9K8aSoB0kwLKy6rbeWCy09hb3+C0KrvgjdExPJRZffTG5zLTOD846YQ9Lo5ZXYtNbXHwzqItm7igsXv5u+bOvio+2HmtW6CRDfnLmzkzldaCZDi+qaHub9zChfz/9s79+ioqzuBf74zmcyQ92vyIAlhEvLkEQghQcTwRkCUqtXDVqu1SitbH9Vdj1jaPeo5ntZ9WOvZCiu2u61nrXZ12WJLl+LCwe5xC4iGR0Re8jABgZYgDyEJ4e4f92YyQCZDCDAP7uecObm/+7u/+X2/8538vnO/93vv/RPN7mze2TgOb7Ib99lT5J38mHzVyYCWZ2mVRF5sm82Se2oBmFDmpaE0i/HPtzPh6IssT3iGGqV7TntVDs+MKeRURycb9rZy0/A8nn6nieOnz1CancyTMyrISIxn1SeH2H4yg4SSEtwnVwBwvN0uUGi5slxzTuEc4tzdufjnISkDYfgdnG3dQ1rzegbKETod8dTNe4mljftZuFQ/sXem6YyhUYPSeIl0aorS8eUXsnPDnbQU3UnRmrv4zFVMBc1wqjsOLWlF/glLvhkP8+hmB8tOD2Wh+bU/dPhomjYVscl7Mze0reGk70Zq63WYS0SPF48sTONXZmC4IjeZYm8S6xdOJSvJDUBi0WhogoPJQyk4spfDcbm8/GF3OOnrP1vH58dOM3tEHtkpHqZUZLPy44PUDtYTr8pztQMamqdlcjkdPH/7CJI9cTgap5GzawVe13RKdr/NcNdu1Kh7qPzol5gxb6oHHMbd+QGk++D+lciAdL7duZvBWYl8f+lmjredodw4nrqSHD5sPoGk+xj2l2VwFrakTWbYF2uI893A3VLE4jW7EIHxpVn84OxtuOPj+WHhJ9C8Ho/LSbE3SU8cG1hD87F4qlpX0ZZWAkCKx8UfHmvAm+zm5MlczigHpY4WKkYXsmNfC7Xt27TQBzYyraqK320+wBTHR8w4+gbXuVNAwcTk/fxwywFKvEmMdOzEYWaAlzgOsHb4s7xQ1cCUypxuG4swodzL62v30Zk6iPhWfY+OtGIS3XF8Z1J3Kuob6/exYW8rxd5EPC4n/3hHNUve+5Tnlm8ls6AcTKZudWF6r19pi6W/XNtOoTdE4PZXcaxbAs3rKZPPcKTkkuB2cVd9ERPKvBw81kacU0fgJpZ5+e3D4xmWrx+gQ+5bwhDgN52vU1leBQNO6BTSl81yBl0zWAGXJ4mCujmwehdDTehmdEkej5T+K/MafBQUPXeOaK8/MJbDJ9qYWpnNj37/CTsOnqAoUw/ydjkEgJzyOs4sd+LKHQodH6Gyr4cmcDmFnBQPza2neGjSEP5munaMpTnJvD1/nP/6MvPAHpaf4q+bNTxPF5IeQ5qW8r30VdD6OW0JeSTMfoH2Lf9FfMcxOuMSSW4/BJ++C/XzIUmHtLrSVV/946ccO9XhT/F8cGIJE8q8JG1YB3pcl20jnmDYmEWQlMMDhe0sXrOLel8GSe44OqpuJ87lRLJXwLblelKaOHXWzrhHaD/igtZVOLO7s80KMxIA8KSlsFdyGRrXwoQDr1Ld+W+4xEwO29/ILTdMJTfVg/eP78BuSFV6fKiofQcdnWf58bvbecKzC4Ug1X8Fbceov+2RHpe1nlCmnYLbOxha4bgaAAneC9pNr8olLSEej6s7PPTN8T6G5afic+8Bs+pKZpLngmstlsuJdQqhSMwCYFzyQSTJ568uSE+gID3BfywifocQyJxpU8+tmPgUdFw42/eB8cV44pyM8elwVHycg8VfH92jSNeVZPrLz84ZFlR0T6qXM/NWMzyrBI7dgTchi8GfbyI7xcNNw/PY+NlRHptWpnPse6AgPYFFd9UwriTrwpN51VA+i1n7VnIoJYcBXh84XTgqZsLmN5HSabDVpNaOuvuCyx+bVkZbR3coJMXjor44k041GZpeZF7749xXVAbJ+t5ZSW7eXzCZ9IR4AP75azp9mG1moPa3j8NmsydEYR15Q4po2fYa+dVTetTtZHYN41r/F+f7m8g+20YryaSnZ8KBRhwOYWxxJvz3Jp3629kGaYNwHt3H/OFOFm0+S51jK5JVCbcuCvr5A0yuyGbhrEqK3Adhuw4djRty4ec5r6GYeQ3F59Q5HaJtrTKg/kFYu9g/2dBiuVJYpxCKBP0Adn55GIovzFLqMxMX9FidnhjPw+ZX9OUkLr9aF7zlCPDa/fXEOYW81AEXdf3Mrp5BTwy6Dve25RTGn4K0Ofp+I+fClrdw1H5DO4VJ3/cvHxLIpPLsHt/SWTKB0wsO8pXtrYz1ZZ5zbmBaDzLnjdB/uxwCQEEdOYmZ8IPgS31XXX8zLNUTzY6MfZI9OdNJ3/Vy91LoXx6BQ0161vXJw1B6I7x5F48PO0H+0a2MObwJKnu2ZSAup0M/7HftAWBIxQi+O7XnkGVQRGDm8/plsVxhrFMIRULAr7qBo4K3ixK6QiiXhWyT3dR+XE8ABCiZDE/u0ausPtWiF+nrIx6Ph5tG9OKMAknO0zb68s8w4UmouRcSM0NfF5CGnFE3l4yMYmiv1/M39jd2rzs1ZKpeE+pMO7hTcTW+xt2t6/TcloYnLl6pND1L2pNTCnHXXNKfJYqw385QJAQ8YPJ7Dudcs3gDZoenF3WXPWYM4hIcQp8R6e4tVN4CqfkXd13KQMgshdRBeiAc9FpE8cnw/kt62WunGwaaMFVcPIz5pt5f4sxpmPUP4OzDb6q0Iqj+ml7a3GKJYGxPIRQJGd3lvOrwyRGJpBbqdXzaT/h/CYeFylv0IH7O0NBtA5n9gl7csGtMZUAa1H5DbyaUWgAFteckBFD/IPzfy1B5M2T1MdTnjAs5/mCxRAK2pxAKp6u7HJ8YPjkiERG9VAZ0h4/CQe19esnvvi4W52uAkknn1tXP11lMR/fpsFEgybnw7fdgdh+2PLVYogzrFC6GdB8Muz3cUkQm2VV6E57kixwDiHRS82HEnbp8vlMAyK7oDo9ZLDFIv8JHInIH8DRQCdQppT4I0m4G8BP0tKZXlVI/6qldxPJoY7gliFxueBzKZ8TWmjyTvqd3Tiu6PtySWCxXnf6OKWwBbgP+JVgDEXECPwWmAc3AehFZppQK88bGlstCZol+xRKpBXDjc6HbWSwxSL+cglJqKxB08pOhDtiplPrUtH0DmANYp2CxWCwRxtXo8+cDnwUcN5s6i8VisUQYIXsKIvIucOEyorBQKfWbyymMiHwL+BbAoEFhzGaxWCyWa5SQTkEpNTVUmxC0AIUBxwWmrqd7vQK8AlBbW6v6eV+LxWKx9JGrET5aD5SKiE9E4oG5wLKrcF+LxWKx9JF+OQURuVVEmoHrgN+JyApTP1BElgMopc4ADwErgK3Ar5VSTf0T22KxWCxXgv5mHy0FlvZQvx+YFXC8HFjen3tZLBaL5coTQzOOLBaLxdJfRKnIHM8VkcPA3n68RRbw58skTqRgdYoOYlEniE29YlGncqVU8qVeHLGrpCqlLtyzsA+IyAdKqdrLJU8kYHWKDmJRJ4hNvWJVp/5cb8NHFovFYvFjnYLFYrFY/MSyU3gl3AJcAaxO0UEs6gSxqZfV6TwidqDZYrFYLFefWO4pWCwWi6WPxJxTEJEZIrJNRHaKyIJwy3OpiMgeEdksIo1d2QQikiEiK0Vkh/mbHm45QyEiPxeRQyKyJaCuRz1E85Kx3SYRqQmf5MEJotPTItJi7NUoIrMCzj1ldNomIjeGR+reEZFCEVktIh+LSJOIPGrqo9ZWvegUtbYSEY+IrBORjUanZ0y9T0TWGtnfNEsKISJuc7zTnB8c8iZKqZh5oXd22wUUA/HARqAq3HJdoi57gKzz6v4eWGDKC4Dnwy3nRejRANQAW0LpgZ4F/3tAgLHA2nDL3wedngb+toe2VeZ76AZ85vvpDLcOPciZB9SYcjKw3cgetbbqRaeotZX5vJNM2QWsNZ//r4G5pn4xMN+U/xpYbMpzgTdD3SPWegr+DX2UUu1A14Y+scIc4Bem/AvgK2GU5aJQSr0HHDmvOpgec4BfKs2fgDQRibjNn4PoFIw5wBtKqTal1G5gJ/p7GlEopQ4opT405ePodcryiWJb9aJTMCLeVubzPmEOXealgMnAW6b+fDt12e8tYIqE2BUt1pxCLG3oo4A/iMgGs88EQI5S6oApfw7khEe0fhNMj2i330MmlPLzgNBe1OlkQgyj0L9CY8JW5+kEUWwrEXGKSCNwCFiJ7tEcVXrxUThXbr9O5vwXQGZv7x9rTiGWGK+UqgFmAt8RkYbAk0r3B6M+dSxW9AAWASXASOAA8E/hFefSEJEk4G3gu0qpY4HnotVWPegU1bZSSnUqpUai96apAyou5/vHmlO46A19Ih2lVIv5ewi9Em0dcLCri27+HgqfhP0imB5Raz+l1EHzz3oWWEJ32CFqdBIRF/rh+e9Kqf801VFtq550igVbASiljgKr0VsXpIlI17JFgXL7dTLnU4G/9Pa+seYUYmJDHxFJFJHkrjIwHdiC1uVe0+xe4LJuh3oVCabHMuAek9kyFvgiIHQR0ZwXT78VbS/QOs01WSA+oBRYd7XlC4WJM/8M2KqUeiHgVNTaKphO0WwrEfGKSJopDwCmocdKVgNfNc3Ot1OX/b4KrDI9vuCEezT9CozOz0JnGexC7yMddpkuQYdidBbERqCpSw90LPB/gB3Au0BGuGW9CF1+he6id6BjnfcH0wOdWfFTY7vNQG245e+DTq8ZmTeZf8S8gPYLjU7bgJnhlj+ITuPRoaFNQKN5zYpmW/WiU9TaChgBfGRk3wL8nakvRjuwncB/AG5T7zHHO8354lD3sDOaLRaLxeIn1sJHFovFYukH1ilYLBaLxY91ChaLxWLxY52CxWKxWPxYp2CxWCwWP9YpWCwWi8WPdQoWi8Vi8WOdgsVisVj8/D+o6HE3/xCdAAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD8CAYAAACYebj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXeYXFd5/z/nTp/tfdWLJctNrrKNsQETMKYYTHEocUhM6IRfEgJOCAFCgISEGorBGGNj041twICNe5Uty5KtXlerstrV9ja93Ht+f5w7MzvSSlprZ3e9mvfzPPvMveeee++ZmZ3zvW855yitNYIgCIIAYM10AwRBEISXDiIKgiAIQh4RBUEQBCGPiIIgCIKQR0RBEARByCOiIAiCIOQRURAEQRDyiCgIgiAIeSYtCkqpBUqpR5VS25RSW5VS/zhOHaWU+o5Sqk0ptUkpdf5k7ysIgiCUHm8JrpEFPqm1fl4pVQWsV0o9qLXeNqbOG4Dl7t/FwA/c16PS2NioFy9eXILmCYIglA/r16/v11o3nej5kxYFrfUh4JC7HVFKbQfmAWNF4Wrgdm3m1FijlKpVSs1xzx2XxYsXs27dusk2TxAEoaxQSu2fzPkljSkopRYD5wHPHnZoHtAxZv+gWyYIgiC8hCiZKCilKoG7gH/SWo+e4DU+pJRap5Ra19fXV6qmCYIgCBOkJKKglPJhBOHnWuu7x6nSCSwYsz/fLStCa32T1nqV1npVU9MJu8QEQRCEE6QU2UcK+DGwXWv9zaNUuwf4GzcL6WXAyLHiCYIgCMLMUIrso0uB9wKblVIb3LLPAAsBtNY3AvcCbwTagDjwvhLcVxAEQSgxpcg+egpQx6mjgb+f7L0EQRCEqUVGNAuCIAh5RBQEQRCmC8eG538KdnamW3JURBQEQRCmi4PPwT0fh72Pz3RLjoqIgiAIwnSRjprX5MjMtuMYiCgIgiBMF5mkeU1FZrYdx0BEQRAEYbrIiigIgiAIOTIJ8yqiIAiCIIilIAiCIBTIi8JhgebBvZAYnv72jIOIgiAIwnRxtEDzbW+GJ742/e0ZBxEFQRCE6SI7TkzBzsLIQRjtmpk2HYaIgiAIwnQxnqWQGAQ0JMV9JAiCUF6MZynE3AXFXiID2kQUBEEQpotsyryOJwoSaBYEQSgzxhunEOs3r2IpnKRkkvDbj5rA0VTzx0/AF2qm/j6CIJSGseMUHMds591Hw6D1zLRrDCIKpaZ/F2z8Bex7aurvte6Wqb+HIAilI2cpoAuT4+VEwclCOjYjzRqLiEKpyZmAmfjMtkMQhJceOUsBjLWgdUEU4CXhQirFGs3CWFKj5jWTPHY9QRDKj7ylAMT74UevhmhPoSw5DDXzpr9dYxBLodSIpSAIwtHIpsAbMtuHNhUEwfKZ15eApSCicDxi/cXqfjySOUvhRZxzIrwEAlKCILxIsgmobDLb3ZsK5R5XFF4CaakiCscheeNfEH3oqy/ihJylMHWiEE1leWJL+5RdXxCEiTOSyJDOOhOrnElC1Ryz3bG2UJ63FEQUXvI4kR7adu84eoXBdnjgs4X0snxMIQ7Z9JQ80X/m7s18/hePFgrEahCEGePN332Km57YM6G6TibBb7tqyVpBOLQBgjVw1bfg2jsAONTTze6emZ1WuyxE4ZsP7uJjP1/PpoPjq7DtaFa39Y97zKszhdSx8dj1ADz9XRh1xyXkLIVUBL51Bmz81WSaPv4teyI0MFooEFEQhNLS/jg8+Y387mgyw7cf2o3tFP/WtNZ0Dic4NDLBxJJMgp6Uj/XZxWa/fims+juYfyEAv35yM1d864lSvIMTpixE4Wdr9nPv5m6+cu/4T/xP7Orj2pufPUKhtePgVzbe7DFEIZdilhgyrzlRiPaYVLPB0rp5tNYcGIxz5WLP2IaW9B6CUPbc/hZ4+Iv53cd39vGth3axo3u0qFoq62A7emLuI8fBctKk8LPeOdWU1S3huw/vZlNXBB2oopqZT1ApC1HwWAqAoXh63OO58tFktqg8nTHzlPjsY8QHcnOZ5EQh5z6K9prXY2Uh7XsK7r3+GC0/koFYmnja5qzaMe9FREEQpgbXCk+kbQCSmeLfWq48NRFRsE1fkdR+nneWm6K6JXzjwV28/ftPk/ZWU6OO8QA6TZREFJRStyilepVSW45y/HKl1IhSaoP79/lS3Hei5L64yGGdfo6Ye/xwtU+njBXgt4/eseujWQqx44tCass9sPamFxWUPjBortfqGWPViCgIQulw7MK2+/tOZHKdv11UNZY2fcqELAX3d57Ex3POCuK+eiLNqwBQCka8DbQyRF3YN9l3MClKZSn8BHj9ceo8qbU+1/374nHqlgytdf6LG0lkxq0TT5njh3/h6ZRR9qBz9I69o2fQ1I0MmIJcSmpOJNKFc2/9xc/46W9+k9/fu3+faWOkGzqem8C7gQMD5nr1jImPiCgIQukYPlDYdqedyIvCYZZCPPdAaU/gN+gKTBI/I1Ry40X30918GQBhv5dOmlmgeqkN+yf7DiZFSURBa/0EMFiKa5WaZMZBawj6LKKpLNlxvryjWgppIwohffQn+VjcmHvxkaPMiT7GUrik/Tuct/u7+X1Pwnxk+q4Pwo9fCwPHz2DIWQpVkTGxChEFQSgdA22FbTfJpOAmKn5wjKdt/uD/DK8euuv413UthZT2oRQk0lkGY8YNXBnwsitVz1w1gJ0Z/+F1upjOmMIlSqmNSqn7lFJnTtdN466VMKfGjCKMpo50IRUsheLONZM0X2KYBI5zlAwfN6bgxIeM/zFVHIgaKwphJ0rILrh9AhnztG91ulZC9vgZDAcG48yr8uHper5QKKIgCCVjpGNrYce1FJKZ8WMK8WSG09UBWtL7j39h9/edUn7qwn7iaZuhmBGAioCHvdlGvMqhOtt3rKtMOdMlCs8Di7TW5wDfBX43XiWl1IeUUuuUUuv6+krzwcTTNj/x/S//om8FjAvJcXSRxRDPFFsKXTvWYGczZNxAs1/ZRBNHcSG5Kynp+KD50u3Dgtlj4gUhnSDsFAJJFdmh4rrO+DGPsXQNJ3hZVQ9kYhyqOMMUiigIQsnYsWV9fttJmoe4+FEshUQygVc5eJ3U8S/sioLjCRL2e0ikbQZj5ryKgJcDTiMATdnuSb+HyTAtoqC1HtVaR93tewGfUqpxnHo3aa1Xaa1XNTU1leTesXSWc6w9LNf7ABhNZLnxiT286TuFqa3HWgq9XQdo/eXr2fjnW8ikC190omdPIU4wBisnAomhfDwhrceki46ZCjekE1Rqd19rquzDXU3HDzjHUlnO1rsA6Ko+272WiIIgnCjfe2Q3l3/tUX70hHHJ+uKFCeoScfObThzFUkjHzW/Y6xzDyk+OQttD+UkytTdIhd9LLJ1l0LUUwn4Pe23TJbbYPUe91HQwLaKglGpVSil3+yL3vgPTce94LEqdilLnGFfNaDJDW2+U/YOFzroQU7DZ39mJpTTJvr1kx4hC/d3vgj998ojrK9t80VZyOO866qWuUCHX0TsOYZJUEDejn9NR/BzmO5zAJHqJjM2K7A6oaGYktMAUiigIwglz81N72TcQZ0276ZKCmRH6dTUAiajp9I+WfZRJmN+81xk/3R2ADb+An72jsPCWN0TI7zHuIzcd3nY0+7N12Foxh56ju6ungVKlpP4SeAZYoZQ6qJR6v1LqI0qpj7hVrgG2KKU2At8B3q31NAzD3XwngQPGIqi0zVP+SCLDir4HuF7fZj74of1c0/NtfGSNpTDgWgPRPrKZgij4ol3jrqaWsxQ8qeH8ZFZ9urZQIdfRZ2JYaCzcuEN8HE2cwHTbiYzNvMw+aD0LlPn6tGMf+yRBEMZFa51PVc9lKYbtUbpVMwCpmHEfeRJD/Iv3V6RTxZ1/Nm6O+/QxRGG007y6A1kdXzjvPhpwA82JjEPc9tBDPQtU38SymaaIkqynoLV+z3GOfw/4XinuNWEcB377YZaEWgEIZEbwksXTvYEP9/0XeCGRdQht+AVXxu7hEut00tkz6B1yzcFEH/bhnfQ4Mxh6XUvBmx6BkQ4A9upWzsPNYHBFwUlGCgqcHMGJ9h+pyBOxFFJZmnUHNLwaBi33rTp4jnOeIAhHksw4+akrYikb29HU6FEOBZdCqo206z5aHl3Lx7z3cPvo24HT8+fnYg4+fYyYQm4RnT4zo0IyUE/Y72U4nmDIFYVI0ngN2qwlXMoWUskkQV9FKd/qhDl5RzTH+8HJEo4Vnu7faK3l8mc/kN9PZGzoWAPAq6xNpLIOg8Om4w+mB8hmitXfGSem4HHNxkB6GIZNBsJuZ36hgjtOIffPBZCJD5MYMX7DovjDBGIKVZl+Ak4CGpfnLQVHLAVBOCEiKdMZX2ptpiXRxmAkQQ0xUpXmN5xJmsQQT9Z1N6eKRxzb7r7/WKKQWzOh38QCs/46wn4P8TEpqaMJY6XcF3oTLWoYtv528m/uBDl5RSF6ZLDmi75bSVqV/N56LQCJRAwOrgPgldYmUlmboRHTeVdlh7AzxV90JjaOKLhmo0dnoHcHo6qKPmoKFbIJcJwiUUhHB0kOm6eHfbp1TN1ju4+01szLGmtEREEQJk80mSVMkp/7v8L34tczNNCLpTTeuvk4WmEnjCXgda14K1MsCjovCml45L9g7Y8KB+OD0L0Foq6l0L+bUVWFPxBwRaEQUxh1B9buqryY3c48QutvnLGJLk9OUcgkYWjfEcW1KsbuylXsyJqOWB98HtJRtrGU5VYn3ughYlHTedfp4fw0FzkCZI54mvc5KRxt5lbi0AY6aSahA8U3zibIxAuZRpnYEOlRMw1Gmx6z9F4mzkgszf9971t87u4XGIgWi1LadlisDpmdxlMLMQWZJVUQTohIMssbLLOugUfbjA6Zh8mq+hZiBHHcTt9rG0vBOmzGZOXuB0ibp/ud9xUOPvkNuOX1EHVTTJ0Mw6qGkM+TDzTnYgq5GEJN2M8Xsn9D7yu+bOa+mAFOPlEYOQj/PcdMZ+0S0aH89j61gIht5hbxdTwNwG/sVwEQ6+/A6z7516oYoyNHWgaHp6X6dJp27S6a0beDfXYDSQ6buySTIJsoWAp2fAQ72kdKe+nQTUX1tj97H//U/wV61/2O+7YU5ysn0janqC4ynjBUzUFJoFkQJkU0leUaj5mqepeeT8wVhYamOcQJoN1O35eb/yw1yhf/sI1h9wlfuZZDkDSJ2CgjkTGDV4f3QzpSiCkAg1QT8nuo8HuJprJHzKJQHfSy2lnJcMN5U/J+J8LJJwpVc8ETQLtuIYAdLM5vb0q3knI7bRXpAqDNbgEgFhklROHp3B7uPPL6hwWbfTrN086ZpJWxDg44TSQ4zFJIx7CThZHMdnwYJz7ECJV063ps5cYVMgmS7c8AMF/1c2ik2CpJZGyWqG4iFYvMU4QqBJoFQXjxRJJZTrPMXEfVxIkMGgu+tqGFBCGUO84o4M5/1j8wwC2r9/L4LtPR54+Txk5GGBoe0z9EjhyENqCr85ZCjpbqQn9REzJ904RmXZ0iTj5RsCxoOhWlbUZ1mKftM1hjnQ/eIADPRppIaTPhlEoOopXFsK4EIJuKEKIQXPbFDh1xeZ0YKlpow0+GCCHaQmYgWYduJulef9C9LplEkSg4iWF0coRRHeZX9qv54bIbzQpMmQSV/S8AcEowwqHhYvdVIm1TqyJkgg2F94pYCoJwokSTGSoxD1/VKkZsyIhCRV0zSSuIyuREwdTxuJZBf9T0E143AB0iTUgn8tmIALH+I1PYe50qQj4P4TGisLihkGVUnReFmftNn3yiANBkUsZ6dS1/lfksd4SugYomklaIncmavHsnNdJHigBx98lep+IEx4hCRbKg9FnL1Nnz60/z8JfeiGPb4Nj4yJLUfjYFjLl3UDfheI27Kj9eIRNDjxntrJPDWKkRIoSprKpht/dU8IVxMnGWJLYDsMg7RNdhlkI8bVNFAsdfBZB3HzkzmNMsCLOZeDyKT9nYykcVCTIRIwoq3EDaCuHJxsnYDiFtOvsKV0D63XifN2ssCJ+y8SiN3xUP7dj4Er2FG7m/2R67irDrPsqxpLEgCmIpTAEZ26E7sAgwogDgUQoqWxipWAooUpgn+chQHxHHnw8Mh1SKkCqIQrN2l+gM1DBadQoAyxKbeJ1+ml2//9/CBFf4eNh3OfvnvZl1zqnUVJvsoz7tZiFlEuhUBFsreqlDJUfwpCNEqKChwk8slQVvkFTXNhqUCUi3WoNHLPGXzNhUqgQEzD9Y3n0kI5oF4YRIx8zvLRmei6U0wVgnGbzgryTjqcCXjZPM2FRgfotVyhWFSG4BruKxRbnU1Bd2tuNXY572m82D6oCuJugvdh8tqA/nt6uDrihkRBRKxmAszb+vNjm/vRhRGIpn4A1fZc+FXwDIu3dqVZSE9ucthTBJAqTRllHxZuUGld/2A/ac/9mi+7RsvgmdyYmCn267hj+f+p9ECVNX64qCe3/ScUhFiRFiVFegUqN4s1GSngrCfg/7B+L0pz34+80aRamqhTTYAxwaSRZlFiUyNpUkUEHXUhD3kSBMilwCSKZqLgAt2S5inhpQiqw3jM+Jk8jYVCjzW29miO/4vkvGjTcG7FjR9YKueKzZYH7L+QfD5tOAQkxhrPto7La4j6aA5qoAh/w5S8HMQTSSyMD8C2hccQlA3n1UT4QEAeKYeEOIlAk0h+oBqMH9wpddAQsuyqeedjhN1Okh0qMmUyGFj1g6y0AsTcBr4amey5cy13Kn/UpzfiYO6SgRQowSxpMaJZCNkPFWUhHwsrMnQkcEPO5yfZnmlVRl+shkC4NbABKpNBUqhQq6/2gyTkEQTojRZAatdV4U7CqTGr7E6ibpM78vx1dBwEmQSBcshYut7bzF8wzLh58EwH/YRHhBMmjHzovGjdmr2Lfk3VC3BIABXUPY7yE8xn0U8I4VBVMu7qMSopQi3HwKD9rn87Q+u+jYooYwljIrHwEEVIYEAdJ4yWIRVimCKg2BSpIECuafx0ddZZAIJlaw2nshAMlO98le+0ikbfqjKRorA4QDXn5sv4kD2syfQiaOlY4S00FGdAXe1BAhO0bGV51/SshZLwBW60o8Ostv/Z8nueZm0JoXDgyx/5DxUXpC1e57df+ZZJyCIEyY3kiSi/7rIX62Zj92bqXEajOCeb7qJxE02YjaFyakEyQyNmHXUsj1CXMSe9BaE9JHTk2TSkTxxMwD4332xTy45F+h0lyzjxqCYyyFsN+D31vohiWmMEUsb63mg5lP0d308qLygNfDgvow2lNIATPxBEWKIGFSVFkZlDdEyjICkMELSlET8jOiTUDoQMMrzLmuKNieALFUloFomoZKP0Gf5V7bWCA6HceTMe6jfl1DONmNnzSOvyofcEq4QpXVFv65Zg2ic6125j31Gdj4K/7+589z68ObAPDmRMEylotYCoIwcZ7c1U8y4/D9x/aQdWca8NQtzB/PVJttHayjQicY6D6Yz1DKsShrZlYNk8Q5rBuNRiMEk+YBLuproHs0CWe+lY7L/492PafIfVQb8hEYIwqFmIK4j0rK8mbjc2+pDvKmlXP4yttX5o8tbawgECpE+3OdccoKEiZJ2MqAL0TaY4I/WXfOwJqQjxEqGNYVeBddbE7uNZlC/kCYRMZmIGYshZDPU3TtbCqKlYkR1UH6qcGfNWltOlBNwK2bs16GqcJbUxjlHFMVxPetpXs0aYLMgC+ccx+Zc7WMUxCECfNUWz9eS3FoJMmBQ+aJ3ldfEAVqFwPQeulfA9Dz4LcJUzy7wAp1gMd3dFNBkpS/ruhYIhahKt1HzFtHY00lh0YSdMUtuhdfDSjCfi+W+0C3vKWqSBRqwmIpTAnLW8z4gKaqADdcez7vuajwhX/08mV8+DWF1UBramp45JOvwvGGCasUFVYafCGyHmMpZJURBb/X4qCawwvOMk6Z30qfriE0tBOAQChMxtZ0jyRpqPAT9OdEwVgkqXiUUHqACOFC4AlQwZr8yks5ARmxqqFpBSy4mAcuuoUuu5a29j04mvzTSkEUzD+WiIIgTAytNU+19fOGlXNYUB/KZxMFGgp9hL/J+P9POf1cNlZeyhuid+NTxU/ulSrJhi2bqFRJqCheL2xweJjFdBIJL6SlOsi9m7t5+f88Qs+ocUGF/BZLGyv477et5NvvPrfIfVTpl5jClHBqi7EUmqoCRxy7aEk9V52/tFDgC7G0qZKsJ+QGmo2lYHuNNWGrwpQVXwv+I/9g/xOnNFWyX7dQEzezooZcy6M/mqahMkDQDRw5WIzqMP5tv6Em2cnj+lxGrMJThSdcQ+ew+adMummxUU8tBCrh/Q/wuje+g1FvPcqd3K/qMEtBiaUgCC+Kvf0x+iIpLj2lgSvPaM0/aHlr5+UTSSpbl+frN134jnyaeswybtthTP8SP7CRSpXECReLQu/AIMvVQeK1y/MxAoANB8xo55qQH6UUf3XxQmrD/nygOeC1sCxFwGuJ+6jUNFcFuP7KFbz9vHnjV3BHNwPgM26ijCdEmBRBlQJvEMctz44RhVBFJdXVtTRWBtivWwrl4YI7qrHSX5SD/L3s1fhH9hHxNXC/9Uoi3oIoeMO1vHqFu5iHMpZC3DtmhlUgGWyiJmsW5Mn9A6uAG1Pw5CwFiSkIwkTYN2AyCk9treLKs1qpUElsLPBXEFXmN18795R8/fnLCskqEb/p/LcGz8fRipdZ2/GRwakq7mfiPe3Uqyh24wqyY2Y/WLtv0FyzLlRUP2cpBMa8iqVQYpRS/P2rl7HctRiOwLJMABlQftci8IZM9hFp8IVRfuOCGmspLKwPc2pLJbVhH7udwj9Cc12hI2+o9OdjCpaCm+030bX8Wv449x/x+ILEfPX5uoGKWv7ptafywueuwBsw/5ApX7F/0g4306yGAZ2PKeQGr+UsBRm8JggTY/+AyRZaWB/m/IV1tPjT2N5KUIqoqmSYSrwVY36DDQWBsCvMg6BTv4zR8ELeGTDzlNlzVxXdI9y/EQBPyxn8x5vP4PorVwCwpXOEpqoAQV/xklg5MciVB3weGacwE+QmsPO4nbHtCRMiRUCnwBdEBYxYOFYhn/hrf3kO33nPeQR9HnZ4CibmJSvm5rdrw/78l9tcFcTBYsPZn2NdxeUEfR7iY0QhWFWPx1LUVfhRPjfbKVAsCp7qVoIqQzVxKnHT3w4b0SzuI0GYGAcG44T9Hhoq/HgsxTtX1uKvMA91cauCPk9r8Qmhwu8xHTJWfbaildol51Jpm9HQesFFRae0RrcBEJ5/Fgvqw3zs8lMIeC0cDfNqi60EIJ+tGPCNsRRkRPP0c7goON4QFSTNMHVfGI87ati2CpZCZcBLlZsy1hkqLMkXCIa59x9ewUWL6zl7Xk3+S26tMW6qSDJDKmsT8FloXyUJd0xCRXVBICy/K07BQhlAoM4ITrM1nI8p4FoxuRHNaHEfCcJE6BiMs7A+jMqtVZCO5H9P61vfxYb5f33Uc9Mhd/xCVSu0nGUKaxbgqZtfVG95ZhfDuoK6ZlOulMqLweGuIwC/xzxEBsfEFmbSfVSSNZpnI1nLDw74guYfwvGFCamUWWvVF8IbNF+KVr5xzw9UVpPLUguEKljQUs0dHzEjpnPuozk1QTZ0mOl5kxmHgNdD0GfRr2tYoPqorK7NX89yLRPCDUX3qXb/sc6pSVIVSRDRIapcMVAydbYgvCj2D8SLJqAjFclb3u/64KfHPylYA8kRhuZdzg+3dzJv7suh0mQe0no2gaB5oBuhkhqiBFWGnSzmHF+he51bG6K9P8b8uvARlw8cYSmI+2hGyM166g8ZUdC+MFXE8WgbvCH8YfOP4lj+cc+vCxfKA4Fi9c8FmluqjaUwmsySytoEfRYhv4c+ahjVIWoqCgFvn2uxWJXFotDYYqbsOL0yTiUJohTupcR9JAgTRmvNAddSyDNGFI5KvYkrWMFqvpK9lorK6oKlMOcc/P4QjlYMqcJDXr+32A01t9b81sezFPIxhZyl4JNA84xg50XBPDVoX5iAMhPp4QsRCJsMH+0Z31KoDft5a+qL3G5fQbCisuhYzlKoDnqZXxdia+cIyYxN0Othbo0Z1RwhnJ/8CgqjlD3VLUXXqmsxlsKiQIRKFSc6ZhW53HoKMqJZEI5PXyRFKuuwqOFwUag8+kkA77wdXv7/aF56Dg0VfpY1V0LdInjHj+HCD6AsixQ+Ip5C/EHVLiy6xJyaY7iPvC+tmELZuo9sj1HuoNv54x9jUvqC+N1BJB7fkWMdALK2wwa9jEsvu5KAr/hjzAWaK4NeXndGKz9bs5/5dSEWNYS5+tx53PDC65nn9PP1MVkIA3Mv5/9t+Thvyz2BuKhgDY43xCuaEoymfQTtQk60zH0kCBOnrc/MJLC4xgO3vgnqFkP/LjgsUHwEtQvgdV9mMbD+c1cUyldek99M4yPlrQD3uXLJstOLLrG40QjR2AV1cvg9h1kKXk9+uc+ZoGxFwfEY908495TvGysKYSz3+LyGmsNPBeDvX72McxbU8qFXLD3iWF2Fn8qAl8UNFZy3sI5bVu+lvT/G6XOrueSUBv7aMSOqvz7mnKrKCv7gvJy/DR3mrlIKa/GlBPc9QjDcAJWFQLRMnS0IE2fdviGUgvM87bD/KfMHxeOWTpCkCpD1FPqQxaecVnT8qrPnMr8uzOLGI0XB67HwWCpvKdz8t6vMGjAzRNmKQs6HH3RjCrkUVMD8k7gpopZ3/JjCWfNqOGve+IJRGfCy7rOvJeC10NrMzqqAj77qFDyW4ht/eQ77B4rnYT9zbjVza4LFQbAcp10Ff/wnGNoHL/tovjgvCjJOQRCOy3P7BlnRUkXlgJlYko+sho2/hLPePulrf993HXVNy3lZ7GHgSPeRz2Nx4eL68U4FjMsoZyn4PDPr1S9bUZjXVA99hcFrtTVjOvjWlRBx12f2jC8KxyPnQlIK/vyPr8TnUXjdL/sdF8w/ov6Zc2t4+t9eM/7FTnsT/PETJnXusk/ki5Ul01wIAsBwPI3HUvmU8RyDsTQPbevh7efPY/3+Ia65YD50PQ81C6D1LGj9r5Lc//Xv/jgt1QG4wX1oqznyN34sQj5Pfs60maYkoqAbYJ9+AAAgAElEQVSUugW4CujVWp81znEFfBt4IxAHrtNaP1+Ke58oKmcyuhZBa63rRgrVQeNySLnzrJ+gKIwlNNkvu7IZXvHP0Hiq2XbJ51rLOAWhzPnYz5+npTrIt951blH5HzZ28R/3bKWxyk88bZun9cdfgLnnHuVKJ8YlpxRnDRbFKCfAf799JUvH8xLMAKWyFH4CfA+4/SjH3wAsd/8uBn7gvs4cvpwouJkIbtoZb/mueXUHtHCU7KNp5zWfP6KoYClIoFkob7pHktjj/A6iKRP5bes1QeZTqjIw2A7nvXda23c8rjyz9fiVpomSiILW+gml1OJjVLkauF2bBYfXKKVqlVJztNaHSnH/E8Lrpoa5I4lpOQM+2wteN9sop/QlsBSmivw4BbEUhDInnraJp4/8HSTcsgF3WdvaSJs50Hr2EXVLwgcfBWb3Q9p0xRTmAR1j9g+6ZTMnCodbClAQBBgjCi8RS2EcJNAsCIZExibmWgVjSabTzKWfwajx8VdE2s2BplOnpiHzzp+a604jL6nBa0qpDyml1iml1vX19U3tzZZeDme/++idfi5F1Tv+OIWXAvlxChJoFsqcRNrOu4rGsrz3fh4NfJJExExbHRxuMw+C1S8uEFxOTJcodAILxuzPd8uK0FrfpLVepbVe1dTUNLUtWno5vP2HRz/u9cNZ18CiS6e2HZMgt0azWApCOZO1HdK2k3cfbesa5c9bjBOiKtFJQGVIR40o+IbaoGFZfjYA4Uim65O5B/gbZXgZMDKj8YSJcs2PYdlR0kRfAsjKa4JgXEcAsXQWrTVff2An/3zHRhxH48uYLMJkPIrXUlgDu0wWn3BUSpWS+kvgcqBRKXUQ+A/AB6C1vhG4F5OO2oZJSX1fKe5b7khMQRAKwWStIZa2ef7AEAszexl68of4sxEA0vEIdf46GO6Ac48+PbZQuuyj9xznuAb+vhT3EgpYMs2FIBRlHW06OMxwPMOnvX+m7rEnCfsvNAeyCVaEeyGrzTgk4aiU7YjmkwGZEE8QikXhiV39ACyxurG0TVPWeKlDpJjv6TUT1tUfOV+ZUEBEYRZTcB+JpSCUL7mYAsBTbX3Uhn0s092gYa7dBRhRWGiZAWzULZqJZs4aJAQ/i7FyE2dJoFkoYxJjLIVd3VFWNiga9DAAfjIAhFWK+fRBoKZo3WXhSEQUZjEF95GIglC+xNOF8Qlp2+GMwJFjnIKkmaN7oG7hEceEYkQUZjESaBaEYvcRwDJPzxF1wiRptruhVlxHx0NEYTZjmZCQlkCzUMYkDpvzaKHuRFO8SE1YpWjM9ogoTAAJNM9iLHdEs5JAs1DGxNM2f+15kIgO0a7ncl7Xr4jWnkZmqIN6ZYLL81U/fp2SIPMEEFGYxVi5qbMlpiCUMYmMzZd9twLwqH0O2hui43U/wv+rd+ZF4VTlzscplsJxEffRLCa3noJkHwnlzFj30RnWfuLzL6Oq9RQGqM6XL1HdZqNm3nQ3b9YhojCLKaynIKIglC9jB6+1qGE8c86irsJPvzai4GhFlUqYCuHGmWjirEJEYRaTH6cggWahjElkiqfMDs9fSYXfwzBm3fUBVTvmYP10Nm1WIqIwi8mNaJY1moVyJpFKF+17W89EKUXU30hWWwx6zPrJaW/lS3p9lJcKIgqzmEKgWSwFoXyxU/H8dkRVQPVcAB6qfAvvzfwbSa+xGNIBGck8EUQUZjEFS0FiCkL5otOx/PZg/QWgTKq2v6qeZ5wzcbxmyd1sQFxHE0FSUmcxVj77SNxHQvmiU64ovPk7LDrn3fnyurAfAOWvgBg4oYaZaN6sQyyFWYylxFIQyps17QO0d/WanVBdUcygvsKIghUwloITFlGYCCIKsxiPZeFoJTEFoWx5901rCJEyO/5w0bHmqgAeS+ENVgKgRBQmhLiPZjHKAgclloJQ1lSopNnwVxaV//XLFnHewjoatjwNQLiuZbqbNisRS2EWYykloiCUNWG/h6vPMNlF+Iothdqwn0uXNdLSYALMoRoRhYkgojCLsRRoLBEFoWyxHY3fyVkKFeNXyomFuI8mhIjCLEYsBaHccbQmoI8jCrlYQ4VMcTERRBRmMUpJTEEobxwNgZylcJj7KE/zGVA1F+qXTl/DZjESaJ7FGEvBQokoCGWKcR+5I5qPZinMXwWf3D59jZrliKUwi7GUQiMpqUJ5kvu/9ztJ8AYhN5hTmBQiCrMYS9xHQhljO2NE4WhWgvCiEVGYxSg30CzuI6EccTXBuI98IgqloiSioJR6vVJqp1KqTSn16XGOX6eU6lNKbXD/PlCK+wrgSEqqUKY4rvvIZyePGM0snDiTDjQrpTzADcAVwEHgOaXUPVrrbYdV/bXW+uOTvZ9QjEYBIgpC+ZEXBScBIbEUSkUpLIWLgDatdbvWOg38Cri6BNcVJoCDJWs0C2VJPqZgJ46ejiq8aEohCvOAjjH7B92yw3mHUmqTUupOpdSC8S6klPqQUmqdUmpdX19fCZp28iOWglCu5J6FvE7iiHmPhBNnugLNfwAWa63PBh4Ebhuvktb6Jq31Kq31qqampmlq2uxGS6BZKFMKMYW4xBRKSClEoRMY++Q/3y3Lo7Ue0Fq789tyM3BBCe4rkAs0yzgFofyw86KQkJTUElIKUXgOWK6UWqKU8gPvBu4ZW0EpNWfM7lsAGV5YIrSScQpCeZK3FLIx8FfNcGtOHiadfaS1ziqlPg7cD3iAW7TWW5VSXwTWaa3vAf5BKfUWIAsMAtdN9r6CQcYpCOWK44DCMe6jgMQUSkVJ5j7SWt8L3HtY2efHbP8b8G+luJdQjMYCxH0klB+O1oTzq66JKJQKGdE8y9EyzYVQptiOpgJ3hlSxFEqGiMIsR2ZJFcoVrY++FKdw4ogozHJknIJQrthaU0HC7IgolAwRhVmOVhZKUlKFMsR2NJVK3EelRkRhliNTZwvlihZLYUoQUZjlaIkpCGWKcR/lLAUZp1AqRBRmOVopJCVVKEcch4L7SCyFkiGiMMsRS0EoV5yx7iOJKZQMEYVZjoxTEMoVR48JNMvKayVDRGGWo1EocR8JZYgZvJYg6w2DJV1ZqZBPcpZjUlLFUhDKD0dDmCS2V6yEUiKiMMuRmIJQruTcR7a4jkqKiMIsx7iPRBSE8sNx5z5yRBRKiojCLMdRlgSahbLE1ppKlcD2SeZRKRFRmOVoZUmgWShLHAexFKYAEYVZjsQUhHIlN05BiyiUFBGFWY6kpArliu0Gmh1xH5UUEYVZjqSkCuWK1poAGbQ3ONNNOakQUZj1SPaRUJ7YDniwweOb6aacVIgozHIk0CyUK47WeHHA8sx0U04qRBRmORJoFsoVx9F4sFGWd6abclIhojDL0UoCzUJ54jgar3JQHhGFUiKiMOsRS0EoTxwnazbEUigpIgqzHIkpCOWKtkUUpgIRhVmOcR+JpSCUH9rJAGCJ+6iklEQUlFKvV0rtVEq1KaU+Pc7xgFLq1+7xZ5VSi0txXwGM+0gsBaH8EEthapi0KCilPMANwBuAM4D3KKXOOKza+4EhrfUy4FvA/072voLBuI/EUhDKEMcGkEBziSmFpXAR0Ka1btdap4FfAVcfVudq4DZ3+07gNUopVYJ7C5J9JJQp2g00S0pqaSmFKMwDOsbsH3TLxq2jtc4CI0BDCe5d9mjEUhDKE22bmIJYCqXlJRVoVkp9SCm1Tim1rq+vb6abMyvQSmFJTEEoR/IpqTLNRSkphSh0AgvG7M93y8ato5TyAjXAwOEX0lrfpLVepbVe1dTUVIKmlQESUxDKFTfQLNlHpaUUovAcsFwptUQp5QfeDdxzWJ17gL91t68BHtFaHm9Lg4xTEMqTfExBRKGkTFoU3BjBx4H7ge3AHVrrrUqpLyql3uJW+zHQoJRqA/4ZOCJtVTgxtLKo0aOw5a6ZboogTC8iClNCST5NrfW9wL2HlX1+zHYS+MtS3Es4DGXhxYY7/w7mXwi1C2e6RYIwPTjiPpoKXlKBZuHFoxmT2du/a+YaIgjTjLbdcQoSaC4pIgqzHTXmKxzYM3PtEITpJuc+8sp6CqVERGG2M1YU+nfPXDsEYZpROfeRWAolRURhtjN2YPhA28y1QxCmG3eaC4kplBYRhVmOLnIfiSgI5YNJfJTso1IjojDbyYmC8sBIB6TjM9seQZgmVH7uI3EflRIRhVlOwEmajQUXm9cDT89cYwRhOslPcyGB5lIiojDLqbBHzMY574JgLWz4ZeFg3y5wJw0ThJMOWY5zShBRmOWEs64oVM+HlX8JO/4IiWE4uB5uuBCevXFmGygIU4TSJtCMR9xHpUREYZaTtxQqGuH0N0M2CV3Pwwu3m/Joz8w1ThCmEll5bUqQT3OWE84Om42KRqhsNtu9O2Db7822En+rcHKitMQUpgKxFGY5PeHlZiPcAJWt4A3Bpl9DYsiUJ0dmrnGCMJW44xTEUigtIgqznN8v+xJvs/8XfCGwLKhfCoc2mIPBGkgOz2wDBWGKyMcURBRKiojCLCfjrWCbXlQoqF9iXqvmQMPyvKXw6I5e2vuiM9BCQZgalGQfTQkiCrMcSymKliuqX2pe55wDoVqTiQS0/+pTPPGH26e/gYIwRRRiCiIKpUREYZZjKbDHqsJYUQjWQHKESCLFX+s/cdrAQzPTSEGYAlQ+piCB5lIiojDL8SiFM1YUmk8HINVyPg/uTZGND9Hb3UlAZQlmBmeolYIwBUigeUoQUZjlKNd99BffeIxE2jbTXbzvPtZ4zmfXiIVKjTDcvQ+AquzQzDZWEEqIJe6jKUFEYZbTM2rmPmrvi/HQ9h7eedMaeurOZ+2+QUZ1BR5tk+nZAUC1I5lIwkmEZB9NCSIKs5xzF9Tmt3/0ZDtr9w7yq7UdrN07yAgVAHj6tgNQp0ex3SUMBWG2Y+VEQUk3Vkrk05zlvPuihWz9zyvxWopNB0366R3rOtjYMcKoDgNQOWLWbvYqh4ef38n6/RJbEGY/ysmSxVO80JQwaUQUTgIqAl4WNxqrIOTz0DmcwNGaFUsWANAYL6zd/L93P8U7fvDMjLRTEEqJ0jY2knlUasQZd5KwvLmStt4o1126mLPn1XD+ojr2bHgSOqHJ6SOjPfiUTSOj7GHeTDdXECaN0lkRhSlALIWThGXNlQCcPa+GN6ycQ0t1kJaWlvzxgz4z6rlRyVxIwsmBpW1siSeUHPlETxIuXFxP0Gdx/qK6fNncljn5bd8prwKgQURBOEmwtI0jlkLJEffRScIrT21i43+8joC38CMJ1TSSPv8DeBoWU3/udThf/QkNanQGWykIpUNiClPDpERBKVUP/BpYDOwD3qm1PmKElFLKBja7uwe01m+ZzH2F8RkrCAAohf8t3wAgpDWDVPE6ax3rrBVk7Dfg84ihKMxeLJ3FkfVCSs5ke4VPAw9rrZcDD7v745HQWp/r/okgzABKKTZbp3G61cE/ee8imszOdJMEYVKIpTA1TFYUrgZuc7dvA946yesJU0jbX/yQJytfzwLVRzQloiDMbixti6UwBUxWFFq01ofc7W6g5Sj1gkqpdUqpNUopEY4Z4gOvWErLohU0q2Ei0chMN0cQJoUEmqeG48YUlFIPAa3jHPr3sTtaa62U0uPUA1ikte5USi0FHlFKbdZa7zm8klLqQ8CHABYuXHjcxgsnQK1JTc3074OFR9NwQXjpY1JSRRRKzXFFQWv92qMdU0r1KKXmaK0PKaXmAL1HuUan+9qulHoMOA84QhS01jcBNwGsWrXqaAIjTAKr3oiCHtoHXDyjbRGEySDuo6lhsu6je4C/dbf/Fvj94RWUUnVKqYC73QhcCmyb5H2FE8TXYJbrVMMHZrglgjA5LEQUpoLJisL/AFcopXYDr3X3UUqtUkrd7NY5HVinlNoIPAr8j9ZaRGGGCNXPJal9eCMiCsLsRmIKU8OkxilorQeA14xTvg74gLv9NLByMvcRSkd1yM9B3UQoenCmmyIIk8KjsziyFGfJkdFLZUbAa3GQZirinTPdFEGYFBaOuI+mABGFMkMpRY/VQnWqa6abIgiTQgLNU4OIQhnS72slZEcgMcHlOSPdYGemtlGC8CKxtI1WMn1bqRFRKEOG/HPNxvD+49ZN7HoU/X8rYfW3p7hVgvDi8Ej20ZQgolCGRIKuKAwdWxSi0VHSP78WZaeh7eFpaJkgTBwRhalBRKEM8bhjFZzBfeA4AKzf28unvn0bkZHC+s39+7dTo2IM+ufCwecgHTcHHAe0jC0UZhbjPhJRKDUiCmXIpWctY1SHsR76HNxwIQCHnrydrw/9A+Fvr4C+nQDEesyg8wcDrwUnAx1rIJuGGy+F331sxto/axhsh2+thAc+B449060Zn55tMLRvpltxQoilMDWIKJQhl69owo8bOB5og2wKT+9WALLagie+Zrb79wLw0/glYHmh/TF4+D+hdxts/MVMNP3YjBw0bXdFDYB9q2euQz6wBkYOwNPfgR1/mtp7aT2+9aY1RPsK+/HBQj3HgZ+9He7716lt2xThkUDzlCCiUIZUBLwM+Ofl9/XIQSqi+9nuLOA2+wr0lrvgrg8SGNjKqA6xJVZNZuFlsPlOWPsjc5K/aoZafwxWfxse+TLc+Arz9HtwPfzkjbDzvhO/pp2Bx78GsYEXf+5ge2G7d/uJt2EiPPBZuN1dqmTnn+GmV0P/bvjOefD1ZeazGGyHb54Oa28y9Q4+B5FDU9+2KcJC3EdTgYhCmRK87rf8pPqjAHTt38U8pwu7bik/817DndnLYPMdnNbzJw7qZkBxcN4bYbQT7BRdC66CdASSRy7tmc46aK3Z0jmCns64g9am829dCXYKtv0eDq41xwZ2F+pFuguxkWNhZ6DrBWMdPfpleP4nx64f7YNDm4rLBtuhbrGZmbZ/57injcuJWDb7Vxfuv+cR6Hoe7v93GNoLygPbfw9PfQuySXj2h8ZK2OZOVTZ8ADLJF3/PF0smAXd9EPrbzP7eJ8z3cYIxKg+OjGieAkQUypSGeUtZdeVfAfDks8+xUPVSv+AM7vzE67k+8xGGQ2Y21UOqGYB1oZeD5cNuPYf/61gKgB4tHhX9yI4ezvnPB7jpiXau+u5TPLazr+j4ls4R+qOpF9XOZMbmnT98hnX7Bo9dsWcrjHTAhR+EOefAtnugc705lvOZa03m+5eRuP8/2XRwmLZes6ZEz2iSLZ0jhWuNdKJ/chXcdLmJB8C42Vffe2Q3P3zcxF0O/PZzJG9+Qz5wD8BgO7puKYf8C3H6JigK62+Db54BqejE6rvvi/42SA5DNmWEAGD3/WQbTmNb8BycjXfAhl/i1J8Cg3vgq4thzQ3gDQI6b9Ws3z/I9x9rm/i9XX73Qie/XHuc+bS6XoDNd8Dq/zOie9ub4Runkfj+K4n+5mP85k/3se77fwfPfL/otLbeCNfevIaRRPFYGQ/iPpoKRBTKmDNOPQ0bi2DXGnzKpm7BaTRXBVnaWME63/kAJKsW0Fod5LfbY/C2G3lwyfXsTdUCsH+f6TzueK6Dt96wmoe295LI2Hzlvh0APLyjJ38vrTVXffcpVn35IVLZMU/CO++Dh7941Dbu7Y+xdu/gEQJD304TJB17HeAn/afy69h50LkONv8GgOHO3WztGiE5cABfoo8dzz3E5ps/zJM//jRaa/7nvh1cd+taY9n07YQbLyPduZFBXQl9rmvlwBpIjhQ14ZdrO7jh0TZSWZu+vVsI2lGSveYz6RlJkOjezSHPXP7YVQW9O837PLi++H08/jV45L8K+x3PQrQbdvyxqFo0leW9P36WjR3jDDiM9hjLDSDaW+S22ldxNneOnokVPYQTrOV1/Z+gt+ZsWHQZ6dd8kftO/ZKp2L8LgFtX7+Orf97Jrp4IPaNJvnb/DjJ2QeiytsM//3oDGzqGOTAQz6/g94untvOD+zfmrcP9AzFuXb232Frsdy22LXdDzxa3UBPq30xw2x28et3HWNV7F/rhL/LnjR381Y/WYDuaHzzWzuq2AbZ2Fn/+HnEfTQkiCmWM5fMT9TdxmbUZgFDrqQBcsKiO30VOByBVuYD3XbqYp/cMsKX+Cm5sq8eqNfGIPW07GYql+fKftrGhY5jfvVCwHHwexWM7+/KdQl+kYCFc/5tNJDNGGDofvwX7yf876ojpg0MJAPYPFlw+Nz66i9gtb4UfvhI2/toU7rqPvuqz+MKjg3yzd1XRNeyBvbzle6v5w4MPAXC62s81+mFek7ifdfuH2Nw5Qn80zUAsDdvvgcQgb0x8kVuzrwfgMetloG2Sux7JXzOeztI5nGA0meUbD+yiOdsNwJ8euJ+X/ffD3PnUJkJOlLUjNbTpeVg6A09+g8ytb2L4t58yHaTjkH36BvST34SRTuPCGXCXGdn4y6L38Oct3Ty5u59Hd46zZEn/GPfYaFfR+JNN1hncZ19EX2gJz17wddrS9bxm5LP0XXUrb3vhfP75+QZT0XWxHezq5DR1gF+uPcAfNx3ihkf38Gx7wUrbfijC3S908qdNXbz9B6v599+a/50PDX6dL6W/yv4B8z3d+NgevvSHLRwaKbil0r1GeMjE4Mlv5MufdU7DS5ZGPcivs5ejsgm2blrL03sGeLZ9gD9uMlOydLnX6hiMo7U2omCJpVBqRBTKnKqWpTQqNzZQfwoAqxbXcX/iNG7MXsWhuVfwnosXEvJ5+PVzHWw7NMr5ZxrB6Ovcyy2r9xJNZfFainja5q3nzuXqc+fyj69ZzsGhBHv7YwDs6YvxYc8feP+8Du7Z2MVn7jadSapvHx5s9uzchO1o9vUVLxPa2T/C93zfxtezATAWx6bH76Ii0YWungO/+yhs+CV0rucxLkAp6KGerWd+EoDnnFOpTvewQu8luncdAEGVIaAyLLT6uOPR9YT6N3OV9Qy7e6J0tG+nV9eSqVvOT+0r+LPvNXw6fi0Z7WHn80/AszdB1wu098XybbzliV3MVf0ARHavZl5kI0+tfQ6AR/sq2ePMydddm15Kxabb0Le/Faf9cbypIZTOwrfOgB/9hckGs7zQ/rjp3Hc/BFrz+w1GcPf1xxiKpbn1N3ezdvN2PnHz/dx77+/y19+09lFwMhyoOBtt+Xg0eQqHaOAf62/kD6OnEPRZxNM27/rhM2ztGmVOUwOduoFk9w4SsShfGf0Mv/d/jsfWb2Nvv3FhPbm7YKWt2z/olvWzOLaJ5zdv5dBIgkX2AVZa7azbP4TWmsrtd/Bs4GNsP1CwFkc6trHTmU/UWws77jXtfdca3pX+HI/Y5/KIfS432FcDEOo13/dnf7eFVNZYKl3DCbqGE1z+9UfZ9fNPUUVCLIUpQEShzLFwXQPLroAqszznK5Y3kcHL/2T/imD9fKqDPlbOr+HezYdIZx1OmdNAzFsHkS4e2dHLeQvruHBxPQBvPmcu3373eVx1thk1/Uy7ydo50NPPv3h/xfWV9/HuCxdw/9Zu0lmHuox5wl6/7lmev+O/WXzDfPr6Cp2Q07mOqzzPcsmwSensGEzwVvtB+nQ1/7vghwxWLIXffQSA2wfO4NqLzTKuvwtfw1+kv8HdzqvwKZt7A5/hfelfkNbFncjI7tV81PN7vu67kfaeIWLde+ixWnjwn19JfVMrH4m8nx7VQDvzqOtdA/ddDzddzsEO47e/aEk9r2xO4XFXor3Ocx93Bf6TDzh3mveVnMMWvYTnfBfyyCvv4NrMv3Od+hKZ0W6SP38PYJ6UAejdCvF+OO+9gIbvng8/fwfDO59gdZsRnT19Ma7/7k9539b3kb37o3zowCd5Y9/N+fdj73sagH8dejM91z3DM/0hALZ2jbK6rZ/LljVy/ZUraO+PcWpLJV//y3PY48wl2bWNkQe+wunWAQIqw5sy9/PU7n4utzbwb2tfRnZgHzc/2c4DW00nv6N7lDsDX+Rx78f57iNttKpB6lWUbW17ae+PcUpyM01qlMGdT+fb5hlsY4+ey7PZU0HbUNHM5tEwoPi7zPW8P/MpDuhm4p5q5kS2AJpD/QNcsKiOxko/h0YSbO0apcEZYkWbec8KGURZakQUyp3T32xe3/KdfNHc2hB/+PhlXLCojouXmM5+5bwa414BVrRUYVfNpUUPsLVrlFWL6nj9Wa0EfRbnLayD4Q4W/e5qzgv3seGA8YHHDmzCozSBrrX8xam1xNI2D2zYQx3GSunbu4kLd3wVgL1tW+gYjPOB254zvnzgImcjw/E0Ow728EprE3+0L+HG54Z4bf8n0We9g8GWl7PZns/rzmiluSrA3c930u7MYf7SM4re7m49H+2rgNazcSwf51ttLFedBFWG4fb1VCY6sWsWEvB6WNpYAcCi+jA9oWUsjBdiGHOf/yaWgp++/yJuubqx6B6OVrzG8wJ/si/ioG4mSYC/y1zPnwfNUuer4wv4fOY6wjrBHmcO16Y/w7ar7smf/+PupegFl4Bj/PWHdqzlVu//8Lm6B9neOcCn4t8CYLmzh9OtDgCGtEkRXhQzGUh7nVae7A3SH02zpLGCkUSG/QNxLl3WyIdfuZTPvul0vvnOczlnfi17PIsJDe+m74U/8axzGr3Nl3Kt92H2DcT4jPfnALzw7GN8+U/b8yJfi7EiLKV55vkNVCnj5jvYtpkHt/Ww1DoEgL/TfH/YGaqTnexXc3k6s9yUNS5nZ3cEv8fCdO8WFyyqZ6M+hdOd3bzX9wjPBT7GB8/2Mrc2ROdwkl09EZpUIbZQlR1CKC0iCuXOJR+Hf++G6rlFxSvn13DXR1/OWfNqzL77qhQsb6kk2LiYpcr88C9YVMd7X7aIJ65/NfUVfth6N+rgc/xL6Pe80DHMmvYBMp3GHaAycS4Ld+DzKO55/Nn8/a6yC9k9Bzv28fFfPM9D23tZFDWd3CKrl0N7dzC643GCKkNX06UADFJN9xU3cMOCb+D3erhoST2LGsIMxNIEvBavuOTlAKxR5wDQ5Z2PuvLL8NovoOuC7LMAABAfSURBVOacw2W+HSxWxloZ2f4orQxQM2cZAEtcUTh9TjXR2hUAZPHQXncZCwZWc1PFjQT+fH0+u+muedfzR/tlrD3telLaxxPzPgiA32MRSWa5d3M3Fy+px2Mpdsx5G3dW/w1Pzb2OLF6ejs9DB00A/9ftfl5ovCr/eYS2/4ZXeTbx/sStfMF7G6dZHdjBeppct9/Pwu/lmvTnGdBV1OshklaIHuq4Z6PxxeespwsW1fHOVQtQSvGBVyzlrHk1eCxFy7ILCJBhpbWXTc5Sas59C3PUIHMZ4FTLuK2e3rSj8F0tdlikCm6h9+jCOJCq2H6+fv9OVnjMZzpv5HnzuR1YixebxkVn0hY821RuXM6OQxFWzq+hsdLP/LoQV57ZwuOpFZxmdfCJ8P1UqiRXdP+YOdUBDg0n2NkdodEVhV9mX82T8z+MUFpEFModpcAXOm61nDgsbqgg6PPgX3Y5i6xeFqtDXLCoDstSNFcHTeXdDwJwcewxLhr4PdfetJqqoW0klTke/ukbubXmZtID+wDQlpdFViGA+sKW7Ww8OEJzpY//396ZBkd1XQn4O71ol1pLa0WtpQUSCKENAQKBQCCzKLZZIkBAHGwGexzwxIyToYhd5aWSwWVXjT2VhAlxEtc4nmEwzthjl4PjmDEuPHFCBpvFGJcATxyzywRsFoOEpDs/7qMlYW3QQq3u3K+qq9+7bzvnne533j333nMrbI18FKYn7nP97vt4Pv0vWnDy3XtWsOnuCQDsP3aOHQc/Y0JuIhFOO57EKABKPfGMGVnAS9Wvc/K2TSxofpRN7jVQsQKGz0ByqihSh3CKbvS+1f4HHNJOhle3meS6YwAYmRaHpGkZ9rfn8EzTSBLaTlPbugP2bdHdQe1hFMxZzZEZ/0Jlw4PY1h7Ck1+m74NX17YuNLdya3E6P1lWztMNZdQ/8COW37uOdFcE+46d51DEGNqVcNKezsKdudS0beCocpPTrLuzXo5MZaldN3bbqx/w3a85i1excv5sPlPaqTQlTyLNFcU7h07jsAkLx3p4d910XvzbiUSHf7Vhtq621rc8oWo64Sn6Tb7B0dGw7rhwjPzUGN5aVcIPP1vJWscLvm2L7dt9y+PizhCtzuNSX9Bqi2B0eyP7f/scbFrMSZVA7OiZjKucyq72fHY5K9h95CwlmfHcUpjKjJEp3FaSwSvtVbQrIbH5KEQnY/9gM08eWUbz5ydoPHme/BirMbvtNi5EdX2ZMfiPcQqGfuF1RxMT7iA/VT8oyZ8JwMPxvyFp9wbdA+bTnfDjcfDp76H0G1xyDWe98xesjd5Koe0TTruKoHAexKZTdWk742z6YScjZgHwWNxjALjazpDrjmZNSTsu+ZI97lv5efutuI9vZ8LF7XwSXUJ4ZCylnnhsAtsOnOJQ0wWqRyQDkJ2o3/DH5yYiIiyYPony7ETeV/kkJad2KJVT7Vtsdnkptul2gnC3Thh4VdeiYXHE5ZQCsJsCyqfN7zhHy3md8sOdT1FmAt+algciOKMTyEvWx88cneaTZ8n4LGaOTvPVQgDG5SSyvbGJ9WdnsNV9JzVFWbS1w8IZlZwN1z29zjmSuFS0FJsomsIyoaBOHxwWS5JnJHVj0kkVHUppGT6H/FQdTpo03I0ryklGfCQ2m3RvXHeBbtwGisdNgyTd4aDevgMlNs7bXaTLGcqzEvBeOYit7TJVdp0W5WLWdFxi9QxzRnF76mn+dZYTgLbK1YgIRe9+myNXXKyKeILq8iKWTPRyp/yA+rcTiQ53sKomj8cXFPPY3CLSXZFk5YzgXTVan3PZi1DzEK4rpyhobaTx1Hkmpup2sNPKxeUrncaFGAYE4xQM/cJmE360tIzvzNRhFBJywF3A9Etv6nxIP52q00ycPqhj4WOXI6veZXdYBSscv6HEcYSMUZWw6DlY8QaiFKsdVhx93ga493c88sAaLjlcpMpZ6sdmcnuKrj2Mn3wL3qVPMce2kU1xK0ma+wMAosIc5CXHsOU9HVefkq9j+9lJuqZQYTV+AwxLiMSTGMnY7IQOpbIqfQ/D8LrHO8rj9cC9sdkJbLp7AjUFKWRl5fLtltUcyFnOolsmQ+oY8Nbo0cKXzsK4lV+5Z9MKUlhTO4KFYzPZ8Q81bL67Eof9q3+5NbUjaG5t5+3mfDLnPco91V4WV3hYUZWLw60f0Bdd+cSWamfUmj0VEnJ1qpG0MWCz4Yp0EiG6DSK++GsUpGmnMKcorW/jOsK0YwiL0T3QXB5axUmGnKE1YTiX4vIYJqcpz0qAY+/7DlPOKCILZ3WcJ3sSUX9+i7K379L3tHwJzXdt442EJXy95RHu//p0osIcJMWE88p9VSwoH8ZTi0pwx4R3EefBulFcnLQOJj8A6aVQqUfe54ueVzwr7ALKGcV3vlbuC40ZBg7TydfQb2oKUroWVN2vUyqUfQOenweNv4ZRt0PNg5AyiiigrOFhnZPHlYVM+jt9XEI2jKnXg8vcBRCZoD8AsemUtR/Fe+Zpos60QFgMeSNLybPZqX5oAQ57fRcRKnISONR0AW9yNAXW2/Gs0Wl8f+5oJg/vaAC224R31k7vKn94DAyr0Ok7CmbDtO9pmeL027mIMClPn2NYfCTRFQ3Uj/XoY+/aCnYnPL9ADxYrXfqV+xUZZmdNrR77kWU5qu7wJsewfv4YDhw/R6lHh4CeqNdxd0/eaDj+ErHZxTgyimHWejIK5oDNBrWPgCvTd55n8/6Zc396j3Up6VQNd/La3uPMGt0PpwBQvEinnLBZTishB84cwuEpJ/5KK+Wfv0rFzoWgOsaTiMuDZOosu5ecCUTOeVKnrnhtje8cLreTWfdvZEpLK1FhHY+bvOQYnlpU2q0oJZ54Sjy3AVYniPBYWuM8jL98ktYyL96LXyLRyayY4u2fbobrQgY1P811UFFRoXbt2hVoMQz9ZeMUOLkPFvwcihd2lCsFu/8NciZDYm5HeXsbHN8DES5wD+8of34BfNwppUR2lX4A98DlK22cOneZdFckYY4bqPie2KunJfVOvf5jQecNam3pqsNAcuAV2PJNuP3HUH5H76J82cKZiy14rbCVX2xqgIOvw+wn9Ajr/3m6Y1tUEnz5FxheCw2b4PFMSB4J976jt587rsdb5FZ3f+4bkmexvterfg+/nAstF2HltoE7fwghIu8ppSr63rN7TPjIMDBMuBci4mFEbddyEf0w6+wQAGx2yBz71YdpbHrX9YyyXi8b4bSTnRR9Yw4BdJ6kG3UIAPFZN88hAGRNhJwpkFfTtyhRYQPjEMDXrkBGWZfaCACly/S3ywOOcO3wrYZ4QPdkG0iHAJAySocmW1t08sHolL6PMdwQJnxkGBjKlkHxYrD7+ZOKsf7sUW49kKsPpxDyxKTAna/1vd9AkztVJwFMG9Mxl3fZHTo8mFOl52UotFJ1L3kB5Ca/X6YU6raqw9vgYhN4xt3c6/0VY5yCYeDw1yGAdgQAk+6D2Az9EDIMPvkzfT3MKKiDytUwdS1E6jYP5m3o2NcRdvPl8dboWtlmPQrc1BRuHiZ8ZBhajLtbhyVKlkDJ4sF54Bh6JzwGZq/vcAiBICYZVu0Eq2GbiLjAyRLi+OUURGShiHwoIu0i0mPDhojMFpFGETksIuv8uaYhxEkvhr/fD7H97DVj+OshLArueFmPwi+cG2hpQhZ/awr7gQXAjp52EBE7sAGYAxQCS0SksKf9DQaDoUfCY2HWP+pQkuGm4FcQWCn1Eej+3L0wHjislPo/a9/NwFzgQG8HGQwGg2HwGYw2hWHAkU7rR60yg8FgMAwx+qwpiMg2oLsA70NKqVcGUhgRuQe4ByAry1QPDQaDYbDp0ykopWr72qcPjgGeTuuZVll313oGeAb0iGY/r2swGAyG62Qwwkf/C4wQkVwRCQMagFf7OMZgMBgMAcDfLqnzReQoMBH4tYi8YZVniMhWAKVUK3Af8AbwEbBFKfWhf2IbDAaD4Wbgb++jl4GXuyk/DtR1Wt8K9JzVzGAwGAxDAjOi2WAwGAw+hmzqbBH5DPizH6dwA6cHSJyhgtEpOAhFnSA09QpFnQqUUrE3evCQTYinlEr253gR2eVPTvGhiNEpOAhFnSA09QpVnfw53oSPDAaDweDDOAWDwWAw+Ahlp/BMoAW4CRidgoNQ1AlCUy+j0zUM2YZmg8FgMAw+oVxTMBgMBsN1EnJOIVQm9BGRT0TkAxHZc7U3gYgkisibInLI+k4ItJx9ISLPikiTiOzvVNatHqL5oWW7fSJSHjjJe6YHnR4VkWOWvfaISF2nbd+zdGoUkVmBkbp3RMQjIttF5IA1cdb9VnnQ2qoXnYLWViISISJ/FJG9lk6PWeW5IrLTkv0FK6UQIhJurR+2tuf0eRGlVMh8ADvwMeAFwoC9QGGg5bpBXT4B3NeUPQmss5bXAU8EWs5+6FENlAP7+9IDPQr+dUCASmBnoOW/Dp0eBb7bzb6F1u8wHMi1fp/2QOvQjZzpQLm1HAsctGQPWlv1olPQ2sq63zHWshPYad3/LUCDVb4R+Ja1vArYaC03AC/0dY1Qqyn4JvRRSrUAVyf0CRXmAs9Zy88B8wIoS79QSu0AzlxT3JMec4FfKs0fgHgRSR8cSftPDzr1xFxgs1KqWSn1J+Aw+nc6pFBKnVBKvW8tn0fnKRtGENuqF516YsjbyrrfF6xVp/VRwHTgV1b5tXa6ar9fATOkj1nRQs0phNKEPgr4rYi8Z80zAZCqlDphLZ8EUgMjmt/0pEew2+8+K5TybKfQXtDpZIUYytBvoSFhq2t0giC2lYjYRWQP0AS8ia7RfK508lHoKrdPJ2v7F0BSb+cPNacQSkxWSpWj57ZeLSLVnTcqXR8M+q5joaIH8BMgDygFTgD/FFhxbgwRiQH+E1ijlDrXeVuw2qobnYLaVkqpNqVUKXpumvHAyIE8f6g5hX5P6DPUUUods76b0JloxwOnrlbRre+mwEnoFz3pEbT2U0qdsv6s7cDP6Ag7BI1OIuJEPzz/XSn1klUc1LbqTqdQsBWAUupzYDt66oJ4Ebmatqiz3D6drO0u4C+9nTfUnEJITOgjItEiEnt1GZgJ7EfrstzabTkwoNOhDiI96fEq8E2rZ0sl8EWn0MWQ5pp4+ny0vUDr1GD1AskFRgB/HGz5+sKKM/8C+Egp9VSnTUFrq550CmZbiUiyiMRby5HALei2ku1AvbXbtXa6ar964C2rxtczgW5Nvwmt83XoXgYfo+eRDrhMN6CDF90LYi/w4VU90LHA/wYOAduAxEDL2g9d/gNdRb+CjnX+TU96oHtWbLBs9wFQEWj5r0On5y2Z91l/xPRO+z9k6dQIzAm0/D3oNBkdGtoH7LE+dcFsq150ClpbAcXAbkv2/cDDVrkX7cAOAy8C4VZ5hLV+2Nru7esaZkSzwWAwGHyEWvjIYDAYDH5gnILBYDAYfBinYDAYDAYfxikYDAaDwYdxCgaDwWDwYZyCwWAwGHwYp2AwGAwGH8YpGAwGg8HH/wNprLbPfEWdcwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "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" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD8CAYAAACYebj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXmcHFW597+neu+Z6dkzk0yWSUjYdwIugIKgKFcBEQXfizvi7vX6Xi/X133f9brgVa6igAhugKiAIoR9TQIJCdnXmcnsW0/v3VXn/eNUb5kJJMwkM9N5vp9PPl1ddbrqdKfm/OpZznOU1hpBEARBALCmuwOCIAjCzEFEQRAEQSggoiAIgiAUEFEQBEEQCogoCIIgCAVEFARBEIQCIgqCIAhCAREFQRAEoYCIgiAIglDAO90d2BdNTU26vb19urshCIIwq1i1atWA1rr5pX5+xopCe3s7K1eunO5uCIIgzCqUUrsm83lxHwmCIAgFRBQEQRCEAiIKgiAIQgERBUEQBKGAiIIgCIJQQERBEARBKCCiIAiCIBQQURAEYeqJ9cHzf57uXggvAREFQRCmnlU3wO/fCZn4dPdEOEBEFARBmHoSA+Y1HZvefhwIG/8GW+6d7l5MOzO2zIUgCLOYxJB5zcSAlmntyn5z6/8xr18cnd5+TDNiKQiCMPUk86Ig7qPZhoiCIAgHzrUvg9U37ft4cti8zkZRyKamuwfTioiCIAgHhp2F/o3m374ocx/NMqJd092DaUViCoIgHBjZpHmdaMBf+wfYdn+JpTALRWFkNzQeMd29mDZEFARBODAKopAYf+y2q9wN5baZhe6j0Y7p7sG0Iu4jQRAmxnFgeOf4/TlXFLIlohDrh7HekkbavMwWUXCc4vaIiIIgCEIRxzHB1s13w49PM7OTSylYCiUD/l8/Abd/ALyh8rbpsYPb16kiVxJcFktBEAShhNU3wA9PhOgecHLF+ECevIVQKgqJQSMeNXvNSZgtlkKpKIilIAiCUMLIboj1moEeygdMKKZslrqPcinIxiFUX9Y0k5w+S+G6h7bR/l9/I2s7L944b/0AjHXvs9lgLM0l1z5Kx1Dxu6/cOURftPw36o2meH5P9ID7PBMQURAEoYxNXaZEhY71mx25THkDdwCNx0oGvVwaMglGY+XB51xy+gbG6x7aDkD/WHqfbW54bKcZvF3hG6FmnLssZzts6jHidtvqLp7tGOGXj+woHL/sZ4/zmu89WPaZH9y7mQ/dvAoA29HjRGMmI6IgCEIZ8YRx+dj5wdEuH1QzKXPcSZe4hnIpyCbJpIopqL26Djs1fSmp9WE/AD37GJC11nz5r89z+zOdBaHr0M2QGSvLrLprXQ8X/uhhBmJphhKZsnNncsYKiaVzZefujaYYS5l9f362i1d9Z8W4NjOVKREFpdT1Sqk+pdS6fRw/Ryk1qpR61v33+am4riAIU4+yzcDnFCwFM6hmcg4fuXk1O3uMJeFzSt1HGcjG8dmmraO89Op67GksiFdf5YrCaLkoPLl9kJztkLU1tqPNwO5+x11Os2kUL1oLA2NpbEczFM8wHDe/TVXAA0A0leUI1UWEOF0jRRfUUCJLKmubcw4mSGWdwmdnOlNlKfwaeP2LtHlYa32y++/LU3RdQRCmGMu1DFS83H3UMZzgb891s363ST31OynQbuppLgXaIeyM8bRvObvP+W9iOjStVVIbJxCFbf0xLr/uCe7b2EfSHbTTOacQH+nUc0zDEhdSvt1YKseQO7AnM2ZfNJ7iNv8X+Jj3dp7aMVj4zEgiY87rbsN4a2KmMiWioLV+CBiainMJgjC95C0FlQ80uyIxmswCEBszcQILXXjCzmbMU7JfZ+j0L8E+9s3ECWGlR0056mkQh5DPPM2Xuo92uwHiaLL4JJ/JOehS9xGYQLtLvl0snSucK5YxA3yqbyu1KkG76mHVrmKW1nA8g+1ocrbDcCJb+Pxs4FDGFF6hlFqjlLpbKXXcIbyuIAgHgOUYUfCm3UEuZ0Qh6opCIl4ywLu+d5Urxh1sT5BI0EecAJGxrXDzZWS/uZhk/84p6d8jWwYKA/ULkXazjrpLLIVedzudcwpP+2nbIZfetyjk28VSuULWUdwd4HXvegDa1CCjSbMvZztE3XhCOucwnLcUUiIKpawGFmmtTwJ+DNwxUSOl1NVKqZVKqZX9/f2HqGuCIJTicfbK1smVWwrpVEmAORsHx8ZLccDT3hA1QS8JHSzs8+kMa9c+M6l+dQ4n2DOS5MpfPsnf1u47bTRPOmtEobdEFLpLRCGVswvtcm7QvEs3oVETuo96oqnCU38ibfZ5+58HYJ4qCtWI+zvlr5P/3cbEUiiitY5qrWPu9l2ATynVNEG767TWy7XWy5ubmw9F1wRB2AvLyZbvcN1JeUshoEtEIxMviEYe7QsT9HlIKTO7eYQaAMK89LTMZztGOOtbK3h4i3lY7HuBNNNC1/KWQrQYAO513T+prE0yY/NKax3hdF/BUojrICl//YSWwsbuYnpt3hUUHjaVYutUvDB7eySR4S3WQ3zWexOprC2WwkQopVqVUsrdPsO97uALf0oQhOnA45RnyeT97XmXSJCS45nE+MltPiMGXq/x6T9mHwOAM4m4Qn4i2IZuM/DmB9oXIu0+ufeOpnEcExDvLnMf5bje9x1eE70d23WDpfAT9zVOaCls6Sv2P+7GFCLRzaS0D4DqdC8dQwnWdo7yPf/PuMp7N+mcw0jciGn8cLIUlFK3AI8DRymlOpVS71NKfVAp9UG3yWXAOqXUGuBHwBVa59MWBEE4FGit+f69m8tm406EZy9LYXjMuFZGk1nCpAhTfErPpWMFS6KALwzAEVYPAM84S831J1EHadeQ695x0z6H9iO9M5/9k7GdgksnbymkczaZVIKgyhKw4wVLIYWfUU9DuaXgikI+SN3eGCaetsGxqU11sVofBUBdpoezv72CT/5+TeGz8XSu4DaaLe6jKSmdrbV++4sc/wnwk6m4liAIL42eaIof3beFmoCX979qyT7beXX5gGtn3Ayj6AArAx8qO5aKj1G9l6Vg+Y2lsDZ4GmfGn2KFczKf4bdmstvgNqhfDNaBPY/uGjADctewGbzzaZ4Pb+mnvbGK+zf24fdavP2MhYXP5EUBzODcUOUvWgpZh2zCWB8+O4XjWgppfAyrWogXFxDKu4/yQrSgIWzSXN26Tju97bzSWUddppeLrPJYaG9J5tNscR/JegqCcJiQD3gmMuWZO09uH8SyFKe3NwATiILrPgrGdhFWxkpIay8BlSOViFK9V0xBuZbCo3WX8KPB00lj5gtURbfCT5bDFbfAUeOnNXUMJUjnbJbOqSnse2BTH5+5fR15x0LXSJI2+hmORbAdzTt++RQtkQC9UdOHpXOqC98jk7NRykylSGRMDKEQLM852MlRAPxOEieTJK19aCyiTghyRaumNNPJ77GYUxNkW1+sIAoDvnnYaQ8Ndh8Xex8mSaDQvjQdNpbeK1YzQ5EyF4JwmDCaz5zJlj+xfuaOdXzr7uKTsU+XD15O1gy4/kRPYd8QEQAyiVgh5pDHEzCWQk3IR5Igi5trSOgAkdgO0A46umfC/p397RWc//2HyvZd99B2ukaS7HGf8P3Jfh4IfJLjxx5hj+tK6o2mCxPVfnDv5sJn0zmHBrccRTyTKxug01kbO+VaCk4anU2SwofXUgzbQRM0doXo+MRTPBO4mghxGqv9VAc8xDN2YcKbE4gw7G/l+NzztFu9LFbFzKi+kWKmVjz94mm0MwERBUE4TIjG4vze/yUah54t7ktl2dYfK0uj9O1lKWjXEgilin724bwoJMfIpPcWhSoAIkETgD12Xi0JAgSSRlS2dvWwP+wYiPPYtvJ8lHlqAJ+yqUnvYWu/Cfy2RAJYllnprXT2cjrnUBc2fUhm7HHHcIv1BXQKnU2Rwk9LJMhQLmBKhrtid2J6NfUqxgLVR0OVn6qAl3g6h3aXGrUCVeysWc4p2qSnBlXxtxwYNRaH32PNmpiCiIIgVDqD2+CLtbQ8fz1nWJu4sOO7hUPrOkfRGhbE15u1lQEf5YOXdktl12SK/vK4tw6AXCpGNjWxKHg9ZqBeNqeaBCFqs+bzqdj4yqm5Ccpb37fBiNCFJ7SyQPXykP/fOMXaCkAwG2VrrxmU59aGSLkuscGSAHQ6axcK18XTOXrc1NSQz0M6ZxcC336dhlySlPbTEgkwkHXdP+7xIxxTbXWOGimIQs7RZJLm+t5gNTsazhzXf4AhVxTa6kPEUuI+EgRhJrDHTBo7ZsvPABhTtYVDz3SMAJov5H4Id3wEAB/lg1feUqjLFUXB8UewtcJOxcZZCr6gEYV8yer2piqSKoQHd+DPjM9C6h4dP4dhOJHBYyn+7bwjubSpi4VWP+daxsqpJcYzHWbGdcjnKWQIjSazhfUTMrbDUb5ePuW9lWQmR8+o6c+ixrCxFNx+BHUKsimSBGitDdJbEIUoaM0yZycAbWqAC7P3Uu01bqV0woiCP1hNd8PLSGsfaTc9Nc9I1LSZXx+SMheCIMwQ/NUA+GwzeI+qYiB3TccIy9Um2lUPjO2BkQ58lPu+dS6D42ganaIrxxsIkSCIk46Ry5SLgt8VhXzOeVtdkJRVskznBKuxlabJDsbSbOiOEk3miAS9HNVaw7+fZgbb46ydANSpGCt3GlEYS2fJOZqWiBnMhxMZtNakcw5f63w3H/HeiR3tpWc0SU3QS33YTzrrYLmWQADXUsBHSyRI1HFnYqej6JHd1CrT38s8D/L2nu+wJPqkORx3YxKhGjzBav7HfhM/zF1a9r1GYzG8lmJOTXDWZB+JKAhCpZMtn5cwVlJ+Yk3nCG/1Plx4f+sfbhn/eTvNWDpHa0nNy3pflt16DjXRzWTTE4vCVy4+nk9dcBSnLKgnrYqiYGXivPP6p3hgU3GC2O4SUfjevZu58hdPMprMEgm5T95DZlGbJmUG4lrihVnNQzHjMmqrM9cYimfI2pqXqeeLP0E6Tk80RWskSMBnkcrZWFkjCiHSqFyKNH5aI0HGtMmeIhUlt2dt4RwnKNOH5uQ2AKJRk70Uqqoh6PPw37nL+Kl9ERlPVeEz6VSCmqCXmqCXgXiGm5/che3M7ClaIgqCUOns9WSeL43dM5qiN5rmtEAnTzjHkMGLf88T4z6ucmmiiQytaohYeAEAi8JZHneOpXl4DTs6TTZRQgfIaYtA0IhOa22Qj5y7FMtSZDzhwvl0JsZDm/t5YntRZEpFoWMowWA8w1A8Q21eFIaLK52BsRTy5OMIbfXmGkOxDOmczSusElFIJekZTdFaGyTo9ZDOOniz5hxGFExMobU2SAxXwNJj2L2bANjDHDzKDOb1YyauMeqKQnVNLUFffihVJMLzCtf1kyMS8lET9JLJOXzm9nU8tWNmF5QWURCECiads3ly0+6yfV7XjfSs65Nv8qbo03Wsd9o5xTbrZNnaBInjOoByMowNDxBUWWKNJwLgSY+yvfo0AipLfNMKAIapJkmAkH/89KdsiShY7mA8UlKqolQU8llCOwfjhQymvKWQpw5zjktPaStMUptfbwbzwbhZy6CG4jmzmWSZpZDO2XhzRixDZFC5YvbRWEEUouRifcR1gB5vW+FcNVGT9hobc0UhEiHglvQAiEeOKGz7yRIJ+qgOFH+TdG5mp6aKKAjCbOO+r8Cux/er6cqdwzy4blfZPr9jRGHN7iF8HqjSMUZ1FZuc+Sy2TMbPKMYFMkI1lp0hNmDO4cxxq96nRvh/H34fNhZnahPIHtHVpPAX1jEopVQUPK47K1+/yHE0azpHCscT0QGWqU66RpLGUkjHylZCA1OA7v++9kiOYjsNGJdSqfsos5copFMJ+sfSLKx2+GjH/6Ul04E/56aUKk0oO0ySIE3VgaL7KD2GjvUzpCMkAsX6naHRbXjJkYgb91NtTV2JpQBbln8RLvkf81uTIxLyMhArTvCLzvDYgoiCIMwmcml4+Lvwqxdb6NCQyNiEVXlmT8BJwfAuPvb0+Xw1cifeTJRRqhihutAm6lY2HdXVWHaa1GAnAJ7Fr4Slr4U3X0d1pIEe3wKq3fMP62qS2k/IP14UbG/Rz+538qJgspye3jlEx1CSS042bpd35v7ELf6vojUmpjC8E4BYeH7hHBGV4GPHxPnAhvfwRd8NAMyrC6JUiaWgirGO4ZEojoalnh6WxVdxdG4jAbvoVovkhohaEerCPuLkA81jkBhkkBrq5phrO43LUE6WdtVDKh4lrX001IQIllgK3upmU8oDCKgsNQEfrz22tfjbJmd2aqqIgiDMJkqqdzLa9aLNMzmHqr1KVgd1CueWKwjrBOc7j6K0zaiuYlQXRSFmGVEY0VV4nAz2qBGF2rlL4Mo/wqJXmHb+4hP0et3OVt1GcAJLwfYVLYWQNoN1fs3iP67qpDrg5c2nmoG3SUVpUlFCpIiEvIV4wmjz6QCkvW721O/eAZiS3F/y/ooTn/pPmoKKoXiadM6mhgSOMm6bwRHj6mnxm98iYMfLRMF85wh1IR85vGStIKRGsZKDDOpagvXGfWQd/S8ALLP2kIhHSRCgvspf9p1Dfgu8Zn6EnyyRkJczFjew8StGyKMzfL6CiIIgzCZKRWHdn160eTpnEybNkNXINdn3c59zKtUksPpMELbK4y4AQ1XBZQTwbNWZ/NY+jyFPI5aTQY1142hFsG5e2flTAbPuSVp7+Zb9r7w3+58Tuo8cf1Fw8usq5C2Fx7YNcs5RzTRV+8uOz1Ejxn3kxhNSbS83P0GNW8xv1MRKMvh4l/demrbfwWe8NzEUz5DOOlSrJJmgEa1YwlgnTT7jxgk6cYJOuSjEPRG8HouagJeUVQXpMbzJAYZ0DU59u2m09HwAjgjF8TspEgSp8nsIlLiPQj4veEx6rJ9cIS4S8Fr4PIoxcR8JgjBllJR0pnfdizbP5ByqVArbV8Xv7HPpp44WVVxLOOjWM8r4ahjVRVFYdMJZHP3+X2L5w3h1Bn+ihyGrDjzlk7OyIbPQfQYf9WE/Hkvhc2cyl6J95tyOVq7lohlJZEhlbfaMJlk6p5oqN0Cdt2zmMGIG1OEdEKqnpv1Uc47mYwvntS0/VaTo1qYI3nJnHYOxDBnbxBSyISMKAXcNiAbLnDtMkqCTKAaVgYTHTOqrq/KRsMKQjuJNDTFIhMzi8+EDD8OiM8HysjhgLJmMCqKUKnMfhfwe8OZFIUuNKwpKKSJBn7iPBEGYQvKiEJlfLhD7IJ1zTMplwDypx50AAeXW97cihXZ2oJaREkshFApx6sJ6HE8Ar5MlnOpjxDNusUSc6hbTnjQNVSbI7K6nVY5rKfRTi0dpgmTIOZqNPWNobWYZhwNmYK1yYxRXeFdw0WNvgb4NUL+YOctOJ/3Wm2k+812F0w7Vn0RYpajCuKSanH4GxlKksw41KoHtikJQZfF7LKrMApDUkCSsEwyr+sK5kl4jCvVhP3HCEO3G42QY0jUE/T6Ye6Ip+V01h3meKGHSZD0m/hAssxSKohBQxn2UJxLySaBZEIQpJC8ELcdB7MXXMc9bCrW1dVy+fAGnLC2mVo5VLy5s62BdmaXg8ZvBzrF8eHWW2mw/scCccedXNSaA6lXOON96WTu3HtIebQbpatcaeHa3sVoWNVYRJk0VyYKl8EbrcSLRLbD7CWhYDEoROO6NUF3shxOIUO1+RntDBHWSxNgw6ZxNhCRO2Li3AmRoqQ2g3FnMNSpBFUmi3obCuVJ+U8+pNuQjqkOFWMYQkfLgeU0rLWqYsEqTc7OqymMKnoL7KOCmpOaJBL1s6R3j6M/dzdqSjKuZhIiCIMwmYr0QboTIvP20FGzCpPAEqvjWZSdSV1tXOGY3LCtsq1AdCavo9/e6C+VoTxAfGRqdAVKhlnHn99YW91UHvCbIOhFB8xTe5YpCPiPq2Q4zMC5qCBP++yf5me8HBVHIWzSgC9k8AITcp/u25eCroklF8SiN02xWQKvN9DI8GiOgsmhXQAJkmRsJQcoEnBuJElA5Yr6i9ZP2mT42VPkZcYKF33dARwj7ykWhzh4iTArHa36nwDhLwcRHWtUQr1r5EfjRKZBJUBP0sbFnjFTW4XdPd0z8W00zIgqCMJuI9UF1i/mXGAT7hV0R+eyjvPvIChQHfl/LUYXtV52wlAvPKPrqva6lgNePhSZCHLtq7rjzB0oCz0uaqmhvrBrXBiDWeBL/lb2Ku+0zAKh23T1rOkepCXhpqPJjda2k3eqjSiXHn6ChRBTCDXD5zXDlH1GBahrdeQpW89EAzFWDdPe7gllVFIWW2qApcgcscudjxILF75T1G7FpqwvRnykulDOkI1SVTD6jppXqbD9h0mi/+b75yWuFmIprKbzHcw/N3Q/A0HYY3FLmSppXV1IPagYhK68Jwmwi1mvcJ9VzAA2JAahp3WfzdM4hrNIod/DyBouiULvgOHgSQPGWVxxLznFwVisspfH6XFHwFAdHVVueeQQQaii6oz7zL8fssx+hgJdb7ddwQWgDaIhYabDNmgnHzYugcmbuRK0KEyhZz0F7/Cg7U24pABzzRtOnQDWWW35CzTGiME8N0t8/AIBV1YCDh6DKMLc2CG5pinm4xf3qFsIQJLW/sIzogoYwm502yBsHVU34vSXPz9Wt+NPDRFSEpPu75mMK4XxMxY0pVKmSVemGthMJFmc7N9cUf9uZhFgKgjCbiPW6lsKc4vsXIJ1zzMCUr5QaNjn+jlaEWo80jYK1YFl4vV6iGB+5L2gGSOUtDlzehoXsTW1d0SevlJo4yAyFNNVg2AS3F1YX109Y1BiGwa3gWiSBkkVqnJOvNH2fM7HgWCUiR8MRaOVhrhpkaMiIgicUwbb8xlKIBAvuo7yQVLeY9NYhagprLyyoD/Nb+7zCaYN1e7nNasz7ZhUl6P6efo+FUhDMxx4sD7arKnbQdXcNbqMmWHwO91oT/1bTjYiCIMwWtHbdR3NI5ieNlcxb+MXD23nbz8vLX6SzJqaA+0TrdwfRUaqKwhIqxhnG3LLaefeR8hVFIbRo+bguRYL752zIB2JDNcZvf0xwEI9bovvy0xdC/6byr4oZMD1nfQKu2WVcRhPgDRbLgBOshZpW5qlBYqOm6Jw3VIvtCZiYQm1RFPI0zTdxlRFdzcJGI4gLG8LECbHquM/yjOcEmurryj5DTdHltGSe+Q3zaamlczRylhEZIm1Q3epaCsWg80wtliruI0GYLWSTkEuhQ428+4+7+B2UWQqbesZY31U+6NnZNF7sgigEwkYURnQV9YEIWL5CEBggblWDA/68KLiWQo+uZ2FL87gueT0WP9eXomrmcPULdD0/WFbV1EMPvGf0pzQdEcQ5/SpefWQzrNhS1t5ZdDaezCjULjBpoPugTBQC1aja+bSPDRNIx8ADvqp6sq4otESKMYU8TfPayWoPw7qaBQ1GFObWBbEUPFB7Ef+bOZ4ra/fy/VcXLQcrUIyhBHwW4ZIsJVv5gCRWqBZCtUYU5pSIwgxVBbEUBGG2oN3VxTKaNcPuU2iJpZDOOcQzdtlgo9yKpPjyomAEwF/TCEpBVTMEi0/CCbe8RSDoplq6GUBr1VHUhssnruW5MfQO7qu55AW7vri5isVNVSxbcgQP2ScA8KbWYS4+2Y1JDJRbCtbp74EPPPSCggBmgZsC/hqYdwqn6vV80PsXALzhWrz+EPOq4ciW6jJLIa29BMK1JAkwQg0LXVHweSzm1oZY0zlKKuuMDwg3Hw2NbuZWiaAGvZ6y1FTtCqoK1ppA+eC2skCzo0UUBEGYDNr44feMpkkRIKZD6BJLIV+SOZEtlmZW+QV2XEshv37yvLnuYLzw5dB2WqF9yhshoz34fWbw8nqNEKwOvmKf3ZoTCVC3D8EotKkJsuI/zuHo+Y28M/tpekJLYazH/V4aulYVMoUAVElZjBciHyMBIFAN53+J9eGXFdZyVsFa/MEwZ7dXUxPwQiqKHTAD+SAR/D4Pq51lrHaWsaC+OPgvbAjz5HYTjB4nCr4gfOgxuPw3cNLbC7uDPqvMfVQVcus9BWuh4QiI91FnFQPPM9RQEPeRIMwa8qIwYvL4+3UEa7iHfKm5/LoC8XSuUL9/b1HIv6p8rv9bf1V2ibQvQjrpJ+xm2+yafxH/+lwW1XbOPrv1/bedPGFpi4nIu1cSgTlm+c+V14OyYGQ3nHE1PHWdaRjYP1EoEw9/NfiCZF//HbjtVe55asAbNNVlM3HQNnZ1G570KCOqlnmW4t3ZawD4XJW/cKpFjWEed0WhbaLUUa8fjnlT2a6qgJfq0hhLPkgfrDVZTsB8T7HEiFgKgiBMDncQ6RxJEfRZRKkiES2u4pXOFkUhjyfrFn3LD55+V0JCxfIOpTzZ+Ga+bL8Lj5sZ4/H5edQ5gZa9/eolLG6qYn59eJ/HS8mLQjrUAqOd8Nd/h7/8mzl4/FuKDf0Tz3cYx96iAJx84knQ4BbN8/hcUUgV4glOxLWSwuVlO0ozp95+RjHTam5dkP3hq5ccz39eUJz7UUjnDdYWgvnLIja3vN8U9hNREARhchTcRxnecPxcYjpEJlHiI3fdR/F00X1k5fKi4A7a/mrwhsyM6AmI1h7J36xzC++H3PLWcyJTk1PfVB1gfn2IUON8M/kuT307zDul+H4/3Ud58UhZofL4w4ceg39bY7a9ASMKbjwh2GgG/COXLNnnaU9aUMe/vmwhLZEAjSUWxAtxysJ6lrWUuLNKLYV83CY1wtGtblrwDPUfiftIEGYL7pNlIqc5bl6E3KZqSJUHmgFiJZaCz867j9xB1uOD998P9YsmvMQbjm8trosM5FPplzTt55P7ixD0eXjkmtfAqg7IF3mde7LxzXsD4AtDNrH/ouC6mbzBSPl+X8gIjTloJvmNuMuSuvu9NSab6q2nzeeUheMtp6+9+QS+fPHx+5x78aJMKAqjWO75ZqgmTI0oKKWuB94I9Gmtj5/guAJ+CFwIJIB3a61XT8W1BeGwwbUUNIp5dSE8oQie5PbC4bwoJDIlopB3HwVKnmBbiuUs9ubsZc2cvayYenrV2UuoDft5y6nz9/mZl0SppfKuO4tZPME6Iwr7GVPIWwre0iykvfG5MYWRVWH6AAAgAElEQVTn/mius+x1cO/noMq4j77z1pP2+VHPZCaYeVwLIxApzgVJjqBcg6bS3Ue/Bl5ofcA3AMvcf1cD/zNF1xWEwwdXFBwUrbVB/FV1hOx4wQ2Rdx+VWgr5pS/LROEACPo8vOPli7CmevZtfgJYpK0srdPEOpSxGPYHXz6A/gIi4g0aV9XGv8JxbzaWwvzTYeErX0rP9x+vG4sI1ha/Y2oUT8FSmJmiMCWWgtb6IaVU+ws0uRi4UWutgSeUUnVKqbla6+6puL4gHBYURMFiXm2IgUg91b1JuoYTLGisKgk02xDthmd/U1xycn/dMYeKvKXgFrErEKozfd1fl43Xb57IX0j0vIFi/OL4txjL4ap/HnifDxS3UirBWuO281VBamTGu48OVaC5DSitE9vp7itDKXW1UmqlUmplf/+L14oXhMMKVxSUUjTXBKita8BSmh3dJq5Q6j4aXn073P9V2u2dOFjGxz6TCNWbiXNtp47fv7+ZR3n81S9uKeRpPeHAzj0ZSrOPwAhecqSgdxVtKUwVWuvrgOsAli9fPjN/MUGYLlxRqAkG8FiKhgbj++/s7oXjF5e5j7b19rAcaHIGyPjCBF9qsPRgoZRZ3jK0V12hJeeY9SIOhFD9PmsjAUVRCNXvMxX3oFBqKeRfSy2FGWoqHCpR6AIWlLyf7+4TBGF/yYuCW82zqsYMqD39fWityyavOWkTS2hTA2Q8YfYv0/4QExm/PgNnvP/Az/PWX0FoP0Qhn410qMhfN+BmRgXrTEzBEvcRwJ3AO5Xh5cCoxBME4QBxRaE27Lol3MGmq6eXrK3zGavEMzY6Y2oetTJE1jM16aQzlrknQd2CfR/Pp4ZGxnmsDy5VzaY6qsd99g7WQnKkkOZb0e4jpdQtwDlAk1KqE/gC4APQWv8MuAuTjroVk5L6nqm4riAcTmjtoCgRBTc3v39ggJ7RVKFdPJ2DjLEUvMoh561wUXgx8jmg+5iwd9B45cfglHcU34fqoHd9Yd5DRbuPtNZvf5HjGvjIVFxLEA5XUpksIaAqmM9/Nxk31SS4f2OxMF48nSvWPAJyvsNcFOJu0sqhFgV/VXnQPFgHyWHYdA8+Sx/27iNBECaJ47qPrPyTr+s+avJnuG9jcWZzPG3jyRVFwfbNsHTUQ00+HfVQu4/2JlgLmTG45XJeZ62sbPeRIAgHH8d2l7DMZxK5lsLRdZo/7SpW34xncmWi4BzulsK5/8+4kI65aHr7UZJppZUlloIgCJNDO26hu4KlYEShwZMinrF5hbWej/j+Qiydw+ckC59zDndLoW4hXPJTM2ltOvEUC+v5sGespSCiIAizBO0OIla+GqjlAX81R6af40S1jUuth/mw53YSaRt/iSjomTab+XClZI5EQOVmbKBZREEQZgmO47qPSktEe/wsia3mzsDnqFVxqkiRSScJOMVspJda90iYYo69BN52E+CKwszUBBEFQZgtaL2X+wggWVxkJ6LcNNT0CEGKyz7ud8VR4eBiWbDgDAD8KifuI0EQJod28rWPiusAM9eUfY7qMLWY4nf1aowwJZaCuI9mDm5cISCiIAjCZMlnH5Ut+vK+e9l+9NVEVII6ZWYxN6gxwiWWQsrazzLUwsHHnV0dQERBEIRJUnAfWSWWgjeAVdMKQAsmLbWVISyliWIsBCWWwszBrZzql5iCIAiTpeA+ssr/bH3Vpqqopcwos9BjJmupOjNZ65j2aZ60JRTxeEFZBMhK9pEgCJOjGFMo/7MNRsorhC4LjACQbT4BLB+qdoqX0hQmhycgMQVBECaP1hOLQijSXPZ+kddYCpnF58E1OyYuUS1MHx4/PsR9JAjCJHHyM5qtvUWhfFGaVm0KwAWramSOwkzE68dPViwFQRAmx77cR2qv1cTqs6Y4Xrgqcmg6JhwYngB+ZEazIAiTJC8K1l6WQtmSltUteN3ZzP6QWAkzEq9fZjQLgjB58impau/1lj0+EipkthuWFPf7D/PqqDMVTwCfuI8EQZgsulD7yDPuWMJyrYL6xcWdIgozE4kpCIIwFeSrpO4dUwDI+muxseDoC4s7fTKTeUbi8bsxhenuyMSIKAjCLMHZx+Q1gDktc7GCtXDMm+C8z8Pck81KX8LMwxPAq8VSEARhkhRjCuPdR57qOahqd77C2f8XPvDghG4mYQbgdS2FmakJshynIMwWCimpngme5c77PKRGD3GPhJfEDA80iygIwmxhHzOaAahfdIg7I7xkJNAsCMJUsM95CsLswhPAp7Mz1n0kd5cgzBLytY+YyFIQZg9ev3EfzVBVkLtLEGYJ2q19pCSAPLvx+PHKIjuCIEwa98nSEkthdlNwH4koCIIwCfIpqdZE2UfC7MHrd+cpTHdHJkbuLkGYJRRjCuI+mtV4Aib7yJ6ZU5qnRBSUUq9XSm1SSm1VSv3XBMffrZTqV0o96/67aiquKwiHFYXsI/UiDYUZjdcPgKWz09yRiZn0PAVlpldeC7wW6ASeVkrdqbV+fq+mv9Naf3Sy1xOEw5V9rbwmzDI8AQAsZ2aKwlTcXWcAW7XW27XWGeBW4OIpOK8gCCXkRcGS7KPZjcdYCh6dmeaOTMxUiEIb0FHyvtPdtzdvUUqtVUr9USm1YKITKaWuVkqtVEqt7O/vn4KuCULloPORSZm8Nrvx5kWhci2F/eEvQLvW+kTgXuCGiRppra/TWi/XWi9vbm6eqIkgHL7ks49EFGY3rvvIY1euKHQBpU/+8919BbTWg1rrtPv2F8BpU3BdQTisyK+nIO6jWY7XFYUKdh89DSxTSi1WSvmBK4A7SxsopeaWvL0I2DAF1xWEw4t86WyxFGY3bkzBO0PdR5POPtJa55RSHwX+DniA67XW65VSXwZWaq3vBD6ulLoIyAFDwLsne11BONzQL7DIjjCLKFgKFSoKAFrru4C79tr3+ZLtTwOfnoprCcJhSz77SCavzW7yloJTue4jQRAOAWIpVAgF91FumjsyMXJ3CcJsQeYpVAaHQaBZEIRDQV4UpCDe7GaGB5rl7hKEWUKhzIW4j2Y3rqUgoiAIwuTQsp5CReDxAWA5ElMQBGESaJmnUBnk3UeIpSAIwmSQGc2VgWUsBY9kHwmCMCnclFSPiMLsxnUf+UQUBEGYFIXJa/JnO6vJl84W95EgCJNBawdHK5RHVl6b1RTWUxBLQRCEyaAdHBSWElGY1bjuI5nRLAjC5CiIwnR3RJgUSmErL15EFARBmAzaQWOJpVAB2Monk9cEQZgkWov7qEKwlQ8v9nR3Y0JEFARhtiDuo4rBtrz4xFIQBGFSaAdH3EcVgSMxBUEQJo120ChEE2Y/juXDI+4jQRAmhXbQgBJVmPU4yoefHNotXTKTEFEQhNmC6z4SZj+25cNHDtsRURAE4SWj0YiVUAk4yojCDNQEEQVBmDWIpVAxOFZeFGaeKsgdJgizBKXFUqgUHMuHX+WYgZogoiAIswXtzlMQZj+O5TUxhRmoCiIKgjBLUG6ZC2H2o90ZzeI+EgThpaMdHElHrQjyMQV3iYwZhYiCIMwaHIkpVAjaMvMUxFIQBOElYwLN8idbCTgen8QUBEGYJBJorhi05cOnKjimoJR6vVJqk1Jqq1LqvyY4HlBK/c49/qRSqn0qrisIhxUSaK4YHMtvYgozTxMmf4cppTzAtcAbgGOBtyuljt2r2fuAYa31UuAHwLcme11BONxQWmIKlUI+plCpZS7OALZqrbdrrTPArcDFe7W5GLjB3f4jcJ6Sql6CcIBotBJLoRLQVmWnpLYBHSXvO919E7bRWueAUaBx7xMppa5WSq1USq3s7++fgq4JQuWg3CqpwuxH51NSZ+B/6Ix67NBaX6e1Xq61Xt7c3Dzd3RGEmYXEFCoG7XEDzc7MW1NhKu6wLmBByfv57r4J2yilvEAtMDgF1xaEwwiNFq9rRaAtHwB2LjPNPRnPVIjC08AypdRipZQfuAK4c682dwLvcrcvA+7XM3F1CUGYwcg8hQrC4wdA52beOs3eyZ5Aa51TSn0U+DvgAa7XWq9XSn0ZWKm1vhP4JXCTUmorMIQRDkEQDgSZp1AxaI+xFLBnnqUwaVEA0FrfBdy1177Pl2yngLdOxbUE4XBF4Uj2UYWQdx85ufQ092Q8cocJwixB3EcVRN59ZOemuSPjkTtMEGYNMnmtUshbClRooFkQhEOA0uI+qhhmcExB7jBBmCXIcpwVhCsKWkRBEISXjkxeqxgKMQURBUEQXiIKB2TyWmXgioK4jwRBeMkoLQXxKgYrLwpZ+N/XwLO/nd7+lCB3mCDMEhQOSEyhMnBjCio1Cl2rYPcT09yhIiIKgjBLUFrLjOZKwWssBV+827wf65nGzpQjoiAIswYN4j6qCJQbU/Anes2Ose7iQceZhh4VkTtMEGYJSkpnVw4eU2HIl3AthFJL4d7PwZ0fmzZxkDtMEGYJCi3ZRxWC8gYACORFId5vgs47HobHrzXZSdb0DM8iCoIwS5CCeBWENwhAIJZfekZDrBfuvgYaFsNrvzxtXav4O2z9nlF6o6np7oYgTBopiFc5OOEmktpPKFGyHtnWf0LfenjFR8BfNW19q/g77KobVvKj+7ZMdzcEYdIYS0HcR5WAZXnYqVvLdz76Q7C8cNyl09Mpl4oWBdvR9EZTRFMzrzytIBwoSmsq/E/2sMFSim16LgCjPnc9+qHtsOwCCDdMY88q/A4bimdwNCQzM29xbEE4UCSmUDlYFmx3RaHDu6h44NxPT1OPikzJymszlYGYWdUolRVREGY/kn1UOVhKsd2ZB0CfUwsLXwlzjoHWE6a5ZxVuKeRFISmiIFQAllgKFYOlVMFS6MlVwXvv5h29l/O9f2ya5p5VoKXQP5bmPb9+ig+9eikZ24iBuI+ESkBiCpWDpYz7KKV9bM400jmc4OEtA6Rz0zubGSpQFCI+m5rux6l55j46514AQConoiDMfiSmUDlYShEjzOsy36ZHN9Cw2qSmdg0ncRyNZU2fm7DiRCGQjXKL/2uwA55KdAMXkRJLQagAFHq6uyBMEZYbG9qtWwC45andAHSPJvnQzatIZh1ufO8Z09O3abnqwaSmlc/Vfp2tvqNojq4DJKYgVAZKCuJVDHtXsOgeTdFcE8DR8NDmAWoC0/e8XpF32FDLK1jFMbQlN+EjJ6IgVARKiyhUCnoCo++qsxYD5iH2uLbIIe5RkYq8w9rqQjyaasdPlqPVblJZB8cR01uY3UhMoXLwecz/46WntBX2XXBccYbz8fNqD3mf8lRcTAGMKPw1uwQ8cIq1hefsJaRzDiG/Z7q7JggvGQvJPqoUWmuD/OPfX8WSpipW7R7mslPnM68uhFLGijhu3vRZChUrCntoZI9u4NzAJm5MXEAqa4soCLMahWNyGYWK4MiWGgAe/NS5hX2tkSAKaKwOTFOvJikKSqkG4HdAO7ATeJvWeniCdjbwnPt2t9b6oslc98WYVxcCFA/bJ3KxbxUebJJZm/qDeVFBOMhYSJXUSuflSxqpnsYgM0zeFv0v4D6t9TLgPvf9RCS11ie7/w6qIAC01YcAeNw6iWBujJPUNgk2C7MeyT6qfH5w+cl85ZLjp7UPk73DLgZucLdvAC6Z5PmmhNqQj2+/5UQ+9cEPoLF4lWetzGoWZj0WjtQ+Eg46kxWFFq11fsXpHqBlH+2CSqmVSqknlFKHRDjedvoC2ua1kaxZxFK1R4riCbMesRSEQ8GLOq+UUv8EWic49JnSN1prrZTaV97nIq11l1JqCXC/Uuo5rfW2Ca51NXA1wMKFC1+08/tDrqqFOaPD4j4SZj2WdkQUhIPOi4qC1vr8fR1TSvUqpeZqrbuVUnOBvn2co8t93a6UegA4BRgnClrr64DrAJYvXz4lEwucqhbmsIMt2ekvNCUIk0FJoFk4BEz2DrsTeJe7/S7gz3s3UErVK6UC7nYTcCbw/CSvu9/o6hZa1DDJjKy+JsxuLPT4+giCMMVM9g77JvBapdQW4Hz3PUqp5UqpX7htjgFWKqXWACuAb2qtD5koWJG5hFQGOzF6qC4pCAcFhYNCAs3CwWVSCbFa60HgvAn2rwSucrcfA6ZtOSFPxCxkQbwXOHa6uiEIk8aSQLNwCKj4O8xXa0TBE++Z5p4IwuSQ7CPhUFDxd5ivzqyD6otPGAMXhFmDR4koCAefir/DrIjJpvWn+6e5J8KMQOuJ6xbPcLTjZs+JKAgHmcq/wwI1JAkQSoqlIAA/Pxse+u509+KAcUQUhENE5d9hSjGgGmhI7nzRprajWdMxgp6FT5LCfpCOQc9zsOaW6e7JAeM47uRLqZIqHGQqXxSAB7xnc3TsSdj1eNn+5/dE+cztz5GzHUaTWc761v1cfO2jPLBJXE0Vycgu8zq0DQa2Tm9fDpCCKIilIBxkDos7bMPS99GjG4j+4xtl+/+6dg83P7mbp3YM8dSOIeZG13KT7+sM7T5k0ygqF8eGx38KqRk0P2R4V3F7893T14+XQDGmIGuCCAeXw0IUrnnTaTztORmne23Z/l2DCQDuWtdNrHsLt/q/wtmedczf8fvp6GZlsecZ+PunjTDMFPKWQu1CWPenQ3vtbGpSH7dtYykoqZIqHGQOC1GoDfvINR5JnTMMiSF6RlM8vXOInYNxAO5Z10uudyN+ZTNIHUcMrJh8horW8MA3oW/jFHyDWchop3l95jfGaphu1t0GXavAVwWv+IgRrb0eEg4anavgay2w6Z6XfApxHwmHisPmDss0HAmA07uBr9+1gSt/8SQ7BuI0VfsZiKXZ2bUHgIfC59GU3QO9617ahbSGZ26GnrXwwDfg2Zun6ivMLqJd7msnbLt/mvvSDX98Dzz3B6hvhxPfBp4A3PcliB1gVtof3gMb/lJ8P7gN+jaUt+nfDHd8GOwsOA7c9R9m/+aXLgqM7DavIgrCQeawucN8LccAMNrxHCs29ZHOOfgyo3x8rnmSHx0ZAmB90xvMByb4A77+kR1c99C44q7ldD4Nf/4w3P4h835o+9R8gZeCnYX/PW/iJ9TuNbDln2Y7E4fdT0x8DseGOz8GOx89sGtH94A3BOEmWH3Di7c/mPSXWGuhegg3wGs+C9sfhNs/sP/nySRg/W2w5lbzXmv43TvglivKLcubLjEPA/0bYceDsGe12T/WPf6cExHrh+dLakv2baDmV68GQElBPOEgc9jcYbWtS4jpIB2bVjOWMhVT3+35O+/s+Cxz1DARTHyBhiPYoNvNgFGC1pr/eXAb1z20vSxldXt/jC/9ZT052w0Edj5tXvvWm9cSUXh4Sz///c/NrOkYmbCPtqPpHk3u/5dyHMhl9nlYj3ZC10pG1/19/MH7vwp/eh84Dvo3b4HrL5g4KPz8HbD6Rnjk+xNeI5rKsr0/Nv7AaCfUtsFJV8Cmuw/8iXwCVu4con8sDZjffZfr/tsniSH4xfnlT/badcOc+XE45UroWl0Y0LXWRFPZfZ/PHdSdzpXmfefT5v95eCd0PGlchY5TtJLGek3swl8DR78R+p4317ruXHjiZxNfI9YP310Kv3+nEdaS6xokpiAcXA4bUZhXH2arbqOt6+9c7bubo1pqON7aAcDLIkPUqAQ55aOxrpYH7ePRu58wT9Au2/rj9I+lGYhl2D2UKOy/bXUXv3p0Jxt2dJgdeVHIM7TDDBSdK7nhtr/yq38+w9f+8PC4/m3rj3HCF//OK75xP2s7R8hue5jP3HAP/T8+HzbeNfGXevS/4SfLy55S00MdxH56Hnp4JwOdJu1yoMN1b2y8y/i3gWjHOkiNQP9G1G6Tqpse2FV+fq3hoe+5HVwB8YFxXfjxfVu4+NpHi6KYJ7qHXPVc7g68DpwcrL/D7Ldzhf4+vm2QPz/bNfF324u+aIorrnuC79+7Gews/3HrSj70m9WF45mcUxCMAh1Pmv+PVb+GQC1c+F246MemG45GNx1pfoO4SUH+1aM7OfGL/+COZ7rYMTBecJxRM0hbsR4zYK+6gYypCg83vInMdefz+Wt/WfzA8A7YcCf66Ath3snGBdS3wVgOm/6218ltSEXhT+8t7Hp85UrzAFIi1krcR8JB5rC5w9rqQ1yfewMjToj/9PyWS4+p4kTPTgBOqx6ihgRZbzWttQEecU5AOVnY9Vjh849vHyxsr9o1TG6sn9iOp1i/Z5S3e+7juJtPhYGt6I6n6Qu2AzAamAu5JMR64Bfn8YvkJ1gTvJpPjX513AS5v63tJuGuI711/Sp8N72Rr+24nObBp+l56JdMyM6HTUaN62/uHk3yk5/+kOq+lWx54Fb6Oowo1MQ7jDDd8UF48JuQiRNJmQEu9tCPC6cb2rNX7v7ILvMkfNq7zRP2r/8FHvqOGdhdsp1reGP272zujZHK2ty/sRftODijndzT4eFD94yR9FTDwCawc9jfXETsjk8CcO2KrXzjro0kMzYdJUK7vT/GOd9ZUbbv9ys7yDmap3YMom+8mFsH3sLS3rsLbX716A5e870HypddzbuNtA3NR8IZ74emZWzsifLa7z/INQ+6IjKwGYA/r9mDhcMPfn8P53/vfvpW3lkmuLGBjuK5u1bB9gd4zHsG651FYGfw58Z4c3+JBbDuT5Aa5YOrF3Dter/Z98xvzOueZ83/CYDW7LjpI/DNBbDjITjzEwD86b5H2NgzBonivaeQiZXCweWwEYVI0McK36v49+yH8WJzVfhBWjBxhKN8fdSoJLa/hpaaIE87R5HxVOE898fC55/YOkBrTYDqgJdVu4ZZe+sX8d1wIX0dW7nGeyuWzsFTP0dFO/n52Fn8tv0bXDN2uflwT3nQ+nS1kb69nmpX7hrmqJYamqr9pDtWlx0bHXPdMyO7jUvCRfe6Lqqe5wC4b0Mfx6afBSC34xFivcZ11ZDtNq6L1CgM7SDbt7lwjur1vy1sJ/p2Fi+ajpkgKtC14I2sarqYwYzHuJ3uuabQ7OUDf+Jr3utZt30Xv1/Zwf/eeAPp75+ANbaHHZk6Tl1Yz5bsHBI9W4g/fROebIzqNdcDxjrqG0vxqT+u4exvryi4blbtGmbnYIKHtvSjteamJ3bx68d2sVD10tvfj9r1KH6V4xrfrfzzeVP9NrH1UT6Z+yXrOkdYv8d9su4vfk+ajgLAcTTv+/VKYukcm2y3rHr/JlJZmw3do/x+7m9ZEfwUV1l/Y85f3wHb7iucIj5gMqpsLBNzinbydKad7+bext2N7yKnLU6xttLXdj5UtxpLBXg6t5Tf7a4xJ1nrxiPSUTOJ7o4Pw81vpWXnn1njHEH23C/AuZ/BwWKB6mNz7xjEi6JQnyj5PxKEg8BhIwpgrIW1egm5yAI893/J7FQWC3U3EeKoYC0ttUHS+Lk1/Uqc526DxBCO7XDl1k/wYO5KfhX+ETt3bkMPbSNAls9kf0yditPJHHjqOjSKh50T+PqOI1in2801tvwDgI9kP87moz+MoxW7+opxBdvRbNnVxb+F7+GE1iCBgfVk8PHGuj/zuO/lVKdcn/LNb4PbrzbbsX5UzAhEfv7F5u5RXmmZiXfzos/iuJO1vNgmQAowvJP+rUZ0RnQVAJ/Pvou09pEd2oXWmrv/eS+5bywk8dSNAPzrbf28bc8VnNb7GZ5ruADW/gFyabRjU5fpxlKa6ObHWL2jny96byAYM4NnL4386O2nsFO3kO3bSmaFqTnUr2uJp3N0j6ZwNPx1rfl+dz9nXrtGTFzlmd0jXP/oTj53xzoag5p/hj/Hd30/B+BZ5wja1CDr1hj//pH9f+c93r/z9T89xr/86BEe2zaA07+RtBU237tpGemczTMdI3SNJPn0hUdz8nHHkdAB9MBmntk9whuch1k+fBeWtvmo13V3bVtR+H/KDHcS00FWO0ei1/wOgFXZRaxwTuFDXRewzjIZbn/InMmWVAS0Q9zXwLCKkKxawM7AUeapP9xkTti50sQ7tt5LWCf4Vu5yNhzxXhKOxR7dwALVz7a+GCSKbrv6hsZ93t+CMBUcVqKwdE41x82rxXt60W9L+1m05jo5qk4TqqlnSVMVX3jTsaxqvgSvzrD6+k/wjzt/wytYy1DTck5OP80nh79KVdK4X17peZ4doeO5KWvWGnqq4U1s1guIpXPs0U2k8aE3mZhApu4IGucuxlKavm7j8lnTMcJrf/AgF+bu5cLua3mvczvN8S1sdBZwxhFzSITbaMj2mABk/wbY+QgkRwqBbEcrxnY+A0C2YxW1Kk53wxnUMcYR0SfJaDMD1nnWtQicLLkt95HVHv54/P/w8cxHudG+gD26ASvayX0b+tj+wI14sQlu+StZK8jOTIS/fPQsLjiuhV+NnALpUfjuMnI3XspcbQLIVT1PUb/jLxxldbJbtwAQrGthfn2Y4UAbteku6tOddOsGmtUoWzuLFs/51ip+6PsJv1/ZSTSVpXPYiMKKjX188+4NXLFMc89bq/DbMV5rGRG40TFZYnXdDzOSyFDlusPsQWMdfevujTh9m/hT5uU8v+gddMx7Ay//+n1cfeNKfB7Fa45uYWFTNVv1POydj7N+/Vo+4b0Nu+UEiMynRpk+OFv+yY77f4mdGkNHu+nV9fzDPtW4F4H1TjvL5lSzbE41bWe/gw41lx92LGFruhaATl878+tDvOrIOXwx+04A7nDOIucJmqysdBRteenWDTzhHMv6PVGe3D7EbmcOC1UfW/pikBikzz+f93m+SsOFn3vJ978g7A+HlSh849IT+M37XgZn/Tu87174P3+AeafgGdnJvEAKKxhBKcV7zlzMZRdewHW5f+HUgT/z+jUfo0s3Yl/+G7qPfhcnqO206WI2TdXJl/IH+9U813Y511r/WtjvYPGkfTQq2oWjFQuXnkBdy0IAOndtY1PPGDc+vovt/XFalLEcTh+8g5dZG1jvLOL1x7diR+YTIk32eTeDxsnBbVfDjRcD8JhzLFbvWrRjc9nQz0h4avC8/qs4WjFHjbDRYwLoh1UAABEgSURBVNwm1li3SccEmnseYhetXHnJG1kVMWLWTTPNo8/hW/EF3uQxbg9L59hFK2csbuTYeRHeeOI8/pY4GtsbhtQovp0PME8Z18aS1DrOTd3PgG8ur01/i09lrybR/loAcrWLC7/J4zWvA+DZtc8W9r3B8yQXex5j566dvPIb97Ouy7h/BuMZFvpG+UbXu1Fu6qhHGZ/6fbkTSUWW8Gr1DLet7qLVMcHiRaqXY+dG6O3cjjcX53m9iBtqruaDf+0jnrYZjGc4c2kTtSEfixrCPOycgLd3De9d/WYWWz14XvUfsNT8JlucNqyBjSx+6JNs/t1n8cR76NX13OucBkC8up0xwnz7shO595Ovpvk1H+XLi39DBh89ugGAjXYbRzRX87LFDTyQWMx3W7/Nl0dez4P6VHAD/M+85iauzHwaB4v1e0b5x/O97LFaWOodYGtfDB0foCdbRXjpWSh/+EBueUE4YA4rUagJ+qiv8oNSsOAMOPJ10LgU7IxJHQ3WFdqetbSJvpd/lt+2f43/zV3IN4OfYH5THc1LTsavbGpUkpzXuF/mnHEZrXPn86Xcu1ndr2hvNH+4RzRXscI5GYAe1czHLzgRT10bAGue38BFP3mE+zf28vrjWnnHEebJNJgexK9sFh77Ms5Y3IC3sR2AbfddT1r7GNLVsMWkmHbqJu5xzqAm3UP612/mNDbyzLH/yZwjX0Z8sRl8qxeeQJduJB1sYvMZXwEgZI+xpeo0gj4PX774OC47bT7x0Fzqs728uv8WFqpeEioEwObsHN62fAEA5xzVjPYEeaTpbYxhvqNP2WQDDZxqbeVMax25Y9/Cq49dwB/sczhugXF1+OYcAUBUh6k+8SIAdmxZR75iwxJl4gLfOydALJ1jY88YbXXm+p87uts8lecnbwGjVh3vf92pBE66lLM867j7wUdoU8bF0m718sMrTuacoIknbHQW8Lfnuvn/7Z17dBTXecB/36529ZYWvd9CAiStLAGSBQhjMAIM5h1qwCI2djExp7ZJXbd1j22IQ2r7tE2ccOI2qQ913MY2sUNcv+KSQy3A5vQ0gBXzEI9iCwXCUzyEZQRGz9s/7mglgRYBElrtcn/n7NmZO3fmft98s/Pt/ebOd/ce/5oX5hWw+r4RfG+WnpY1MzaMH7WU83bp+/yqZRIH48rAPRsKF3DRGcvK5oc5pVzUSDrZh94i8cL/cdYWwyGVzJnoAo66SgAdlmzHnaSfHdSidf/sm2TtFLK1k/iXQ2nUEcUbMlvvEJXGtpZcDqpU8pIi2X20no/3ncQZl42rrY4TZ+q4VH+a2pYI7hhiQkeGm88t5RS6JUbfsGhrgZAoT7GIsHJWPvc9+DjvxT9GYuEUAEJTbvPUaZr09/DgBzAokynuBCoPn6OhsYUFJelEBgfxyPhsNrYVAxCekkd0mAMi9UxwGXKKsJavOHexmSn5iYTWV0PBfHh4Ayp3JuNmLtb7Jeh/2XmNVRwNc7O6rZy1YYv5xdgK7m1cxVbXbCrbcgn506e82TKZ4GLdU4ks0yNYEjPdTGxczWzHq0zb4KJROQCIHlUOwGR3Ii8tGEGoU5dvbC3iy4yFfJq8BIBDKomJufH6mCEOpuQn8J0j01jU+GzHeZjyPM2ubOyiiB37AE9Pz6Mow8VdOXo/V0oeAJ+rHMaUjAYgqP4w90ft5tHQjWSLDv2MizqFw649xbeKUnjrkVIm2PeATctG7gwte3oByycNQ0Yvo02CWHxprSfcs8StGJYQwXdDN3CwLZm9QXk0NLZgE5ian8i8ojSGxEcAkB4Thgi8vKONlS1LaZ7/OtjskDWeY0t3URtzO0eW7KCi8MfY2lpwqiZUeCKhDjtTv3qGGdVzcQbZiAsP9pyLxWMH89PykR5nXtWcxtCECDJjw3nlgWLeWDqalTPdfHIhkx3h4/mgdSxrtx0m1RVKWV4Cu4/Wc6ahieRh+s9ECXu5VF/LOSK5Oz/xKheywdA3BPlaAJ8TO7RjOTjqis12m/DRd+/E1p7HPi4HhSAowjKLIVXf9OcWpfJR1QmUghmFyTwyPhuHXTh4upRTxyaTMNJ6Uzoshlabk2ccb7E8eD3jLr7ExMRL+p9w0YOQUYpklHraj0ntkC+sZBHuiFmsrviC05tPATG8OLOAZW88yXj7PraGjOfTNKu3k3kHPLaVsJhsMj7/PSfPN1I+ejBHdycQIU2UTrini541SdMo/PoTnldLWTd/AU3bfw/Hf85F1zDiIjpueg+Py2J91UlqbOm0KsEuirCsMUhhBZz+AkeSm2zgvcfGefZJy8iksi2HyqjJTIyJp16FkS0nmK0+JkTV4RA9xNVRU8FzrlSeO3s36YPCGJs1CN7ZDIXzwZUJ+XP0i1yDrWNHJtLinsecfR0JDAddOgZ73yX1my/4vixjcWk2a7bUUJQxCFeYs4vOIQ47seFOjtdfIjM2jNzESM+2YYmRfPJUGQBB9jHc+9kqlge9z8G4Mr53Vz7v7zjG9kN1tLa0dVwbQHxkMHNHprKyZioPVzaxSw1hldV7uKdAj3Zy2PV/sXlnHyUuwkmKy8lT03K5PXMQX9Y2sPPIOfInzKe16gWWsYGwlnoiBiV2sYPBcLMwTiEiAZwR0NTQpafQmc4/epxhMChTv8XqyvAUD4mPYNPfTLxi3xUz84F3OwpEsIfHwvkTRLbVs821gtBXrecT8TlX7J+SqKcTrZU4ksr+gm/bbJTlxTP2H3Q+obK8BEoLcvigKoof3eMmxNEptXKCGwEq/tpKkSBCXdY/YgtyYrN3TcFcG1fKiKpXebxsCAlRIaQMHcGcjc8zfsykLvVuzxzE6MExhDrtXKzLIrKhBolOB0cIpI/q9vwNTYxkeNMqyrN0GKo5JpeF9f9LUFNH5lBlC0KqK1gM/ErySBs0Vr/b8E0dZN0FIxfpio9shk6ZQkOKFkK7U0gqhCNbdbK7tFH84M9fYP/pRtZsqWGi1Wu5nLoL+o3wVbNv85qBdHhaNAl5d7Bs/xAWRqXx5JgM5oxMoeD7GyhI7f6ayYiL4s22YsZmxzIy3dVlmztZ7+OwC797YgLxkR03+1cfKqGxpZXgIDuMWcYdm54HgcGZmd22YzD0NcYpiEDsEJ0LqJueQre7xLt12oawG4zxtqctcGUQ2ilWTrz7iqrhIQ4eiP4Pxg3P5VEr701ydCg/v7+YmtMN2G3CszPcjEhzcW9xWvfydrrZxRTN6bbO/WMysdtsLC/TPZPhadHcNqqM8jHZVxzr9aU6BBTy4e3wp2btEK5CVIiDlTPdjBuqh2LGLXwZ/n06OBNpu3AGm2rVjuWc9Ya584/kJEXA4S36AEkFnQXoevCsCR3LQ6fodzaSCuHb6yAomLwkJy8tGMHU27oPvfzzomIOnb1AWV6CV/lFhNX3jeDv3tntOccRwUFUrpyC3YsjmTU8hQMnG1gx032Fs4kOdeBOjmJ4anQXh9BOcJDlsEd9Bzbp50Du7MFe5TMY+hIZqFNPlpSUqMrKyv5p7DdL9Dj+ha9D/tye61dvhNq9On/OjfDKnfrm9VSNfps2LgeqK3T2Ti83GaXUwMulf/6kzi+UmH/9+54+AKoNfvuEzj+0+F2ofA1qPoEhkyGjVDvP/1kNzx4HR6j3Y72UAw21ut6R7bpnMcATx11qbiXIJgTZe5Dzoyf1eblvLbhn9Y9wBr9GRP6glCq54f2NUwA2vQhbfgiL34chZTe/vYt10Hheh6Fudfb/VqeMmLJKr795r3aQoHtu4XHwlzuufowLZ+H8cd1DCDRamqBqHRQuhCBnz/UNtzy9dQomfAQdD5tDXVev11eExeiPQQ8Bdc/uWE8p7nAKjV/D4Dt7PkZ4rP4EIkFOnc3VYOgnjFMAPaql+SIkjfC1JIbc6Tpdd2iMfmgcn+triQyGW4qBHXjtLxyhULJkwMehbwlSi2H5ZzozK0B8nk/FMRhuNXp1FxSRBSKyV0TaRMRrDEtE7hGRAyJSLSJP96ZNwy2CezaMXQ4503wticFwS9Hbv8Z7gD8DtnirICJ24GfAdCAfWCQiNzBcxXBLERwB01705GsyGAz9Q6+eKSil9gM9DZUcDVQrpWqsum8Dc4F9vWnbYDAYDH1PfwTRU4FOU1Zx1CozGAwGwwCjx56CiFQASd1sWqGU+qAvhRGRZcAygIyMjB5qGwwGg6Gv6dEpKKWm9LKNY0B6p/U0q6y7ttYAa0C/vNbLdg0Gg8FwnfRH+OgzYJiIZImIEygHPuyHdg0Gg8FwnfR2SOo8ETkKjAX+S0Q2WOUpIrIeQCnVAiwHNgD7gXVKqb29E9tgMBgMN4Pejj56D3ivm/LjwIxO6+uB9b1py2AwGAw3H/MKr8FgMBg8DNgsqSJyGjjci0PEAWf6SJyBgtHJPwhEnSAw9QpEnXKVUpE9V+ueAZsQTynV/VRZ14iIVPYmfexAxOjkHwSiThCYegWqTr3Z34SPDAaDweDBOAWDwWAweAhkp7DG1wLcBIxO/kEg6gSBqZfR6TIG7INmg8FgMPQ/gdxTMBgMBsN1EnBOIVAm9BGRQyJSJSI720cTiEiMiHwsIl9a3wN+sgEReU1ETonInk5l3eohmpct2+0WkWLfSe4dLzqtEpFjlr12isiMTtuesXQ6ICIDctYgEUkXkc0iss+aOOsJq9xvbXUVnfzWViISIiLbRWSXpdMPrPIsEdlmyf5rK6UQIhJsrVdb2wf32IhSKmA+gB04CGQDTmAXkO9ruW5Ql0NA3GVlPwSetpafBv7J13Jegx4TgGJgT096oN+C/x0gQCmwzdfyX4dOq4C/7aZuvnUdBgNZ1vVp97UO3ciZDBRby5HAF5bsfmurq+jkt7ayzneEtewAtlnnfx1QbpW/AjxqLT8GvGItlwO/7qmNQOspeCb0UUo1Ae0T+gQKc4FfWsu/BL7lQ1muCaXUFqDusmJveswFXlearYBLRJL7R9Jrx4tO3pgLvK2UalRK/RGoRl+nAwql1Aml1OfW8nl0nrJU/NhWV9HJGwPeVtb5brBWHdZHAZOAd6zyy+3Ubr93gMnSw6xogeYUAmlCHwX8t4j8wZpnAiBRKXXCWj4JJPpGtF7jTQ9/t99yK5TyWqfQnt/pZIUYitD/QgPCVpfpBH5sKxGxi8hO4BTwMbpH85XSyUehq9wenazt9UDs1Y4faE4hkLhTKVWMntv6cRGZ0Hmj0v1Bvx86Fih6AP8KDAFGAieAH/tWnBtDRCKA/wT+Sin1dedt/mqrbnTya1sppVqVUiPRc9OMBvL68viB5hSueUKfgY5S6pj1fQqdiXY0UNveRbe+T/lOwl7hTQ+/tZ9Sqtb6sbYB/0ZH2MFvdBIRB/rmuVYp9a5V7Ne26k6nQLAVgFLqK2AzeuoCl4i0py3qLLdHJ2t7NHD2ascNNKcQEBP6iEi4iES2LwNTgT1oXR6yqj0E9Ol0qP2INz0+BB60RraUAvWdQhcDmsvi6fPQ9gKtU7k1CiQLGAZs72/5esKKM/8C2K+U+kmnTX5rK286+bOtRCReRFzWcihwN/pZyWZgvlXtcju1228+sMnq8XnH10/Tb8LT+RnoUQYH0fNI+1ymG9AhGz0KYhewt10PdCxwI/AlUAHE+FrWa9DlLXQXvRkd61zqTQ/0yIqfWbarAkp8Lf916PSGJfNu64eY3Kn+CkunA8B0X8vvRac70aGh3cBO6zPDn211FZ381lbAcGCHJfse4DmrPBvtwKqB3wDBVnmItV5tbc/uqQ3zRrPBYDAYPARa+MhgMBgMvcA4BYPBYDB4ME7BYDAYDB6MUzAYDAaDB+MUDAaDweDBOAWDwWAweDBOwWAwGAwejFMwGAwGg4f/B7D1uT8K6L2RAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD8CAYAAACYebj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXeYZFWZ/z/nVg6dc08eJpJmGIasgiAuSpRVEcXssqw5rWnXhO6KLj9XFAURVEQWEJUgGQaGNDNMYpice3pCT+fu6srpnt8f51bq7oFhpumuqjmf5+mnqu49995TVV3ne99w3iOklGg0Go1GA2BMdAc0Go1GUzxoUdBoNBpNFi0KGo1Go8miRUGj0Wg0WbQoaDQajSaLFgWNRqPRZNGioNFoNJosWhQ0Go1Gk0WLgkaj0Wiy2Ce6A4eivr5eTp8+faK7odFoNCXFmjVreqWUDUd6fNGKwvTp01m9evVEd0Oj0WhKCiFE+9Ecr91HGo1Go8miRUGj0Wg0WbQoaDQajSaLFgWNRqPRZNGioNFoNJosWhQ0Go1Gk0WLgkaj0WiyaFHQjMQ0Ye1dkEpMdE80Gs04o0VBM5KD6+Dhz8OuJRPdE41GM85oUdCMJB5Uj7HAxPZDo9GMO1oUNCNJRtVjRhw0Gs0xgxYFzUiSEfWoRUGjOebQoqAZSUYUEqGJ7YdGoxl3tChoRqLdRxrNMYsWBc1Isu4jbSloNMcaWhQ0I8laCkMT2w+NRjPuaFHQjCQRth61paDRHGtoUdCMJGspaFHQaI41tChoRqIDzRrNMYsWBc1IyiUlNR6C+66BwIGJ7olGUzJoUdDkCHbCw1+E6IB6XeqWQvcW2PIP2L9yonui0ZQM9onugKaI2L0U1t4JTr96nQiBlCDEhHbriElYoqarvWo0h422FDQ5YlYKasZtJM2cK6kUyQTKU7GJ7YdGU0JoUdDkGK0qasaFdP8nYePfx7c/R0tG3NIJZfHctABW3TGxfdJoihwtCpoc8TxRENa/RuZue8s/YM+L49+noyFrKcTV38AeePSrE9oljabY0aKgyZFvKfga1GN8CNJJMJMFged4Kk00kR7nDr5JsjGFGLLUg+YazTihRUGTI5ZX1sLXqB4ToRGltKOJNAt++BQfuX3FOHewkBW7+3hmc9ehG8Rz7qNk9PBEIZJI8eKOnjHonUZTmmhROAZ5alMnD60bJXc/r9bRvqSVgXTnpbDtcWt/iFV7+vnI7SuIJU3W7h0ch94emg/dtoLP/Gn1oRtYMQWZipOI5FlB5qEtnK/ct46P3rGSzoAKTveG4kz/1qMs2VIoPl+9bx2/fm7nkXdeoylStCgcg/xpeTu/fX73yB157qPnu7257ZlYQnyI7z64kbbeMH6XnSqPo/D43p1qslhyfLN9pJSjbg8NKdE62DdIMpJnBQUPFrS7+5V2vnjPqwAs29UHKIsBYHePqgP140e3FBzz0s5e1u1T579v1V5+/Mjmo3wXGk1xMCaiIIT4vRCiWwix8RD7zxNCBIQQ66y/743FdTVHRjyVzg56+ZjRnCi0yWYeO+8R9SKsBkoSIcKJFOfNbeRT50wnGEtimnkDcvtLKiA9uPet7H6WSkLUEWAwkizYnkyb6jGqhCAei5LKdx8NtBe0X9XWz9Jt3QAEY+pzCceVNZH5nNp6w9n2UkoGIgliSdXm6c1dPLK+UGg0mlJlrCyFPwIXvUGbF6WUC62/68foupojIJ4yCcVHulAS4YHs8yhuDtong7MCwt3WgUGiiTQep41KjwNTQihfXDI1k96KuQ1SwpP/AW0vZDe96Poya9z/Rkcgmt22dFs3C374FIFIXmA8HScVyxOFYaIVTaYJxVMFFkcwroQmEM0JTl8obu1LkUxL4kklPv3hBMFYoTBpNKXKmIiClPIFoH8szqV560mkzFEtBXsyV+soKp0MRZPg8kNIBV7NmCUKDhuVbuU6GsobNLMlt5O5QXrM6NoIy2+Ghz6X3VQllPh0DOSut2F/gEgiTW84jsj0JxUnnW8pDBZaCpFEWglcPPeZZCyFfFF4pU39iw+E1QzpeEq1GYgkCSfSpM3R3VgaTSkxnjGFs4QQrwkhHhdCnDCO19UMI54y1UCYP4il4tjNOP1SBZijuJQrxenLWgpGOkYiGcfrtFHpURVShqIp9vSGufuV9jGxFExTsq1zlEyh9fepx7rZI3YN9uzLPu+wAsTxpImREblUAtOyGuLSTmpgX8HxmdTa7V05UQxZlkK+a6prSJ27zxKFmGUpDEQS1jEjhVajKTXGSxTWAtOklAuAXwEPjtZICHGtEGK1EGJ1T49OC3yriFu+8Egyz4VkpaO2y2ZAicJQLKnqIOWVifDKGO58SyGW5Lwbl/IfD2wknbDE4AgshbQpGYwkeHZrN//0ixfY158nLFLChr+p54ZtxLGJrlwWUOdghGb6iKXS2JLKUhDpOKblPtotW0gNdRYcH7FEYVNHLqYSyrMUDKv0U1YEMqKQSpNKm1lrQouCphwYF1GQUg5JKUPW88cAhxCifpR2t0kpF0spFzc0NIxH145JElYgNpw/iFnpqLtkKwBB6VF+cldFwbEVImpZCkoU8t0r6cy8gCMQhf9buZd3/Ow52i0xODCYd45kBIId6nk0lwYbxQmAMbAru21W7zO84Poy5lAX9pQSBSMdRyZCxKWdA7IeOVQYFM4EjDcdyGUoZT6bwUiSpkp3Qbv+rKWQJhBNkglF6LiCphwYF1EQQjQLoUptCiFOt67bNx7X1owkEyBdsbuPv6y2XCkxNdg+kT6Nf018hbVyds59lIePKKe13cL8Py/iBvttbNifu7tOxzOWwpt3H63fN8hQLJW1EDJ34+p8eQIRy4lCv6wEwBPMxQiaIttxijQM7ceetiwFMwHxEGHcdMtqbOHCOQcZS2FbVzBbEDZkZSEFokmqvU5cdoNYMs3qPf3s7FbiF0+ZWdcR5DKXNJpSZkxKZwsh7gHOA+qFEPuB7wMOACnlrcD7gX8TQqSAKPAheajkcs0R0xuK89+PbuFHV5yIz3XorzaeUqJwy9JdHAzE+ODiKVn3UUD6WCXnAco1RI2/4Fg/UWZ0PIIt2stZxmY+uTF3123Gj9x9tKdPDeAZUegbTRSELTuXQkqJDTWY18RUNlE4nqIl3QE2MIIHsUm130gnEIkQYemhmxocsT5Ip8CmPqP8tNNar5NEysy6ggLRBFUeO26HjVgyzftvXZ7tViyZpj+csw5CWhQ0ZcBYZR9dLaVskVI6pJSTpZR3SClvtQQBKeXNUsoTpJQLpJRnSimXjcV1NYWs2N3H3189wJaDQ4dsI6XMuo/2D0SzLpHMYDtEbtLaaJZCkxjAF1GzoWtEKDu5C0Bmsn2GDqhJbKE3jgslUibBWDI7D2C/lUk0EE6QSpv84pntDARU3yLuhqz7KJ4ycaEG5Na0ci0dDESZLpQV4Ajmgsk2M4GRDFuWQg0CmUuzJRcrCEST1Ptd+N32rPsoEE1S7XHidhgEh8UMYkkz60oCS0Q1mhJHz2guIzKZMsMDnj99Yitr2lU6ZTxlMk10cpw4QCieIp4yVRaSFVMIymGiMCymsNCw/PfNJ1MpItjJXUtm7ujbX7aqqr5QcOyDowjW9x/eyLt+/jy9ITW47h/IWQpPburiF8/s4PdL1WzhbWE/pOOQjBFP5kShWirR6BiIMl2oILI7mJuLYJgJbMmc+0i9OdUulTb5FA/yZ8d/AVDnd+Jz2fMshSR1LpOfpm+kYnDriM+8O5gLwutAs6Yc0KJQRmSCvpG86qVdQzFuWborO+M2njL5rv0ubnT8NtsmlkojrTvwYJ6lMBRNIodZCqca29WT6W8DoJowJ02qAsCMq7t9GbJ89gN7sseZpuTL963jvb/Mld/uC8X529oDdA3Fs9vCiVwwN+NScphqf5essTo8SDyZwoUSkgoipE3JQPd+fEK1dYf3AxCSbmxmAlsqQli6GbTVqnNYfYwk05xk7OZEQ/W13u/CnycKg5EkixKrOC+9nPf2/oHhdAzmREHHFDTlgBaFMmLQCnrmZxWtbVezlAOWFRFPpakRIZpFbq5hLGmSigQwpSAiVKZNhctOypSkbEokMvMXTjV2YNpc0LoIgGoRZMEUJQqRsDW/IGi5ZvJE4aCV458fSfrL6v0kUiYO28jlPgciiawryW9Tfe/K3OVHB4knEtiEJIYLt0gSiYSJdedSU/0RJQqD+LHLBPZUmDAe0r4mq49KJKOJNNWE8aDEpM7vzIpCLJlWllVCnXeP2TiinwcDUVx2A5shdExBUxZoUSgjMu6jfFFYY4nCoGVFJFImXmLUEQDUCB1NpkmEBwnhobVGWQaTa5UYRA312CursudM1s4BXx0ANYRYMFkN1ra0GsSFafnZ+9uyx7T3hbnMWMYCZ64665r2AeY0+blgXtOIZaD7QomsKykeVdk+XdK6y48FSFhWyZBNWQ/R0ACiX7m2QtJNVURlJLWbTdhlEkc6QszwgK8REwFBZSlEE0okXSKFjTT1fhc+l41wPJW1vKYE16nLWrEHgDNmqL4cDMSo8ykh0SmpmnJAi0IZkRn4w3nuo7V7lShkUifjKRMfMZwiTSVqYI0m0qQigwzhZXqdJQo1HgAiuNQ58WTPmZr6NvCoQbFGBFkwRYmC0xxWHTWv8Fx7b4hfOm/mb8Y3s9sC0QTvsr3Kf9c9xi+uWog/L2NqIJLIBrHjUfXYJzKiMEgipgQo5FDiFAsO4Ajux0SwRU7DwMTEYLucjF0mcabDxAwvVX4PAVEFIRVTiCTSVAklOh7iNHpgrrmbcFzNQXCRoD6wQb0/K8X1ifMO8MeBj/Ml29/oDMSo9lqioGMKmjJAi0IZkXERZVIs46k0Gw8MMU10Eg8PsbVziD29YbyW371BqABtLJkmHQ0QlF5m1CtRmFKjLISMGESkK3ud1Nu/AV41QFeLEA1+tc8lc7EBADm0H1JKjPoPKqvBjslvlu7krhXtBCMxvtH/fWpX3sjl01Jc41iaPfZgIJadwJaMKYvBrFCzrYkOkrTSX2MuJQqJ0CDuyEGGbLX0CWU9dBpNhPDgkAmc6SgJw0ON18kgFRBR7rNoMkU1OVE4sfdRvtR2HUasn4FwgpniIDbL8qkQUZwkmbPyP/DEujjT2ELXUIxqr4MKt13HFDRlgRaFMmIwmokpZMo2DJFIp/mH67tcGnmAz/55LT9+dAvejP8clQkUS6YhFmAIL+fOaeC06TWcOVMN+h0R9S8SwcWnE1/jvfH/xltRnbUUfnhhC97u1fyb7WE8IlHQHyFN2Pg3SCezpSiC+Hhg7QEeXneAheGXc41vOplvpX6DjyiV7sI5FinLVeSongSAGR0kFVdWSdKjZr4nwgNUJbsJuZsZMpSrq11MIi4dGKg5DQmbT4mC6cmtIheNZIPTXhGnNt6BjTTuxAD94QSNIjdZzk+UE0UbhiUSPhElnjKp8ihReHpzF+fc8Owh13fQaEoBLQrFSvcWNcHqMBiMJAjFUyNiCmvbB3CSopIwtaku9g9E6QrkLIUTjT0sEtuJJtOI+BBD0svc5gruv+5sZjYoi+F/nlNzAKK4WGKeynYxA4fNUPMXbE482x/Bded7+Kbj3tE79+B1sPr32AJ7AOgRtQRjKfrCCd6RfGlE8woiWWsFYFK1B2nVVPLVKVGIBftIJZQVIa1lQ4OBXppkLwlvC0FDubP20EIib35m3F5Brc9BwPRgWvMyUqFcwN1LHH9CBcn9MkxHIEajUO63XuckKkSERcYOAAKtb6dWKGGpdDuyrq8Dg9Hs5ECNphTRolCMdG6A35wJL//iDZvev3ofC69/mjP+6xm6g2qwz6Skrt07wHFWfLiWIIm0icibbfw9x1383fUDYkkTW2KIIF7qLVfQzHo/Xzh/FmFUNlLUch95nFZBOiGUtdCxdtR+rTNnsnHqNVA5GXPLo/hCKr4waHoZiiU5OBijlgD93ukFx1WIKK3VymX1mbfN4AzXnuydfEN9PWHpIh7sJ22JgqhQojDQ10ur6IOqSYRt6k3vMFtJkFsdLmyvodrrJIQH01qAx4zkRMFDHHdMiUKliLCvP0IDylIYcE/FT5TFxnZSVdNI1M6lBiUKVV4HO3tyFVbz60FpNKWGFoVipFMFNune8vrtgL1WWYj84HI4kbEUBjltkhrMa6y7Wi8jl8qMJtM4kkFiNj9uhxr0DUPwtXfPRbhUKmom4Oxx5FUpdavaQ9TNGnHOflnJk5O/CCdeCe3LmCvV8p92mSCSSBNNpqkhSMg/E9zV2eMqiHDlosnc9KGFfPNMNz8PfIXLjJeJSzuT6yoYxE8y1Jd1HzmrVJzB7N+DRyRw1E4l6FCura3JZuJ5ohBx1FHrczIkPch4RhRyCwvNqAKblapaRZg9fWEm2YfAVUXUWYtfRFlk7MCcfDr46vGJOC4SVHkcTK7Oze/QoqApZbQoFCOZyV/+pjdsOpqrIhxPsbcvQudQjEVNyq2Ruav1iZGiEI8ncKXDmM6KEfvsHrUtaomC15knCpnsogVXZzcNSXWXH8SrSkDMuQhDJnmbbRMAHnJxhxoRUgHr+twaCRUiSq3PyeULJ+EIqrkGU0U3MZxMqfEyICuQ4T5Mq+ieu6oRUwqqg8qt42+cxnrv6fyx+vMsT80mIXOiEHPVUu11EMSLkVmVLc9S+Omls7LzFypFmI0HhpQo+BtJO/zUM0SjGMTWOA8jE2gnRKXbzq8/soj/vHi++gy0KGhKGC0KxcigVbfH7nr9dqi1Eaq9joJt4Xiap7coYTnDshQy/m8fhRlCADLSi4EJ7qoR+9zeSgaknw6psnzc+ZZC2jrXyVdlNw1IJSJB6WEgkiDQsIhV5pzsfo/IXF9SQxDhrStYOKeCSC7QHFKuHDVJzUlrtZt+WYER68dMKnGr8FcSxMPklBKoyqYZCIeXv9ouQmIUxBQSbmUphKRHzalIJzHyqq7aw53ZCq+VROgNxWkyBqGiGdNZgUuowd5WNQmbvz77uVZ6HNT6nCyeroRCWwqaUkaLQjFiTcIiEXr9dljzDmxpTnYrEWiscBFJpHh6cydzmvy0eKxKoiKEjXTWfWSK3OBuC6m7Y5unmuFUeN2cH7+Rxx3vBoZZCpfdrAShekp20wCWKFiWQlt/nKsS32Pd2Tezv/ld2ZnDfqI4RBq7vx4WXAXzLwWgylCWAgDhXEG9OC5qvE4GqMAR68dMqPfh8XkJ4mWqsASkejJuh40Bq3qp4XTn+uusoMbrzJXyiAcx4jn3EX25dRkqraU+6+Qg+JuQrsq8D6UZe2byniUKAFWe3MJDGk2pokWhGOlT/nfihycKH2AJD/A1ZoiD1HiddAzGWLVngAuPb8qtm4xydWTcR2bjSdntdmt9AbtvpCiogbiSKr8aSD35orDoo3DlbYVdt9Y4CEpLFHpDmBj4F15BsnJq1n2UiXE4Kxtg5nlw+W8A+Pw5TdR5Cy0FgLhwYRiCsL0Gd3IAaVkKTpeXsFDZSnFc4GvEbbdlJ+s5XblJd26nTbmPMkX/4kPY4zlLISvGQLMzBkiq0/2WKOSVEK9owVGpLIUaQlkxyFg4gYgWBU3pokWh2EjGIGC5jw7LUkizQG7FhslX61eyeHoNibRJ2pScObOu4Bw/dNzJ1bZn1anf+3O44hYAhDW711NRM+L8GddUhceB02bgcbz+EhwZS2EIL/3hJG29EQwBU2q9GE4vXhFHYFJjTRhzV1kL8Dn9gKClcylcXwvbnywob500lBss7anFbUYwkkpU7E4PEUsU2rwngmHgchjZDCxXnii47DZcdhsphzXAx4ZwJAIEsF5nLAW7m0ZHDD9RnDIGFU2IfEuhsgVnhZofMVV007rvMdi3KmsxLNnazXtvejFXllyjKSHGZJEdzRgysIdMTaLDEoWkyVxTTQy7VC5ll+/L2X3HNfhhR+4cl9hWZJ87/HUQVwOyaS1P6a2oHXH+aq9y5XgcBj6XrdBSyCONDRtp+obFFNp6w0yq8eCy27C51eD7oPN7zBcqBuCptIrMGQa4KlXZbYD/+yC0LMyeP2EV6jO89RABT1QJmXC4cRspSMPB2jOYB7jtuT463R4Ygri05+Ih7gqIA/EhXMlBBkQ1VSKWK+BXN5vaYDQ74xt/M1jrB8Vw4XZVIhzK2vim4154+l6onorjyxvwOW28uKMXUGXAZzWODN5rNMWMthSKjYyV4PAelvvIkRik1TwILQsg1MX0+LbsvuZKd4H7KB+72w8OdRftiCj3UWVN3Yh21dbdr8dhY1ajn5n1vhFtAKI2y0KQan8QL2lTsn7/YLaekt2tHhcYu9WSmYDhz1uq2513Nw5wcF32acqmLAVnlRIRX6wr80aYlVbutmDLWQC4HLl/a4/Xm+2P29ruq7DeZzyIJ9Gviuo5fCDT4KmBiiaqRIR6MqLQgM2j+tZvq1dzNGyFwX3CSggy1gIoy0SjKTW0KBQbAZWGScPcw7IUJkWt9Q3O/Kx6HVYL0tT5nBiGOKQoCKcfnGrA9MVVQLdqFFGo8alBzu2wcf91Z/OVC+eMaAPw0LRvsddsYNCp5g3EDCUA7X2RrJA4XaMIiifPZZVZ0KdqKtg9Bc3ShrIUPNUqTddrWQrYXLzmPk0dPuWUbF8ztNSojKqg9GS319RmCusN4Uv0E3fXZz8LKlrBXYVPhqm2CuXhqcVmpeYG7CM/I058v8paWnsXf05+jYylZ+pyF5oSRItCsTF0AIShJoQNE4VAJDlida8pcWsNgTn/BJWTaAluBKCp0sq6SYTB5hx5HbtL3R0DDagMnNrahhHNqj0Z99Hr3/XubTiPdyRu4mDFSawzZxKpzk1oy5StcHoL13tOYxRMXCPjt6+aDC0nAyBRNbXTNvV+quqU6FQkulS6qWHwh+b/5LTYr2muUQO3267+rR02wdQKNTAH8VJnZTXV16v3GQsNUG0OYHobslYTlS3grsJrBqm3WT4jTw12jyUujjzLJsOU09XjriUcZ7Zla0uZWhM0JYgWhWIjcAD8zXTEXMhh7qPr/ryG7z+0qWCbJz1ECru64568mNqB9QA0VVpzHOLBwrvxDEJkB8IW0UdUOqmtqhzRLBNodh8ilpDthyUasmY6VyR+TG19S3bf5QtVzSKXp1AUpLtaxRIyZNxHlS3Qqu76o16rCJ5diUJdYysADWYvSdQg73D76KGGlmrVxmX1pbHCTbzhRJ5ML+bryeuYbolTS6OyNro72vGLKPbK5qxAUtEM7mrsiSH++6JJ1purxmFlZoWcuYV2PlrxOz7svyMnbH1KoDNVV9NaFTQliA40FxtDB4h6m3loS4BrHUHyh+Ku4MjZyA4zStzwqC9y0mK8mx+ingCNFdbcgURYZfZc+h2ikTCeJd/JHWwttVkrQvSKWjzDV7ohP9D8+qKQmb/QXKUG5tNn1HLqtBr+edFkaqw7dPsw95HdP+yuO2MpVLZC04kARKuOwxvZj2lTAtbc3EJaCmxCkhBOfIDXZcdhE9T7rBLelqXQXOXG6fLw8eRXAZhWp1xEkxuqiUs74YPK9eauaYF4nvvI6QMzhRjqAGEDVyUun42l6QXsqT4j292AqxWnzQCPJd5W9lKNCNEh63W1VE1JokWh2Bg6QLdjJmHpxiaTaj0CuxpU40lzhPvImY6StPztGZfLpa0BPn2B5b5JhNUgd+oncA51Qr4oOHL1euKOkbOZAWoyloLj9Y3Kd81voi+UyIpItcfBh06fWtBG5K/37K3LDvxZMjGFilY1d6F1EUOT30ndweezVk2Nz0U/FdQxRFKoa1192lROaK1UMRRylkJzpVsN2haZdR+m1akJb86AClBX1E+CPuuzqGwBy2XFwB7wVIMQuJ12PpH8Jp+pnZE936Unt6qgtsdKnbVmQ1eLIEhIa1HQlCBaFIoJKSFwgD1ViwhbtYZIhMCuAqPxVLpgqU0Ap4yRtO6iqVLWwfffXgnWIjkkQtYcALD5h60xbM/N9jVdo4tCpdvBcQ0+5jS9fmrlzAY/337vfO5avgeACrdjZCNHXvD46ntzvvgM+e6jima49jlSa58DQDpUX4UQDNlrqUsPIa0yICdNruKkybn+R6zPqKnSXZCJJCxLqMLtYEB4aU3tBwG1TZOhLeM+as2V7+jbkXW9ZYQmf0b3v7xjpnrSWzhZLTMHw9QVtDUliI4pFBPRAUhF2RiqIGSteJaySjwD1CY7ccZ6Cg5xm1GSNksAqiarx0xaK1iiYA14xrCv2zCIWeKTKfA2HMMQLPnaedm4wBvhdar7jAr3KPcbzpxlklmkp4CM+6iiNXeIlT4q8qya+pNVyY1G3+gurc4h5WZrqnRlXUnDPWNxZ012USB/bWvOaqpsgUrrc+zblRUFn9NGc6WbmQ2FcRH1XgpjNpmsJZ19pClFtCgUE1Y66oZgBf4KFbw80JUTgZ/Km/hy8vaCQ1wyRipjKdhdaqJVgSiEIa9Ew1P283jEd2X2dab6aWbwPVr8lhjk5+tnceSLwijBb6/Vh4y4AfaayewwJxGsmpfdVrHwfQCIzGSzYbzvFCVg7z2pRS0IBLRUugva1J1wfu6Fb1hKalVGAGW2n3abwYrvXMAVp4wijsMKCX7yFPVai4KmFNGiUExEVRnnflnBaXOUK6hn11pIRkmbknoGqZUD2awW05R4iJG25w22VZNzVVYhF1Ow+FPzd3i89QvZ12Gp/PK+qrERhXfMbuC7lxzPSZNGcUflu49GqcjKSe+HD/8lb1CGuqoqPldzCzUnXphrN+WMkcfmcfLkavbccDFTar1ZS+H8+YWus9qFl+Ze2ByqP3aPEiZfIxiWqI0mXsOxOSCv7Lgzoeop6eQjTSkyJjEFIcTvgUuAbinliaPsF8BNwHtRBQM+IaUcfcmuYxlTzfJNY3DCjFZYD4vXfAMO3kv8Q3/FL6JUyTDhRIrK9BDJYC9e4oWiUD0FDr6mnq+/X817cOYshZs+tBCbkfOl+PyVEO7FUzlK/v0R4HHa+PTbZoy+M2MpuKvANsq/nqtCzbfIw+2w8dRXzi1sZ9hUTGK0+RfDmFbn4++fPXukSE0+rfD1mZ+FORflXGyVrTDYfnji9dfkAAAgAElEQVSiACognVD1mByWKOiUVE0pMlaB5j8CNwN/OsT+9wCzrb8zgFusR00+lrtBImiszxukO9Yilv0SP1Fiwkk4nqLyxf/CvvNZvCJGqMBSmAJbH4PenfD3z6hteQHlOn/hGg01VdUQBuE9zMHvaLA51B344Q60r8fc9xx200VTR7mezQ7nfzf3uqJZ/WWomvzmRSGwDwxH1lLQKamaUmRMREFK+YIQYvrrNLkc+JNUv5IVQohqIUSLlPLgWFy/bJAqXcXrduLx5d3ZVk2Bvl04RJpKGeZgPAXhbozgQbzYCDqHiUI6Dm3P57aJ1/ESZu/eR5bNfktweEcPMk8E7/j6ofdVZiauHa4oWO1qZ2JPqJpJ2lDQlCLjFVOYBOQ5utlvbdPkY4lCXYUnm4lzQNZhuqowhlQQ2ifiBCNRYqEAIh2jkgjSkZf/n1nwZsfT6vGf74CzczGEEWQEZSzu3g8Hp3f8rnU0ZILdhyuWmXb1s/EE27nMeFm7jzQlSVEFmoUQ1wohVgshVvf09LzxAeWGJQoNFW7w1bFh4Q94X/x6IrYKbMED2Wbx4ABdvaoqpyFkYVZP0wnqceczqrDcSe9X6yAfisyxo6y69pZQ0QI108fnWkdD1Zu0FLx14KqCimYc8X5+6fy1Wt5ToykxxksUDgBT8l5PtrYVIKW8TUq5WEq5uKFhZHG2skeqQHN9hcrScZ/1GbqpYQgf9khuwZlEqB9HKq8uUv5M4eqpUD8HzKSqtPpGOMbZUrjmb3Dh9eNzraOh3vrs8tJjX5ezvwDvvwNiuXklMj1yPWyNptgZL1F4GPiYUJwJBHQ8YSSRuJoZW1+pBurp9T6cdoOuRGGOfTIyiCsdyb4uKB8BMMtK3zwcURhv95G3tmDeRNEy/W3whbXQdPzhta87DmZfCCd/MLtJmnrlNU3pMSaiIIS4B1gOzBVC7BdCfFoIcZ0Q4jqryWPAbmAn8Dvgs2Nx3XJjIKxm4jZUWovf2AzOmFHLzmDhzF0zPIDbzImCMXydgtmWKDTOf+OLOv0qEH2IMhfHLEKogf7NMvtC9px7E6BFQVOajFX20dVvsF8CnxuLa5Uzoagqu1DlzaWNnjungfbdTsibIGxGB/AQzb423MPuvGecC+/7Lcy/7I0vuviT0LpwZAkMzREjrGwvLQqaUkSPBEWEaVVQs+VV9jxvbgMBCi0BR7gTg1xmi224pWAYsOBDhbWGDkXNdDjhfUfcZ81IhM1aW0JXxNOUIFoUignrzlKInLvouAY/aWfh4jfuSEfBa5tbLw5fVBiWKKS1paApPXTp7CJCWimpRl4JCCEE0lUFMUhKGxLwRApj9I7h7iPNhGJYooCZev2GGk0RokWhmLBEQRiFdZ5NdzXEIIgHIQz88a6C/XbPMPeRZkIRhvpZafeRphTR7qMiwrTcR9k7TQvDqzKDQtJDxPBTn1ZzFtJSiYfTM3JtZc3EIaygvZTaUtCUHloUignrzjI/pgBgt4rVhfCScFRSg5ogdRBV7trp0e6jYiJjKaCzjzQliBaFYsKa0WzYCt1HTr8a/MPCQ9KbWxfggKzHlALn8OwjzYQiLEvP1KKgKUG0KBQRMhtTKAz1+Hw+otJJRPhI1M7Jbt9kTqeDOgyb/hqLiWyigBYFTQmiR5MiIicKhV9LtcfBIH4ihg9HpuAdsHfhV7maG8a1j5rDwNCT1zSlixaFYsKKKRjDRcHr4DvJT3Of80qqpp+c3f6dK07jxR9+YFy7qHljdExBU8rolNRiIhNTGBZorvI4eM48hTkuP/XTcpaC0641vRgxbJl5CloUNKWHHlWKiExeuxi2fnG1VxU+ctlt2F2ece+X5s2RCTRLqUVBU3poUSgm5OjuoyqPWqDe7VDb25yzCQqdhlqsGNp9pClhtPuomDiEKORbCgDJTz7D9liKU8e3d5rDJDP5UAeaNaWIFoUiIus+MkbGFCBnKcxpGaelMzVHRNb9p91HmhJEu4+KiUygeZil4LAZ+Jy2rKWgKW50oFlTymhRKCZGqZKaobXaQ53fOd490hwBWUtPi4KmBNHuo2JCqoVzhhfEA/jTp0/H59JfVylgy7qPdJVUTemhR5kiQmarpIoR+1qqdCpqyaAtBU0Jo91HxYQ0SUsxqihoSgcjWzpbWwqa0kOLQjEhTUwMDKFFoZSx6YJ4mhJGi0IxkRWFie6I5mjIBpp1SqqmBNGiUExIExOhLYUSJ1MQT2hR0JQgWhSKCS0K5YEuna0pYbQoFBNmWruPygGryq3QgWZNCaJFoZjQlkJ5oGMKmhJmTERBCHGREGKbEGKnEOJbo+z/hBCiRwixzvr7zFhct/yQylLQpkJpI/Q8BU3pctST14QQNuDXwIXAfmCVEOJhKeXmYU3vk1J+/mivV84Iy1LQlDiGdh9pSpexsBROB3ZKKXdLKRPAvcDlY3DeYw5pmkgtCqWP0O4jTekyFqIwCdiX93q/tW04/yyEWC+E+KsQYsoYXLfsEFIFmjUljpV9pFNSNaXIeI1A/wCmSylPBp4G7hytkRDiWiHEaiHE6p6ennHqWjFhalEoE1IY2lLQlCRjMQIdAPLv/Cdb27JIKfuklHHr5e0w+qJhUsrbpJSLpZSLGxoaxqBrJYZ2H5UNJgaYOqagKT3GQhRWAbOFEDOEEE7gQ8DD+Q2EEC15Ly8DtozBdcsQqS2FMsHE0O4jTUly1NlHUsqUEOLzwJOADfi9lHKTEOJ6YLWU8mHgi0KIy4AU0A984mivW44ImUbqOQplQRpDZx9pSpIxWU9BSvkY8Niwbd/Le/5t4Ntjca1yRqeklg+mjiloShTtqygmpImJXoe5HDAxMLSloClBtCgUE1LqQHOZYGLTloKmJNGiUEQIdPZRuWAKHVPQlCZaFIoJmcYU+ispByQCtChoShA9AhURQuqU1HJBp6RqShU9AhUT0kTqr6Qs0O4jTamiR6AiQiD1PIUywcSmRUFTkmhRKCa0pVA2qJRU7T7SlB56BCoiDJnW2UdlgikMBFoUNKWHFoViQkqdfVQmSF3mQlOi6BGoiFDzFPRXUg6YQscUNKWJHoGKCCH15LVyQaekakoVLQpFhJAmUruPygIpDAy0paApPfQIVEQITNCWQllg6piCpkTRolBUSEyhq6SWA1LYMHT2kaYE0aJQRAg9T6FskHpGs6ZE0SNQEaFnNJcPekazplTRolBEqBmw+ispB1SgWbuPNKWHHoGKCT15rWzQK69pShU9AhURAp2SWi5IYbOyyTSa0kKPQEWEgUSnpJYHep6CplTRolBM6MlrZYMUukqqpjTRI1ARYWCCFoWyQM1T0JaCpvTQI1ARIaSpl+MsE9Q8BTnR3dBo3jR6BCoiBFJbCmWDjiloShM9AhURKvtIB5rLAV3mQlOqjIkoCCEuEkJsE0LsFEJ8a5T9LiHEfdb+V4QQ08fiuuWGymvXOl0OmELPU9CUJkc9AgkhbMCvgfcAxwNXCyGOH9bs08CAlHIW8L/AT4/2uuWIgdTZR+WCDjRrSpSxGIFOB3ZKKXdLKRPAvcDlw9pcDtxpPf8rcIEQ2k8yHD15rXzQ8xQ0pcpYjECTgH15r/db20ZtI6VMAQGgbgyuXVboQHP5IA1tKWhKk6IagYQQ1wohVgshVvf09Ex0d8YdVRahqL4SzREihYFNi4KmBBmLEegAMCXv9WRr26hthBB2oAroG34iKeVtUsrFUsrFDQ0NY9C10sLQM5rLBx1T0JQoYzECrQJmCyFmCCGcwIeAh4e1eRj4uPX8/cCzUuqZPcMxtPuobNAzmjWliv1oTyClTAkhPg88CdiA30spNwkhrgdWSykfBu4A7hJC7AT6UcKhGYYONJcROiVVU6IctSgASCkfAx4btu17ec9jwAfG4lrljLYUygcpbDqmoClJ9AhUROjsozJCu480JYoegYoIXSW1fNDZR5pSRY9ARYShYwrlg2HDEBJ0PoWmxNAjUBGh3UdlhLCpR1MXxdOUFnoEKiK0+6h8kJYoSDM1wT3RaN4cegQqFqTEpi2F8sFQ36NcdQektTBoSgc9AhULGd+zFoXywLIUjKe+A21LJ7YvGs2bQI9AxUJmopMWhfIg/3vsb5u4fmg0bxI9AhULWVGwTWw/NGODkfc9DuyZsG5oNG8WLQrFQlYU9DIT5YAw8n5aA3ugZ5vORNKUBFoUigVpDRjafVQe5Ft8e16CX58BG/8+cf3RaA6TMal9pBkDtPuorJD532NsUD12rge7E1oXQfWU0Q/UaCYYLQpFgjTTCMimMmpKG2GMIu77V8GyX6rn3z4ALv/4dkqjOQz0CFQkpNM6+6isGE0U9i7PPc+IQzKm/jSaIkGPQEWCaQUhhQ40lwWZCqkvpU8g7qqD48639gionAwH1/Ptv69n960fhL9+cuI6qtEMQ4tCkZARhVHvMDUlhzuh4gib5XTufvsSOPkqtaN+DrQuJNq1nftWttPc9wqyfZkunKcpGrQoFAnS1IHmcsKdVKLQLyvoCsagfrbaMWkR1M3CEWhnvmjHSwwRG4ShjgnsrUaTQ4tCkZC1FLT7qCzIfI2dspbuoTjJ2tlEbBXsqz2LSMU07KT490mbsu2XPP/sBPVUoylEi0KRYFqWgtCB5rJg69zPckPyQzxsnk13MMbyfXFOCv+Gv8TOYH20AYCzw88QwgfAmldenMjuajRZ9AhUJMh0xlLQ7qNyQDp93Jq+DBODrqE4T27qJI2NfQNRnuupAMAZ7UbOeDs9tibmG3tJpvVKbZqJR4tCkZALNOuvpBzIH987AzGe3twFwN7+CE+154LKFRf/mET98cwVe+kM6NRUzcSjR6AiwbTKXAgtCmVBfziefR6Kp+gOxqnxOtjWGaStL8KyWV+Fq+6G+tmYDcczUxzkQO/gBPZYo1HoEahI0NlH5UX3kBKFOU25WctXnz6VcMKyCM/6HMy/BAD3lAXYhUlw34Zx76dGMxwtCkWC1IHmsmJWoxKDC+Y3ATCz3sfc5ors/hMnVWWfV00/BQDZqUVBM/Ho2kdFgplZslGLQllw1WlTOOu4OvwuO89s7uLGDywgZapYwswGH5VuR7ats+E4Yjhx922dqO5qNFm0KBQJ2ZRUPaO5LBBCMK1OpZs+/dVzAegJKpfSgsnVhY0NG3vtM6gN7RjXPmo0o3FUt6VCiFohxNNCiB3WY80h2qWFEOusv4eP5pplS6Z0tg40ly31fieXnNzCFadMGrGvz3cckxJ62U7NxHO0I9C3gCVSytnAEuv1aESllAutv8uO8ppliZnOFMTTolCuCCG4+cOLOHdOw4h94YoZ1BCA6MAE9EyjyXG0I9DlwJ3W8zuBK47yfMcsuSqpWhSOReJVx6nHrm0T3BPNsc7RjkBNUsqD1vNOoOkQ7dxCiNVCiBVCCC0co5DNPtLuo2OTulkARDp0sFkzsbxhoFkI8QzQPMqu/8h/IaWUQohD1f+dJqU8IISYCTwrhNggpdw1yrWuBa4FmDp16ht2vpyQUpfOPpZxNswkKW0ku7ZPdFc0xzhvKApSyncdap8QoksI0SKlPCiEaAG6D3GOA9bjbiHEUuAUYIQoSClvA24DWLx48TFVYF4XxDu2qa30sVc2Utm/c6K7ojnGOdoR6GHg49bzjwMPDW8ghKgRQris5/XAOcDmo7xu2SF1SuoxTa3PxW7ZgnNw90R3pXwI98K2Jya6FyXH0YrCDcCFQogdwLus1wghFgshbrfazAdWCyFeA54DbpBSalEYhtSB5mOaWp+T3bIFX7gdMsURNUfHsz+Ce66CYNdE96SkOKrJa1LKPuCCUbavBj5jPV8GnHQ01zkWyIqCthSOSSrddvbSgt1MQGAf1Eyf6C6VNqkEbHpQPd+7HE7Q+S2Hi74tLRKk1NlHxzJCCHpdVnJFr44rHDW7noWYVXV274qJ7UuJoUeg8aTjVThE0TOdkqoJ+KarJ31HWO7CNNUdsgZW/Q68dTDlTFjzB1j9e5DHVO7KEaNHoPHkgevg8W+OuiuTkip06exjFltFI2Hhg94jFIXnfwq3nqMHv72vwM5n4Owvwox3QCoGj3wFOtZOdM9KAi0K40UsAD3bYKB91N0yrS2FY51av5t20XrklsLB16B3O/Qd4+6nV+8CdxWc/i9wxr/Caf+itndvmdh+lQh6BBovOl4FJAQ7IJ0s3LfnJeYu+SSgA83HMnU+JzvTLdmYws7uIOffuJRdPaHDO8HQfvW458W3qIclwmA7NMwDpw989fCen4LdA13jmPTYvQXW369ceiWGFoVgFzz/s1wa4FuRvrbpAVhxi3ouTRjqKNzf9kL2qbYUjl2aq9ysT02BYAehXa/wzMb9zOtfwn1/++sIl1AsmUYOdxMFMqLw0jj1uEgJ7IfKvEq0hg0a5kL3mxSFthfh0a8dWR8e/Rr8/TPwfx+ARPjIzjFB6BFow1/guf+C/auUL/fn82D7k2N3/mQU7v8EbM+bRBPYV9imLze5W8cUjl1aqz3cm34nIUctO//0OdxtS/iN85d8p/NLfPWnN7GpIwBAIJpk3nef4GdP5hXPS4RzFVb3vFQoIiV4t3rESAmBA1A1uXB74/Fv3n302r2w6vY3f6NomtC5UT3f9Szcc3VJxXm0KPRatWb2roADa9Sd/PYjmAV5qB/egTW553MvVo+Dw0ShPycKNlNnjxyrTKp2E8LLH8UVLBQ7cOzL3fFPDm7ghe29APzsia38k7GKVSuX5Q4OHFCPU8+CUBcM7FGvOzfAfzUfefB6IpESkrE3d0y4F9JxqJpSuL1xPoQ6IdJ/+OfqtUS3cwMcWAs3zhlp5Y9GzxaIB+CKW+FdP4C253PjTIZkFP50ueVWLi60KPRYX9a+V6Brk3qe5845LNbeBT9ugFBe6aeUWmWL9uXq8Rtt8P7fq+f5loKU0Leb3tZ38vf024jVH//m34OmLGit9gDwcqgFgMXmBqLCC/VzON21h62dQ2zuGOKhldv4leOXXCf+rg7c+wqsu1s9P+F96nH/KvW452U1SO5fPY7vZIxYfx/8vzkQP8yYCuR+W8MthUmnqsflv4bo4BufR8rc2NC1QX2eoS5oX/b6x0FuXsTUM+F4a9Lc7qWFbbo2q207l7zx+caZY1sUpMzdDeSLQt/O3J3Xqtth38pDnyMehIc/D2YKOtdDIgJ3XQk/boJ198DeZdB4AnhrweEGf5O6Vr9V4ybSB/EAA01n8dXkZxEOz1v3fjVFTWOFG5shaDdVBfq5xn6C7haYdConsYutHUP89ImtnO/ahlOkmZJs49/uWk3nHz8KL/9CnWT2heDw5UShy3JjHGVGkmlOgPtj73KVtfdm3D6ZuErVsNXtpp0NCz8CL94IP50G2596/fOEutTdPihLYXCven44d/ZtL6jfec10qJkGNTNGikLGcsi/QXzmB7D+L298/reYY0oUdvWEeHVv3spWkT7lh22Yr57vWkKff7ba1/YCxEPIx/6d9L3XQHSAoViSQHRY5tBr9+ae97epzI9dS8Dphxd+piyFaWfn2jj9Kof69gvVRCMrnhDyTQPAEG/FO9eUAjZD0FzpppNa4lJVoEn4J0HrIqrMAYI97Ty/vYd/naSW7TxOdBDYsoRmM+fzvn8HMGlR7kYme6OzQ/2/Pfo1WHazcl+MQiyZpjtY6LLZ3hXk+O8/wcq2Q7heBtph6CAdg1F2dAXf9Pte0z7AT5/YyvPbewq2p7qstSXeTIDYEoX96TruWtHOA6/u5/cvtSEBLv5/8J7/Ie2sZOlDd/DsVvW57f7T59j/wp2F5+mxbhbdVSo+MGilkh98LdskHE+NDPYPHYStj8AJV4JQP+b0jHMx216A2BDheEq1y6QdZ1zJWx+Fl/4Xlt98+O/1LaIsRUFKyfPbe+gYLPzH/8QfVvK+3yzjBw9v4uHXOnJf/Du+nm3zu4FTiTtroO155IE1CGliC3chn/g2197xAl/5U2G6X2r/GhKuWqTDq0Rh30oQNrjge8oaEAac9TkiiRTxVBrO/jzMPA8ivTx43++yd3Bhf0YUtCocy0yq9mBi0Gkoa8FWOy3r+jhZ7MLrNJgfWolpc2MXJt+w30sUd/b4bz64hXDTqeruNjqAtO6y0z07kevuVpbvU/8Bz/yAz969ht+9UFiV9cYnt/Hem14ssAxe3NFLLGnyi2dGWetBSvjzlfDwF7j+H5v58O2vkH4Dq2JvXyR7/va+MB+5fQW3LN3FDY8XLjCUtEQhcmDj4Xx0isB+cHj5xmP7+O6DG/nKfa9x/SOb2dMXAYeHrvkf4+nYPOaEVvK5u1bxansfM3f/mcnPfrHwPJk7+fmXQd8OEp3qczQ71oFp8oeX2zjh+0+qcSSfVbcjzTT32y4mlkzz5xXtfHjlDNLxKIHb3ssvf/RFOtY8mht7AvuVe+yxb6jXnRuUdTSBlJ0oBGNJPn/Pq3z89ys578alLNmi7gYCkST7+pVI/HHZHr72l3UkuyyzdMrp8LavALBdTqbNvwh2P0+0TfkG7+XdiNfu4d6eK/lUx/cL/ukDu9ewPDKZ3elGUr07lWuo+SRY9FE1+F96E9TO4MO/e4XvPrgRFn8Krvk7vUY91dvuI9W9DQwHYa/ygWpROLZprVYDvKidAUBVyyxoPhFpOFhg7OIbszowAu3ET1UTshYau2lvuYirE//Bv5tfwJTwgjwFZBq5/DeIVJReWYnRs5mBx3/MWnMWTzveibn2LpZvbuMvqwuTHp7d2k1vKMF9q/fxyT+sJJEyWbdP+eCX7epj/f5Cf/wPb/8L9O0ktHcd9Qee4aLIP1i959DB3N5QnAt+vpTbX1Ji9IOHN2E3DK5Y2MrO7iCJlJWwEe7Fk1TXSh7cVHD8gh8+lb3LLyAZhd1LifqnsGx3P184fxY/uFTF6HZbcz1e3TvIc+kFtIp+tjg+wt7Hf547Pj/W0L0FXJUw/1KQJs6BnYSkGyMRpG3HBv78yNPYSLOmvXBN7dSmh3kxfSL//uwQv35uJ//54EZeSc3mS8nPYQzu5dv2u2n9x4eVNQEQ2MfAY9erOSbn/6dKdNn7yiE/v/Gg7EQhkkizqq2fL79rNpVuO4+sV6uFLt/dB8AL57zGqim/wp0OE976HFS0qEyF87/LIyffzHPmQtYYJ0OwA2P9fewyW/he7CNsF+pH+jaxnnXtfWpCUSpOdWgXm+R0ticbiHduVVkKU04Hhwc+9hCc/AGiiTTr9w9m+zAQTfNA4gzOFhuJ7V0LdbPYF1BuqVqfcwI+NU2xMLnGC0DT9PkAeBumg90FTSdwRWMXHzYfBn8T7gu+lT0mdc5XWW6ewP2JswD47e46ZOUk0i8rV8RT5ukIJLXpXjbO+zI3Ry7ESIb5mvg/2rsH6B5S7qKOwSi7e1VO/X8/uoXntvWwuzfEun0DnDGjFoAV1v8wQPdQjOr2xwHwJ3r4RPSPfMt+D09uVC4cKWX23ADEAmw9GCSZltz9yl4SKZOXdvZy9elTeOe8RpJpmZuoZ91Jd8oaXP1blUXSuZEXt3cTiCb565r9Iz67+BPfhe5N/MK8imqvg+vOPY7LF6rYQpv1vrZ2DvGCeTLS5gLguK5c+nlgy3Pw9Pfg3o+omEzrKeq3bPGoVJ+v+fg3WeL6dz7teZ4DA3neiEg/9v7trDDVd/fijl5OnFTJsm+dz2PmmSyK38rJsdvocU9X7R0+SEaoee23rK69GM78HBgOXnj6Ab5y37oR72+8KDtRaKp089zXz+PL75rD3OaK7D/Dyzt7qXKaTNl8Gw09y/mt4+d49r8Ax12gfH+GjZW2U5AYPB2bC4A7sIu15mwSOLg4+kPun/wdAH5054N86LYVyK7N2EgTrT+R/aIZX6gdkmHWmHOIJnI18bd0DmFK2NcfZSCc4PntPaw1Z+EUabwdy6BxPi/u6OW4Bh/NVe6Rb0pzzPCxs6Zx6zWn4mo4Tm2oVpVTxaRTaQmsw7lnKZx+LcLlZ0vdu9k28+NMm5XLWDt/XiPr9g9xX2Qx9nSEJ2znwYlXArDBcTIfvfoaovUncg8XcY19CZtcn6L3sesB9RsB9XMIWr7vlW397OuPcv68Rlqq3GzqGKI/nMA0JUu393ChsZaEUDcys0QHPhFn92vLiLct58Hffp9v3HAjV9+2gj0r/wE3TCW0+SlucfwvFf0buXfVXpJpyfyWSo5vqQRgy8EhgrEkfe2qcOTj6dNxx/vghRvh1nOIrVExvKXbeogl1W9sIJwgGo2RWvt//C39Nn7bNY/rLz8Rn8tOjc9JjdfBrh5LFA4G8dRNRXx1M/ucM5lt7sl+dsEtz8DLN8HWR5Bdm9jmmA+eGjrdMwGYefolrDLncNygyig8o7Kf9v4Iy3f1cTAQzaafr5VzAFi3b5A5TRW0VLnxu+wk05Ih/DxkezcAyYbc93Zj79mEpROmnsm83idJx95ExtUYU3aiAOBzqSDd9Dofbb1hpJQ8t62bf23ajogOIE/+IGfbNuNKDvFAcB6f+MNKQvFUNgaxbLAa89JfsqXlCv6Ufjc/++eTueNTZ3PFxZcAMCOxk55gnMBuleHhaF2Io246ACnh4JqXarl31d5sfzYdyPkIN3YEeGZLF/vcSngMmSZZN5dX2vp4++yGt/yz0RQ3jZVuLjqxWfmyT/sXaDpR7Zi0CNIJcHiVCxKY/4X7mfuxX1LhdjDJSmf9yZUnceenTud/oxfzveTH2XXmTzj17Rfz7fS/MnjFXQghmNXo59uxj3FN4tvslJOo2f0oAEu2dFPvd3La9Npsf+5bpdxLC6dUc0JrJSt293HODc/yuxd38/zWg8wyDjAw6fyC9/Cj5P/DdedFvK/zJv7o/B9SnZvoeuTHADg33M17bKu4wrmSXz+n4mlzmiqYUW2jwp5iy8Eh/ueRVxl67iYOylruSL+XhHDBc+r48w/cws2e26hPdvDSjl4SKZNLfjgvztgAABHBSURBVPUSt999Nz4Z5on06XztwjlctqA1258Z9b6s+2hr5xDzWirAV0/YOwWXUBZ6p6xBducmAwqZ5icbK7jh8a0sCSkvwWkLF7Kl+fJsm2ZbkL39ET7+h5V8628bSO1ZTkoatByfSyyZ3ViR/cwz/KTv7Xwr+Rmebr0uu+2VxDQe3XCQgTO/QaPs4xPygcP5d3lLKEtRyDCj3kcgmmTXU79lVmAZl9hWgL8ZcfktrHMuIiltXL+5kaXbenhqUycHBpWpm0iZHJjxAe5u+jp73XP54GlTeMecBhyNc4nh4iSjDQcpjBU3s8tsoXbKHByzzmWn2coHk98nipvtXTml39QxhM+pZiq/srufJVu6WXDiSQwKdXe0kynEkiZvn10//h+SpjipmgQX3wh2y52YybM/5RqV3jyMOU1+6nxOGitcnDungc9efAaPeS7jn0+fydzWan74/Rt4+wnTAZjVWAHAMnkSnZMupCnezvMbdvPU5k7ev6iZsya7sBuCer+TTR1DeBw2FjYZHN9aRddQnGgyzR9e3sO2bVtxksIz7wKiUvXT9NQxxejhwfTZ3H7SPUgEd81/hdNsKttmQVJl75zhOUDXUBwhJLMHXsD+kxZ+672F9fsDzN38K6bJg3w1+W/slw3c5fkIALemLqGJPi6RS/m463keeq2DRzd0cGAwin/Pk8Skg/d/4Bq+cMHsgs9mZoOf3b1hwvEU7f0R5jWr352smppts8MxD3dob8Fxr5qzufX5XbQ3vhPpa4T62Zxx2bX8iqsI151EU/ogiZRJImWye8dGIq89wBY5lXNPmJ7NIpxtiUHmcX5LJWls3Js+nxcD6ve+w5zE9PoKfvPcTl5OzOLB9Nkcl9g6YbOgy1oUptf5AKhd+T9ca3+U1tQ+dcdls/PEvJ9wVeK7/OQj72BStYdH1quUunnN6gfzyyU7WL1ngCm1efMGbHYGK+dyoXcHX7L/jcpwOz9KfZQ5zVWcc8bZfLnhNmYueAfzWyrZcGCQe1bu5aF1B3ilrZ+FU6uZXuflzmV7iCbTXLJgEh3eeQA82lmF12njzJl14/4ZaUqEhnlw5e/gnd8ZdffX/2ku/3vVQoSVqPDxs6fzyncuyLojnfbcTz1z19pa7WHxWedjCMkt9z6IEILPmffype2f4IHPnsPCKdUAfHhyD64bj+Ns9x4A3A6DzqEY01CZN5WTT6BdTKKTeowTriDtrsH2np/x6Svfg5h2Du5N92HYXQTsddQJlbI6K70bkNzuvRXXX68B4OzEcra37eGK9JM8YJ7DcvME5jT5+VH/BbxL/oYnWj7LH0/7B+lJp/FP3m08uamTXz+3C49NcpFtFS+aJ3HKccPmJwAzG/5/e2ceHdV5HfDflWY0EtqFFrSMdrFLYhFiMWCbxZjFwVDAwuQEb3WKLRfHbXwgzilu0tZOnTQ+zbEbEzex09I4sXFKEkMcnOA0rlsTsAHLCzE2uAWDxWJ2AkL6+sf3NIzEjFbQaF7v75w58+Z733vv3rlv3p3vfstN5PCp87y06yDG2AczgC/LtgCOSypklJLVbDuvW4ywo6WUooJ8hg5K5k9vvxv58gcQn8qQgmzq1zxFYvFYUv9o5zLNit3OprjVxJ7+hCcvzmdkfir+DNs3VJGT1OZ9aa0fERiUEs9/fWJ4puBr1Pu+zpqbhrPv6Fnq/+0tvnLxLny3bQgMae1r3OcUjIHXHofThynOTMTHBTKajzDY04jnxMeBNIf3zBnLmntu58aRucytyuU379sOrGlDs8lLjef57ft5/9ApBqW0nUw2aNoK/Bc+pN6zgfXNU3i1ZRQV2UkUZybyi/um8M3F1UwdnEnDgZOsfvFtVj63g/89dpaFowtYOaOCs03NZCf7qC3J4FzBZBpNGmsbYG5lbiDspSiXIQJVSyAhPeTuEXmpTB3cNvwYG2bSS3mWfUD50weQXDIOgLr8I6yaVU7y+88Tc+JjKjOaKXOcxwLfNjDNjDi3DU+M8OCsoQzOSeLOYc5IoYFlbC28i1/mroBZf0ts/e+5aVKldVCtaTBv+BvO5E8OyJDQ9BmDOMa1za9DVR3M+zYAa+LWkSjn+feERQBOSFVolEy+s3Q0t82dSmz5NPLP7Sb+4in2HTnDD6acJFeOsSVhJtkpl/fJTSgdiAg8uH4XFdlJXOt8Tym5tt/mlDeTjPyyQP0vNn2JJRfWsOam4fzy/qlkJfvamUIgvQTv+c9I5ySPxz3J8YRCZvzxMX4tEykeOIDSzER8npjAwIE5lbncOr6QW8b52f7VmSyfVMy+o2d55rMqMnPyuW5INovG2hGI+VmZxMdF7lngvqfQ0T3w6qPw5g8pXPZTCsROiMlsOQItBJxCSryXauef0JIaP2ud8dqDc5J5ffV0Nuw4wMrnduDztvObo26FprNs3PwrVp1cxtyqXNLbjRiqzE8FIDXBy9PLaygemBi4scqzkjEYYmOEqkVf4ZYnJ3Hh4AVuGddurRZFuUqUZiUigm0FJ+dASj43Z38KhYdgizPU89heRvvz8MYKQ078JwDJjW/y2we/RF5qPHdMLoGNL9nJmEk5fOGO+ksXCJ6VP2Y5DCyD0uvJOXMUPt5AS0IGMeeOsTS1Ac/5ZiieHAiP3RzzO3b5xjK65hp2vLaX+uvL8acnsHBsASnxXnvOkmuR336DR8eeIG30NCZsW8lpTzr+8QtC6jumMJ1HFlTyyKb3eWRhZaDVlJFXDkBT4iAKS4aAM1m5KbmAllNxjMhLDf8lOkOGFya8SYI5h0x5gIM/T2FYdhKe2Bg+P6GImuKMgGMuSB/A3y2wqep9nliq/fbc+46eDTjzxxZVcfOofDKTIzsC0X1OIbPCDgVdt4i4DX/GvPwb4UjQ/hAJ0cuzk/jm4mq+/MJORuTZpuXnqvO4cLGF8SUhQjrj7uKEuYHi1/YGDB1MdYF1NktrC9t02gFUFly60bxeL99aNonN7x5ibFHof4CKcqWJ98by9fkjA+EhSqbCe7+wGcpaOfYhsyrHsHVFOd6nP7Ad3Pu3kh/fBE/NhOtW24UcM0o7DnN44qDMdkTHZtlROTHDPwfbn2HloHfgY6zTyBriDNE8Q9X8+xkyuIy6cX7SE+O47ZqStucsqAGJYc7ARihKhB9tJqnmDlZMHxZWjLraQpbU+IkJaj3FpNs+hcKiMjw5l64xc/woco55ifd2sGKx8xxZnbcTDkB+5XXc2ngEv9MymD4sh+nDcsIePtqfTrU/jU+Onwu0XESEyf2gX1Eum6bdT6ipqTHbtvViEa+3/hU23Au51W2mpnPvVnsDhqC5xYRtcneXNz46SrU/reMbS1H6A/u3wdPT7Xbt3bD1e/bB23TOZi/7+UqYdB+8/h1n/1o7qevgLvsPf/EPunadw7vhiVpY8JQdYtq61MNf7IbkQfDMPFvngXch1tvxub5daRecq66zM6qXrYeKGd3X/cUv2hBX0TXwqB8TG4d8tbHzeP750/BYmXWkaYVwf+jc65FARLYbY2p6erz7+hRaGbUMciqtQ4gJusHSisIecqUcAsD40oHqEJTooKDGPtwHZNpZtal+O3nr0wZoeNH+fmrutO9b19pj/vCyXQ+ocGLXr5M1BG7fBCMXgX+8LfMm2sXjAOY9Dp9f37lDAMgohs/22nwFsXFt1xfrDgufgiGzIT4F4lOR5NyudfD6ki4tj9Oqi0twr1MQgarFdjtzsO2gS86zK5UqitKWW9bBXa/YBeAygsI1+34HA8tt2ZJnwRMPQ+fZOROe+Eu/sa5SNAliPeC3Hdxtwk+Z5ZBb1bXzpJfYtcY+etW2GOIGdE+OUKQWts3Y1hmT/hxG/on9A+oi3NenEMyIhXbaekaJvdk9uoSEooQkJffSdkapTQwDdi2ebDt0mqFzYdX/QNNZ2L3J5goIMxqqUwqc5SMySjquF46MEjh7xL5mPNyzc7Rn9qO21dFVPL5LOVJchLudQpofpj5o1zDJrQJ0sTlF6ZRh8+DMYTh1CA5ss3MkWvH47Ou2l8L2zXWJrKE2TFXQw9B38ICRsmlhq3WL4smd1/l/QK/CRyKyWETeEZEWEQlrXRG5UUR2i8geEVkVrt5VYdpDMHSOzcTUPvGGoiiXUz4D6tZdCuWEevgXTQw5s7rLxMTAfdth4n09Oz7daWEMyLR9h8oVo7d9Cg3AQiBs/kqxmeifAGYDw4GlIqI5JxWlv5Nbbd9b11+60nh81jn0hNawU9n1PT+HEpJehY+MMe8Bgan1YagF9hhjPnLqPgfMB7qRTklRlD6neqkN02RWdFq1z4lPhelrbKtGuaL0RZ9CPhCcyWM/4K4xXIriRjw+myiqvzLlgUhL4Eo6dQoi8gowKMSuh4wxG66kMCJyN3A3QGFhYSe1FUVRlCtNp07BGNPb9tkBIHhhnwKnLNS11gJrwc5o7uV1FUVRlG7SFz00vwcqRKREROKAOuBnfXBdRVEUpZv0dkjqAhHZD0wEXhKRl53yPBHZCGCMuQjUAy8D7wE/Mca8E+6ciqIoSuTo7eijnwKX5Y0zxnwCzAn6vBHY2JtrKYqiKFcfHeCrKIqiBFCnoCiKogRQp6AoiqIE6LdJdkTkMDYvU0/JpG3ONTegOkUHbtQJ3KmXG3UaYoxJ7unB/XaVVGNMVue1wiMi23qTfag/ojpFB27UCdypl1t16s3xGj5SFEVRAqhTUBRFUQK42SmsjbQAVwHVKTpwo07gTr1Up3b0245mRVEUpe9xc0tBURRF6SaucwoRTf15BRGRfSLytojsaB1NICIZIrJZRD5w3nuYNb3vEJHvi0ijiDQElYXUQyz/6Nhul4iMiZzk4Qmj08MicsCx1w4RmRO0b7Wj024RmRUZqTtGRPwiskVE3nVS7K50yqPWVh3oFLW2EpF4EdkqIjsdnf7aKS8RkTcc2X/sLD6KiPicz3uc/cWdXsQY45oXEAt8CJQCccBOYHik5eqhLvuAzHZlfw+scrZXAd+ItJxd0GMqMAZo6EwP7HpZmwABJgBvRFr+buj0MPCXIeoOd+5DH1Di3J+xkdYhhJy5wBhnOxn4gyN71NqqA52i1lbO953kbHuBN5zv/ydAnVP+XWCFs30P8F1nuw74cWfXcFtLIZD60xhzAWhN/ekW5gPPOtvPAjdHUJYuYYz5D+BYu+JweswHfmgs/w2kiUhu30jadcLoFI75wHPGmPPGmL3AHux92q8wxhw0xrzpbJ/CrmicTxTbqgOdwtHvbeV836edj17nZYBpwAtOeXs7tdrvBWC6dJI/2W1OIVTqz45ugv6MAX4lItudjHQAOcaYg872ISAnMqL1mnB6RLv96p1QyveDQntRp5MTYhiN/RfqClu10wmi2FYiEisiO4BGYDO2RXPc2DQF0FbugE7O/hPAwI7O7zan4CYmG2PGALOBe0VkavBOY9uDUT90zC16AP8ElAGjgIPAtyIrTs8QkSRgPXC/MeZk8L5otVUInaLaVsaYZmPMKGwWy1pg6JU8v9ucQpdTf/Z3jDEHnPdGbM6KWuDT1ia6894YOQl7RTg9otZ+xphPnR9rC/A9LoUdokYnEfFiH57rjDEvOsVRbatQOrnBVgDGmOPAFmySszQRaV22KFjugE7O/lTgaEfndZtTcEXqTxFJFJHk1m3gBqABq8typ9pyYENkJOw14fT4GfAFZ2TLBOBEUOiiX9Munr4Aay+wOtU5o0BKgApga1/L1xlOnPmfgfeMMf8QtCtqbRVOp2i2lYhkiUias50AzMT2lWwBFjnV2tup1X6LgN84Lb7wRLo3/Sr0zs/BjjL4EHgo0vL0UIdS7CiIncA7rXpgY4G/Bj4AXgEyIi1rF3T5EbaJ3oSNdd4ZTg/syIonHNu9DdREWv5u6PQvjsy7nB9iblD9hxyddgOzIy1/GJ0mY0NDu4AdzmtONNuqA52i1lZAFfCWI3sD8FdOeSnWge0Bngd8Tnm883mPs7+0s2vojGZFURQlgNvCR4qiKEovUKegKIqiBFCnoCiKogRQp6AoiqIEUKegKIqiBFCnoCiKogRQp6AoiqIEUKegKIqiBPg/SJzFLl5Z5SwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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" + }, + { + "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" + }, + { + "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": [ - "import sys\r\n", - "param_dict,_ = paddle.load('model.pdparams') #读取保存的参数\r\n", - "model = AutoEncoder() \r\n", - "model.load_dict(param_dict) #加载参数\r\n", - "model.eval() #预测\r\n", - "data_reader = paddle.io.DataLoader(train_dataset,\r\n", - " places=[paddle.CPUPlace()],\r\n", - " batch_size=128,\r\n", - " shuffle=False,\r\n", - " drop_last=False,\r\n", - " num_workers=0)\r\n", - "for batch_id, data in enumerate(data_reader()):\r\n", - " x = data[0]\r\n", - " out = model(x)\r\n", - " step = np.arange(287)\r\n", - " plt.plot(step,x[0,0,:-1].numpy())\r\n", - " plt.plot(step,out[0,0].numpy())\r\n", - " plt.show()\r\n", - " sys.exit()\r\n" + "import sys\n", + "param_dict= paddle.load('model') #读取保存的参数\n", + "model = AutoEncoder() \n", + "model.load_dict(param_dict) #加载参数\n", + "model.eval() #预测\n", + "data_reader = paddle.io.DataLoader(train_dataset,\n", + " places=[paddle.CPUPlace()],\n", + " batch_size=128,\n", + " shuffle=False,\n", + " drop_last=False,\n", + " num_workers=0)\n", + "for batch_id, data in enumerate(data_reader()):\n", + " x = data[0]\n", + " out = model(x)\n", + " step = np.arange(287)\n", + " plt.plot(step,x[0,0,:-1].numpy())\n", + " plt.plot(step,out[0,0].numpy())\n", + " plt.show()\n", + " sys.exit\n" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "* 可以看出对正常数据的重构效果十分不错\n", "* 接下来我们对异常数据进行探测\n", @@ -627,10 +846,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 14, + "metadata": {}, "outputs": [ { "data": { @@ -644,77 +861,73 @@ } ], "source": [ - "df_test_value = (df_daily_jumpsup - training_mean) / training_std\r\n", - "fig, ax = plt.subplots()\r\n", - "df_test_value.plot(legend=False, ax=ax)\r\n", - "plt.show()\r\n", + "df_test_value = (df_daily_jumpsup - training_mean) / training_std\n", + "fig, ax = plt.subplots()\n", + "df_test_value.plot(legend=False, ax=ax)\n", + "plt.show()\n", "#这是测试集里面的异常数据,可以看到第11~~12天发生了异常" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 15, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "142\n", - "[2990, 2991, 2992, 2993, 2994, 2995, 2997, 2998, 3000, 3001, 3002, 3003, 3004, 3005, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131, 3132, 3133, 3134]\n" + "141\n", + "[2990, 2991, 2992, 2993, 2994, 2996, 2997, 2998, 2999, 3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131]\n" ] } ], "source": [ - "#探测异常数据\r\n", - "threshold = 0.033 #阀值设定,即刚才求得的值\r\n", - "param_dict,_ = paddle.load('model.pdparams') #读取保存的参数\r\n", - "model = AutoEncoder() \r\n", - "model.load_dict(param_dict) #加载参数\r\n", - "model.eval() #预测\r\n", - "mse_loss = paddle.nn.loss.MSELoss()\r\n", - "\r\n", - "def create_sequences(values, time_steps=288):\r\n", - " '''\r\n", - " 探测数据预处理\r\n", - " '''\r\n", - " output = []\r\n", - " for i in range(len(values) - time_steps):\r\n", - " output.append(values[i : (i + time_steps)])\r\n", - " return np.stack(output)\r\n", - "\r\n", - "\r\n", - "x_test = create_sequences(df_test_value.values)\r\n", - "x = paddle.to_tensor(x_test).astype('float32')\r\n", - "\r\n", - "abnormal_index = [] #记录检测到异常时数据的索引\r\n", - "\r\n", - "for i in range(len(x_test)):\r\n", - " input_x = paddle.reshape(x[i],(1,1,288))\r\n", - " out = model(input_x)\r\n", - " loss = mse_loss(input_x[:,:,:-1],out)\r\n", - " if loss.numpy()[0]>threshold:\r\n", - " #开始检测到异常时序列末端靠近异常点,所以我们要加上序列长度,得到真实索引位置\r\n", - " abnormal_index.append(i+288)\r\n", - "\r\n", - "#不再检测异常时序列的前端靠近异常点,所以我们要减去索引长度得到异常点真实索引,为了结果明显,我们给异常位置加宽40单位\r\n", - "abnormal_index = abnormal_index[:(-288+40)]\r\n", - "print(len(abnormal_index))\r\n", - "print(abnormal_index)\r\n" + "#探测异常数据\n", + "threshold = 0.033 #阀值设定,即刚才求得的值\n", + "param_dict = paddle.load('model') #读取保存的参数\n", + "model = AutoEncoder() \n", + "model.load_dict(param_dict) #加载参数\n", + "model.eval() #预测\n", + "mse_loss = paddle.nn.loss.MSELoss()\n", + "\n", + "def create_sequences(values, time_steps=288):\n", + " '''\n", + " 探测数据预处理\n", + " '''\n", + " output = []\n", + " for i in range(len(values) - time_steps):\n", + " output.append(values[i : (i + time_steps)])\n", + " return np.stack(output)\n", + "\n", + "\n", + "x_test = create_sequences(df_test_value.values)\n", + "x = paddle.to_tensor(x_test).astype('float32')\n", + "\n", + "abnormal_index = [] #记录检测到异常时数据的索引\n", + "\n", + "for i in range(len(x_test)):\n", + " input_x = paddle.reshape(x[i],(1,1,288))\n", + " out = model(input_x)\n", + " loss = mse_loss(input_x[:,:,:-1],out)\n", + " if loss.numpy()[0]>threshold:\n", + " #开始检测到异常时序列末端靠近异常点,所以我们要加上序列长度,得到真实索引位置\n", + " abnormal_index.append(i+288)\n", + "\n", + "#不再检测异常时序列的前端靠近异常点,所以我们要减去索引长度得到异常点真实索引,为了结果明显,我们给异常位置加宽40单位\n", + "abnormal_index = abnormal_index[:(-288+40)]\n", + "print(len(abnormal_index))\n", + "print(abnormal_index)\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 16, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -724,20 +937,20 @@ } ], "source": [ - "#异常检测结果可视化\r\n", - "df_subset = df_daily_jumpsup.iloc[abnormal_index]\r\n", - "fig, ax = plt.subplots()\r\n", - "df_daily_jumpsup.plot(legend=False, ax=ax)\r\n", - "df_subset.plot(legend=False, ax=ax, color=\"r\")\r\n", + "#异常检测结果可视化\n", + "df_subset = df_daily_jumpsup.iloc[abnormal_index]\n", + "fig, ax = plt.subplots()\n", + "df_daily_jumpsup.plot(legend=False, ax=ax)\n", + "df_subset.plot(legend=False, ax=ax, color=\"r\")\n", "plt.show()" ] } ], "metadata": { "kernelspec": { - "display_name": "PaddlePaddle 1.8.4 (Python 3.5)", + "display_name": "Python 3", "language": "python", - "name": "py35-paddle1.2.0" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -749,7 +962,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.2" } }, "nbformat": 4, diff --git a/paddle2.0_docs/addition_rnn/addition_rnn.ipynb b/paddle2.0_docs/addition_rnn/addition_rnn.ipynb old mode 100644 new mode 100755 index 310d5b7dd23..1293f3653aa --- a/paddle2.0_docs/addition_rnn/addition_rnn.ipynb +++ b/paddle2.0_docs/addition_rnn/addition_rnn.ipynb @@ -2,9 +2,7 @@ "cells": [ { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "# 使用序列到序列模型完成数字加法\n", "* 作者:[jm12138](https://github.com/jm12138)\n", @@ -13,9 +11,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 简要介绍\n", "* 本示例教程介绍如何使用飞桨完成一个数字加法任务\n", @@ -25,20 +21,16 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 环境设置\n", - "* 本示例教程基于飞桨2.0-rc0版本" + "* 本示例教程基于飞桨2.0-rc版本" ] }, { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -49,27 +41,25 @@ } ], "source": [ - "# 导入项目运行所需的包\r\n", - "import random\r\n", - "import numpy as np\r\n", - "\r\n", - "import paddle\r\n", - "import paddle.nn as nn\r\n", - "\r\n", - "from visualdl import LogWriter\r\n", - "\r\n", - "# 打印Paddle版本\r\n", - "print('paddle version: %s' % paddle.__version__)\r\n", - "\r\n", - "# 设置CPU为运行位置\r\n", + "# 导入项目运行所需的包\n", + "import random\n", + "import numpy as np\n", + "\n", + "import paddle\n", + "import paddle.nn as nn\n", + "\n", + "from visualdl import LogWriter\n", + "\n", + "# 打印Paddle版本\n", + "print('paddle version: %s' % paddle.__version__)\n", + "\n", + "# 设置CPU为运行位置\n", "place = paddle.CPUPlace()" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 构建数据集\n", "* 随机生成数据,并使用生成的数据构造数据集\n", @@ -78,10 +68,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, + "execution_count": 8, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -94,126 +82,124 @@ } ], "source": [ - "# 编码函数\r\n", - "def encoder(text, LEN, label_dict):\r\n", - " # 文本转ID\r\n", - " ids = [label_dict[word] for word in text]\r\n", - " # 对长度进行补齐\r\n", - " ids += [label_dict[' ']]*(LEN-len(ids))\r\n", - " return ids\r\n", - "\r\n", - "# 单个数据生成函数\r\n", - "def make_data(inputs, labels, DIGITS, label_dict):\r\n", - " MAXLEN = DIGITS + 1 + DIGITS\r\n", - " # 对输入输出文本进行ID编码\r\n", - " inputs = encoder(inputs, MAXLEN, label_dict)\r\n", - " labels = encoder(labels, DIGITS + 1, label_dict)\r\n", - " return inputs, labels\r\n", - "\r\n", - "# 批量数据生成函数\r\n", - "def gen_datas(DATA_NUM, MAX_NUM, DIGITS, label_dict):\r\n", - " datas = []\r\n", - " while len(datas)max_acc:\r\n", - " max_acc = avg_acc\r\n", - " print('saving the best_model...')\r\n", - " paddle.save(model.state_dict(), 'best_model.pdparams')\r\n", - " model.train()\r\n", - "\r\n", - " # 反向传播\r\n", - " loss.backward()\r\n", - "\r\n", - " # 使用优化器进行参数优化\r\n", - " opt.step()\r\n", - "\r\n", - " # 清除梯度\r\n", - " opt.clear_grad()\r\n", - "\r\n", - " # 全局步数加一\r\n", - " global_step += 1\r\n", - "\r\n", - "# 保存最终模型\r\n", - "paddle.save(model.state_dict(),'final_model.pdparams')" + "# 初始化log写入器\n", + "log_writer = LogWriter(logdir=\"./log\")\n", + "\n", + "# 模型参数设置\n", + "embedding_size = 128\n", + "hidden_size=128\n", + "num_layers=1\n", + "\n", + "# 训练参数设置\n", + "epoch_num = 200\n", + "learning_rate = 0.001\n", + "log_iter = 20\n", + "eval_iter = 500\n", + "\n", + "# 定义一些所需变量\n", + "global_step = 0\n", + "log_step = 0\n", + "max_acc = 0\n", + "\n", + "# 实例化模型\n", + "model = Addition_Model(\n", + " char_len=len(label_dict), \n", + " embedding_size=embedding_size, \n", + " hidden_size=hidden_size, \n", + " num_layers=num_layers, \n", + " DIGITS=DIGITS)\n", + "\n", + "# 将模型设置为训练模式\n", + "model.train()\n", + "\n", + "# 设置优化器,学习率,并且把模型参数给优化器\n", + "opt = paddle.optimizer.Adam(\n", + " learning_rate=learning_rate,\n", + " parameters=model.parameters()\n", + ")\n", + "\n", + "# 启动训练,循环epoch_num个轮次\n", + "for epoch in range(epoch_num):\n", + " # 遍历数据集读取数据\n", + " for batch_id, data in enumerate(train_reader()):\n", + " # 读取数据\n", + " inputs, labels = data\n", + "\n", + " # 模型前向计算\n", + " loss, acc = model(inputs, labels=labels)\n", + "\n", + " # 打印训练数据\n", + " if global_step%log_iter==0:\n", + " print('train epoch:%d step: %d loss:%f acc:%f' % (epoch, global_step, loss.numpy(), acc.numpy()))\n", + " log_writer.add_scalar(tag=\"train/loss\", step=log_step, value=loss.numpy())\n", + " log_writer.add_scalar(tag=\"train/acc\", step=log_step, value=acc.numpy())\n", + " log_step+=1\n", + "\n", + " # 模型验证\n", + " if global_step%eval_iter==0:\n", + " model.eval()\n", + " losses = []\n", + " accs = []\n", + " for data in dev_reader():\n", + " loss, acc = model(inputs, labels=labels)\n", + " losses.append(loss.numpy())\n", + " accs.append(acc.numpy())\n", + " avg_loss = np.concatenate(losses).mean()\n", + " avg_acc = np.concatenate(accs).mean()\n", + " print('eval epoch:%d step: %d loss:%f acc:%f' % (epoch, global_step, avg_loss, avg_acc))\n", + " log_writer.add_scalar(tag=\"dev/loss\", step=log_step, value=avg_loss)\n", + " log_writer.add_scalar(tag=\"dev/acc\", step=log_step, value=avg_acc)\n", + "\n", + " # 保存最佳模型\n", + " if avg_acc>max_acc:\n", + " max_acc = avg_acc\n", + " print('saving the best_model...')\n", + " paddle.save(model.state_dict(), 'best_model')\n", + " model.train()\n", + "\n", + " # 反向传播\n", + " loss.backward()\n", + "\n", + " # 使用优化器进行参数优化\n", + " opt.step()\n", + "\n", + " # 清除梯度\n", + " opt.clear_grad()\n", + "\n", + " # 全局步数加一\n", + " global_step += 1\n", + "\n", + "# 保存最终模型\n", + "paddle.save(model.state_dict(),'final_model')" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 模型测试\n", "* 使用保存的最佳模型进行测试" @@ -476,57 +2129,53 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, + "execution_count": 7, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "the model answer: 12+22=34 \n", - "the true answer: 12+22=34\n" + "the model answer: 12+40=52 \n", + "the true answer: 12+40=52\n" ] } ], "source": [ - "# 反转字符表\r\n", - "label_dict_adv = {v: k for k, v in label_dict.items()}\r\n", - "\r\n", - "# 输入计算题目\r\n", - "input_text = '12+22'\r\n", - "\r\n", - "# 编码输入为ID\r\n", - "inputs = encoder(input_text, MAXLEN, label_dict)\r\n", - "\r\n", - "# 转换输入为向量形式\r\n", - "inputs = np.array(inputs).reshape(-1, MAXLEN)\r\n", - "inputs = paddle.to_tensor(inputs)\r\n", - "\r\n", - "# 加载模型\r\n", - "params_dict = paddle.load('best_model.pdparams')\r\n", - "model.set_dict(params_dict)\r\n", - "\r\n", - "# 设置为评估模式\r\n", - "model.eval()\r\n", - "\r\n", - "# 模型推理\r\n", - "out = model(inputs)\r\n", - "\r\n", - "# 结果转换\r\n", - "result = ''.join([label_dict_adv[_] for _ in np.argmax(out.numpy(), -1).reshape(-1)])\r\n", - "\r\n", - "# 打印结果\r\n", - "print('the model answer: %s=%s' % (input_text, result))\r\n", + "# 反转字符表\n", + "label_dict_adv = {v: k for k, v in label_dict.items()}\n", + "\n", + "# 输入计算题目\n", + "input_text = '12+40'\n", + "\n", + "# 编码输入为ID\n", + "inputs = encoder(input_text, MAXLEN, label_dict)\n", + "\n", + "# 转换输入为向量形式\n", + "inputs = np.array(inputs).reshape(-1, MAXLEN)\n", + "inputs = paddle.to_tensor(inputs)\n", + "\n", + "# 加载模型\n", + "params_dict= paddle.load('best_model')\n", + "model.set_dict(params_dict)\n", + "\n", + "# 设置为评估模式\n", + "model.eval()\n", + "\n", + "# 模型推理\n", + "out = model(inputs)\n", + "\n", + "# 结果转换\n", + "result = ''.join([label_dict_adv[_] for _ in np.argmax(out.numpy(), -1).reshape(-1)])\n", + "\n", + "# 打印结果\n", + "print('the model answer: %s=%s' % (input_text, result))\n", "print('the true answer: %s=%s' % (input_text, eval(input_text)))" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 总结\n", "* 你还可以通过变换网络结构,调整数据集,尝试不同的参数的方式来进一步提升本示例当中的数字加法的效果\n", @@ -536,9 +2185,9 @@ ], "metadata": { "kernelspec": { - "display_name": "PaddlePaddle 2.0.0b0 (Python 3.5)", + "display_name": "Python 3", "language": "python", - "name": "py35-paddle1.2.0" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -550,7 +2199,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.2" } }, "nbformat": 4, diff --git a/paddle2.0_docs/image_ocr/OCR.ipynb b/paddle2.0_docs/image_ocr/OCR.ipynb old mode 100644 new mode 100755 index db68b55e8c8..782e8ebe874 --- a/paddle2.0_docs/image_ocr/OCR.ipynb +++ b/paddle2.0_docs/image_ocr/OCR.ipynb @@ -1,39 +1,33 @@ { "cells": [ { + "cell_type": "markdown", + "metadata": {}, "source": [ "# 通过OCR实现验证码识别\n", "\n", "作者: [GT_老张](https://github.com/GT-ZhangAcer) \n", - "时间: 2020.10.16\n", + "时间: 2020.11\n", "\n", "本篇将介绍如何通过飞桨实现简单的CRNN+CTC自定义数据集OCR识别模型,数据集采用[CaptchaDataset](https://github.com/GT-ZhangAcer/CaptchaDataset)中OCR部分的9453张图像,其中前8453张图像在本案例中作为训练集,后1000张则作为测试集。 \n", "在更复杂的场景中推荐使用[PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)产出工业级模型,模型轻量且精度大幅提升。 \n", "同样也可以在[PaddleHub](https://www.paddlepaddle.org.cn/hubdetail?name=chinese_ocr_db_crnn_mobile&en_category=TextRecognition)中快速使用PaddleOCR。\n", "\n" - ], - "cell_type": "markdown", - "metadata": { - "collapsed": false - } + ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "**数据展示**\n", "

\n", "
\n", - "

\n", - "\n", - "点此[快速获取本节数据集](https://aistudio.baidu.com/aistudio/datasetdetail/57285),待数据集下载完毕后可使用`!unzip OCR_Dataset.zip -d data/`命令或熟悉的解压软件进行解压,待数据准备工作完成后修改本文“训练准备”中的`DATA_PATH = 解压后数据集路径`。" - ], - "cell_type": "markdown", - "metadata": {} + "

" + ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 自定义数据集读取器\n", "\n", @@ -45,10 +39,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 1, + "metadata": {}, "outputs": [], "source": [ "import os\n", @@ -109,18 +101,14 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 模型配置" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 定义模型结构以及模型输入\n", "\n", @@ -128,22 +116,23 @@ "\n", "CTC相关论文:[Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neu](http://people.idsia.ch/~santiago/papers/icml2006.pdf) \n", "

\n", - "
\n", + "
\n", "

\n", "\n", - "网络部分,因本篇采用数据集较为简单且图像尺寸较小并不适合较深层次网络。若在对尺寸较大的图像进行模型构建,可以考虑使用更深层次网络/注意力机制来完成。当然也可以通过目标检测形式先检出文本位置,然后进行OCR部分模型构建。(下方样例来源[PaddleOCR](v))\n", + "网络部分,因本篇采用数据集较为简单且图像尺寸较小并不适合较深层次网络。若在对尺寸较大的图像进行模型构建,可以考虑使用更深层次网络/注意力机制来完成。当然也可以通过目标检测形式先检出文本位置,然后进行OCR部分模型构建。\n", "\n", "

\n", - "
\n", + "
\n", + " \n", + " \n", + "PaddleOCR效果图\n", "

" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 8, + "metadata": {}, "outputs": [], "source": [ "import paddle\n", @@ -174,7 +163,7 @@ " stride=2)\n", " self.bn2 = paddle.nn.BatchNorm2D(64)\n", " # 定义一层1x1卷积压缩通道数,输出通道数设置为比LABEL_MAX_LEN稍大的定值可获取更优效果,当然也可设置为LABEL_MAX_LEN\n", - " self.conv3 = paddle.nn.Conv2d(in_channels=64,\n", + " self.conv3 = paddle.nn.Conv2D(in_channels=64,\n", " out_channels=LABEL_MAX_LEN + 4,\n", " kernel_size=1)\n", " # 定义全连接层,压缩并提取特征(可选)\n", @@ -214,25 +203,19 @@ " if self.is_infer:\n", " # 输出层 - Shape = (Batch Size, Max label len, Prob) \n", " x = paddle.nn.functional.softmax(x)\n", - " # 转换为标签\n", - " x = paddle.tensor.argmax(x, axis=-1)\n", " return x" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 训练准备" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 定义label输入以及超参数\n", "监督训练需要定义label,预测则不需要该步骤。" @@ -240,10 +223,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ "# 数据集路径设置\n", @@ -260,9 +241,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 定义CTC Loss\n", "\n", @@ -273,10 +252,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 15, + "metadata": {}, "outputs": [], "source": [ "class CTCLoss(paddle.nn.Layer):\n", @@ -287,8 +264,8 @@ " super().__init__()\n", "\n", " def forward(self, ipt, label):\n", - " input_lengths = paddle.tensor.creation.fill_constant([BATCH_SIZE, 1], \"int64\", LABEL_MAX_LEN + 4)\n", - " label_lengths = paddle.tensor.creation.fill_constant([BATCH_SIZE, 1], \"int64\", LABEL_MAX_LEN)\n", + " input_lengths = paddle.full(shape=[BATCH_SIZE, 1],fill_value=LABEL_MAX_LEN + 4,dtype= \"int64\")\n", + " label_lengths = paddle.full(shape=[BATCH_SIZE, 1],fill_value=LABEL_MAX_LEN,dtype= \"int64\")\n", " # 按文档要求进行转换dim顺序\n", " ipt = paddle.tensor.transpose(ipt, [1, 0, 2])\n", " # 计算loss\n", @@ -298,19 +275,15 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 实例化模型并配置优化策略" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "# 实例化模型\n", @@ -319,10 +292,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 17, + "metadata": {}, "outputs": [], "source": [ "# 定义优化器\n", @@ -335,30 +306,131 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 开始训练\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 19, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/10\n", - "step 529/529 - loss: 0.2174 - 50ms/step\n", - "save checkpoint at /home/aistudio/output/0\n", + "step 100/529 - loss: 0.0191 - 66ms/step\n", + "step 200/529 - loss: 0.0082 - 65ms/step\n", + "step 300/529 - loss: 0.0094 - 65ms/step\n", + "step 400/529 - loss: 0.0378 - 64ms/step\n", + "step 500/529 - loss: 0.0135 - 64ms/step\n", + "step 529/529 - loss: 0.0087 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/0\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0081 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 2/10\n", + "step 100/529 - loss: 0.0084 - 64ms/step\n", + "step 200/529 - loss: 0.0308 - 64ms/step\n", + "step 300/529 - loss: 0.0169 - 64ms/step\n", + "step 400/529 - loss: 0.2335 - 64ms/step\n", + "step 500/529 - loss: 0.0071 - 64ms/step\n", + "step 529/529 - loss: 0.0029 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/1\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0075 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 3/10\n", + "step 100/529 - loss: 0.0080 - 64ms/step\n", + "step 200/529 - loss: 0.0040 - 64ms/step\n", + "step 300/529 - loss: 0.0033 - 64ms/step\n", + "step 400/529 - loss: 0.0053 - 64ms/step\n", + "step 500/529 - loss: 0.0366 - 64ms/step\n", + "step 529/529 - loss: 0.1938 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/2\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0112 - 28ms/step\n", + "Eval samples: 1000\n", + "Epoch 4/10\n", + "step 100/529 - loss: 0.0067 - 64ms/step\n", + "step 200/529 - loss: 0.0049 - 64ms/step\n", + "step 300/529 - loss: 0.0211 - 66ms/step\n", + "step 400/529 - loss: 0.0041 - 65ms/step\n", + "step 500/529 - loss: 0.0461 - 65ms/step\n", + "step 529/529 - loss: 0.0031 - 65ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/3\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0064 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 5/10\n", + "step 100/529 - loss: 0.0036 - 63ms/step\n", + "step 200/529 - loss: 0.0039 - 64ms/step\n", + "step 300/529 - loss: 0.0101 - 64ms/step\n", + "step 400/529 - loss: 0.0076 - 64ms/step\n", + "step 500/529 - loss: 0.0665 - 64ms/step\n", + "step 529/529 - loss: 0.0018 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/4\n", "Eval begin...\n", - "step 63/63 - loss: 0.2749 - 18ms/step\n", - "Eval samples: 1000\n" + "step 63/63 - loss: 0.0078 - 26ms/step\n", + "Eval samples: 1000\n", + "Epoch 6/10\n", + "step 100/529 - loss: 0.1070 - 65ms/step\n", + "step 200/529 - loss: 0.0042 - 64ms/step\n", + "step 300/529 - loss: 0.0312 - 64ms/step\n", + "step 400/529 - loss: 0.0027 - 64ms/step\n", + "step 500/529 - loss: 0.0050 - 64ms/step\n", + "step 529/529 - loss: 0.0029 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/5\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0055 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 7/10\n", + "step 100/529 - loss: 0.0060 - 65ms/step\n", + "step 200/529 - loss: 0.0401 - 64ms/step\n", + "step 300/529 - loss: 0.0043 - 64ms/step\n", + "step 400/529 - loss: 0.0051 - 64ms/step\n", + "step 500/529 - loss: 0.0043 - 64ms/step\n", + "step 529/529 - loss: 0.0025 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/6\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0090 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 8/10\n", + "step 100/529 - loss: 0.0020 - 64ms/step\n", + "step 200/529 - loss: 0.0027 - 63ms/step\n", + "step 300/529 - loss: 0.0077 - 63ms/step\n", + "step 400/529 - loss: 0.0163 - 63ms/step\n", + "step 500/529 - loss: 0.0024 - 63ms/step\n", + "step 529/529 - loss: 0.0029 - 63ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/7\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0090 - 27ms/step\n", + "Eval samples: 1000\n", + "Epoch 9/10\n", + "step 100/529 - loss: 0.0025 - 66ms/step\n", + "step 200/529 - loss: 0.0036 - 65ms/step\n", + "step 300/529 - loss: 0.0047 - 65ms/step\n", + "step 400/529 - loss: 0.0066 - 65ms/step\n", + "step 500/529 - loss: 0.0486 - 65ms/step\n", + "step 529/529 - loss: 0.0020 - 65ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/8\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0082 - 26ms/step\n", + "Eval samples: 1000\n", + "Epoch 10/10\n", + "step 100/529 - loss: 0.0022 - 63ms/step\n", + "step 200/529 - loss: 0.0019 - 63ms/step\n", + "step 300/529 - loss: 0.0019 - 64ms/step\n", + "step 400/529 - loss: 0.0027 - 64ms/step\n", + "step 500/529 - loss: 0.0031 - 64ms/step\n", + "step 529/529 - loss: 0.0060 - 64ms/step\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/9\n", + "Eval begin...\n", + "step 63/63 - loss: 0.0099 - 28ms/step\n", + "Eval samples: 1000\n", + "save checkpoint at /Users/lican02/Desktop/book-develop/paddle2.0_docs/image_ocr/output/final\n" ] } ], @@ -375,28 +447,22 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "## 预测前准备" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 像定义训练Reader一样定义预测Reader" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 20, + "metadata": {}, "outputs": [], "source": [ "# 与训练近似,但不包含Label\n", @@ -438,48 +504,40 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 参数设置" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 38, + "metadata": {}, "outputs": [], "source": [ - "# 待预测目录 - 可在测试数据集中挑出\b3张图像放在该目录中进行推理\n", + "# 待预测目录\n", "INFER_DATA_PATH = \"./sample_img\"\n", - "# 训练后存档点路径 - 10代表使用第10个存档点\n", - "CHECKPOINT_PATH = \"./output/10\"\n", + "# 训练后存档点路径 - final 代表最终训练所得模型\n", + "CHECKPOINT_PATH = \"./output/final.pdparams\"\n", "# 每批次处理数量\n", "BATCH_SIZE = 32" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": false - }, + "metadata": {}, "source": [ "### 展示待预测数据" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 23, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -504,52 +562,34 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## 开始预测\n", - "> 飞桨2.0 CTC Decoder 相关API正在迁移中,本节暂时使用简易版解码器。" - ], - "cell_type": "markdown", - "metadata": { - "collapsed": false - } + "> 飞桨2.0 CTC Decoder 相关API正在迁移中,暂时使用[第三方解码器](https://github.com/awni/speech/blob/072bcf9ff510d814fbfcaad43b2883ecf8f60806/speech/models/ctc_decoder.py)进行解码。" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 49, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predict begin...\n", - "step 1/1 [==============================] - 17ms/step\n", + "step 1/1 [==============================] - 24ms/step\n", "Predict samples: 3\n", "文件名:9451.jpg,预测结果为:(3, 4, 6, 3)\n", - "文件名:9452.jpg,预测结果为:(0, 3, 0, 0)\n", - "文件名:9450.jpg,预测结果为:(8, 2, 0, 5)\n" + "文件名:9450.jpg,预测结果为:(8, 2, 0, 5)\n", + "文件名:9452.jpg,预测结果为:(0, 3, 0, 0)\n" ] } ], "source": [ - "# 编写简易版解码器\n", - "def ctc_decode(text, blank=10):\n", - " \"\"\"\n", - " 简易CTC解码器\n", - " :param text: 待解码数据\n", - " :param blank: 分隔符索引值\n", - " :return: 解码后数据\n", - " \"\"\"\n", - " result = []\n", - " cache_idx = -1\n", - " for char in text:\n", - " if char != blank and char != cache_idx:\n", - " result.append(char)\n", - " cache_idx = char\n", - " return result\n", "\n", + "from ctc import decode\n", "\n", "# 实例化预测模型\n", "model = paddle.Model(Net(is_infer=True), inputs=input_define)\n", @@ -563,19 +603,19 @@ "img_names = infer_reader.get_names()\n", "results = model.predict(infer_reader, batch_size=BATCH_SIZE)\n", "index = 0\n", - "for text_batch in results[0]:\n", - " for prob in text_batch:\n", - " out = ctc_decode(prob, blank=10)\n", - " print(f\"文件名:{img_names[index]},推理结果为:{out}\")\n", + "for result in results[0]:\n", + " for prob in result:\n", + " out, _ = decode(prob, blank=10)\n", + " print(f\"文件名:{img_names[index]},预测结果为:{out}\")\n", " index += 1" ] } ], "metadata": { "kernelspec": { - "display_name": "PaddlePaddle 1.8.4 (Python 3.5)", + "display_name": "Python 3", "language": "python", - "name": "py35-paddle1.2.0" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -587,9 +627,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.5" } }, "nbformat": 4, "nbformat_minor": 1 -} \ No newline at end of file +} diff --git a/paddle2.0_docs/landmark_detection/1_facial_landmark.ipynb b/paddle2.0_docs/landmark_detection/1_facial_landmark.ipynb index 16a2a1ff9bc..9ee62fc2148 100644 --- a/paddle2.0_docs/landmark_detection/1_facial_landmark.ipynb +++ b/paddle2.0_docs/landmark_detection/1_facial_landmark.ipynb @@ -4,16 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 关键点检测方法及应用1: 人脸关键点检测\n", - "作者:[钟祝寺](https://github.com/zzs95)
\n", - "日期:2020.10.21" + "# 关键点检测方法及应用1: 人脸关键点检测\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "本示例教程当前是基于2.0-beta版本Paddle做的案例实现,未来会随着2.0的系列版本发布进行升级。\n", + "本示例教程当前是基于2.0-rc版本Paddle做的案例实现,未来会随着2.0的系列版本发布进行升级。\n", "\n", "## 1.简要介绍\n", "在图像处理中,关键点本质上是一种特征。它是对一个固定区域或者空间物理关系的抽象描述,描述的是一定邻域范围内的组合或上下文关系。它不仅仅是一个点信息,或代表一个位置,更代表着上下文与周围邻域的组合关系。关键点检测的目标就是通过计算机从图像中找出这些点的坐标,作为计算机视觉领域的一个基础任务,关键点的检测对于高级别任务,例如识别和分类具有至关重要的意义。\n", @@ -30,59 +28,40 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "# !pip install paddlepaddle==2.0.0b0 -f https://paddlepaddle.org.cn/whl/stable.html\r\n", - "# !python -m pip install paddlepaddle-gpu==2.0.0b0 -i https://mirror.baidu.com/pypi/simple" - ] - }, - { - "cell_type": "markdown", "metadata": {}, + "outputs": [], "source": [ - "安装好paddle2.0后重启环境。" + "# !pip install paddlepaddle==2.0.0rc0 -f https://paddlepaddle.org.cn/whl/stable.html\n", + "# !python -m pip install paddlepaddle-gpu==2.0.0rc0 -i https://mirror.baidu.com/pypi/simple" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 1, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.0.0-beta0\n" + "2.0.0-rc0\n" ] } ], "source": [ - "import numpy as np\r\n", - "import matplotlib.pyplot as plt\r\n", - "import pandas as pd\r\n", - "import os\r\n", - "\r\n", - "import paddle\r\n", - "from paddle.io import Dataset\r\n", - "from paddle.vision.transforms import transforms\r\n", - "from paddle.vision.models import resnet18\r\n", - "from paddle.nn import functional as F\r\n", - "print(paddle.__version__)\r\n", - "# device = paddle.set_device('cpu') \r\n", - "device = paddle.set_device('gpu') \r\n", - "# if use static graph, do not set\r\n", - "paddle.disable_static(device)" + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import os\n", + "\n", + "import paddle\n", + "from paddle.io import Dataset\n", + "from paddle.vision.transforms import transforms\n", + "from paddle.vision.models import resnet18\n", + "from paddle.nn import functional as F\n", + "print(paddle.__version__)\n", + "# device = paddle.set_device('cpu') \n", + "device = paddle.set_device('gpu') " ] }, { @@ -103,13 +82,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 2, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -123,8 +97,8 @@ } ], "source": [ - "!unzip -o data/data60/test.zip -d data/data60/\r\n", - "!unzip -o data/data60/training.zip -d data/data60/" + "!unzip -o data/data60/test.zip -d data/data60/\n", + "!unzip -o data/data60/training.zip -d data/data60" ] }, { @@ -139,92 +113,87 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ - "Train_Dir = 'data/data60//training.csv'\r\n", - "Test_Dir = 'data/data60//test.csv'\r\n", - "lookid_dir = 'data/data60/IdLookupTable.csv'\r\n", - "class ImgTransforms(object):\r\n", - " \"\"\"\r\n", - " 图像预处理工具,用于将图像进行升维(96, 96) => (96, 96, 3),\r\n", - " 并对图像的维度进行转换从HWC变为CHW\r\n", - " \"\"\"\r\n", - " def __init__(self, fmt):\r\n", - " self.format = fmt\r\n", - "\r\n", - " def __call__(self, img):\r\n", - " if len(img.shape) == 2:\r\n", - " img = np.expand_dims(img, axis=2)\r\n", - " img = img.transpose(self.format)\r\n", - "\r\n", - " if img.shape[0] == 1:\r\n", - " img = np.repeat(img, 3, axis=0)\r\n", - " return img\r\n", - "\r\n", - "class FaceDataset(Dataset):\r\n", - " def __init__(self, data_path, mode='train', val_split=0.2):\r\n", - " self.mode = mode\r\n", - " assert self.mode in ['train', 'val', 'test'], \\\r\n", - " \"mode should be 'train' or 'test', but got {}\".format(self.mode)\r\n", - " self.data_source = pd.read_csv(data_path)\r\n", - " # 清洗数据, 数据集中有很多样本只标注了部分关键点, 这里有两种策略\r\n", - " # 第一种, 将未标注的位置从上一个样本对应的关键点复制过来\r\n", - " # self.data_source.fillna(method = 'ffill',inplace = True)\r\n", - " # 第二种, 将包含有未标注的样本从数据集中移除\r\n", - " self.data_source.dropna(how=\"any\", inplace=True) \r\n", - " self.data_label_all = self.data_source.drop('Image', axis = 1)\r\n", - " \r\n", - " # 划分训练集和验证集合\r\n", - " if self.mode in ['train', 'val']:\r\n", - " np.random.seed(43)\r\n", - " data_len = len(self.data_source)\r\n", - " # 随机划分\r\n", - " shuffled_indices = np.random.permutation(data_len)\r\n", - " # 顺序划分\r\n", - " # shuffled_indices = np.arange(data_len)\r\n", - " self.shuffled_indices = shuffled_indices\r\n", - " val_set_size = int(data_len*val_split)\r\n", - " if self.mode == 'val':\r\n", - " val_indices = shuffled_indices[:val_set_size]\r\n", - " self.data_img = self.data_source.reindex().iloc[val_indices]\r\n", - " self.data_label = self.data_label_all.reindex().iloc[val_indices]\r\n", - " elif self.mode == 'train':\r\n", - " train_indices = shuffled_indices[val_set_size:]\r\n", - " self.data_img = self.data_source.reindex().iloc[train_indices]\r\n", - " self.data_label = self.data_label_all.reindex().iloc[train_indices]\r\n", - " elif self.mode == 'test':\r\n", - " self.data_img = self.data_source\r\n", - " self.data_label = self.data_label_all\r\n", - "\r\n", - " self.transforms = transforms.Compose([\r\n", - " ImgTransforms((2, 0, 1))\r\n", - " ])\r\n", - "\r\n", - " # 每次迭代时返回数据和对应的标签\r\n", - " def __getitem__(self, idx):\r\n", - "\r\n", - " img = self.data_img['Image'].iloc[idx].split(' ')\r\n", - " img = ['0' if x == '' else x for x in img]\r\n", - " img = np.array(img, dtype = 'float32').reshape(96, 96)\r\n", - " img = self.transforms(img)\r\n", - " label = np.array(self.data_label.iloc[idx,:],dtype = 'float32')/96\r\n", - " return img, label\r\n", - "\r\n", - " # 返回整个数据集的总数\r\n", - " def __len__(self):\r\n", - " return len(self.data_img)\r\n", - "# 训练数据集和验证数据集\r\n", - "train_dataset = FaceDataset(Train_Dir, mode='train')\r\n", - "val_dataset = FaceDataset(Train_Dir, mode='val')\r\n", - "\r\n", - "# 测试数据集\r\n", + "Train_Dir = 'data/data60//training.csv'\n", + "Test_Dir = 'data/data60//test.csv'\n", + "lookid_dir = 'data/data60/IdLookupTable.csv'\n", + "class ImgTransforms(object):\n", + " \"\"\"\n", + " 图像预处理工具,用于将图像进行升维(96, 96) => (96, 96, 3),\n", + " 并对图像的维度进行转换从HWC变为CHW\n", + " \"\"\"\n", + " def __init__(self, fmt):\n", + " self.format = fmt\n", + "\n", + " def __call__(self, img):\n", + " if len(img.shape) == 2:\n", + " img = np.expand_dims(img, axis=2)\n", + " img = img.transpose(self.format)\n", + "\n", + " if img.shape[0] == 1:\n", + " img = np.repeat(img, 3, axis=0)\n", + " return img\n", + "\n", + "class FaceDataset(Dataset):\n", + " def __init__(self, data_path, mode='train', val_split=0.2):\n", + " self.mode = mode\n", + " assert self.mode in ['train', 'val', 'test'], \\\n", + " \"mode should be 'train' or 'test', but got {}\".format(self.mode)\n", + " self.data_source = pd.read_csv(data_path)\n", + " # 清洗数据, 数据集中有很多样本只标注了部分关键点, 这里有两种策略\n", + " # 第一种, 将未标注的位置从上一个样本对应的关键点复制过来\n", + " # self.data_source.fillna(method = 'ffill',inplace = True)\n", + " # 第二种, 将包含有未标注的样本从数据集中移除\n", + " self.data_source.dropna(how=\"any\", inplace=True) \n", + " self.data_label_all = self.data_source.drop('Image', axis = 1)\n", + " \n", + " # 划分训练集和验证集合\n", + " if self.mode in ['train', 'val']:\n", + " np.random.seed(43)\n", + " data_len = len(self.data_source)\n", + " # 随机划分\n", + " shuffled_indices = np.random.permutation(data_len)\n", + " # 顺序划分\n", + " # shuffled_indices = np.arange(data_len)\n", + " self.shuffled_indices = shuffled_indices\n", + " val_set_size = int(data_len*val_split)\n", + " if self.mode == 'val':\n", + " val_indices = shuffled_indices[:val_set_size]\n", + " self.data_img = self.data_source.reindex().iloc[val_indices]\n", + " self.data_label = self.data_label_all.reindex().iloc[val_indices]\n", + " elif self.mode == 'train':\n", + " train_indices = shuffled_indices[val_set_size:]\n", + " self.data_img = self.data_source.reindex().iloc[train_indices]\n", + " self.data_label = self.data_label_all.reindex().iloc[train_indices]\n", + " elif self.mode == 'test':\n", + " self.data_img = self.data_source\n", + " self.data_label = self.data_label_all\n", + "\n", + " self.transforms = transforms.Compose([\n", + " ImgTransforms((2, 0, 1))\n", + " ])\n", + "\n", + " # 每次迭代时返回数据和对应的标签\n", + " def __getitem__(self, idx):\n", + "\n", + " img = self.data_img['Image'].iloc[idx].split(' ')\n", + " img = ['0' if x == '' else x for x in img]\n", + " img = np.array(img, dtype = 'float32').reshape(96, 96)\n", + " img = self.transforms(img)\n", + " label = np.array(self.data_label.iloc[idx,:],dtype = 'float32')/96\n", + " return img, label\n", + "\n", + " # 返回整个数据集的总数\n", + " def __len__(self):\n", + " return len(self.data_img)\n", + "# 训练数据集和验证数据集\n", + "train_dataset = FaceDataset(Train_Dir, mode='train')\n", + "val_dataset = FaceDataset(Train_Dir, mode='val')\n", + "\n", + "# 测试数据集\n", "test_dataset = FaceDataset(Test_Dir, mode='test')" ] }, @@ -238,13 +207,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 5, + "metadata": {}, "outputs": [ { "data": { @@ -258,23 +222,23 @@ } ], "source": [ - "def plot_sample(x, y, axis):\r\n", - " img = x.reshape(96, 96)\r\n", - " axis.imshow(img, cmap='gray')\r\n", - " axis.scatter(y[0::2], y[1::2], marker='x', s=10, color='b')\r\n", - "\r\n", - "fig = plt.figure(figsize=(10, 7))\r\n", - "fig.subplots_adjust(\r\n", - " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\r\n", - "\r\n", - "# 随机取16个样本展示\r\n", - "for i in range(16):\r\n", - " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\r\n", - " idx = np.random.randint(train_dataset.__len__())\r\n", - " # print(idx)\r\n", - " img, label = train_dataset[idx]\r\n", - " label = label*96\r\n", - " plot_sample(img[0], label, axis)\r\n", + "def plot_sample(x, y, axis):\n", + " img = x.reshape(96, 96)\n", + " axis.imshow(img, cmap='gray')\n", + " axis.scatter(y[0::2], y[1::2], marker='x', s=10, color='b')\n", + "\n", + "fig = plt.figure(figsize=(10, 7))\n", + "fig.subplots_adjust(\n", + " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\n", + "\n", + "# 随机取16个样本展示\n", + "for i in range(16):\n", + " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\n", + " idx = np.random.randint(train_dataset.__len__())\n", + " # print(idx)\n", + " img, label = train_dataset[idx]\n", + " label = label*96\n", + " plot_sample(img[0], label, axis)\n", "plt.show()" ] }, @@ -288,28 +252,23 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ - "class FaceNet(paddle.nn.Layer):\r\n", - " def __init__(self, num_keypoints, pretrained=False):\r\n", - " super(FaceNet, self).__init__()\r\n", - " self.backbone = resnet18(pretrained)\r\n", - " self.outLayer1 = paddle.nn.Sequential(\r\n", - " paddle.nn.Linear(1000, 512),\r\n", - " paddle.nn.ReLU(),\r\n", - " paddle.nn.Dropout(0.1))\r\n", - " self.outLayer2 = paddle.nn.Linear(512, num_keypoints*2)\r\n", - " def forward(self, inputs):\r\n", - " out = self.backbone(inputs)\r\n", - " out = self.outLayer1(out)\r\n", - " out = self.outLayer2(out)\r\n", + "class FaceNet(paddle.nn.Layer):\n", + " def __init__(self, num_keypoints, pretrained=False):\n", + " super(FaceNet, self).__init__()\n", + " self.backbone = resnet18(pretrained)\n", + " self.outLayer1 = paddle.nn.Sequential(\n", + " paddle.nn.Linear(1000, 512),\n", + " paddle.nn.ReLU(),\n", + " paddle.nn.Dropout(0.1))\n", + " self.outLayer2 = paddle.nn.Linear(512, num_keypoints*2)\n", + " def forward(self, inputs):\n", + " out = self.backbone(inputs)\n", + " out = self.outLayer1(out)\n", + " out = self.outLayer2(out)\n", " return out" ] }, @@ -323,131 +282,112 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 14, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--------------------------------------------------------------------------------\n", - " Layer (type) Input Shape Output Shape Param #\n", - "================================================================================\n", - " Conv2D-1 [-1, 3, 96, 96] [-1, 64, 48, 48] 9,408\n", - " BatchNorm-1 [-1, 64, 48, 48] [-1, 64, 48, 48] 256\n", - " ConvBNLayer-1 [-1, 3, 96, 96] [-1, 64, 48, 48] 0\n", - " Pool2D-1 [-1, 64, 48, 48] [-1, 64, 24, 24] 0\n", - " Conv2D-2 [-1, 64, 24, 24] [-1, 64, 24, 24] 36,864\n", - " BatchNorm-2 [-1, 64, 24, 24] [-1, 64, 24, 24] 256\n", - " ConvBNLayer-2 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " Conv2D-3 [-1, 64, 24, 24] [-1, 64, 24, 24] 36,864\n", - " BatchNorm-3 [-1, 64, 24, 24] [-1, 64, 24, 24] 256\n", - " ConvBNLayer-3 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " Conv2D-4 [-1, 64, 24, 24] [-1, 64, 24, 24] 4,096\n", - " BatchNorm-4 [-1, 64, 24, 24] [-1, 64, 24, 24] 256\n", - " ConvBNLayer-4 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " BasicBlock-1 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " Conv2D-5 [-1, 64, 24, 24] [-1, 64, 24, 24] 36,864\n", - " BatchNorm-5 [-1, 64, 24, 24] [-1, 64, 24, 24] 256\n", - " ConvBNLayer-5 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " Conv2D-6 [-1, 64, 24, 24] [-1, 64, 24, 24] 36,864\n", - " BatchNorm-6 [-1, 64, 24, 24] [-1, 64, 24, 24] 256\n", - " ConvBNLayer-6 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " BasicBlock-2 [-1, 64, 24, 24] [-1, 64, 24, 24] 0\n", - " Conv2D-7 [-1, 64, 24, 24] [-1, 128, 24, 24] 73,728\n", - " BatchNorm-7 [-1, 128, 24, 24] [-1, 128, 24, 24] 512\n", - " ConvBNLayer-7 [-1, 64, 24, 24] [-1, 128, 24, 24] 0\n", - " Conv2D-8 [-1, 128, 24, 24] [-1, 128, 12, 12] 147,456\n", - " BatchNorm-8 [-1, 128, 12, 12] [-1, 128, 12, 12] 512\n", - " ConvBNLayer-8 [-1, 128, 24, 24] [-1, 128, 12, 12] 0\n", - " Conv2D-9 [-1, 64, 24, 24] [-1, 128, 12, 12] 8,192\n", - " BatchNorm-9 [-1, 128, 12, 12] [-1, 128, 12, 12] 512\n", - " ConvBNLayer-9 [-1, 64, 24, 24] [-1, 128, 12, 12] 0\n", - " BasicBlock-3 [-1, 64, 24, 24] [-1, 128, 12, 12] 0\n", - " Conv2D-10 [-1, 128, 12, 12] [-1, 128, 12, 12] 147,456\n", - " BatchNorm-10 [-1, 128, 12, 12] [-1, 128, 12, 12] 512\n", - " ConvBNLayer-10 [-1, 128, 12, 12] [-1, 128, 12, 12] 0\n", - " Conv2D-11 [-1, 128, 12, 12] [-1, 128, 12, 12] 147,456\n", - " BatchNorm-11 [-1, 128, 12, 12] [-1, 128, 12, 12] 512\n", - " ConvBNLayer-11 [-1, 128, 12, 12] [-1, 128, 12, 12] 0\n", - " BasicBlock-4 [-1, 128, 12, 12] [-1, 128, 12, 12] 0\n", - " Conv2D-12 [-1, 128, 12, 12] [-1, 256, 12, 12] 294,912\n", - " BatchNorm-12 [-1, 256, 12, 12] [-1, 256, 12, 12] 1,024\n", - " ConvBNLayer-12 [-1, 128, 12, 12] [-1, 256, 12, 12] 0\n", - " Conv2D-13 [-1, 256, 12, 12] [-1, 256, 6, 6] 589,824\n", - " BatchNorm-13 [-1, 256, 6, 6] [-1, 256, 6, 6] 1,024\n", - " ConvBNLayer-13 [-1, 256, 12, 12] [-1, 256, 6, 6] 0\n", - " Conv2D-14 [-1, 128, 12, 12] [-1, 256, 6, 6] 32,768\n", - " BatchNorm-14 [-1, 256, 6, 6] [-1, 256, 6, 6] 1,024\n", - " ConvBNLayer-14 [-1, 128, 12, 12] [-1, 256, 6, 6] 0\n", - " BasicBlock-5 [-1, 128, 12, 12] [-1, 256, 6, 6] 0\n", - " Conv2D-15 [-1, 256, 6, 6] [-1, 256, 6, 6] 589,824\n", - " BatchNorm-15 [-1, 256, 6, 6] [-1, 256, 6, 6] 1,024\n", - " ConvBNLayer-15 [-1, 256, 6, 6] [-1, 256, 6, 6] 0\n", - " Conv2D-16 [-1, 256, 6, 6] [-1, 256, 6, 6] 589,824\n", - " BatchNorm-16 [-1, 256, 6, 6] [-1, 256, 6, 6] 1,024\n", - " ConvBNLayer-16 [-1, 256, 6, 6] [-1, 256, 6, 6] 0\n", - " BasicBlock-6 [-1, 256, 6, 6] [-1, 256, 6, 6] 0\n", - " Conv2D-17 [-1, 256, 6, 6] [-1, 512, 6, 6] 1,179,648\n", - " BatchNorm-17 [-1, 512, 6, 6] [-1, 512, 6, 6] 2,048\n", - " ConvBNLayer-17 [-1, 256, 6, 6] [-1, 512, 6, 6] 0\n", - " Conv2D-18 [-1, 512, 6, 6] [-1, 512, 3, 3] 2,359,296\n", - " BatchNorm-18 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,048\n", - " ConvBNLayer-18 [-1, 512, 6, 6] [-1, 512, 3, 3] 0\n", - " Conv2D-19 [-1, 256, 6, 6] [-1, 512, 3, 3] 131,072\n", - " BatchNorm-19 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,048\n", - " ConvBNLayer-19 [-1, 256, 6, 6] [-1, 512, 3, 3] 0\n", - " BasicBlock-7 [-1, 256, 6, 6] [-1, 512, 3, 3] 0\n", - " Conv2D-20 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,359,296\n", - " BatchNorm-20 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,048\n", - " ConvBNLayer-20 [-1, 512, 3, 3] [-1, 512, 3, 3] 0\n", - " Conv2D-21 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,359,296\n", - " BatchNorm-21 [-1, 512, 3, 3] [-1, 512, 3, 3] 2,048\n", - " ConvBNLayer-21 [-1, 512, 3, 3] [-1, 512, 3, 3] 0\n", - " BasicBlock-8 [-1, 512, 3, 3] [-1, 512, 3, 3] 0\n", - " Pool2D-2 [-1, 512, 3, 3] [-1, 512, 1, 1] 0\n", - " Linear-1 [-1, 512] [-1, 1000] 513,000\n", - " ResNet-1 [-1, 3, 96, 96] [-1, 1000] 0\n", - " Linear-2 [-1, 1000] [-1, 512] 512,512\n", - " ReLU-1 [-1, 512] [-1, 512] 0\n", - " Dropout-1 [-1, 512] [-1, 512] 0\n", - " Linear-3 [-1, 512] [-1, 30] 15,390\n", - "================================================================================\n", - "Total params: 12,231,366\n", - "Trainable params: 12,211,910\n", - "Non-trainable params: 19,456\n", - "--------------------------------------------------------------------------------\n", + "-------------------------------------------------------------------------------\n", + " Layer (type) Input Shape Output Shape Param # \n", + "===============================================================================\n", + " Conv2D-121 [[1, 3, 96, 96]] [1, 64, 48, 48] 9,408 \n", + " BatchNorm2D-121 [[1, 64, 48, 48]] [1, 64, 48, 48] 256 \n", + " ReLU-61 [[1, 64, 48, 48]] [1, 64, 48, 48] 0 \n", + " MaxPool2D-7 [[1, 64, 48, 48]] [1, 64, 24, 24] 0 \n", + " Conv2D-122 [[1, 64, 24, 24]] [1, 64, 24, 24] 36,864 \n", + " BatchNorm2D-122 [[1, 64, 24, 24]] [1, 64, 24, 24] 256 \n", + " ReLU-62 [[1, 64, 24, 24]] [1, 64, 24, 24] 0 \n", + " Conv2D-123 [[1, 64, 24, 24]] [1, 64, 24, 24] 36,864 \n", + " BatchNorm2D-123 [[1, 64, 24, 24]] [1, 64, 24, 24] 256 \n", + " BasicBlock-49 [[1, 64, 24, 24]] [1, 64, 24, 24] 0 \n", + " Conv2D-124 [[1, 64, 24, 24]] [1, 64, 24, 24] 36,864 \n", + " BatchNorm2D-124 [[1, 64, 24, 24]] [1, 64, 24, 24] 256 \n", + " ReLU-63 [[1, 64, 24, 24]] [1, 64, 24, 24] 0 \n", + " Conv2D-125 [[1, 64, 24, 24]] [1, 64, 24, 24] 36,864 \n", + " BatchNorm2D-125 [[1, 64, 24, 24]] [1, 64, 24, 24] 256 \n", + " BasicBlock-50 [[1, 64, 24, 24]] [1, 64, 24, 24] 0 \n", + " Conv2D-127 [[1, 64, 24, 24]] [1, 128, 12, 12] 73,728 \n", + " BatchNorm2D-127 [[1, 128, 12, 12]] [1, 128, 12, 12] 512 \n", + " ReLU-64 [[1, 128, 12, 12]] [1, 128, 12, 12] 0 \n", + " Conv2D-128 [[1, 128, 12, 12]] [1, 128, 12, 12] 147,456 \n", + " BatchNorm2D-128 [[1, 128, 12, 12]] [1, 128, 12, 12] 512 \n", + " Conv2D-126 [[1, 64, 24, 24]] [1, 128, 12, 12] 8,192 \n", + " BatchNorm2D-126 [[1, 128, 12, 12]] [1, 128, 12, 12] 512 \n", + " BasicBlock-51 [[1, 64, 24, 24]] [1, 128, 12, 12] 0 \n", + " Conv2D-129 [[1, 128, 12, 12]] [1, 128, 12, 12] 147,456 \n", + " BatchNorm2D-129 [[1, 128, 12, 12]] [1, 128, 12, 12] 512 \n", + " ReLU-65 [[1, 128, 12, 12]] [1, 128, 12, 12] 0 \n", + " Conv2D-130 [[1, 128, 12, 12]] [1, 128, 12, 12] 147,456 \n", + " BatchNorm2D-130 [[1, 128, 12, 12]] [1, 128, 12, 12] 512 \n", + " BasicBlock-52 [[1, 128, 12, 12]] [1, 128, 12, 12] 0 \n", + " Conv2D-132 [[1, 128, 12, 12]] [1, 256, 6, 6] 294,912 \n", + " BatchNorm2D-132 [[1, 256, 6, 6]] [1, 256, 6, 6] 1,024 \n", + " ReLU-66 [[1, 256, 6, 6]] [1, 256, 6, 6] 0 \n", + " Conv2D-133 [[1, 256, 6, 6]] [1, 256, 6, 6] 589,824 \n", + " BatchNorm2D-133 [[1, 256, 6, 6]] [1, 256, 6, 6] 1,024 \n", + " Conv2D-131 [[1, 128, 12, 12]] [1, 256, 6, 6] 32,768 \n", + " BatchNorm2D-131 [[1, 256, 6, 6]] [1, 256, 6, 6] 1,024 \n", + " BasicBlock-53 [[1, 128, 12, 12]] [1, 256, 6, 6] 0 \n", + " Conv2D-134 [[1, 256, 6, 6]] [1, 256, 6, 6] 589,824 \n", + " BatchNorm2D-134 [[1, 256, 6, 6]] [1, 256, 6, 6] 1,024 \n", + " ReLU-67 [[1, 256, 6, 6]] [1, 256, 6, 6] 0 \n", + " Conv2D-135 [[1, 256, 6, 6]] [1, 256, 6, 6] 589,824 \n", + " BatchNorm2D-135 [[1, 256, 6, 6]] [1, 256, 6, 6] 1,024 \n", + " BasicBlock-54 [[1, 256, 6, 6]] [1, 256, 6, 6] 0 \n", + " Conv2D-137 [[1, 256, 6, 6]] [1, 512, 3, 3] 1,179,648 \n", + " BatchNorm2D-137 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,048 \n", + " ReLU-68 [[1, 512, 3, 3]] [1, 512, 3, 3] 0 \n", + " Conv2D-138 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,359,296 \n", + " BatchNorm2D-138 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,048 \n", + " Conv2D-136 [[1, 256, 6, 6]] [1, 512, 3, 3] 131,072 \n", + " BatchNorm2D-136 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,048 \n", + " BasicBlock-55 [[1, 256, 6, 6]] [1, 512, 3, 3] 0 \n", + " Conv2D-139 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,359,296 \n", + " BatchNorm2D-139 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,048 \n", + " ReLU-69 [[1, 512, 3, 3]] [1, 512, 3, 3] 0 \n", + " Conv2D-140 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,359,296 \n", + " BatchNorm2D-140 [[1, 512, 3, 3]] [1, 512, 3, 3] 2,048 \n", + " BasicBlock-56 [[1, 512, 3, 3]] [1, 512, 3, 3] 0 \n", + "AdaptiveAvgPool2D-7 [[1, 512, 3, 3]] [1, 512, 1, 1] 0 \n", + " Linear-19 [[1, 512]] [1, 1000] 513,000 \n", + " ResNet-7 [[1, 3, 96, 96]] [1, 1000] 0 \n", + " Linear-20 [[1, 1000]] [1, 512] 512,512 \n", + " ReLU-70 [[1, 512]] [1, 512] 0 \n", + " Dropout-7 [[1, 512]] [1, 512] 0 \n", + " Linear-21 [[1, 512]] [1, 30] 15,390 \n", + "===============================================================================\n", + "Total params: 12,227,014\n", + "Trainable params: 12,207,814\n", + "Non-trainable params: 19,200\n", + "-------------------------------------------------------------------------------\n", "Input size (MB): 0.11\n", - "Forward/backward pass size (MB): 14.87\n", - "Params size (MB): 46.66\n", - "Estimated Total Size (MB): 61.63\n", - "--------------------------------------------------------------------------------\n", + "Forward/backward pass size (MB): 10.51\n", + "Params size (MB): 46.64\n", + "Estimated Total Size (MB): 57.26\n", + "-------------------------------------------------------------------------------\n", "\n" ] }, { "data": { "text/plain": [ - "{'total_params': 12231366, 'trainable_params': 12211910}" + "{'total_params': 12227014, 'trainable_params': 12207814}" ] }, - "execution_count": 8, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from paddle.static import InputSpec\r\n", - "\r\n", - "paddle.disable_static()\r\n", - "num_keypoints = 15\r\n", - "model = paddle.Model(FaceNet(num_keypoints))\r\n", - "model.summary((3, 96, 96))" + "from paddle.static import InputSpec\n", + "\n", + "paddle.disable_static()\n", + "num_keypoints = 15\n", + "model = paddle.Model(FaceNet(num_keypoints))\n", + "model.summary((1,3, 96, 96))" ] }, { @@ -463,327 +403,322 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 16, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/60\n", - "step 7/7 - loss: 0.2203 - 570ms/step\n", + "step 7/7 - loss: 0.0935 - 580ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.2003 - 476ms/step\n", + "step 2/2 - loss: 7.1147 - 509ms/step\n", "Eval samples: 428\n", "Epoch 2/60\n", - "step 7/7 - loss: 0.1293 - 574ms/step\n", + "step 7/7 - loss: 0.0360 - 590ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.1363 - 454ms/step\n", + "step 2/2 - loss: 1.0652 - 487ms/step\n", "Eval samples: 428\n", "Epoch 3/60\n", - "step 7/7 - loss: 0.0499 - 799ms/step\n", + "step 7/7 - loss: 0.0288 - 590ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0530 - 455ms/step\n", + "step 2/2 - loss: 0.1534 - 499ms/step\n", "Eval samples: 428\n", "Epoch 4/60\n", - "step 7/7 - loss: 0.0128 - 557ms/step\n", + "step 7/7 - loss: 0.0212 - 584ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0124 - 454ms/step\n", + "step 2/2 - loss: 0.0404 - 511ms/step\n", "Eval samples: 428\n", "Epoch 5/60\n", - "step 7/7 - loss: 0.0079 - 555ms/step\n", + "step 7/7 - loss: 0.0170 - 582ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0068 - 474ms/step\n", + "step 2/2 - loss: 0.0093 - 518ms/step\n", "Eval samples: 428\n", "Epoch 6/60\n", - "step 7/7 - loss: 0.0028 - 573ms/step\n", + "step 7/7 - loss: 0.0139 - 598ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0046 - 454ms/step\n", + "step 2/2 - loss: 0.0043 - 546ms/step\n", "Eval samples: 428\n", "Epoch 7/60\n", - "step 7/7 - loss: 0.0021 - 559ms/step\n", + "step 7/7 - loss: 0.0125 - 588ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0046 - 469ms/step\n", + "step 2/2 - loss: 0.0018 - 529ms/step\n", "Eval samples: 428\n", "Epoch 8/60\n", - "step 7/7 - loss: 0.0020 - 560ms/step\n", + "step 7/7 - loss: 0.0097 - 577ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0024 - 461ms/step\n", + "step 2/2 - loss: 0.0020 - 526ms/step\n", "Eval samples: 428\n", "Epoch 9/60\n", - "step 7/7 - loss: 0.0018 - 561ms/step\n", + "step 7/7 - loss: 0.0117 - 595ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0017 - 454ms/step\n", + "step 2/2 - loss: 0.0014 - 511ms/step\n", "Eval samples: 428\n", "Epoch 10/60\n", - "step 7/7 - loss: 0.0018 - 563ms/step\n", + "step 7/7 - loss: 0.0098 - 592ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0014 - 454ms/step\n", + "step 2/2 - loss: 0.0011 - 531ms/step\n", "Eval samples: 428\n", "Epoch 11/60\n", - "step 7/7 - loss: 0.0018 - 560ms/step\n", + "step 7/7 - loss: 0.0102 - 603ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0011 - 454ms/step\n", + "step 2/2 - loss: 0.0015 - 496ms/step\n", "Eval samples: 428\n", "Epoch 12/60\n", - "step 7/7 - loss: 0.0016 - 554ms/step\n", + "step 7/7 - loss: 0.0085 - 595ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0010 - 456ms/step\n", + "step 2/2 - loss: 0.0014 - 485ms/step\n", "Eval samples: 428\n", "Epoch 13/60\n", - "step 7/7 - loss: 0.0018 - 559ms/step\n", + "step 7/7 - loss: 0.0102 - 571ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.8745e-04 - 453ms/step\n", + "step 2/2 - loss: 0.0017 - 487ms/step\n", "Eval samples: 428\n", "Epoch 14/60\n", - "step 7/7 - loss: 0.0019 - 616ms/step\n", + "step 7/7 - loss: 0.0086 - 576ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.8130e-04 - 478ms/step\n", + "step 2/2 - loss: 0.0014 - 483ms/step\n", "Eval samples: 428\n", "Epoch 15/60\n", - "step 7/7 - loss: 0.0015 - 553ms/step\n", + "step 7/7 - loss: 0.0081 - 581ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.7889e-04 - 454ms/step\n", + "step 2/2 - loss: 0.0023 - 488ms/step\n", "Eval samples: 428\n", "Epoch 16/60\n", - "step 7/7 - loss: 0.0017 - 567ms/step\n", + "step 7/7 - loss: 0.0079 - 590ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.5601e-04 - 463ms/step\n", + "step 2/2 - loss: 0.0010 - 485ms/step\n", "Eval samples: 428\n", "Epoch 17/60\n", - "step 7/7 - loss: 0.0017 - 565ms/step\n", + "step 7/7 - loss: 0.0070 - 588ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.4202e-04 - 462ms/step\n", + "step 2/2 - loss: 0.0011 - 489ms/step\n", "Eval samples: 428\n", "Epoch 18/60\n", - "step 7/7 - loss: 0.0017 - 559ms/step\n", + "step 7/7 - loss: 0.0070 - 592ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 0.0010 - 457ms/step\n", + "step 2/2 - loss: 9.4825e-04 - 493ms/step\n", "Eval samples: 428\n", "Epoch 19/60\n", - "step 7/7 - loss: 0.0017 - 567ms/step\n", + "step 7/7 - loss: 0.0068 - 593ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.7536e-04 - 465ms/step\n", + "step 2/2 - loss: 0.0012 - 493ms/step\n", "Eval samples: 428\n", "Epoch 20/60\n", - "step 7/7 - loss: 0.0015 - 565ms/step\n", + "step 7/7 - loss: 0.0074 - 592ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.0152e-04 - 468ms/step\n", + "step 2/2 - loss: 0.0015 - 517ms/step\n", "Eval samples: 428\n", "Epoch 21/60\n", - "step 7/7 - loss: 0.0014 - 570ms/step\n", + "step 7/7 - loss: 0.0246 - 591ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 9.0222e-04 - 462ms/step\n", + "step 2/2 - loss: 0.0178 - 513ms/step\n", "Eval samples: 428\n", "Epoch 22/60\n", - "step 7/7 - loss: 0.0015 - 568ms/step\n", + "step 7/7 - loss: 0.0098 - 611ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.8668e-04 - 453ms/step\n", + "step 2/2 - loss: 0.0090 - 500ms/step\n", "Eval samples: 428\n", "Epoch 23/60\n", - "step 7/7 - loss: 0.0013 - 557ms/step\n", + "step 7/7 - loss: 0.0111 - 589ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.7608e-04 - 456ms/step\n", + "step 2/2 - loss: 0.0047 - 495ms/step\n", "Eval samples: 428\n", "Epoch 24/60\n", - "step 7/7 - loss: 0.0013 - 555ms/step\n", + "step 7/7 - loss: 0.0066 - 581ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.8894e-04 - 458ms/step\n", + "step 2/2 - loss: 0.0032 - 487ms/step\n", "Eval samples: 428\n", "Epoch 25/60\n", - "step 7/7 - loss: 0.0013 - 566ms/step\n", + "step 7/7 - loss: 0.0071 - 578ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.6504e-04 - 456ms/step\n", + "step 2/2 - loss: 8.8009e-04 - 495ms/step\n", "Eval samples: 428\n", "Epoch 26/60\n", - "step 7/7 - loss: 0.0012 - 578ms/step\n", + "step 7/7 - loss: 0.0054 - 565ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.1451e-04 - 452ms/step\n", + "step 2/2 - loss: 0.0015 - 485ms/step\n", "Eval samples: 428\n", "Epoch 27/60\n", - "step 7/7 - loss: 0.0012 - 572ms/step\n", + "step 7/7 - loss: 0.0055 - 588ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.3616e-04 - 749ms/step\n", + "step 2/2 - loss: 8.3565e-04 - 489ms/step\n", "Eval samples: 428\n", "Epoch 28/60\n", - "step 7/7 - loss: 0.0013 - 553ms/step\n", + "step 7/7 - loss: 0.0062 - 581ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.3413e-04 - 457ms/step\n", + "step 2/2 - loss: 0.0017 - 510ms/step\n", "Eval samples: 428\n", "Epoch 29/60\n", - "step 7/7 - loss: 0.0011 - 560ms/step\n", + "step 7/7 - loss: 0.0055 - 582ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.0764e-04 - 457ms/step\n", + "step 2/2 - loss: 8.2400e-04 - 480ms/step\n", "Eval samples: 428\n", "Epoch 30/60\n", - "step 7/7 - loss: 0.0011 - 560ms/step\n", + "step 7/7 - loss: 0.0056 - 579ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.2735e-04 - 457ms/step\n", + "step 2/2 - loss: 0.0012 - 484ms/step\n", "Eval samples: 428\n", "Epoch 31/60\n", - "step 7/7 - loss: 0.0010 - 567ms/step\n", + "step 7/7 - loss: 0.0051 - 579ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 7.9266e-04 - 453ms/step\n", + "step 2/2 - loss: 0.0011 - 499ms/step\n", "Eval samples: 428\n", "Epoch 32/60\n", - "step 7/7 - loss: 0.0012 - 561ms/step\n", + "step 7/7 - loss: 0.0054 - 572ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 6.9983e-04 - 458ms/step\n", + "step 2/2 - loss: 8.0666e-04 - 484ms/step\n", "Eval samples: 428\n", "Epoch 33/60\n", - "step 7/7 - loss: 0.0010 - 568ms/step\n", + "step 7/7 - loss: 0.0049 - 574ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 6.7500e-04 - 457ms/step\n", + "step 2/2 - loss: 0.0013 - 493ms/step\n", "Eval samples: 428\n", "Epoch 34/60\n", - "step 7/7 - loss: 0.0011 - 568ms/step\n", + "step 7/7 - loss: 0.0058 - 586ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 6.6316e-04 - 459ms/step\n", + "step 2/2 - loss: 0.0015 - 484ms/step\n", "Eval samples: 428\n", "Epoch 35/60\n", - "step 7/7 - loss: 0.0011 - 561ms/step\n", + "step 7/7 - loss: 0.0050 - 591ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 6.3884e-04 - 467ms/step\n", + "step 2/2 - loss: 7.4962e-04 - 483ms/step\n", "Eval samples: 428\n", "Epoch 36/60\n", - "step 7/7 - loss: 9.9395e-04 - 559ms/step\n", + "step 7/7 - loss: 0.0047 - 562ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 6.0092e-04 - 456ms/step\n", + "step 2/2 - loss: 7.5357e-04 - 482ms/step\n", "Eval samples: 428\n", "Epoch 37/60\n", - "step 7/7 - loss: 0.0011 - 550ms/step\n", + "step 7/7 - loss: 0.0052 - 581ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.8750e-04 - 460ms/step\n", + "step 2/2 - loss: 0.0013 - 497ms/step\n", "Eval samples: 428\n", "Epoch 38/60\n", - "step 7/7 - loss: 9.3226e-04 - 565ms/step\n", + "step 7/7 - loss: 0.0045 - 577ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.3959e-04 - 462ms/step\n", + "step 2/2 - loss: 0.0018 - 503ms/step\n", "Eval samples: 428\n", "Epoch 39/60\n", - "step 7/7 - loss: 9.2422e-04 - 562ms/step\n", + "step 7/7 - loss: 0.0046 - 574ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.2893e-04 - 454ms/step\n", + "step 2/2 - loss: 0.0021 - 488ms/step\n", "Eval samples: 428\n", "Epoch 40/60\n", - "step 7/7 - loss: 9.9294e-04 - 558ms/step\n", + "step 7/7 - loss: 0.0051 - 587ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.6088e-04 - 461ms/step\n", + "step 2/2 - loss: 7.6643e-04 - 494ms/step\n", "Eval samples: 428\n", "Epoch 41/60\n", - "step 7/7 - loss: 9.5442e-04 - 551ms/step\n", + "step 7/7 - loss: 0.0047 - 577ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.2197e-04 - 454ms/step\n", + "step 2/2 - loss: 0.0045 - 488ms/step\n", "Eval samples: 428\n", "Epoch 42/60\n", - "step 7/7 - loss: 9.2407e-04 - 572ms/step\n", + "step 7/7 - loss: 0.0042 - 580ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.5484e-04 - 473ms/step\n", + "step 2/2 - loss: 0.0017 - 484ms/step\n", "Eval samples: 428\n", "Epoch 43/60\n", - "step 7/7 - loss: 9.3951e-04 - 576ms/step\n", + "step 7/7 - loss: 0.0044 - 573ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.0847e-04 - 483ms/step\n", + "step 2/2 - loss: 0.0021 - 487ms/step\n", "Eval samples: 428\n", "Epoch 44/60\n", - "step 7/7 - loss: 9.3463e-04 - 566ms/step\n", + "step 7/7 - loss: 0.0067 - 594ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.2639e-04 - 457ms/step\n", + "step 2/2 - loss: 0.0020 - 492ms/step\n", "Eval samples: 428\n", "Epoch 45/60\n", - "step 7/7 - loss: 9.6260e-04 - 863ms/step\n", + "step 7/7 - loss: 0.0043 - 586ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.2387e-04 - 459ms/step\n", + "step 2/2 - loss: 8.7041e-04 - 488ms/step\n", "Eval samples: 428\n", "Epoch 46/60\n", - "step 7/7 - loss: 7.9236e-04 - 562ms/step\n", + "step 7/7 - loss: 0.0058 - 592ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.2232e-04 - 488ms/step\n", + "step 2/2 - loss: 0.0013 - 492ms/step\n", "Eval samples: 428\n", "Epoch 47/60\n", - "step 7/7 - loss: 8.8867e-04 - 561ms/step\n", + "step 7/7 - loss: 0.0039 - 583ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.7546e-04 - 472ms/step\n", + "step 2/2 - loss: 9.8993e-04 - 488ms/step\n", "Eval samples: 428\n", "Epoch 48/60\n", - "step 7/7 - loss: 9.2187e-04 - 563ms/step\n", + "step 7/7 - loss: 0.0046 - 571ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.1036e-04 - 467ms/step\n", + "step 2/2 - loss: 6.6509e-04 - 482ms/step\n", "Eval samples: 428\n", "Epoch 49/60\n", - "step 7/7 - loss: 8.4267e-04 - 573ms/step\n", + "step 7/7 - loss: 0.0052 - 572ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 5.0897e-04 - 457ms/step\n", + "step 2/2 - loss: 6.6502e-04 - 481ms/step\n", "Eval samples: 428\n", "Epoch 50/60\n", - "step 7/7 - loss: 8.1840e-04 - 559ms/step\n", + "step 7/7 - loss: 0.0050 - 573ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.8478e-04 - 460ms/step\n", + "step 2/2 - loss: 0.0014 - 493ms/step\n", "Eval samples: 428\n", "Epoch 51/60\n", - "step 7/7 - loss: 7.9169e-04 - 564ms/step\n", + "step 7/7 - loss: 0.0036 - 578ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.9722e-04 - 457ms/step\n", + "step 2/2 - loss: 7.2478e-04 - 487ms/step\n", "Eval samples: 428\n", "Epoch 52/60\n", - "step 7/7 - loss: 7.4572e-04 - 561ms/step\n", + "step 7/7 - loss: 0.0037 - 581ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.6681e-04 - 459ms/step\n", + "step 2/2 - loss: 6.2614e-04 - 491ms/step\n", "Eval samples: 428\n", "Epoch 53/60\n", - "step 7/7 - loss: 7.7328e-04 - 563ms/step\n", + "step 7/7 - loss: 0.0035 - 590ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.4126e-04 - 468ms/step\n", + "step 2/2 - loss: 8.6040e-04 - 502ms/step\n", "Eval samples: 428\n", "Epoch 54/60\n", - "step 7/7 - loss: 8.3519e-04 - 565ms/step\n", + "step 7/7 - loss: 0.0047 - 579ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.5718e-04 - 461ms/step\n", + "step 2/2 - loss: 0.0013 - 489ms/step\n", "Eval samples: 428\n", "Epoch 55/60\n", - "step 7/7 - loss: 7.3492e-04 - 586ms/step\n", + "step 7/7 - loss: 0.0033 - 579ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.7409e-04 - 461ms/step\n", + "step 2/2 - loss: 6.6288e-04 - 483ms/step\n", "Eval samples: 428\n", "Epoch 56/60\n", - "step 7/7 - loss: 7.7133e-04 - 561ms/step\n", + "step 7/7 - loss: 0.0035 - 571ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.4491e-04 - 462ms/step\n", + "step 2/2 - loss: 6.5621e-04 - 489ms/step\n", "Eval samples: 428\n", "Epoch 57/60\n", - "step 7/7 - loss: 7.5041e-04 - 561ms/step\n", + "step 7/7 - loss: 0.0170 - 575ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.4271e-04 - 843ms/step\n", + "step 2/2 - loss: 0.0131 - 487ms/step\n", "Eval samples: 428\n", "Epoch 58/60\n", - "step 7/7 - loss: 7.5371e-04 - 848ms/step\n", + "step 7/7 - loss: 0.0075 - 574ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.9145e-04 - 451ms/step\n", + "step 2/2 - loss: 9.3899e-04 - 488ms/step\n", "Eval samples: 428\n", "Epoch 59/60\n", - "step 7/7 - loss: 7.7562e-04 - 570ms/step\n", + "step 7/7 - loss: 0.0039 - 595ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.1318e-04 - 456ms/step\n", + "step 2/2 - loss: 7.3599e-04 - 485ms/step\n", "Eval samples: 428\n", "Epoch 60/60\n", - "step 7/7 - loss: 7.3029e-04 - 858ms/step\n", + "step 7/7 - loss: 0.0037 - 582ms/step\n", "Eval begin...\n", - "step 2/2 - loss: 4.2197e-04 - 454ms/step\n", + "step 2/2 - loss: 0.0012 - 485ms/step\n", "Eval samples: 428\n" ] } ], "source": [ - "model = paddle.Model(FaceNet(num_keypoints=15))\r\n", - "optim = paddle.optimizer.Adam(learning_rate=1e-3,\r\n", - " parameters=model.parameters())\r\n", - "model.prepare(optim, paddle.nn.MSELoss())\r\n", - "model.fit(train_dataset, val_dataset, epochs=60, batch_size=256)\r\n" + "model = paddle.Model(FaceNet(num_keypoints=15))\n", + "optim = paddle.optimizer.Adam(learning_rate=1e-3,\n", + " parameters=model.parameters())\n", + "model.prepare(optim, paddle.nn.MSELoss())\n", + "model.fit(train_dataset, val_dataset, epochs=60, batch_size=256)\n" ] }, { @@ -793,25 +728,20 @@ "## 6. 模型预测\n", "为了更好的观察预测结果,我们分别可视化验证集结果与标注点的对比,和在未标注的测试集的预测结果。\n", "### 6.1 验证集结果可视化\n", - "红色的关键点为网络预测的结果, 绿色的关键点为标注的ground-truth。" + "红色的关键点为网络预测的结果, 绿色的关键点为标注的groundtrue。" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 17, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predict begin...\n", - "step 428/428 [==============================] - 17ms/step \n", + "step 428/428 [==============================] - 15ms/step \n", "Predict samples: 428\n" ] } @@ -822,13 +752,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 20, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -840,7 +765,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -850,26 +775,26 @@ } ], "source": [ - "def plot_sample(x, y, axis, gt=[]):\r\n", - " img = x.reshape(96, 96)\r\n", - " axis.imshow(img, cmap='gray')\r\n", - " axis.scatter(y[0::2], y[1::2], marker='x', s=10, color='r')\r\n", - " if gt!=[]:\r\n", - " axis.scatter(gt[0::2], gt[1::2], marker='x', s=10, color='lime')\r\n", - "\r\n", - "\r\n", - "fig = plt.figure(figsize=(10, 7))\r\n", - "fig.subplots_adjust(\r\n", - " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\r\n", - "\r\n", - "for i in range(16):\r\n", - " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\r\n", - " idx = np.random.randint(val_dataset.__len__())\r\n", - " img, gt_label = val_dataset[idx]\r\n", - " gt_label = gt_label*96\r\n", - " label_pred = result[0][idx].reshape(-1)\r\n", - " label_pred = label_pred*96\r\n", - " plot_sample(img[0], label_pred, axis, gt_label)\r\n", + "def plot_sample(x, y, axis, gt=[]):\n", + " img = x.reshape(96, 96)\n", + " axis.imshow(img, cmap='gray')\n", + " axis.scatter(y[0::2], y[1::2], marker='x', s=10, color='r')\n", + " if gt!=[]:\n", + " axis.scatter(gt[0::2], gt[1::2], marker='x', s=10, color='lime')\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10, 7))\n", + "fig.subplots_adjust(\n", + " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\n", + "\n", + "for i in range(16):\n", + " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\n", + " idx = np.random.randint(val_dataset.__len__())\n", + " img, gt_label = val_dataset[idx]\n", + " gt_label = gt_label*96\n", + " label_pred = result[0][idx].reshape(-1)\n", + " label_pred = label_pred*96\n", + " plot_sample(img[0], label_pred, axis, gt_label)\n", "plt.show()" ] }, @@ -882,20 +807,15 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 21, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predict begin...\n", - "step 1783/1783 [==============================] - 17ms/step \n", + "step 1783/1783 [==============================] - 15ms/step \n", "Predict samples: 1783\n" ] } @@ -906,17 +826,12 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, + "execution_count": 22, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -926,17 +841,17 @@ } ], "source": [ - "fig = plt.figure(figsize=(10, 7))\r\n", - "fig.subplots_adjust(\r\n", - " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\r\n", - "\r\n", - "for i in range(16):\r\n", - " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\r\n", - " idx = np.random.randint(test_dataset.__len__())\r\n", - " img, _ = test_dataset[idx]\r\n", - " label_pred = result[0][idx].reshape(-1)\r\n", - " label_pred = label_pred*96\r\n", - " plot_sample(img[0], label_pred, axis)\r\n", + "fig = plt.figure(figsize=(10, 7))\n", + "fig.subplots_adjust(\n", + " left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\n", + "\n", + "for i in range(16):\n", + " axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])\n", + " idx = np.random.randint(test_dataset.__len__())\n", + " img, _ = test_dataset[idx]\n", + " label_pred = result[0][idx].reshape(-1)\n", + " label_pred = label_pred*96\n", + " plot_sample(img[0], label_pred, axis)\n", "plt.show()" ] } @@ -961,5 +876,5 @@ } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 1 } diff --git a/paddle2.0_docs/super_resolution_sub_pixel/super_resolution_sub_pixel_paddle2.0.ipynb b/paddle2.0_docs/super_resolution_sub_pixel/super_resolution_sub_pixel_paddle2.0.ipynb index 1cf7f878e6f..5ceb52367da 100644 --- a/paddle2.0_docs/super_resolution_sub_pixel/super_resolution_sub_pixel_paddle2.0.ipynb +++ b/paddle2.0_docs/super_resolution_sub_pixel/super_resolution_sub_pixel_paddle2.0.ipynb @@ -1,14 +1,12 @@ { "cells": [ { + "cell_type": "markdown", + "metadata": {}, "source": [ "# 通过Sub-Pixel实现图像超分辨率\n", - "作者:[陆俊陶](https://github.com/ralph0813)\n", - "\n", - "日期:2020.10.21\n" - ], - "cell_type": "markdown", - "metadata": {} + "\n" + ] }, { "cell_type": "markdown", @@ -35,14 +33,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.0.0-beta0\n" + "2.0.0-rc0\n" ] } ], @@ -61,9 +59,7 @@ "from paddle.io import Dataset\n", "from paddle.vision.transforms import transforms\n", "\n", - "print(paddle.__version__)\n", - "# 开启动态图\n", - "paddle.disable_static()" + "print(paddle.__version__)" ] }, { @@ -77,21 +73,20 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 27, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/ralph/anaconda3/envs/paddle2/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" + "BSR/BSDS500/data/images/test/69000.jpg\r" ] } ], "source": [ - "# !curl -O http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/BSR/BSR_bsds500.tgz\n", - "# !tar -xf BSR_bsds500.tgz" + "!wget --no-check-certificate --no-cookies --header \"Cookie: oraclelicense=accept-securebackup-cookie\" http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/BSR/BSR_bsds500.tgz\n", + "!tar -zxvf BSR_bsds500.tgz" ] }, { @@ -148,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -284,7 +279,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -303,7 +298,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -348,7 +343,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -357,10 +352,10 @@ " def __init__(self, upscale_factor=3, channels=1):\n", " super(Sub_Pixel_CNN, self).__init__()\n", " \n", - " self.conv1 = paddle.nn.Conv2d(channels,64,5,stride=1, padding=2)\n", - " self.conv2 = paddle.nn.Conv2d(64,64,3,stride=1, padding=1)\n", - " self.conv3 = paddle.nn.Conv2d(64,32,3,stride=1, padding=1)\n", - " self.conv4 = paddle.nn.Conv2d(32,channels * (upscale_factor ** 2),3,stride=1, padding=1)\n", + " self.conv1 = paddle.nn.Conv2D(channels,64,5,stride=1, padding=2)\n", + " self.conv2 = paddle.nn.Conv2D(64,64,3,stride=1, padding=1)\n", + " self.conv3 = paddle.nn.Conv2D(64,32,3,stride=1, padding=1)\n", + " self.conv4 = paddle.nn.Conv2D(32,channels * (upscale_factor ** 2),3,stride=1, padding=1)\n", "\n", " def forward(self, x):\n", " x = self.conv1(x)\n", @@ -380,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -398,30 +393,30 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--------------------------------------------------------------------------------\n", - " Layer (type) Input Shape Output Shape Param #\n", - "================================================================================\n", - " Conv2d-1 [-1, 1, 100, 100] [-1, 64, 100, 100] 1,664\n", - " Conv2d-2 [-1, 64, 100, 100] [-1, 64, 100, 100] 36,928\n", - " Conv2d-3 [-1, 64, 100, 100] [-1, 32, 100, 100] 18,464\n", - " Conv2d-4 [-1, 32, 100, 100] [-1, 9, 100, 100] 2,601\n", - "================================================================================\n", + "---------------------------------------------------------------------------\n", + " Layer (type) Input Shape Output Shape Param # \n", + "===========================================================================\n", + " Conv2D-5 [[1, 1, 100, 100]] [1, 64, 100, 100] 1,664 \n", + " Conv2D-6 [[1, 64, 100, 100]] [1, 64, 100, 100] 36,928 \n", + " Conv2D-7 [[1, 64, 100, 100]] [1, 32, 100, 100] 18,464 \n", + " Conv2D-8 [[1, 32, 100, 100]] [1, 9, 100, 100] 2,601 \n", + "===========================================================================\n", "Total params: 59,657\n", "Trainable params: 59,657\n", "Non-trainable params: 0\n", - "--------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------\n", "Input size (MB): 0.04\n", "Forward/backward pass size (MB): 12.89\n", "Params size (MB): 0.23\n", "Estimated Total Size (MB): 13.16\n", - "--------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------\n", "\n" ] }, @@ -431,13 +426,13 @@ "{'total_params': 59657, 'trainable_params': 59657}" ] }, - "execution_count": 7, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.summary((1, 100, 100))" + "model.summary((1,1, 100, 100))" ] }, { @@ -458,32 +453,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1/20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ralph/anaconda3/envs/paddle2/lib/python3.7/site-packages/paddle/fluid/layers/utils.py:77: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3,and in 3.9 it will stop working\n", - " return (isinstance(seq, collections.Sequence) and\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step 13/13 [==============================] - loss: 0.0127 - 91ms/step \n", + "Epoch 1/20\n", + "step 13/13 [==============================] - loss: 0.0289 - 115ms/step \n", "Epoch 2/20\n", - "step 13/13 [==============================] - loss: 0.0093 - 80ms/step \n", - "Epoch 3/20\n" + "step 13/13 [==============================] - loss: 0.0107 - 112ms/step \n", + "Epoch 3/20\n", + "step 13/13 [==============================] - loss: 0.0056 - 114ms/step \n", + "Epoch 4/20\n", + "step 13/13 [==============================] - loss: 0.0047 - 113ms/step \n", + "Epoch 5/20\n", + "step 13/13 [==============================] - loss: 0.0049 - 113ms/step \n", + "Epoch 6/20\n", + "step 13/13 [==============================] - loss: 0.0031 - 113ms/step \n", + "Epoch 7/20\n", + "step 13/13 [==============================] - loss: 0.0038 - 112ms/step \n", + "Epoch 8/20\n", + "step 13/13 [==============================] - loss: 0.0037 - 115ms/step \n", + "Epoch 9/20\n", + "step 13/13 [==============================] - loss: 0.0029 - 114ms/step \n", + "Epoch 10/20\n", + "step 13/13 [==============================] - loss: 0.0023 - 114ms/step \n", + "Epoch 11/20\n", + "step 13/13 [==============================] - loss: 0.0020 - 113ms/step \n", + "Epoch 12/20\n", + "step 13/13 [==============================] - loss: 0.0031 - 113ms/step \n", + "Epoch 13/20\n", + "step 13/13 [==============================] - loss: 0.0021 - 114ms/step \n", + "Epoch 14/20\n", + "step 13/13 [==============================] - loss: 0.0030 - 115ms/step \n", + "Epoch 15/20\n", + "step 13/13 [==============================] - loss: 0.0032 - 112ms/step \n", + "Epoch 16/20\n", + "step 13/13 [==============================] - loss: 0.0024 - 114ms/step \n", + "Epoch 17/20\n", + "step 13/13 [==============================] - loss: 0.0027 - 113ms/step \n", + "Epoch 18/20\n", + "step 13/13 [==============================] - loss: 0.0017 - 114ms/step \n", + "Epoch 19/20\n", + "step 13/13 [==============================] - loss: 0.0031 - 113ms/step \n", + "Epoch 20/20\n", + "step 13/13 [==============================] - loss: 0.0039 - 114ms/step \n" ] } ], @@ -522,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 51, "metadata": {}, "outputs": [ { @@ -530,7 +546,7 @@ "output_type": "stream", "text": [ "Predict begin...\n", - "step 100/100 [==============================] - 5ms/step ETA: 0s - 5ms/\n", + "step 100/100 [==============================] - 7ms/step \n", "Predict samples: 100\n" ] } @@ -548,7 +564,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -662,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 54, "metadata": {}, "outputs": [ { @@ -670,51 +686,45 @@ "output_type": "stream", "text": [ "Predict begin...\n", - "step 1/1 [==============================] - 1ms/step\n", + "step 1/1 [==============================] - 3ms/step\n", "Predict samples: 1\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "psmr_low: 30.381882136539197 psmr_pre: 29.77534256177609\n" + "psmr_low: 30.381882136539197 psmr_pre: 29.799047324766427\n" ] } ], @@ -726,19 +736,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 7.模型保存" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "# 7.模型保存\n", "将模型保存到 checkpoint/model_final ,并保留训练参数" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -748,13 +752,9 @@ ], "metadata": { "kernelspec": { - "name": "Python 3.7.9 64-bit ('paddle2': conda)", - "display_name": "Python 3.7.9 64-bit ('paddle2': conda)", - "metadata": { - "interpreter": { - "hash": "141821192e6d49b6ec1853aa9636bb5696934ff0e6db6ae169fa58946d8a5bab" - } - } + "display_name": "Python 3", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -766,9 +766,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9-final" + "version": "3.8.2" } }, "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file + "nbformat_minor": 1 +}