1324 lines
316 KiB
Plaintext
1324 lines
316 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"<p style=\"text-align: center;\"><img alt=\"school-logo\" src=\"../images/school_logo.png\" style=\"zoom: 50%;\" /></p>\n",
|
||
"\n",
|
||
"<h1 align=\"center\">本科生《深度学习》课程<br>实验报告</h1>\n",
|
||
"<div style=\"text-align: center;\">\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">课程名称</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">深度学习</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">实验题目</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">前馈神经网络实验</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">学号</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">21281280</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">姓名</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">柯劲帆</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">班级</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">物联网2101班</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">指导老师</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">张淳杰</span></div>\n",
|
||
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">报告日期</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">2023年10月24日</span></div>\n",
|
||
"</div>"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"实验环境：\n",
|
||
"- OS：Ubuntu 22.04 (Kernel: 6.2.0-34-generic)\n",
|
||
"- CPU：12th Gen Intel(R) Core(TM) i7-12700H\n",
|
||
"- GPU：NVIDIA GeForce RTX 3070 Ti Laptop\n",
|
||
"- cuda: 12.2\n",
|
||
"- conda: miniconda 23.9.0\n",
|
||
"- python：3.10.13\n",
|
||
"- pytorch：2.1.0"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 1,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"ename": "ModuleNotFoundError",
|
||
"evalue": "No module named 'matplotlib'",
|
||
"output_type": "error",
|
||
"traceback": [
|
||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||
"\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)",
|
||
"\u001b[1;32m/home/kejingfan/Codedir/School-DeepLearningCourse-Lab/Lab2/前馈神经网络实验.ipynb Cell 3\u001b[0m line \u001b[0;36m8\n\u001b[1;32m <a href='vscode-notebook-cell://wsl%2Bubuntu-22.04/home/kejingfan/Codedir/School-DeepLearningCourse-Lab/Lab2/%E5%89%8D%E9%A6%88%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E5%AE%9E%E9%AA%8C.ipynb#W2sdnNjb2RlLXJlbW90ZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtorch\u001b[39;00m \u001b[39mimport\u001b[39;00m nn\n\u001b[1;32m <a href='vscode-notebook-cell://wsl%2Bubuntu-22.04/home/kejingfan/Codedir/School-DeepLearningCourse-Lab/Lab2/%E5%89%8D%E9%A6%88%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E5%AE%9E%E9%AA%8C.ipynb#W2sdnNjb2RlLXJlbW90ZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtorchvision\u001b[39;00m \u001b[39mimport\u001b[39;00m datasets, transforms\n\u001b[0;32m----> <a href='vscode-notebook-cell://wsl%2Bubuntu-22.04/home/kejingfan/Codedir/School-DeepLearningCourse-Lab/Lab2/%E5%89%8D%E9%A6%88%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E5%AE%9E%E9%AA%8C.ipynb#W2sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n",
|
||
"\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'matplotlib'"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"import time\n",
|
||
"import numpy as np\n",
|
||
"import torch\n",
|
||
"from torch.nn.functional import *\n",
|
||
"from torch.utils.data import Dataset, DataLoader\n",
|
||
"from torch import nn\n",
|
||
"from torchvision import datasets, transforms\n",
|
||
"import matplotlib.pyplot as plt"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"引用相关库。"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务一\n",
|
||
"**手动实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
|
||
"- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先生成数据集。\n",
|
||
"\n",
|
||
"一共有3个数据集：\n",
|
||
"\n",
|
||
"1. 回归任务数据集。\n",
|
||
" - 生成单个数据集。\n",
|
||
" - 数据集的大小为$10000$且训练集大小为$7000$，测试集大小为$3000$。\n",
|
||
" - 数据集的样本特征维度$p$为$500$，且服从如下的高维线性函数：$y = 0.028 + \\sum_{p}^{i=1}0.0056 x_i + \\epsilon $。\n",
|
||
"2. 二分类任务数据集。\n",
|
||
" - 共生成两个数据集。\n",
|
||
" - 两个数据集的大小均为$10000$且训练集大小为$7000$，测试集大小为$3000$。\n",
|
||
" - 两个数据集的样本特征$x$的维度均为$200$，且分别服从均值互为相反数且方差相同的正态分布。\n",
|
||
" - 两个数据集的样本标签分别为$0$和$1$。\n",
|
||
"3. MNIST手写体数据集。\n",
|
||
" - 该数据集包含$60,000$个用于训练的图像样本和$10,000$个用于测试的图像样本。\n",
|
||
" - 图像是固定大小（$28\\times 28$像素），其值为$0$到$1$。为每个图像都被平展并转换为$784$（$28 \\times 28$）个特征的一维numpy数组。 "
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"实现回归任务数据集。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 2,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"训练数据集大小：7000，测试数据集大小：3000\n",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0][0] = 0.002744067460298538\n",
|
||
"y[0] = tensor([0.0210])\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"class My_Regression_Dataset(Dataset):\n",
|
||
" def __init__(self, train=True):\n",
|
||
" data_size = 7000 if train else 3000\n",
|
||
" np.random.seed(0)\n",
|
||
" x = np.random.rand(data_size, 500) * 0.005\n",
|
||
" noise = np.random.randn(data_size) * 1e-7\n",
|
||
" y = 0.028 - 0.0056 * x.sum(axis=1) + noise\n",
|
||
" y = y.reshape(-1, 1)\n",
|
||
" self.data = [[x[i], y[i]] for i in range(x.shape[0])]\n",
|
||
"\n",
|
||
" def __len__(self):\n",
|
||
" return len(self.data)\n",
|
||
"\n",
|
||
" def __getitem__(self, index):\n",
|
||
" x, y = self.data[index]\n",
|
||
" x = torch.FloatTensor(x)\n",
|
||
" y = torch.FloatTensor(y)\n",
|
||
" return x, y\n",
|
||
"\n",
|
||
" \n",
|
||
"# 测试，并后面的训练创建变量\n",
|
||
"train_regression_dataset = My_Regression_Dataset(train=True)\n",
|
||
"test_regression_dataset = My_Regression_Dataset(train=False)\n",
|
||
"\n",
|
||
"train_regression_dataset_size = len(train_regression_dataset)\n",
|
||
"test_regression_dataset_size = len(test_regression_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_regression_dataset_size}，测试数据集大小：{test_regression_dataset_size}\")\n",
|
||
"x0, y0 = train_regression_dataset[0]\n",
|
||
"print(f\"训练数据集的第1对数据：\")\n",
|
||
"print(f\"x[0]第1个特征维度数据x[0][0] = {x0[0]}\")\n",
|
||
"print(f\"y[0] = {y0}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"实现二分类任务数据集。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 3,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"训练数据集大小：14000，测试数据集大小：6000\n",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0][0] = -0.519691526889801\n",
|
||
"y[0] = tensor([0])\n",
|
||
"训练数据集的第7001对数据：\n",
|
||
"x[7000]第1个特征维度数据x[7000][0] = 0.3035626709461212\n",
|
||
"y[7000] = tensor([1])\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"class My_BinaryCLS_Dataset(Dataset):\n",
|
||
" def __init__(self, train=True, num_features=200):\n",
|
||
" num_samples = 7000 if train else 3000\n",
|
||
" \n",
|
||
" x_1 = np.random.normal(loc=-0.5, scale=0.2, size=(num_samples, num_features))\n",
|
||
" x_2 = np.random.normal(loc=0.5, scale=0.2, size=(num_samples, num_features))\n",
|
||
" \n",
|
||
" labels_1 = np.zeros((num_samples, 1))\n",
|
||
" labels_2 = np.ones((num_samples, 1))\n",
|
||
" \n",
|
||
" x = np.concatenate((x_1, x_2), axis=0)\n",
|
||
" labels = np.concatenate((labels_1, labels_2), axis=0)\n",
|
||
" self.data = [[x[i], labels[i]] for i in range(2 * num_samples)]\n",
|
||
"\n",
|
||
" def __len__(self):\n",
|
||
" return len(self.data)\n",
|
||
"\n",
|
||
" def __getitem__(self, index):\n",
|
||
" x, y = self.data[index]\n",
|
||
" x = torch.FloatTensor(x)\n",
|
||
" y = torch.LongTensor(y)\n",
|
||
" return x, y\n",
|
||
"\n",
|
||
"\n",
|
||
"# 测试，并后面的训练创建变量\n",
|
||
"train_binarycls_dataset = My_BinaryCLS_Dataset(train=True)\n",
|
||
"test_binarycls_dataset = My_BinaryCLS_Dataset(train=False)\n",
|
||
"\n",
|
||
"train_binarycls_dataset_size = len(train_binarycls_dataset)\n",
|
||
"test_binarycls_dataset_size = len(test_binarycls_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_binarycls_dataset_size}，测试数据集大小：{test_binarycls_dataset_size}\")\n",
|
||
"x0, y0 = train_binarycls_dataset[0]\n",
|
||
"print(f\"训练数据集的第1对数据：\")\n",
|
||
"print(f\"x[0]第1个特征维度数据x[0][0] = {x0[0]}\")\n",
|
||
"print(f\"y[0] = {y0}\")\n",
|
||
"\n",
|
||
"x7000, y7000 = train_binarycls_dataset[7000]\n",
|
||
"print(f\"训练数据集的第7001对数据：\")\n",
|
||
"print(f\"x[7000]第1个特征维度数据x[7000][0] = {x7000[0]}\")\n",
|
||
"print(f\"y[7000] = {y7000}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用MNIST数据集。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先造一个展示图片的函数。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def imshow(img):\n",
|
||
" img = img.squeeze().numpy()\n",
|
||
" plt.imshow(img)\n",
|
||
" plt.axis('off')\n",
|
||
" plt.show()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"调用`torchvision.datasets.MNIST()`，获取数据集。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"训练数据集大小：60000，测试数据集大小：10000\n",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0]的大小 = torch.Size([1, 28, 28])\n",
|
||
"y[0] = 5\n",
|
||
"x[0]的图像：\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 640x480 with 1 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"transform = transforms.Compose(\n",
|
||
" [\n",
|
||
" transforms.ToTensor(),\n",
|
||
" transforms.Normalize((0.5,), (0.5,)),\n",
|
||
" ]\n",
|
||
")\n",
|
||
"\n",
|
||
"train_mnist_dataset = datasets.MNIST(root=\"dataset\", train=True, transform=transform, download=True)\n",
|
||
"test_mnist_dataset = datasets.MNIST(root=\"dataset\", train=False, transform=transform, download=True)\n",
|
||
"\n",
|
||
"train_mnist_dataset_size = len(train_mnist_dataset)\n",
|
||
"test_mnist_dataset_size = len(test_mnist_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_mnist_dataset_size}，测试数据集大小：{test_mnist_dataset_size}\")\n",
|
||
"\n",
|
||
"x0, y0 = train_mnist_dataset[0]\n",
|
||
"print(f\"训练数据集的第1对数据：\")\n",
|
||
"print(f\"x[0]第1个特征维度数据x[0]的大小 = {x0.shape}\")\n",
|
||
"print(f\"y[0] = {y0}\")\n",
|
||
"print(f\"x[0]的图像：\")\n",
|
||
"imshow(x0)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"接下来手动实现前馈神经网络并训练。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先手动实现一些工具和基本模型层。这些工具都在前一个实验中实现并测试过，在此就不再分析其原理和具体实现步骤，也不在此重新测试。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"# 手动实现torch.nn.functional.one_hot\n",
|
||
"def my_one_hot(indices: torch.Tensor, num_classes: int):\n",
|
||
" one_hot_tensor = torch.zeros(len(indices), num_classes, dtype=torch.long).to(indices.device)\n",
|
||
" one_hot_tensor.scatter_(1, indices.view(-1, 1), 1)\n",
|
||
" return one_hot_tensor\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.functional.softmax\n",
|
||
"def my_softmax(predictions: torch.Tensor, dim: int):\n",
|
||
" max_values = torch.max(predictions, dim=dim, keepdim=True).values\n",
|
||
" exp_values = torch.exp(predictions - max_values)\n",
|
||
" softmax_output = exp_values / torch.sum(exp_values, dim=dim, keepdim=True)\n",
|
||
" return softmax_output\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.Linear\n",
|
||
"class My_Linear:\n",
|
||
" def __init__(self, in_features: int, out_features: int):\n",
|
||
" self.weight = torch.normal(mean=0.001, std=0.5, size=(out_features, in_features), requires_grad=True, dtype=torch.float32)\n",
|
||
" self.bias = torch.normal(mean=0.001, std=0.5, size=(1,), requires_grad=True, dtype=torch.float32)\n",
|
||
" self.params = [self.weight, self.bias]\n",
|
||
"\n",
|
||
" def __call__(self, x):\n",
|
||
" return self.forward(x)\n",
|
||
"\n",
|
||
" def forward(self, x):\n",
|
||
" x = torch.matmul(x, self.weight.T) + self.bias\n",
|
||
" return x\n",
|
||
"\n",
|
||
" def to(self, device: str):\n",
|
||
" for param in self.params:\n",
|
||
" param.data = param.data.to(device=device)\n",
|
||
" return self\n",
|
||
"\n",
|
||
" def parameters(self):\n",
|
||
" return self.params\n",
|
||
"\n",
|
||
" \n",
|
||
"# 手动实现torch.nn.Flatten\n",
|
||
"class My_Flatten:\n",
|
||
" def __call__(self, x: torch.Tensor):\n",
|
||
" x = x.view(x.shape[0], -1)\n",
|
||
" return x\n",
|
||
"\n",
|
||
" \n",
|
||
"# 手动实现torch.nn.ReLU\n",
|
||
"class My_ReLU():\n",
|
||
" def __call__(self, x: torch.Tensor):\n",
|
||
" x = torch.max(x, torch.tensor(0.0, device=x.device))\n",
|
||
" return x\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.Sigmoid\n",
|
||
"class My_Sigmoid():\n",
|
||
" def __call__(self, x: torch.Tensor):\n",
|
||
" x = 1. / (1. + torch.exp(-x))\n",
|
||
" return x\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.BCELoss\n",
|
||
"class My_BCELoss:\n",
|
||
" def __call__(self, prediction: torch.Tensor, target: torch.Tensor):\n",
|
||
" loss = -torch.mean(target * torch.log(prediction) + (1 - target) * torch.log(1 - prediction))\n",
|
||
" return loss\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.CrossEntropyLoss\n",
|
||
"class My_CrossEntropyLoss:\n",
|
||
" def __call__(self, predictions: torch.Tensor, targets: torch.Tensor):\n",
|
||
" max_values = torch.max(predictions, dim=1, keepdim=True).values\n",
|
||
" exp_values = torch.exp(predictions - max_values)\n",
|
||
" softmax_output = exp_values / torch.sum(exp_values, dim=1, keepdim=True)\n",
|
||
"\n",
|
||
" log_probs = torch.log(softmax_output)\n",
|
||
" nll_loss = -torch.sum(targets * log_probs, dim=1)\n",
|
||
" average_loss = torch.mean(nll_loss)\n",
|
||
" return average_loss\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.optim.SGD\n",
|
||
"class My_optimizer:\n",
|
||
" def __init__(self, params: list[torch.Tensor], lr: float):\n",
|
||
" self.params = params\n",
|
||
" self.lr = lr\n",
|
||
"\n",
|
||
" def step(self):\n",
|
||
" with torch.no_grad():\n",
|
||
" for param in self.params:\n",
|
||
" param.data = param.data - self.lr * param.grad.data\n",
|
||
"\n",
|
||
" def zero_grad(self):\n",
|
||
" for param in self.params:\n",
|
||
" if param.grad is not None:\n",
|
||
" param.grad.data = torch.zeros_like(param.grad.data)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先造一个显示训练损失和测试正确率的函数。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 7,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def draw_loss_and_acc(train_loss:list[float], test_acc:list[float]):\n",
|
||
" # train loss\n",
|
||
" plt.figure(figsize=(10, 5))\n",
|
||
" plt.subplot(1, 2, 1)\n",
|
||
" plt.plot(range(1, num_epochs + 1), train_loss, label='Train Loss', color='blue')\n",
|
||
" plt.xlabel('Epoch')\n",
|
||
" plt.ylabel('Train Loss')\n",
|
||
" plt.legend()\n",
|
||
" \n",
|
||
" # test acc\n",
|
||
" plt.subplot(1, 2, 2)\n",
|
||
" plt.plot(range(1, num_epochs + 1), test_acc, label='Test Accuracy', color='green')\n",
|
||
" plt.xlabel('Epoch')\n",
|
||
" plt.ylabel('Test Accuracy')\n",
|
||
" plt.legend()\n",
|
||
" \n",
|
||
" plt.tight_layout()\n",
|
||
" plt.show()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"手动构建回归任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 8,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_1_1:\n",
|
||
" def __init__(self):\n",
|
||
" self.linear = My_Linear(in_features=500, out_features=1)\n",
|
||
" self.sigmoid = My_Sigmoid()\n",
|
||
" self.params = self.linear.params\n",
|
||
"\n",
|
||
" def __call__(self, x):\n",
|
||
" return self.forward(x)\n",
|
||
"\n",
|
||
" def forward(self, x):\n",
|
||
" x = self.linear(x)\n",
|
||
" x = self.sigmoid(x)\n",
|
||
" return x\n",
|
||
"\n",
|
||
" def to(self, device: str):\n",
|
||
" for param in self.params:\n",
|
||
" param.data = param.data.to(device=device)\n",
|
||
" return self\n",
|
||
"\n",
|
||
" def parameters(self):\n",
|
||
" return self.params\n",
|
||
" \n",
|
||
" def train(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = True\n",
|
||
" \n",
|
||
" def eval(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = False"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述回归模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 9,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 2.8978282511234283, Used Time: 353.962ms, Test Acc: 36.794%, Used Time: 133.922ms\n",
|
||
"Epoch [2/10], Train Loss: 1.4448097050189972, Used Time: 175.900ms, Test Acc: 81.232%, Used Time: 128.733ms\n",
|
||
"Epoch [3/10], Train Loss: 1.4289481192827225, Used Time: 198.616ms, Test Acc: 93.077%, Used Time: 131.016ms\n",
|
||
"Epoch [4/10], Train Loss: 1.4270987510681152, Used Time: 197.384ms, Test Acc: 97.134%, Used Time: 135.690ms\n",
|
||
"Epoch [5/10], Train Loss: 1.4268036112189293, Used Time: 186.521ms, Test Acc: 98.251%, Used Time: 129.092ms\n",
|
||
"Epoch [6/10], Train Loss: 1.4267750978469849, Used Time: 186.903ms, Test Acc: 98.479%, Used Time: 129.014ms\n",
|
||
"Epoch [7/10], Train Loss: 1.4267622083425522, Used Time: 196.603ms, Test Acc: 98.527%, Used Time: 132.037ms\n",
|
||
"Epoch [8/10], Train Loss: 1.426765315234661, Used Time: 204.839ms, Test Acc: 98.537%, Used Time: 132.721ms\n",
|
||
"Epoch [9/10], Train Loss: 1.4267539158463478, Used Time: 194.532ms, Test Acc: 98.539%, Used Time: 132.098ms\n",
|
||
"Epoch [10/10], Train Loss: 1.4267604500055313, Used Time: 202.596ms, Test Acc: 98.540%, Used Time: 128.826ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 3\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_1().to(device)\n",
|
||
"criterion = My_BCELoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" \n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" total_epoch_acc += (1 - torch.abs(y_pred - targets) / torch.abs(targets)).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_regression_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"手动构建二分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 10,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_1_2:\n",
|
||
" def __init__(self):\n",
|
||
" self.fc = My_Linear(in_features=200, out_features=1)\n",
|
||
" self.sigmoid = My_Sigmoid()\n",
|
||
" self.params = self.fc.parameters()\n",
|
||
"\n",
|
||
" def __call__(self, x):\n",
|
||
" return self.forward(x)\n",
|
||
"\n",
|
||
" def forward(self, x):\n",
|
||
" x = self.fc(x)\n",
|
||
" x = self.sigmoid(x)\n",
|
||
" return x\n",
|
||
"\n",
|
||
" def to(self, device: str):\n",
|
||
" for param in self.params:\n",
|
||
" param.data = param.data.to(device=device)\n",
|
||
" return self\n",
|
||
"\n",
|
||
" def parameters(self):\n",
|
||
" return self.params\n",
|
||
" \n",
|
||
" def train(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = True\n",
|
||
" \n",
|
||
" def eval(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = False"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述二分类模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 11,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 57.00982600450516, Used Time: 230.368ms, Test Acc: 66.017%, Used Time: 166.204ms\n",
|
||
"Epoch [2/10], Train Loss: 10.472276136279106, Used Time: 209.454ms, Test Acc: 94.183%, Used Time: 175.770ms\n",
|
||
"Epoch [3/10], Train Loss: 4.121680565178394, Used Time: 213.171ms, Test Acc: 98.383%, Used Time: 172.317ms\n",
|
||
"Epoch [4/10], Train Loss: 2.3858484774827957, Used Time: 222.556ms, Test Acc: 99.400%, Used Time: 182.800ms\n",
|
||
"Epoch [5/10], Train Loss: 1.6423252075910568, Used Time: 183.790ms, Test Acc: 99.550%, Used Time: 190.588ms\n",
|
||
"Epoch [6/10], Train Loss: 1.232148002833128, Used Time: 224.288ms, Test Acc: 99.800%, Used Time: 212.908ms\n",
|
||
"Epoch [7/10], Train Loss: 0.9720441102981567, Used Time: 211.697ms, Test Acc: 99.900%, Used Time: 187.609ms\n",
|
||
"Epoch [8/10], Train Loss: 0.8034970238804817, Used Time: 219.023ms, Test Acc: 99.933%, Used Time: 163.564ms\n",
|
||
"Epoch [9/10], Train Loss: 0.6857249233871698, Used Time: 220.023ms, Test Acc: 99.933%, Used Time: 185.545ms\n",
|
||
"Epoch [10/10], Train Loss: 0.592832000926137, Used Time: 231.004ms, Test Acc: 99.950%, Used Time: 191.013ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5e-3\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_2().to(device)\n",
|
||
"criterion = My_BCELoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device).to(dtype=torch.float)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" output = model(x)\n",
|
||
" pred = (output > 0.5).to(dtype=torch.long)\n",
|
||
" total_epoch_acc += (pred == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
"\n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_binarycls_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"手动构建MNIST多分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 12,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_1_3:\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" self.flatten = My_Flatten()\n",
|
||
" self.linear = My_Linear(in_features=28 * 28, out_features=num_classes)\n",
|
||
" self.params = self.linear.params\n",
|
||
"\n",
|
||
" def __call__(self, x: torch.Tensor):\n",
|
||
" return self.forward(x)\n",
|
||
"\n",
|
||
" def forward(self, x: torch.Tensor):\n",
|
||
" x = self.flatten(x)\n",
|
||
" x = self.linear(x)\n",
|
||
" return x\n",
|
||
"\n",
|
||
" def to(self, device: str):\n",
|
||
" for param in self.params:\n",
|
||
" param.data = param.data.to(device=device)\n",
|
||
" return self\n",
|
||
"\n",
|
||
" def parameters(self):\n",
|
||
" return self.params\n",
|
||
" \n",
|
||
" def train(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = True\n",
|
||
" \n",
|
||
" def eval(self):\n",
|
||
" for param in self.params:\n",
|
||
" param.requires_grad = False"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述MNIST多分类模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 13,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 367.9293797016144, Used Time: 751.721ms, Test Acc: 73.320%, Used Time: 294.007ms\n",
|
||
"Epoch [2/10], Train Loss: 133.2528795003891, Used Time: 769.317ms, Test Acc: 79.920%, Used Time: 266.492ms\n",
|
||
"Epoch [3/10], Train Loss: 106.34030884504318, Used Time: 765.257ms, Test Acc: 80.740%, Used Time: 285.056ms\n",
|
||
"Epoch [4/10], Train Loss: 93.35072726011276, Used Time: 778.732ms, Test Acc: 84.460%, Used Time: 256.720ms\n",
|
||
"Epoch [5/10], Train Loss: 85.63974636793137, Used Time: 754.908ms, Test Acc: 83.050%, Used Time: 273.081ms\n",
|
||
"Epoch [6/10], Train Loss: 79.69779297709465, Used Time: 756.135ms, Test Acc: 85.490%, Used Time: 248.706ms\n",
|
||
"Epoch [7/10], Train Loss: 75.14733672142029, Used Time: 808.793ms, Test Acc: 86.180%, Used Time: 269.727ms\n",
|
||
"Epoch [8/10], Train Loss: 71.68338397145271, Used Time: 755.723ms, Test Acc: 86.310%, Used Time: 284.321ms\n",
|
||
"Epoch [9/10], Train Loss: 68.71114844083786, Used Time: 747.782ms, Test Acc: 86.920%, Used Time: 278.054ms\n",
|
||
"Epoch [10/10], Train Loss: 66.33750835061073, Used Time: 743.276ms, Test Acc: 87.730%, Used Time: 258.968ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 1e-1\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"num_classes = 10\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_3(num_classes).to(device)\n",
|
||
"criterion = My_CrossEntropyLoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (images, targets) in enumerate(train_loader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" images = images.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" one_hot_targets = my_one_hot(targets, num_classes=num_classes).to(dtype=torch.float)\n",
|
||
"\n",
|
||
" outputs = model(images)\n",
|
||
" loss = criterion(outputs, one_hot_targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (image, targets) in enumerate(test_loader):\n",
|
||
" image = image.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" outputs = model(image)\n",
|
||
" pred = my_softmax(outputs, dim=1)\n",
|
||
" total_epoch_acc += (pred.argmax(1) == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务二\n",
|
||
"**利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
|
||
"- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建回归任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 14,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_1(nn.Module):\n",
|
||
" def __init__(self):\n",
|
||
" super().__init__()\n",
|
||
" self.linear = nn.Linear(in_features=500, out_features=1)\n",
|
||
" self.sigmoid = nn.Sigmoid()\n",
|
||
"\n",
|
||
" def forward(self, x):\n",
|
||
" x = self.linear(x)\n",
|
||
" x = self.sigmoid(x)\n",
|
||
" return x"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述二分类模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 15,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 2.1101853772997856, Used Time: 195.015ms, Test Acc: 78.956%, Used Time: 144.186ms\n",
|
||
"Epoch [2/10], Train Loss: 1.4286116436123848, Used Time: 214.837ms, Test Acc: 96.060%, Used Time: 146.329ms\n",
|
||
"Epoch [3/10], Train Loss: 1.4267941787838936, Used Time: 214.863ms, Test Acc: 99.014%, Used Time: 147.720ms\n",
|
||
"Epoch [4/10], Train Loss: 1.4267428517341614, Used Time: 195.811ms, Test Acc: 99.311%, Used Time: 150.746ms\n",
|
||
"Epoch [5/10], Train Loss: 1.426711082458496, Used Time: 212.999ms, Test Acc: 99.330%, Used Time: 144.737ms\n",
|
||
"Epoch [6/10], Train Loss: 1.4266885295510292, Used Time: 220.414ms, Test Acc: 99.332%, Used Time: 153.153ms\n",
|
||
"Epoch [7/10], Train Loss: 1.4267256334424019, Used Time: 219.407ms, Test Acc: 99.332%, Used Time: 148.779ms\n",
|
||
"Epoch [8/10], Train Loss: 1.426725186407566, Used Time: 184.097ms, Test Acc: 99.332%, Used Time: 150.357ms\n",
|
||
"Epoch [9/10], Train Loss: 1.4267201945185661, Used Time: 213.742ms, Test Acc: 99.332%, Used Time: 148.762ms\n",
|
||
"Epoch [10/10], Train Loss: 1.4267090111970901, Used Time: 226.117ms, Test Acc: 99.332%, Used Time: 146.309ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB3RklEQVR4nO3deVxVdf7H8fdlkU0WN2RxAdwzt7RMbdF0VHLMNZfxl6ZtUzplZiUzo2lqjDaZYzY6laaV5lJpi2UZlmaaW9HkVOaCggiiJSCgiHB+fzDcEQVkuZdz7+X1fDzug3vPPefcz7laxzffzWIYhiEAAAAAAGBzbmYXAAAAAACAqyJ0AwAAAABgJ4RuAAAAAADshNANAAAAAICdELoBAAAAALATQjcAAAAAAHZC6AYAAAAAwE4I3QAAAAAA2ImH2QVUt4KCAp08eVL+/v6yWCxmlwMAqGEMw9C5c+cUFhYmNzd+911V3NcBAGYp7z29xoXukydPqnHjxmaXAQCo4ZKSktSoUSOzy3B63NcBAGa71j29xoVuf39/SYVfTEBAgMnVAABqmszMTDVu3Nh6P0LVcF8HAJilvPf0Ghe6i7qeBQQEcHMGAJjGkbpCb9++Xc8//7z279+vlJQUbdiwQYMHD7a+bxiGnnnmGb366qtKT09Xjx49tGTJErVo0cK6z2+//aY//elP+vDDD+Xm5qZhw4bpH//4h2rXrl3q5164cEFPPPGE1qxZo9zcXPXr10///Oc/1bBhw3LXzn0dAGC2a93TGUwGAEANl52drQ4dOujll18u8f358+dr0aJFWrp0qXbv3i0/Pz/169dPFy5csO4zZswY/ec//9GWLVv00Ucfafv27XrwwQfL/NzHH39cH374odavX69t27bp5MmTGjp0qE2vDQAAs1kMwzDMLqI6ZWZmKjAwUBkZGfxGHABQ7Rz9PmSxWIq1dBuGobCwMD3xxBOaOnWqJCkjI0MNGzbUihUrNGrUKP3000+67rrrtHfvXnXp0kWStHnzZt155506ceKEwsLCrvqcjIwMNWjQQKtXr9bw4cMlST///LPatGmjXbt26eabby5XvY7+fQIAXFd570G0dAMAgFIlJCQoNTVVffr0sW4LDAxU165dtWvXLknSrl27FBQUZA3cktSnTx+5ublp9+7dJZ53//79ysvLK3be1q1bq0mTJtbzAgDgCmrcmG4AcFT5+fnKy8szuwxUkaenp9zd3c0uw2ZSU1Ml6apx1g0bNrS+l5qaquDg4GLve3h4qG7dutZ9SjpvrVq1FBQUVOp5S5Kbm6vc3Fzr68zMzHJfCwAAZiB0A4DJDMNQamqq0tPTzS4FNhIUFKSQkBCHmizNVcTGxmrWrFlmlwEAQLkRugHAZEWBOzg4WL6+vgQ1J2YYhnJycpSWliZJCg0NNbmiqgsJCZEknTp1qtj1nDp1Sh07drTuU3TNRS5duqTffvvNenxJ57148aLS09OLtXafOnWq1GMkKSYmRlOmTLG+LlquBQAAR0XoBgAT5efnWwN3vXr1zC4HNuDj4yNJSktLU3BwsNN3NY+MjFRISIji4uKsITszM1O7d+/Www8/LEnq1q2b0tPTtX//fnXu3FmStHXrVhUUFKhr164lnrdz587y9PRUXFychg0bJkk6ePCgEhMT1a1bt1Lr8fLykpeXlw2vEAAA+yJ0A4CJisZw+/r6mlwJbKnozzMvL88pQndWVpYOHz5sfZ2QkKD4+HjVrVtXTZo00eTJkzVnzhy1aNFCkZGRmj59usLCwqwznLdp00b9+/fXAw88oKVLlyovL0+TJk3SqFGjrDOXJycnq3fv3nrjjTd00003KTAwUPfdd5+mTJmiunXrKiAgQH/605/UrVu3cs9cDgCAMyB0A4ADoEu5a3G2P899+/apV69e1tdF3bfHjRunFStW6KmnnlJ2drYefPBBpaen65ZbbtHmzZvl7e1tPWbVqlWaNGmSevfuLTc3Nw0bNkyLFi2yvp+Xl6eDBw8qJyfHuu3FF1+07pubm6t+/frpn//8ZzVcMQAA1Yd1ugHARBcuXFBCQoIiIyOLBRg4t7L+XLkP2RbfJwDALKzTDQBwKhEREVq4cKHZZQAAANgUoRsAUCEWi6XMx8yZMyt13r179+rBBx+sUm09e/bU5MmTq3QOAAAAW2JMNwCgQlJSUqzP165dqxkzZujgwYPWbbVr17Y+NwxD+fn58vC49u2mQYMGti0UAADAAdDSDQCokJCQEOsjMDBQFovF+vrnn3+Wv7+/PvnkE3Xu3FleXl7asWOHjhw5okGDBqlhw4aqXbu2brzxRn3++efFzntl93KLxaLXXntNQ4YMka+vr1q0aKEPPvigSrW/++67atu2rby8vBQREaEXXnih2Pv//Oc/1aJFC3l7e6thw4YaPny49b133nlH7dq1k4+Pj+rVq6c+ffooOzu7SvUAAADXR0s3ADgQw5Aum9y5Wvn6SraadHvatGn6+9//rqioKNWpU0dJSUm68847NXfuXHl5eemNN97QwIEDdfDgQTVp0qTU88yaNUvz58/X888/r5deekljxozR8ePHVbdu3QrXtH//fo0YMUIzZ87UyJEjtXPnTj3yyCOqV6+e7r33Xu3bt0+PPvqo3nzzTXXv3l2//fabvvrqK0mFrfujR4/W/PnzNWTIEJ07d05fffWVathcpAAAoBII3VWwaJH01VfSxIlSz55mVwPAFeTkSJf1zq5WWVmSn59tzvXss8/qd7/7nfV13bp11aFDB+vr2bNna8OGDfrggw80adKkUs9z7733avTo0ZKk5557TosWLdKePXvUv3//Cte0YMEC9e7dW9OnT5cktWzZUj/++KOef/553XvvvUpMTJSfn59+//vfy9/fX02bNlWnTp0kFYbuS5cuaejQoWratKkkqV27dhWuAYBjOZd7TkfPHtVv539TgVFgfeQb+cVfF+Tb7f0KHauCEq+jtF8AGiplu533B5zBv37/L9WuVT3/6CJ0V8GOHdI770i33kroBoDLdenSpdjrrKwszZw5U5s2bbIG2PPnzysxMbHM87Rv39763M/PTwEBAUpLS6tUTT/99JMGDRpUbFuPHj20cOFC5efn63e/+52aNm2qqKgo9e/fX/3797d2be/QoYN69+6tdu3aqV+/furbt6+GDx+uOnXqVKoWANWjwChQcmayjp49qqNnj+rI2SPFnp/JOWN2iQBM8lL0S9X2WYTuKmjUqPDniRPm1gHAdfj6FrY4m/XZtuJ3RZP51KlTtWXLFv39739X8+bN5ePjo+HDh+vixYtlnsfT07PYa4vFooKCklt6qsrf31/ffvutvvzyS3322WeaMWOGZs6cqb179yooKEhbtmzRzp079dlnn+mll17SX/7yF+3evVuRkZF2qQdA+WRfzFZCekJhkP7tSLFwnZCeoIv5Zf9/pr5vfTXwbSB3N3e5W9zlZnGzPtzdrnh9xfvl2cf6vkrev8xjrnjfYrHIoqvHAVlKGBtU0n4V2beq53QGzjREyFm/Y0fm62nDf/hcg6mhOzY2Vu+9955+/vln+fj4qHv37po3b55atWpV6jH/+c9/NGPGDO3fv1/Hjx/Xiy++aNryMIRuALZmsdiui7cj+frrr3XvvfdqyJAhkgpbvo8dO1atNbRp00Zff/31VXW1bNlS7u7ukiQPDw/16dNHffr00TPPPKOgoCBt3bpVQ4cOlcViUY8ePdSjRw/NmDFDTZs21YYNGzRlypRqvQ6gpjEMQ6lZqcXC9OUt1qlZqWUe7+HmoaaBTdWsbjNFBUUpqk5U4fM6hc8DvAKq6UoA1FSmhu5t27Zp4sSJuvHGG3Xp0iX9+c9/Vt++ffXjjz9e1UpSJCcnR1FRUbr77rv1+OOPV3PFxRG6AaB8WrRooffee08DBw6UxWLR9OnT7dZiffr0acXHxxfbFhoaqieeeEI33nijZs+erZEjR2rXrl1avHix/vnPf0qSPvroIx09elS33Xab6tSpo48//lgFBQVq1aqVdu/erbi4OPXt21fBwcHavXu3Tp8+rTZt2tjlGoCa5sKlC0o4m1BiN/CjZ4/q/KXzZR4f5B2kZnX+F6SLnjer20yNAhrJw43OnQDMY+r/gTZv3lzs9YoVKxQcHKz9+/frtttuK/GYG2+8UTfeeKOkwtlxzUToBoDyWbBggSZMmKDu3burfv36evrpp5WZmWmXz1q9erVWr15dbNvs2bP117/+VevWrdOMGTM0e/ZshYaG6tlnn9W9994rSQoKCtJ7772nmTNn6sKFC2rRooXefvtttW3bVj/99JO2b9+uhQsXKjMzU02bNtULL7yg6Ohou1wD4GoMw9DpnNP/C9W/HdHR9P89Tz6XXObxbhY3NQlsUixQX/68jg/zKwBwXBbDgQYzHD58WC1atNAPP/yg66+//pr7R0REaPLkyWV2L8/NzVVubq71dWZmpho3bqyMjAwFBFStO1FiotS0qVSrlnT+vOTGqucAKujChQtKSEhQZGSkvL29zS4HNlLWn2tmZqYCAwNtch8C36ejMgxD/9z7T8UlxFlbrbMulj1hRe1atdWsTrMSu4E3CWyiWu61qql6ACif8t6DHKavTUFBgSZPnqwePXqUK3CXV2xsrGbNmmWz810uNLRw/OXFi9KZM1JwsF0+BgAAwKks2LVAU7dMLbbNIovCA8JLbKmOqhOl+r71mSwKgEtymNA9ceJEHThwQDt27LDpeWNiYopNclPU0m0Lnp5Sw4ZSamphF3NCNwAAqOl2Je3StLjCIYBTbp6i3lG9FVUnShFBEfL2oEcPgJrHIUL3pEmT9NFHH2n79u1qVDRQ2ka8vLzk5eVl03NerlGj/4XuG26w28cAAAA4vN/O/6aR74zUpYJLGtl2pP7e9++0XgOo8UwdhWwYhiZNmqQNGzZo69atTrnWKZOpAQAAFP67btzGcUrKTFLzus31ysBXCNwAIJNbuidOnKjVq1fr/fffl7+/v1JTC9dZDAwMlI+PjyRp7NixCg8PV2xsrCTp4sWL+vHHH63Pk5OTFR8fr9q1a6t58+bVfg1FoTu57Ek3AaBMDjSnJWyAP0/URAt2LdBHv3wkL3cvrRu+jvWvAeC/TG3pXrJkiTIyMtSzZ0+FhoZaH2vXrrXuk5iYqJSUFOvrkydPqlOnTurUqZNSUlL097//XZ06ddL9999vxiXQ0g2gSjw9PSVJOTk5JlcCWyr68yz68wVc3eXjuBf2X6hOoZ1MrggAHIepLd3laQn48ssvi72OiIhwqBYEQjeAqnB3d1dQUJDS0tIkSb6+vnTHdGKGYSgnJ0dpaWkKCgqSu7u72SUBdnflOO6HOj9kdkkA4FAcYiI1Z0boBlBVISEhkmQN3nB+QUFB1j9XwJUxjhsAro3QXUWXh27DKFy3GwAqwmKxKDQ0VMHBwcrLyzO7HFSRp6cnLdyoMRjHDQDXRuiuovDwwp85OVJ6ulSnjqnlAHBi7u7uhDUATuPycdwv9nuRcdwAUApTJ1JzBd7eUv36hc/pYg4AAGqCy8dxj2g7Qn/s8kezSwIAh0XotoGi1m5CNwAAcHWGYejejfcqKTNJzeo006sDX2UcNwCUgdBtA0ymBgAAaooXv3lRH/7yoWq519L6u9czjhsAroHQbQOEbgAAUBN8c+IbPf3505Kkhf1YjxsAyoPQbQOEbgAA4OoYxw0AlUPotoGi0J2cbG4dAAAA9lA0jjsxI5Fx3ABQQYRuG6ClGwAAuDLGcQNA5RG6bYDQDQAAXBXjuAGgagjdNlC0ZFhGhnTunLm1AAAA2ArjuAGg6gjdNuDvLwUGFj5nXDcAAHAFjOMGANsgdNsIXcwBAIArYRw3ANgGodtGCN0AAMBVMI4bAGyH0G0jReO6Cd0AAMCZMY4bAGyL0G0jtHQDAABnZxiGxr8/nnHcAGBDhG4bIXQDAABnt/Cbhfrg4AeM4wYAGyJ020hR6Gb2cgCAKzp37pwmT56spk2bysfHR927d9fevXut71sslhIfzz//fKnnnDlz5lX7t27dujouByXYfWK3nvr8KUmM4wYAW/IwuwBXQUs3AMCV3X///Tpw4IDefPNNhYWF6a233lKfPn30448/Kjw8XCkpKcX2/+STT3Tfffdp2LBhZZ63bdu2+vzzz62vPTz4p4kZGMcNAPbDnc1GikL3mTPShQuSt7e59QAAYCvnz5/Xu+++q/fff1+33XabpMJW6g8//FBLlizRnDlzFBISUuyY999/X7169VJUVFSZ5/bw8LjqWFSvonHcxzOOM44bAOyA7uU2EhQk+foWPqeLOQDAlVy6dEn5+fnyvuI3yj4+PtqxY8dV+586dUqbNm3Sfffdd81zHzp0SGFhYYqKitKYMWOUmJhY5v65ubnKzMws9kDVXD6Oe93d6xjHDQA2Rui2EYuFLuYAANfk7++vbt26afbs2Tp58qTy8/P11ltvadeuXVd1K5eklStXyt/fX0OHDi3zvF27dtWKFSu0efNmLVmyRAkJCbr11lt17ty5Uo+JjY1VYGCg9dG4ceMqX19Ndvk47hf7vagbQm8wuSIAcD2EbhsidAMAXNWbb74pwzAUHh4uLy8vLVq0SKNHj5ab29X/lFi+fLnGjBlzVcv4laKjo3X33Xerffv26tevnz7++GOlp6dr3bp1pR4TExOjjIwM6yMpKanK11ZTXT6O++7r7tbDXR42uyQAcEmM6bYhQjcAwFU1a9ZM27ZtU3Z2tjIzMxUaGqqRI0deNWb7q6++0sGDB7V27doKf0ZQUJBatmypw4cPl7qPl5eXvLy8KnxuFMc4bgCoPrR021B4eOFPQjcAwFX5+fkpNDRUZ8+e1aeffqpBgwYVe3/ZsmXq3LmzOnToUOFzZ2Vl6ciRIwoNDbVVuSjFleO4A70DzS4JAFwWoduGaOkGALiqTz/9VJs3b1ZCQoK2bNmiXr16qXXr1ho/frx1n8zMTK1fv173339/iefo3bu3Fi9ebH09depUbdu2TceOHdPOnTs1ZMgQubu7a/To0Xa/npqMcdwAUL3oXm5DhG4AgKvKyMhQTEyMTpw4obp162rYsGGaO3euPD09rfusWbNGhmGUGpqPHDmiM2fOWF+fOHFCo0eP1q+//qoGDRrolltu0TfffKMGDRrY/XpqKsZxA0D1sxiGYZhdRHXKzMxUYGCgMjIyFBBg2yUxvv1W6txZCgmRSpjMFQAAu96HaiK+z/IzDEOD1w7WBwc/ULM6zbT/wf10KweAKijvPYju5TZU1NJ96pSUl2duLQAAAJf7x+5/MI4bAExA6Lah+vWlWrUkw6ClGwAAOI49yXv01BbGcQOAGQjdNuTmxgzmAADAsZw9f1Yj1o9QXkEe47gBwASEbhtjMjUAAOAoWI8bAMxH6LYxQjcAAHAU/9j9D71/8H3GcQOAiQjdNkboBgAAjoBx3ADgGAjdNsaYbgAAYDbGcQOA4yB02xgt3QAAwEyM4wYAx0LotjFCNwAAMBPjuAHAsRC6bawodJ88KeXnm1sLAACoWS4fx72g7wLGcQOAAyB021hIiOTuXhi409LMrgYAANQUl4/jHn7dcD1y4yNmlwQAEKHb5tzdpdDQwud0MQcAANXh8nHcUXWi9NrA1xjHDQAOgtBtB4zrBgAA1WnR7kX/G8c9nHHcAOBICN12QOgGAADVZU/yHj255UlJheO4O4d1NrkiAMDlCN12QOgGAADV4ez5sxr5zkjGcQOAAyN02wGhGwAA2JthGJrwwQQdSz/GOG4AcGCmhu7Y2FjdeOON8vf3V3BwsAYPHqyDBw9e87j169erdevW8vb2Vrt27fTxxx9XQ7XlR+gGAAD2tmj3Im38eSPjuAHAwZkaurdt26aJEyfqm2++0ZYtW5SXl6e+ffsqOzu71GN27typ0aNH67777tN3332nwYMHa/DgwTpw4EA1Vl628PDCn4RuAABgD4zjBgDnYTEMwzC7iCKnT59WcHCwtm3bpttuu63EfUaOHKns7Gx99NFH1m0333yzOnbsqKVLl17zMzIzMxUYGKiMjAwFBATYrPbLHTsmRUZKtWpJFy5I9PQCABSpjvtQTVITv8+z58/qhldu0LH0Yxp+3XCtG76ObuUAYILy3oMcakx3RkaGJKlu3bql7rNr1y716dOn2LZ+/fpp165ddq2tIsLCCn9evCidOWNuLQAAwHUwjhsAnI+H2QUUKSgo0OTJk9WjRw9df/31pe6Xmpqqhg0bFtvWsGFDpaamlrh/bm6ucnNzra8zMzNtU3AZatWSGjaUTp2SkpOlBg3s/pEAAKAG+OLYF4zjBgAn4zAt3RMnTtSBAwe0Zs0am543NjZWgYGB1kfjxo1tev7SMJkaAACwtR9O/SBJ+n3L3zOOGwCchEOE7kmTJumjjz7SF198oUZFabUUISEhOnXqVLFtp06dUkhISIn7x8TEKCMjw/pISkqyWd1lIXQDAABbS0hPkCQ1q9PM5EoAAOVlaug2DEOTJk3Shg0btHXrVkVGRl7zmG7duikuLq7Yti1btqhbt24l7u/l5aWAgIBij+pA6AYAALZWFLojg679byYAgGMwdUz3xIkTtXr1ar3//vvy9/e3jssODAyUj4+PJGns2LEKDw9XbGysJOmxxx7T7bffrhdeeEEDBgzQmjVrtG/fPr3yyiumXUdJCN0AAMDWjp49KkmKrEPoBgBnYWpL95IlS5SRkaGePXsqNDTU+li7dq11n8TERKWkpFhfd+/eXatXr9Yrr7yiDh066J133tHGjRvLnHzNDIRuAABgS4ZhKOEsLd0A4GxMbekuzxLhX3755VXb7r77bt199912qMh2CN0AAMCWzuScUXZetiSpaVBTk6sBAJSXQ0yk5orCwwt/njghleN3CwAAAGUqGs8d5h8mbw9vk6sBAJQXodtOikJ3draUkWFuLQAAwPnRtRwAnBOh2058faW6dQuf08UcAABUVVFLd1SdKJMrAQBUBKHbjhjXDQAAbIWWbgBwToRuOyoK3cnJ5tYBAACc39F0lgsDAGdE6LYjWroBAICt0NINAM6J0G1HhG4AAGAL+QX5SsxIlERLNwA4G0K3HRG6AQCALSSfS1ZeQZ483TwV7h9udjkAgAogdNsRoRsAANhCUdfyJoFN5O7mbnI1AICKIHTbEaEbAOAqzp07p8mTJ6tp06by8fFR9+7dtXfvXuv79957rywWS7FH//79r3nel19+WREREfL29lbXrl21Z88ee16G02K5MABwXoRuOwr/b++v9HQpK8vUUgAAqJL7779fW7Zs0ZtvvqkffvhBffv2VZ8+fZR82RId/fv3V0pKivXx9ttvl3nOtWvXasqUKXrmmWf07bffqkOHDurXr5/S0tLsfTlOh0nUAMB5EbrtKCBA8vcvfM6yYQAAZ3X+/Hm9++67mj9/vm677TY1b95cM2fOVPPmzbVkyRLrfl5eXgoJCbE+6tSpU+Z5FyxYoAceeEDjx4/Xddddp6VLl8rX11fLly+39yU5HZYLAwDnRei2M7qYAwCc3aVLl5Sfny9vb+9i2318fLRjxw7r6y+//FLBwcFq1aqVHn74Yf3666+lnvPixYvav3+/+vTpY93m5uamPn36aNeuXba/CCdHSzcAOC9Ct50RugEAzs7f31/dunXT7NmzdfLkSeXn5+utt97Srl27lJKSIqmwa/kbb7yhuLg4zZs3T9u2bVN0dLTy8/NLPOeZM2eUn5+vhg0bFtvesGFDpaamllpLbm6uMjMziz1qgqIx3bR0A4Dz8TC7AFdXFLrpXg4AcGZvvvmmJkyYoPDwcLm7u+uGG27Q6NGjtX//fknSqFGjrPu2a9dO7du3V7NmzfTll1+qd+/eNqsjNjZWs2bNstn5nMGFSxd08txJSbR0A4AzoqXbzmjpBgC4gmbNmmnbtm3KyspSUlKS9uzZo7y8PEVFlTybdlRUlOrXr6/Dhw+X+H79+vXl7u6uU6dOFdt+6tQphYSElFpHTEyMMjIyrI+kpKTKX5STOJ5+XJLk5+mn+r71Ta4GAFBRhG47I3QDAFyJn5+fQkNDdfbsWX366acaNGhQifudOHFCv/76q0JDQ0t8v1atWurcubPi4uKs2woKChQXF6du3bqV+vleXl4KCAgo9nB1ly8XZrFYTK4GAFBRhG47I3QDAFzBp59+qs2bNyshIUFbtmxRr1691Lp1a40fP15ZWVl68skn9c033+jYsWOKi4vToEGD1Lx5c/Xr1896jt69e2vx4sXW11OmTNGrr76qlStX6qefftLDDz+s7OxsjR8/3oxLdFjWSdQYzw0ATokx3XZG6AYAuIKMjAzFxMToxIkTqlu3roYNG6a5c+fK09NTly5d0r///W+tXLlS6enpCgsLU9++fTV79mx5eXlZz3HkyBGdOXPG+nrkyJE6ffq0ZsyYodTUVHXs2FGbN2++anK1mu7o2f8uF8Z4bgBwSoRuOysK3adPSxcuSFestgIAgFMYMWKERowYUeJ7Pj4++vTTT695jmPHjl21bdKkSZo0aVJVy3Np1pnLCd0A4JToXm5ndepIPj6Fz0+eNLcWAADgfFguDACcG6HbziwWKTy88DldzAEAQEVZx3TT0g0ATonQXQ0Y1w0AACoj40KGzl44K4mWbgBwVoTuakDoBgAAlVHUtbyBbwPVrlXb5GoAAJVB6K4GhG4AAFAZLBcGAM6P0F0NikJ3crK5dQAAAOfCcmEA4PwI3dWAlm4AAFAZLBcGAM6P0F0NCN0AAKAyWC4MAJwfobsaFIXulBQpL8/cWgAAgPNguTAAcH6E7mrQoIHk6SkZhpSaanY1AADAGRiGoWPpxyRJUXWizC0GAFBphO5q4OYmhYcXPqeLOQAAKI9T2ad0/tJ5uVnc1CSwidnlAAAqidBdTQjdAACgIoq6ljcKaCRPd0+TqwEAVBahu5owmRoAAKgIlgsDANdA6K4mhG4AAFARzFwOAK6B0F1NCN0AAKAimLkcAFwDobuaFIXu5GRz6wAAAM7B2tJN6AYAp0boria0dAMAgIooCt0sFwYAzo3QXU0ub+kuKDC3FgAA4NguFVxSUkaSJMZ0A4CzI3RXk5CQwvW6L12S0tLMrgYAADiypIwk5Rv58nL3UkjtELPLAQBUAaG7mnh4SKGhhc/pYg4AAMpStFxYRFCE3Cz8cw0AnBn/F69GjOsGAADlwXJhAOA6CN3VKDy88CehGwAAlIXlwgDAdRC6qxEt3QAAoDxYLgwAXAehuxoRugEAQHmwXBgAuA5CdzUidAMAgPKwdi9nTDcAOD1CdzUidAMAgGvJycvRqexTkuheDgCuwNTQvX37dg0cOFBhYWGyWCzauHHjNY95+eWX1aZNG/n4+KhVq1Z644037F+ojRSF7uRkyTDMrQUAADimolbuQK9A1fGpY3I1AICqMjV0Z2dnq0OHDnr55ZfLtf+SJUsUExOjmTNn6j//+Y9mzZqliRMn6sMPP7RzpbYRFlb488IF6bffzK0FAAA4JpYLAwDX4mHmh0dHRys6Orrc+7/55pt66KGHNHLkSElSVFSU9u7dq3nz5mngwIH2KtNmvLyk4GApLa2wi3m9emZXBAAAHA3LhQGAa3GqMd25ubny9vYuts3Hx0d79uxRXl6eSVVVDOO6AQBAWVguDABci1OF7n79+um1117T/v37ZRiG9u3bp9dee015eXk6c+ZMicfk5uYqMzOz2MNMhG4AAFAWlgsDANfiVKF7+vTpio6O1s033yxPT08NGjRI48aNkyS5uZV8KbGxsQoMDLQ+GjduXJ0lX4XQDQAAysJyYQDgWpwqdPv4+Gj58uXKycnRsWPHlJiYqIiICPn7+6tBgwYlHhMTE6OMjAzrIykpqZqrLi48vPAnoRsAAFzJMAy6lwOAizF1IrXK8vT0VKP/NhmvWbNGv//970tt6fby8pKXl1d1llcmWroBAEBpfjv/mzJzC4fCRQRFmFsMAMAmTA3dWVlZOnz4sPV1QkKC4uPjVbduXTVp0kQxMTFKTk62rsX9yy+/aM+ePeratavOnj2rBQsW6MCBA1q5cqVZl1BhhG4AAFCaolbukNoh8vH0MbkaAIAtmBq69+3bp169ellfT5kyRZI0btw4rVixQikpKUpMTLS+n5+frxdeeEEHDx6Up6enevXqpZ07dyoiIqK6S680QjcAACgNy4UBgOsxNXT37NlThmGU+v6KFSuKvW7Tpo2+++47O1dlX0VjurOypMxMKSDA3HoAAIDjYOZyAHA9TjWRmivw85Pq1Cl8Tms3AMBZnDt3TpMnT1bTpk3l4+Oj7t27a+/evZKkvLw8Pf3002rXrp38/PwUFhamsWPH6uTJk2Wec+bMmbJYLMUerVu3ro7LcVi0dAOA6yF0m4Au5gAAZ3P//fdry5YtevPNN/XDDz+ob9++6tOnj5KTk5WTk6Nvv/1W06dP17fffqv33ntPBw8e1F133XXN87Zt21YpKSnWx44dO6rhahyXdeZylgsDAJfhlLOXO7tGjaQffiB0AwCcw/nz5/Xuu+/q/fff12233SapsJX6ww8/1JIlSzRnzhxt2bKl2DGLFy/WTTfdpMTERDVp0qTUc3t4eCgkJMSu9TsTlgsDANdDS7cJaOkGADiTS5cuKT8/X97e3sW2+/j4lNoynZGRIYvFoqCgoDLPfejQIYWFhSkqKkpjxowpNoFqSXJzc5WZmVns4SoKjAIdSz8miZZuAHAlhG4TELoBAM7E399f3bp10+zZs3Xy5Enl5+frrbfe0q5du5SSknLV/hcuXNDTTz+t0aNHK6CMGUO7du2qFStWaPPmzVqyZIkSEhJ066236ty5c6UeExsbq8DAQOujcePGNrlGR3Dy3EldzL8od4u7GgU0MrscAICNELpNUDSDOaEbAOAs3nzzTRmGofDwcHl5eWnRokUaPXq03NyK/1MiLy9PI0aMkGEYWrJkSZnnjI6O1t1336327durX79++vjjj5Wenq5169aVekxMTIwyMjKsj6SkJJtcnyMomkStSWATebgxAhAAXAX/RzcBLd0AAGfTrFkzbdu2TdnZ2crMzFRoaKhGjhypqKj/LW1VFLiPHz+urVu3ltnKXZKgoCC1bNlShw8fLnUfLy8veXl5Vfo6HBnLhQGAa6Kl2wSEbgCAs/Lz81NoaKjOnj2rTz/9VIMGDZL0v8B96NAhff7556pXr16Fz52VlaUjR44oNDTU1mU7BZYLAwDXROg2QVHoPntWys42txYAAMrj008/1ebNm5WQkKAtW7aoV69eat26tcaPH6+8vDwNHz5c+/bt06pVq5Sfn6/U1FSlpqbq4sWL1nP07t1bixcvtr6eOnWqtm3bpmPHjmnnzp0aMmSI3N3dNXr0aDMu0XQsFwYAronu5SYICJBq15aysqTkZKllS7MrAgCgbBkZGYqJidGJEydUt25dDRs2THPnzpWnp6eOHTumDz74QJLUsWPHYsd98cUX6tmzpyTpyJEjOnPmjPW9EydOaPTo0fr111/VoEED3XLLLfrmm2/UoEGD6rosh8JyYQDgmgjdJrBYClu7f/6Z0A0AcA4jRozQiBEjSnwvIiJChmFc8xzHjh0r9nrNmjW2KM1lHD17VBIt3QDgauhebhLGdQMAgCK5l3KVnJksiZZuAHA1hG6TELoBAECRxIxEGTLk6+mrYL9gs8sBANgQodskhG4AAFDk8vHcFovF5GoAALZE6DYJoRsAABSxLhfGeG4AcDmEbpOEhxf+JHQDAABmLgcA10XoNgkt3QAAoAihGwBcF6HbJEWhOy1Nys01txYAAGAulgsDANdF6DZJvXqSl1fh85Mnza0FAACYyzqmm5ZuAHA5hG6TWCx0MQcAANK53HP69fyvkmjpBgBXROg2UVHoTk42tw4AAGCeovHc9XzqKcArwORqAAC2Rug2ES3dAACA5cIAwLURuk1E6AYAVNYzzzyj48ePm10GbICZywHAtRG6TUToBgBU1vvvv69mzZqpd+/eWr16tXJZCsNpMYkaALg2QreJCN0AgMqKj4/X3r171bZtWz322GMKCQnRww8/rL1795pdGiroaDrLhQGAKyN0m4jQDQCoik6dOmnRokU6efKkli1bphMnTqhHjx5q3769/vGPfygjI8PsElEOtHQDgGsjdJsoPLzwZ0qKdOmSubUAAJyXYRjKy8vTxYsXZRiG6tSpo8WLF6tx48Zau3at2eWhDIZh/G9MNy3dAOCSCN0mCg6WPDykggIpNdXsagAAzmb//v2aNGmSQkND9fjjj6tTp0766aeftG3bNh06dEhz587Vo48+anaZKMPpnNPKycuRRRY1DWxqdjkAADsgdJvI3V0KCyt8ThdzAEBFtGvXTjfffLMSEhK0bNkyJSUl6W9/+5uaN29u3Wf06NE6ffq0iVXiWoq6locHhMvLw8vkagAA9uBhdgE1XaNGUmIioRsAUDEjRozQhAkTFF40VqkE9evXV0FBQTVWhYpiuTAAcH2EbpMxmRoAoDKmT59udgmwAeskaoznBgCXRfdykxWF7uRkc+sAADiXYcOGad68eVdtnz9/vu6++24TKkJlHD373+XCaOkGAJdF6DYZLd0AgMrYvn277rzzzqu2R0dHa/v27SZUhMqgezkAuD5Ct8kI3QCAysjKylKtWrWu2u7p6anMzEwTKkJlFIXuqDpRJlcCALAXQrfJCN0AgMpo165diWtwr1mzRtddd50JFaGi8gvylZiRKIkx3QDgyio8kdr58+dlGIZ8fX0lScePH9eGDRt03XXXqW/fvjYv0NVdPqa7oEBy49cgAIBymD59uoYOHaojR47ojjvukCTFxcXp7bff1vr1602uDuVxIvOELhVcUi33WgrzDzO7HACAnVQ44g0aNEhvvPGGJCk9PV1du3bVCy+8oEGDBmnJkiU2L9DVhYRIFouUlyexlCoAoLwGDhyojRs36vDhw3rkkUf0xBNP6MSJE/r88881ePBgs8tDORR1LW8a2FRuFn7rDgCuqsL/h//222916623SpLeeecdNWzYUMePH9cbb7yhRYsW2bxAV+fpWRi8JbqYAwAqZsCAAfr666+VnZ2tM2fOaOvWrbr99tvNLgvlZJ25nK7lAODSKhy6c3Jy5O/vL0n67LPPNHToULm5uenmm2/W8ePHbV5gTcC4bgAAah7rGt3MXA4ALq3Cobt58+bauHGjkpKS9Omnn1rHcaelpSkgIMDmBdYEhG4AQEXl5+fr73//u2666SaFhISobt26xR5wfCwXBgA1Q4VD94wZMzR16lRFRESoa9eu6tatm6TCVu9OnTrZvMCagNANAKioWbNmacGCBRo5cqQyMjI0ZcoUa++zmTNnml0eyoHlwgCgZqjw7OXDhw/XLbfcopSUFHXo0MG6vXfv3hoyZIhNi6spLp/BHACA8li1apVeffVVDRgwQDNnztTo0aPVrFkztW/fXt98840effRRs0vENVi7lzOmGwBcWqWmygwJCVGnTp3k5uamzMxMbdy4Uf7+/mrdurWt66sRaOkGAFRUamqq2rVrJ0mqXbu2MjIyJEm///3vtWnTJjNLQzmczzuvlKwUSXQvBwBXV+HQPWLECC1evFhS4ZrdXbp00YgRI9S+fXu9++67Ni+wJiB0AwAqqlGjRkpJKQxtzZo102effSZJ2rt3r7y8vMwsDeVwPKNw8ln/Wv6q68MYfABwZRUO3du3b7cuGbZhwwYZhqH09HQtWrRIc+bMsXmBNcHlodswzK0FAOAchgwZori4OEnSn/70J02fPl0tWrTQ2LFjNWHCBJOrw7VcvlyYxWIxuRoAgD1VeEx3RkaGdVbUzZs3a9iwYfL19dWAAQP05JNP2rzAmiAsrPDn+fPS2bMSk84CAK7lb3/7m/X5yJEj1bRpU+3cuVMtWrTQwIEDTawM5cFyYQBQc1S4pbtx48batWuXsrOztXnzZuuSYWfPnpW3t3eFzrV9+3YNHDhQYWFhslgs2rhx4zWPWbVqlTp06CBfX1+FhoZqwoQJ+vXXXyt6GQ7F21uqX7/wOV3MAQDXkpeXpwkTJighIcG67eabb9aUKVMI3E6C5cIAoOaocOiePHmyxowZo0aNGiksLEw9e/aUVBigiyZ0Ka/s7Gx16NBBL7/8crn2//rrrzV27Fjdd999+s9//qP169drz549euCBByp6GQ6Hcd0AgPLy9PRkHhUnx3JhAFBzVDh0P/LII9q1a5eWL1+uHTt2yM2t8BRRUVEVHtMdHR2tOXPmlHupsV27dikiIkKPPvqoIiMjdcstt+ihhx7Snj17KnoZDofQDQCoiMGDB5erh5itnDt3TpMnT1bTpk3l4+Oj7t27a+/evdb3DcPQjBkzFBoaKh8fH/Xp00eHDh265nlffvllRUREyNvbW127dnWJe3p5sFwYANQcFR7TLUldunRRly5dZBiGDMOQxWLRgAEDbF3bVbp166Y///nP+vjjjxUdHa20tDS98847uvPOO0s9Jjc3V7m5udbXmZmZdq+zMgjdAICKaNGihZ599ll9/fXX6ty5s/z8/Iq9b+t1uu+//34dOHBAb775psLCwvTWW2+pT58++vHHHxUeHq758+dr0aJFWrlypSIjIzV9+nT169dPP/74Y6nDz9auXaspU6Zo6dKl6tq1qxYuXKh+/frp4MGDCg4Otmn9jobu5QBQc1gMo+LzZb/xxht6/vnnrb/BbtmypZ588kndc889lS/EYtGGDRs0ePDgMvdbv369JkyYoAsXLujSpUsaOHCg3n33XXl6epa4/8yZMzVr1qyrtmdkZCggIKDS9dra3LnSX/8qjR8vLV9udjUAAHvJzMxUYGBgle9DkZGlhzWLxaKjR49W+txXOn/+vPz9/fX+++8X+yV7586dFR0drdmzZyssLExPPPGEpk6dKqnwPtuwYUOtWLFCo0aNKvG8Xbt21Y033mhdirSgoECNGzfWn/70J02bNq1ctdnq+6xOZ8+fVd35hbOmZsVkya+W3zWOAAA4ovLegyrcvXzBggV6+OGHdeedd2rdunVat26d+vfvrz/+8Y968cUXq1T0tfz444967LHHNGPGDO3fv1+bN2/WsWPH9Mc//rHUY2JiYpSRkWF9JCUl2bXGyipq6U5ONrcOAIBzSEhIKPVhy8AtSZcuXVJ+fv5VLdY+Pj7asWOHEhISlJqaqj59+ljfCwwMVNeuXbVr164Sz3nx4kXt37+/2DFubm7q06dPqcdIhT3YMjMziz2cTVErd7BfMIEbAGqACncvf+mll7RkyRKNHTvWuu2uu+5S27ZtNXPmTD3++OM2LfBysbGx6tGjh3Vpsvbt28vPz0+33nqr5syZo9DQ0KuO8fLykpeXl91qshW6lwMAHJW/v7+6deum2bNnq02bNmrYsKHefvtt7dq1S82bN1dqaqokqWHDhsWOa9iwofW9K505c0b5+fklHvPzzz+XWktsbGyJPdicCcuFAUDNUuHQnZKSou7du1+1vXv37kpJSbFJUaXJycmRh0fxkt3d3SUVTuDizAjdAICKmDBhQpnvL7fxWKU333xTEyZMUHh4uNzd3XXDDTdo9OjR2r9/v00/51piYmI0ZcoU6+vMzEw1bty4WmuoKut4biZRA4AaocLdy5s3b65169ZdtX3t2rVq0aJFhc6VlZWl+Ph4xcfHSyrsKhcfH6/ExERJhTfWy1vUBw4cqPfee09LlizR0aNH9fXXX+vRRx/VTTfdpLCwsIpeikMJDy/8mZlZ+AAAoCxnz54t9khLS9PWrVv13nvvKT093eaf16xZM23btk1ZWVlKSkrSnj17lJeXp6ioKIWEhEiSTp06VeyYU6dOWd+7Uv369eXu7l6hY6TCHmwBAQHFHs6mqKU7KojlwgCgJqhwS/esWbM0cuRIbd++XT169JBUuH52XFxciWG8LPv27VOvXr2sr4t+cz1u3DitWLFCKSkp1gAuSffee6/OnTunxYsX64knnlBQUJDuuOMOzZs3r6KX4XBq15aCgqT09MJx3U74bwgAQDXasGHDVdsKCgr08MMPq1mzZnb7XD8/P/n5+ens2bP69NNPNX/+fEVGRiokJERxcXHq2LGjpMIW6N27d+vhhx8u8Ty1atVS586dFRcXZ51EtaCgQHFxcZo0aZLd6ncEtHQDQM1SqdnL9+/frxdffFE//fSTJKlNmzZ64okn1KlTJ5sXaGuOPMtpu3bSgQPSZ59Jv/ud2dUAAOzB3vehgwcPqmfPnjYf8vXpp5/KMAy1atVKhw8f1pNPPilvb2999dVX8vT01Lx58/S3v/2t2JJh//73v4stGda7d28NGTLEGqrXrl2rcePG6V//+pduuukmLVy4UOvWrdPPP/981Vjv0jjyfb00bV5uo5/P/KzP7/lcvaN6m10OAKCSynsPqtQ63Z07d9Zbb71VbFtaWpqee+45/fnPf67MKaHCLuYHDjCuGwBQeUeOHNGlS5dsft6MjAzFxMToxIkTqlu3roYNG6a5c+dal+x86qmnlJ2drQcffFDp6em65ZZbtHnz5mIznh85ckRnzpyxvh45cqROnz6tGTNmKDU1VR07dtTmzZvLHbidUYFRoGPpxyTR0g0ANUWlWrpL8v333+uGG25Qfn6+LU5nN478G/H775eWLZOefVaaPt3sagAA9mCr+9Dlk4lJhROKpqSkaNOmTRo3bpx17WtX58j39ZKcPHdS4QvC5WZx04W/XJCnu6fZJQEAKsmuLd2wD2YwBwCU13fffVfstZubmxo0aKAXXnjhmjObwzxFk6g1DmhM4AaAGoLQ7UAI3QCA8vriiy/MLgGVwCRqAFDzVHjJMNgPoRsAUF4JCQk6dOjQVdsPHTqkY8eOVX9BKBeWCwOAmqfcLd1Xjh270unTp6tcTE1XFLqTk82tAwDg+O69915NmDBBLVq0KLZ99+7deu211/Tll1+aUxjKREs3ANQ85Q7dV44dK8ltt91WpWJquqLQ/euv0vnzko+PufUAABzXd999px49ely1/eabb3b5da6dmTV0BxG6AaCmKHfoZuyY/QUGSn5+UnZ2YWt38+ZmVwQAcFQWi0Xnzp27antGRobDryRSkxV1L6elGwBqDsZ0OxCLhXHdAIDyue222xQbG1ssYOfn5ys2Nla33HKLiZWhNHn5eUrKTJJESzcA1CTMXu5gGjWSDh4kdAMAyjZv3jzddtttatWqlW699VZJ0ldffaXMzExt3brV5OpQksSMRBUYBfL28FZI7RCzywEAVBNauh1MeHjhT0I3AKAs1113nf79739rxIgRSktL07lz5zR27Fj9/PPPuv76680uDyW4fDy3xWIxuRoAQHWhpdvB0L0cAFBeYWFheu6558wuA+XEeG4AqJlo6XYwhG4AQHm8/vrrWr9+/VXb169fr5UrV5pQEa6FmcsBoGaqVEt3enq69uzZo7S0NBUUFBR7b+zYsTYprKYidAMAyiM2Nlb/+te/rtoeHBysBx98UOPGjTOhKpSF0A0ANVOFQ/eHH36oMWPGKCsrSwEBAcXGJFksFkJ3FRG6AQDlkZiYqMjIq8Nb06ZNlZiYaEJFuBa6lwNAzVTh7uVPPPGEJkyYoKysLKWnp+vs2bPWx2+//WaPGmuUotCdliZdvGhuLQAAxxUcHKx///vfV23//vvvVa9ePRMqwrUcPXtUEi3dAFDTVDh0Jycn69FHH5Wvr6896qnx6teXatWSDENKSTG7GgCAoxo9erQeffRRffHFF8rPz1d+fr62bt2qxx57TKNGjTK7PFwh62KWTueclkRLNwDUNBUO3f369dO+ffvsUQskWSx0MQcAXNvs2bPVtWtX9e7dWz4+PvLx8VHfvn11xx13aO7cuWaXhyscSz8mSarjXUdB3kGm1gIAqF4VHtM9YMAAPfnkk/rxxx/Vrl07eXp6Fnv/rrvusllxNVWjRtLRo4RuAEDpatWqpbVr12rOnDmKj4+Xj4+P2rVrp6ZNm5pdGkrAeG4AqLkqHLofeOABSdKzzz571XsWi0X5+flVr6qGo6UbAFBeLVq0UIsWLSRJmZmZWrJkiZYtW0avNAfDzOUAUHNVOHRfuUQYbC88vPAnoRsAUB5ffPGFli9frvfee0+BgYEaMmSI2SXhCtaWbkI3ANQ4lVqnG/ZFSzcA4FqSk5O1YsUKvf7669bVRFavXq0RI0YUW84TjsHa0k33cgCoccoVuhctWqQHH3xQ3t7eWrRoUZn7PvroozYprCYjdAMASvPuu+9q2bJl2r59u6Kjo/XCCy8oOjpafn5+ateuHYHbQbFcGADUXOUK3S+++KLGjBkjb29vvfjii6XuZ7FYCN02QOgGAJRm5MiRevrpp7V27Vr5+/ubXQ7KwTAMWroBoAYrV+hOSEgo8Tnsoyh0p6RIly5JHgwCAAD813333aeXX35ZX375pe655x6NHDlSderUMbsslOHX878q62KWJCkiKMLcYgAA1a7C63TD/ho2lNzdpfx86dQps6sBADiSf/3rX0pJSdGDDz6ot99+W6GhoRo0aJAMw2CyUwdVNIlamH+YvD28Ta4GAFDdKtWGeuLECX3wwQdKTEzUxYsXi723YMECmxRWk7m7S2FhUlKSlJz8v9nMAQCQJB8fH40bN07jxo3ToUOH9Prrr2vfvn3q0aOHBgwYoOHDh2vo0KFml4n/YrkwAKjZKhy64+LidNdddykqKko///yzrr/+eh07dkyGYeiGG26wR401UqNGhaH7xAnpppvMrgYA4KhatGih5557TnPmzNGmTZu0bNkyjR49Wrm5uWaXhv+yLhfGeG4AqJEq3L08JiZGU6dO1Q8//CBvb2+9++67SkpK0u233667777bHjXWSEymBgCoCDc3Nw0cOFAbN25UUlKS2eXgMrR0A0DNVuHQ/dNPP2ns2LGSJA8PD50/f161a9fWs88+q3nz5tm8wJqK0A0AqKzg4GCzS8BlWC4MAGq2CoduPz8/6zju0NBQHTlyxPremTNnbFdZDUfoBgDANbBcGADUbBUe033zzTdrx44datOmje6880498cQT+uGHH/Tee+/p5ptvtkeNNVLR5GmEbgAAnFd+Qb6Opx+XJEXViTK5GgCAGSocuhcsWKCsrMK1JmfNmqWsrCytXbtWLVq0YOZyG6KlGwAA53fy3EnlFeTJ081T4f4sRwIANVGFQnd+fr5OnDih9u3bSyrsar506VK7FFbTFYXu5GSpoEByY0V1AMBloqKitHfvXtWrV6/Y9vT0dN1www06evSoSZXhckVdy5sENpG7m7vJ1QAAzFChKOfu7q6+ffvq7Nmz9qoH/xUaKlks0sWLEkPlAQBXOnbsmPLz86/anpubq+TkZBMqQklYLgwAUOHu5ddff72OHj2qyEhuHvZUq5bUsKGUmlrYxZyJaAEAkvTBBx9Yn3/66acKDAy0vs7Pz1dcXJwiIiJMqAwlYbkwAECFQ/ecOXM0depUzZ49W507d5afn1+x9wMCAmxWXE3XqFFh6E5Olm64wexqAACOYPDgwZIki8WicePGFXvP09NTEREReuGFF0yoDCVhuTAAQLlD97PPPqsnnnhCd955pyTprrvuksVisb5vGIYsFkuJXd1QOY0aSfv2MZkaAOB/CgoKJEmRkZHau3ev6tevb3JFKAvLhQEAyj2me9asWcrOztYXX3xhfWzdutX6KHoN22EGcwBAaRISEq4K3Onp6Xb5rPz8fE2fPl2RkZHy8fFRs2bNNHv2bBmGYd3HYrGU+Hj++edLPe/MmTOv2r9169Z2uQazFI3pZrkwAKi5yt3SXXRjvf322+1WDIojdAMASjNv3jxFRERo5MiRkqS7775b7777rkJDQ/Xxxx+rQ4cONv2sJUuWaOXKlWrbtq327dun8ePHKzAwUI8++qgkKSUlpdgxn3zyie677z4NGzaszHO3bdtWn3/+ufW1h0eFR745rNxLuTp57qQkupcDQE1WoTvb5d3JYX+EbgBAaZYuXapVq1ZJkrZs2aLPP/9cmzdv1rp16/Tkk0/qs88+s9ln7dy5U4MGDdKAAQMkSREREXr77be1Z88e6z4hISHFjnn//ffVq1cvRUWV3cLr4eFx1bGu4njGcRky5Ofpp/q+DAMAgJqqQqG7ZcuW1wzev/32W5UKwv+Ehxf+JHQDAK6Umpqqxo0bS5I++ugjjRgxQn379lVERIS6du1q08/q3r27XnnlFf3yyy9q2bKlvv/+e+3YsUMLFiwocf9Tp05p06ZNWrly5TXPfejQIYWFhcnb21vdunVTbGysmjRpYtP6zXL5cmE0XABAzVWh0D1r1qxiS5PAvi5v6TaMwnW7AQCQpDp16igpKUmNGzfW5s2bNWfOHEmFw8FsPanptGnTlJmZqdatW8vd3V35+fmaO3euxowZU+L+K1eulL+/v4YOHVrmebt27aoVK1aoVatWSklJ0axZs3TrrbfqwIED8vf3L/GY3Nxc5ebmWl9nZmZW/sLsjOXCAABSBUP3qFGjFMyC0dWmqKU7J0dKT5fq1DG1HACAAxk6dKj+8Ic/qEWLFvr1118VHR0tSfruu+/UvHlzm37WunXrtGrVKq1evVpt27ZVfHy8Jk+erLCwsKuWLZOk5cuXa8yYMfL29i7zvEU1S1L79u3VtWtXNW3aVOvWrdN9991X4jGxsbGaNWtW1S6omrBcGABAqkDopltU9fPxkerVk379tbC1m9ANACjy4osvKiIiQklJSZo/f75q164tqXBCs0ceecSmn/Xkk09q2rRpGjVqlCSpXbt2On78uGJjY68K3V999ZUOHjyotWvXVvhzgoKC1LJlSx0+fLjUfWJiYjRlyhTr68zMTGs3e0dT1NLNzOUAULNVePZyVK9Gjf4Xutu1M7saAICj8PT01NSpU6/a/vjjj9v8s3JycuTmVnyVUXd3d+ua4ZdbtmyZOnfuXKnZ07OysnTkyBHdc889pe7j5eUlLy+vCp/bDJeP6QYA1FzlXqe7oKDA5l3Lt2/froEDByosLEwWi0UbN24sc/977723xDVA27Zta9O6HAkzmAMASvPmm2/qlltuUVhYmI4fPy5JWrhwod5//32bfs7AgQM1d+5cbdq0SceOHdOGDRu0YMECDRkypNh+mZmZWr9+ve6///4Sz9O7d28tXrzY+nrq1Knatm2bjh07pp07d2rIkCFyd3fX6NGjbVq/WRjTDQCQKhC67SE7O1sdOnTQyy+/XK79//GPfyglJcX6SEpKUt26dXX33XfbuVLzFIXu5GRz6wAAOJYlS5ZoypQpio6OVnp6unXytKCgIC1cuNCmn/XSSy9p+PDheuSRR9SmTRtNnTpVDz30kGbPnl1svzVr1sgwjFJD85EjR3TmzBnr6xMnTmj06NFq1aqVRowYoXr16umbb75RgwYNbFq/GTJzM/Xb+cIVXWjpBoCazWI4SL9xi8WiDRs2aPDgweU+ZuPGjRo6dKgSEhLUtGnTch2TmZmpwMBAZWRkKCAgoJLVVp85c6Tp06X77pNee83sagAAVWWr+9B1112n5557ToMHD5a/v7++//57RUVF6cCBA+rZs2excOvKHPW+/n3q9+r4r46q71tfp588bXY5AAA7KO89qEKzlzuaZcuWqU+fPmUGbmdaWqQkdC8HAJQkISFBnTp1umq7l5eXsrOzTagIl6NrOQCgiKndy6vi5MmT+uSTT0odN1YkNjZWgYGB1oejznBaGkI3AKAkkZGRio+Pv2r75s2b1aZNm+ovCMVYlwujazkA1HhOG7pXrlypoKCga3ZHj4mJUUZGhvWRlJRUPQXaSNFa3YRuAIAkPfvss8rJydGUKVM0ceJErV27VoZhaM+ePZo7d65iYmL01FNPmV1mjVc0c3lUEMuFAUBN55Tdyw3D0PLly3XPPfeoVq1aZe7rTEuLlKSopTsjQzp3TvL3N7ceAIC5Zs2apT/+8Y+6//775ePjo7/+9a/KycnRH/7wB4WFhekf//iHdT1tmMfavZyWbgCo8ZwydG/btk2HDx/WfffdZ3YpdufvLwUESJmZhTOYt25tdkUAADNdPv/pmDFjNGbMGOXk5CgrK8vmS3ui8hjTDQAoYmr38qysLMXHx1vHpCUkJCg+Pl6JiYmSCruGjx079qrjli1bpq5du+r666+vznJNw7huAMDlLBZLsde+vr4EbgdiGIaOpR+TREs3AMDklu59+/apV69e1tdTpkyRJI0bN04rVqxQSkqKNYAXycjI0Lvvvqt//OMf1VqrmRo1kn78kdANACjUsmXLq4L3lX777bdqqgZXSstOU05ejiyyqElgE7PLAQCYzNTQ3bNnT5W1TPiKFSuu2hYYGKicnBw7VuV4aOkGAFxu1qxZCgwMNLsMlKKoa3mjgEaq5V723DMAANfnlGO6a5qi0J2cbG4dAADHMGrUKLqTOzCWCwMAXM5plwyrSWjpBgAUuVa3cpjPulxYHZYLAwAQup0CoRsAUKSsYVlwDMxcDgC4HN3LnQChGwBQpKCgwOwScA2EbgDA5WjpdgJFofvMGenCBXNrAQAAZSvqXs6YbgCAROh2CkFBko9P4XMmUwMAwHFdKrikxIzC5U5p6QYASIRup2Cx0MUcAABncCLzhPKNfHm5eynUP9TscgAADoDQ7SQI3QAAOL6i5cKaBjWVm4V/ZgEACN1Og9ANAIDjY7kwAMCVCN1OgtANAIDjY+ZyAMCVCN1OgtANAIDjI3QDAK5E6HYSRaGb2csBAHBcLBcGALgSodtJ0NINAIDjo6UbAHAlQreTKArdqalSXp65tQAAgKvl5OUoNStVEi3dAID/IXQ7ifr1pVq1JMOQUlLMrgYAAFzpWPoxSVKAV4DqeNcxtxgAgMMgdDsJNzcpLKzwOV3MAQBwPJcvF2axWEyuBgDgKAjdToRx3QAAOC7GcwMASkLodiKEbgAAHJd15nJCNwDgMoRuJ0LoBgDAcVlbuplEDQBwGUK3EyF0AwDguOheDgAoCaHbiRC6AQBwTIZh6OjZo5Jo6QYAFEfodiJFoTs52dw6AABAcWcvnFVmbqYkKSIowtxiAAAOhdDtRIpC98mTUn6+ubUAAID/KZpELaR2iHw9fU2uBgDgSAjdTiQkRHJ3ly5dktLSzK4GAAAUYTw3AKA0hG4n4u4uhYYWPmdcNwAAjsO6XBjjuQEAVyB0O5nw8MKfhG4AABwHLd0AgNIQup0MM5gDAOB4CN0AgNIQup0MoRsAAMdD93IAQGkI3U6G0A0AgGMpMAqsLd1RdaJMrgYA4GgI3U6G0A0AqG75+fmaPn26IiMj5ePjo2bNmmn27NkyDMO6z7333iuLxVLs0b9//2ue++WXX1ZERIS8vb3VtWtX7dmzx56XYhcp51J0Mf+i3C3uahTQyOxyAAAOxsPsAlAxhG4AQHWbN2+elixZopUrV6pt27bat2+fxo8fr8DAQD366KPW/fr376/XX3/d+trLy6vM865du1ZTpkzR0qVL1bVrVy1cuFD9+vXTwYMHFRwcbLfrsbWiVu4mgU3k4cY/rQAAxdHS7WSKQndysnRZAwMAAHazc+dODRo0SAMGDFBERISGDx+uvn37XtUq7eXlpZCQEOujTp06ZZ53wYIFeuCBBzR+/Hhdd911Wrp0qXx9fbV8+XJ7Xo7NMZ4bAFAWQreTCQsr/JmbK/36q7m1AABqhu7duysuLk6//PKLJOn777/Xjh07FB0dXWy/L7/8UsHBwWrVqpUefvhh/VrGjerixYvav3+/+vTpY93m5uamPn36aNeuXaUel5ubq8zMzGIPszFzOQCgLPSBcjK1akkNG0qnThV2Ma9f3+yKAACubtq0acrMzFTr1q3l7u6u/Px8zZ07V2PGjLHu079/fw0dOlSRkZE6cuSI/vznPys6Olq7du2Su7v7Vec8c+aM8vPz1bBhw2LbGzZsqJ9//rnUWmJjYzVr1izbXZwNELoBAGUhdDuhRo3+F7o7djS7GgCAq1u3bp1WrVql1atXq23btoqPj9fkyZMVFhamcePGSZJGjRpl3b9du3Zq3769mjVrpi+//FK9e/e2WS0xMTGaMmWK9XVmZqYaN25ss/NXBt3LAQBlIXQ7oUaNpP37mUwNAFA9nnzySU2bNs0arNu1a6fjx48rNjbWGrqvFBUVpfr16+vw4cMlhu769evL3d1dp06dKrb91KlTCgkJKbUWLy+va07QVt2Onj0qieXCAAAlY0y3EwoPL/xJ6AYAVIecnBy5uRX/J4O7u7sKCgpKPebEiRP69ddfFRoaWuL7tWrVUufOnRUXF2fdVlBQoLi4OHXr1s02hVeDi/kXdSKz8IZM93IAQEkI3U6IZcMAANVp4MCBmjt3rjZt2qRjx45pw4YNWrBggYYMGSJJysrK0pNPPqlvvvlGx44dU1xcnAYNGqTmzZurX79+1vP07t1bixcvtr6eMmWKXn31Va1cuVI//fSTHn74YWVnZ2v8+PHVfo2VlZiRKEOGfD19FeznPMucAQCqD93LnRChGwBQnV566SVNnz5djzzyiNLS0hQWFqaHHnpIM2bMkFTY6v3vf/9bK1euVHp6usLCwtS3b1/Nnj27WFfwI0eO6MyZM9bXI0eO1OnTpzVjxgylpqaqY8eO2rx581WTqzmyovHcEUERslgsJlcDAHBEhG4nROgGAFQnf39/LVy4UAsXLizxfR8fH3366afXPM+xY8eu2jZp0iRNmjSpihWah5nLAQDXQvdyJ3R56DYMc2sBAKAms85cTugGAJSC0O2EiiZSy86WMjLMrQUAgJrM2tLNcmEAgFIQup2Qr69Ut27h8+Rkc2sBAKAmY7kwAMC1ELqdFOO6AQAwH2O6AQDXQuh2UoRuAADMlXUxS2dyCmdjp3s5AKA0pobu7du3a+DAgQoLC5PFYtHGjRuveUxubq7+8pe/qGnTpvLy8lJERISWL19u/2IdDKEbAABzFU2iVtenrgK8AkyuBgDgqExdMiw7O1sdOnTQhAkTNHTo0HIdM2LECJ06dUrLli1T8+bNlZKSooKCAjtX6niKJlMjdAMAYA66lgMAysPU0B0dHa3o6Ohy779582Zt27ZNR48eVd3/ziQWERFhp+ocGy3dAACYy7pcGF3LAQBlcKox3R988IG6dOmi+fPnKzw8XC1bttTUqVN1/vx5s0urdoRuAADMRUs3AKA8TG3prqijR49qx44d8vb21oYNG3TmzBk98sgj+vXXX/X666+XeExubq5yc3OtrzMzM6urXLsidAMAYC6WCwMAlIdTtXQXFBTIYrFo1apVuummm3TnnXdqwYIFWrlyZamt3bGxsQoMDLQ+GjduXM1V20dR6E5Pl7KyTC0FAIAaiZZuAEB5OFXoDg0NVXh4uAIDA63b2rRpI8MwdKKUJt+YmBhlZGRYH0lJSdVVrl0FBEj+/oXPk5PNrQUAgJrGMAzGdAMAysWpQnePHj108uRJZV3WtPvLL7/Izc1NjYqafq/g5eWlgICAYg9XUXTJhG4AAKrXmZwzys7LlkUWNQ1sanY5AAAHZmrozsrKUnx8vOLj4yVJCQkJio+PV2JioqTCVuqxY8da9//DH/6gevXqafz48frxxx+1fft2Pfnkk5owYYJ8fHzMuARTMa4bAABzFHUtD/MPk5eHl8nVAAAcmamhe9++ferUqZM6deokSZoyZYo6deqkGTNmSJJSUlKsAVySateurS1btig9PV1dunTRmDFjNHDgQC1atMiU+s1G6AYAwBx0LQcAlJeps5f37NlThmGU+v6KFSuu2ta6dWtt2bLFjlU5D0I3AADmKGrpZuZyAMC1ONWYbhRH6AYAwBxFy4UxczkA4FoI3U4sPLzwJ6EbAIDqxXJhAIDyInQ7MVq6AQAwB2O6AQDlReh2YkWh+/Rp6cIFc2sBAKCmyC/IV2JG4USvtHQDAK6F0O3E6taVvL0Ln588aW4tAADUFMnnkpVXkCdPN0+F+YeZXQ4AwMERup2YxUIXcwAAqltR1/KmQU3l7uZucjUAAEdH6HZyhG4AAKoXy4UBACqC0O3kikJ3crK5dQAAUFOwXBgAoCII3U6Olm4AAKoXy4UBACqC0O3kCN0AAFQvlgsDAFQEodvJEboBAKhetHQDACqC0O3kwsMLfxK6AQCwvwuXLujkucJ1OmnpBgCUB6HbyRW1dKekSHl55tYCAICrO55+XJJUu1Zt1fOpZ3I1AABnQOh2csHBkoeHZBhSaqrZ1QAA4NouXy7MYrGYXA0AwBkQup2cmxtdzAEAqC4sFwYAqChCtwtgMjUAAKqHdeZyQjcAoJwI3S6A0A0AQPWwzlzOJGoAgHIidLuAotCdnGxuHQAAuDqWCwMAVBSh2wXQ0g0AQPWwdi+npRsAUE6EbhdA6AYAwP4yLmTo7IWzkqSIoAhziwEAOA1CtwsgdAMA7Ck/P1/Tp09XZGSkfHx81KxZM82ePVuGYUiS8vLy9PTTT6tdu3by8/NTWFiYxo4dq5MnT5Z53pkzZ8pisRR7tG7dujouqVKKupYH+wWrdq3aJlcDAHAWHmYXgKorWjIsOVkqKChcRgwAAFuZN2+elixZopUrV6pt27bat2+fxo8fr8DAQD366KPKycnRt99+q+nTp6tDhw46e/asHnvsMd11113at29fmedu27atPv/8c+trDw/H/acJy4UBACrDce9sKLeQkMKgfemSlJZW+BoAAFvZuXOnBg0apAEDBkiSIiIi9Pbbb2vPnj2SpMDAQG3ZsqXYMYsXL9ZNN92kxMRENWnSpNRze3h4KMRJblyM5wYAVAZtoi7A0/N/QZsu5gAAW+vevbvi4uL0yy+/SJK+//577dixQ9HR0aUek5GRIYvFoqCgoDLPfejQIYWFhSkqKkpjxoxRYmKiLUu3KWYuBwBUBi3dLqJRI+nkycLQ3aWL2dUAAFzJtGnTlJmZqdatW8vd3V35+fmaO3euxowZU+L+Fy5c0NNPP63Ro0crICCg1PN27dpVK1asUKtWrZSSkqJZs2bp1ltv1YEDB+Tv71/iMbm5ucrNzbW+zszMrNrFVQChGwBQGYRuF9GokbRnDy3dAADbW7dunVatWqXVq1erbdu2io+P1+TJkxUWFqZx48YV2zcvL08jRoyQYRhasmRJmee9vKW8ffv26tq1q5o2bap169bpvvvuK/GY2NhYzZo1q+oXVQl0LwcAVAbdy10EM5gDAOzlySef1LRp0zRq1Ci1a9dO99xzjx5//HHFxsYW268ocB8/flxbtmwps5W7JEFBQWrZsqUOHz5c6j4xMTHKyMiwPpKSkip1TRVlGAYt3QCASiF0uwhCNwDAXnJycuR2xdIY7u7uKigosL4uCtyHDh3S559/rnr16lX4c7KysnTkyBGFhoaWuo+Xl5cCAgKKPapDalaqLly6IDeLm5oElj4xHAAAVyJ0u4ii0J2cbG4dAADXM3DgQM2dO1ebNm3SsWPHtGHDBi1YsEBDhgyRVBi4hw8frn379mnVqlXKz89XamqqUlNTdfHiRet5evfurcWLF1tfT506Vdu2bdOxY8e0c+dODRkyRO7u7ho9enS1X+O1FLVyNw5oLE93T5OrAQA4E8Z0uwhaugEA9vLSSy9p+vTpeuSRR5SWlqawsDA99NBDmjFjhiQpOTlZH3zwgSSpY8eOxY794osv1LNnT0nSkSNHdObMGet7J06c0OjRo/Xrr7+qQYMGuuWWW/TNN9+oQYMG1XJdFcF4bgBAZRG6XcTlodswJIvF3HoAAK7D399fCxcu1MKFC0t8PyIiQoZhXPM8x44dK/Z6zZo1NqiuejCeGwBQWXQvdxFhYYU/L1yQfvvN3FoAAHA11pZuQjcAoIII3S7Cy0sq6o1HF3MAAGzL2tJN93IAQAURul0I47oBALCPotAdVSfK5EoAAM6G0O1CCN0AANheXn6eEjMSJdG9HABQcYRuF0LoBgDA9pIyk1RgFMjbw1shtUPMLgcA4GQI3S6E0A0AgO0VTaIWERQhC8uDAAAqiNDtQgjdAADYHsuFAQCqgtDtQopCd3KyuXUAAOBKWC4MAFAVhG4XQks3AAC2x3JhAICqIHS7kPDwwp/nzkmZmebWAgCAq2C5MABAVRC6XYifn1SnTuFzWrsBALCNo2ePSqJ7OQCgcgjdLqaotZvQDQBA1WVfzFZadpokupcDACqH0O1iGNcNAIDtHEs/JkkK8g5SkHeQqbUAAJwTodvFELoBALAdlgsDAFQVodvFELoBALAd63JhdC0HAFSSqaF7+/btGjhwoMLCwmSxWLRx48Yy9//yyy9lsViueqSmplZPwU6A0A0AgO3Q0g0AqCpTQ3d2drY6dOigl19+uULHHTx4UCkpKdZHcHCwnSp0PoRuAABsh+XCAABV5WHmh0dHRys6OrrCxwUHBysoKMj2BbkAQjcAALbDcmEAgKpyyjHdHTt2VGhoqH73u9/p66+/Nrsch1IUus+elXJyzK0FAABnZhgGY7oBAFXmVKE7NDRUS5cu1bvvvqt3331XjRs3Vs+ePfXtt9+Wekxubq4yMzOLPVxZQIBUu3bh8+Rkc2sBAMCZ/Xb+N527eE6SFBEUYW4xAACnZWr38opq1aqVWrVqZX3dvXt3HTlyRC+++KLefPPNEo+JjY3VrFmzqqtE01ksha3dP/9c2MW8RQuzKwIAwDkVjecOrR0qbw9vk6sBADgrp2rpLslNN92kw4cPl/p+TEyMMjIyrI+kpKRqrM4c4eGFPxnXDQBA5dG1HABgC07V0l2S+Ph4hYaGlvq+l5eXvLy8qrEi8zGZGgAAVcdyYQAAWzA1dGdlZRVrpU5ISFB8fLzq1q2rJk2aKCYmRsnJyXrjjTckSQsXLlRkZKTatm2rCxcu6LXXXtPWrVv12WefmXUJDonQDQBA1RW1dLNcGACgKkwN3fv27VOvXr2sr6dMmSJJGjdunFasWKGUlBQlJiZa37948aKeeOIJJScny9fXV+3bt9fnn39e7BwgdAMAYAtH01kuDABQdaaG7p49e8owjFLfX7FiRbHXTz31lJ566ik7V+X8CN0AAFQdY7oBALbg9BOp4WqEbgAAqqbAKNDxjOOSaOkGAFQNodsFFYXutDQpN9fcWgAAcEYnz53UxfyL8nDzUKOARmaXAwBwYoRuF1SvnlQ0YXtKirm1AADgjIq6ljcJbCJ3N3eTqwEAODNCtwuyWOhiDgBAVbBcGADAVgjdLorQDQBA5bFcGADAVgjdLorQDQBA5bFcGADAVgjdLio8vPAnoRsAgIpjuTAAgK0Qul0ULd0AAFQeY7oBALZC6HZRhG4AACon91KukjOTJdHSDQCoOkK3iyJ0AwBQOYkZiTJkyNfTVw18G5hdDgDAyRG6XVRR6E5JkS5dMrcWAACcSVHX8qg6UbJYLCZXAwBwdoRuFxUcLHl4SAUFUmqq2dUAAJxZfn6+pk+frsjISPn4+KhZs2aaPXu2DMOw7mMYhmbMmKHQ0FD5+PioT58+OnTo0DXP/fLLLysiIkLe3t7q2rWr9uzZY89LKRfrJGqM5wYA2ACh20W5u0thYYXP6WIOAKiKefPmacmSJVq8eLF++uknzZs3T/Pnz9dLL71k3Wf+/PlatGiRli5dqt27d8vPz0/9+vXThQsXSj3v2rVrNWXKFD3zzDP69ttv1aFDB/Xr109paWnVcVmlOnqW5cIAALZD6HZhRV3Mk5PNrQMA4Nx27typQYMGacCAAYqIiNDw4cPVt29fa6u0YRhauHCh/vrXv2rQoEFq37693njjDZ08eVIbN24s9bwLFizQAw88oPHjx+u6667T0qVL5evrq+XLl1fTlZXMOnM5k6gBAGyA0O3CmEwNAGAL3bt3V1xcnH755RdJ0vfff68dO3YoOjpakpSQkKDU1FT16dPHekxgYKC6du2qXbt2lXjOixcvav/+/cWOcXNzU58+fUo9RpJyc3OVmZlZ7GFrLBcGALAlD7MLgP0QugEAtjBt2jRlZmaqdevWcnd3V35+vubOnasxY8ZIklL/O3lIw4YNix3XsGFD63tXOnPmjPLz80s85ueffy61ltjYWM2aNasql3NN1jHdtHQDAGyAlm4XFh5e+JPQDQCoinXr1mnVqlVavXq1vv32W61cuVJ///vftXLlymqvJSYmRhkZGdZHUlKSTc9/Lvecfj3/qyRaugEAtkFLtwujpRsAYAtPPvmkpk2bplGjRkmS2rVrp+PHjys2Nlbjxo1TSEiIJOnUqVMKDQ21Hnfq1Cl17NixxHPWr19f7u7uOnXqVLHtp06dsp6vJF5eXvLy8qriFZWuqGt5fd/68vfyt9vnAABqDlq6XRihGwBgCzk5OXJzK/5PBnd3dxUUFEiSIiMjFRISori4OOv7mZmZ2r17t7p161biOWvVqqXOnTsXO6agoEBxcXGlHlMdWC4MAGBrtHS7sMtnLy8okNz4FQsAoBIGDhyouXPnqkmTJmrbtq2+++47LViwQBMmTJAkWSwWTZ48WXPmzFGLFi0UGRmp6dOnKywsTIMHD7aep3fv3hoyZIgmTZokSZoyZYrGjRunLl266KabbtLChQuVnZ2t8ePHm3GZki5bLozx3AAAGyF0u7DQUMlikfLypNOnpSvmqgEAoFxeeuklTZ8+XY888ojS0tIUFhamhx56SDNmzLDu89RTTyk7O1sPPvig0tPTdcstt2jz5s3y9va27nPkyBGdOXPG+nrkyJE6ffq0ZsyYodTUVHXs2FGbN2++anK16sTM5QAAW7MYhmGYXUR1yszMVGBgoDIyMhQQEGB2OXYXFialpEj79kmdO5tdDQCgpt2H7M3W3+fAtwfqo18+0tIBS/VQl4dsUCEAwFWV9x5ES7eLa9SoMHSfOEHoBgDgWlguDHBNhmHo0qVLys/PN7sUOBF3d3d5eHjIYrFU6TyEbhfXqJG0d2/huG4AAFA6wzDoXg64oIsXLyolJUU5OTlmlwIn5Ovrq9DQUNWqVavS5yB0uzhmMAcAoHxO55xWTl6OLLKoaVBTs8sBYAMFBQVKSEiQu7u7wsLCVKtWrSq3WqJmMAxDFy9e1OnTp5WQkKAWLVpctZJHeRG6XRyhGwCA8inqWt4ooJFquVe+RQOA47h48aIKCgrUuHFj+fr6ml0OnIyPj488PT11/PhxXbx4sdjkoBXBIlIuLjy88CehGwCAsrFcGOC6KttCCdji7w5/+1wcLd0AAJQP47kBAPZA6HZxl4fumrU4HAAAFWOduZzQDQCwIUK3iyvqXn7+vHT2rLm1AADgyKwt3XQvB2Aii8VS5mPmzJlVOvfGjRvLvf9DDz0kd3d3rV+/vtKfCUK3y/P2lurXL3xOF3MAAEpH93IAjiAlJcX6WLhwoQICAoptmzp1arXUkZOTozVr1uipp57S8uXLq+Uzy3Lx4kWzS6g0QncNwLhuAADKll+Qr8SMRElSVJ0ok6sBUJOFhIRYH4GBgbJYLMW2rVmzRm3atJG3t7dat26tf/7zn9ZjL168qEmTJik0NFTe3t5q2rSpYmNjJUkRERGSpCFDhshisVhfl2b9+vW67rrrNG3aNG3fvl1JSUnF3s/NzdXTTz+txo0by8vLS82bN9eyZcus7//nP//R73//ewUEBMjf31+33nqrjhw5Iknq2bOnJk+eXOx8gwcP1r333mt9HRERodmzZ2vs2LEKCAjQgw8+KEl6+umn1bJlS/n6+ioqKkrTp09XXl5esXN9+OGHuvHGG+Xt7a369etryJAhkqRnn31W119//VXX2rFjR02fPr3M76MqWDKsBmjUSIqPJ3QDAFCaE5kndKngkrzcvRTqH2p2OQDsxDAM5eTlmPLZvp6+VV4jfNWqVZoxY4YWL16sTp066bvvvtMDDzwgPz8/jRs3TosWLdIHH3ygdevWqUmTJkpKSrKG5b179yo4OFivv/66+vfvL3d39zI/a9myZfq///s/BQYGKjo6WitWrCgWTMeOHatdu3Zp0aJF6tChgxISEnTmzBlJUnJysm677Tb17NlTW7duVUBAgL7++mtdunSpQtf797//XTNmzNAzzzxj3ebv768VK1YoLCxMP/zwgx544AH5+/vrqaeekiRt2rRJQ4YM0V/+8he98cYbunjxoj7++GNJ0oQJEzRr1izt3btXN954oyTpu+++07///W+99957FaqtIgjdNUBRS/ecOdKbb0q1ahU+vLz+97w6XteqJbFaAwDAERUtF9Y0qKncLNysAFeVk5ej2rG1TfnsrJgs+dXyq9I5nnnmGb3wwgsaOnSoJCkyMlI//vij/vWvf2ncuHFKTExUixYtdMstt8hisahp06bWYxs0aCBJCgoKUkhISJmfc+jQIX3zzTfWIPp///d/mjJliv7617/KYrHol19+0bp167Rlyxb16dNHkhQV9b9eQi+//LICAwO1Zs0aeXp6SpJatmxZ4eu944479MQTTxTb9te//tX6PCIiQlOnTrV2g5ekuXPnatSoUZo1a5Z1vw4dOkiSGjVqpH79+un111+3hu7XX39dt99+e7H6bY3QXQN06lT4Mymp8GEmD49rB/SSgnlpvxQsaXt5t1X1+Ir8orK8+9rjnGZ/fhV/oSup7Jn3q/s92J4t/o5Ux3mDg6VVq2x7TjgOxnMDcHTZ2dk6cuSI7rvvPj3wwAPW7ZcuXVJgYKAk6d5779Xvfvc7tWrVSv3799fvf/979e3bt8KftXz5cvXr10/1/zs51J133qn77rtPW7duVe/evRUfHy93d3fdfvvtJR4fHx+vW2+91Rq4K6tLly5XbVu7dq0WLVqkI0eOKCsrS5cuXVJAQECxz778+7nSAw88oAkTJmjBggVyc3PT6tWr9eKLL1apzmshdNcA998vXX+99Ouv0sWLhY/c3P89r+rrst7Lzy9ey6VLhY8cc3r1AEClNWlidgWwJ5YLA2oGX09fZcVkmfbZVZGVVVj3q6++qq5duxZ7r6ir+A033KCEhAR98skn+vzzzzVixAj16dNH77zzTrk/Jz8/XytXrlRqaqo8PDyKbV++fLl69+4tHx+fMs9xrffd3NxkXNHKceW4bEny8yveM2DXrl0aM2aMZs2apX79+llb01944YVyf/bAgQPl5eWlDRs2qFatWsrLy9Pw4cPLPKaqCN01gJub1L27OZ+dn188kJcnwJfUylhay6Ojba/IPo5yDkc67lotk+VpuazqOezV6orqZY/eCr5V+7cSHNyY9mPUol4LNavTzOxSANiRxWKpchdvszRs2FBhYWE6evSoxowZU+p+AQEBGjlypEaOHKnhw4erf//++u2331S3bl15enoq/8pWsSt8/PHHOnfunL777rti474PHDig8ePHKz09Xe3atVNBQYG2bdtm7V5+ufbt22vlypXKy8srsbW7QYMGSklJsb7Oz8/XgQMH1KtXrzJr27lzp5o2baq//OUv1m3Hjx+/6rPj4uI0fvz4Es/h4eGhcePG6fXXX1etWrU0atSoawb1qiJ0w67c3SUfn8IHAACOqnX91mpdv7XZZQBAmWbNmqVHH31UgYGB6t+/v3Jzc7Vv3z6dPXtWU6ZM0YIFCxQaGqpOnTrJzc1N69evV0hIiIKCgiQVjoGOi4tTjx495OXlpTp16lz1GcuWLdOAAQOs46CLXHfddXr88ce1atUqTZw4UePGjdOECROsE6kdP35caWlpGjFihCZNmqSXXnpJo0aNUkxMjAIDA/XNN9/opptuUqtWrXTHHXdoypQp2rRpk5o1a6YFCxYoPT39mtffokULJSYmas2aNbrxxhu1adMmbdiwodg+zzzzjHr37q1mzZpp1KhRunTpkj7++GM9/fTT1n3uv/9+tWnTRpL09ddfV/BPoeKYKQQAAAAAnMD999+v1157Ta+//rratWun22+/XStWrFBkZOHQGH9/f82fP19dunTRjTfeqGPHjunjjz+W238nTXrhhRe0ZcsWNW7cWJ2KJn66zKlTp7Rp0yYNGzbsqvfc3Nw0ZMgQ67JgS5Ys0fDhw/XII4+odevWeuCBB5SdnS1JqlevnrZu3aqsrCzdfvvt6ty5s1599VVrq/eECRM0btw4jR071jqJ2bVauSXprrvu0uOPP65JkyapY8eO2rlz51VLffXs2VPr16/XBx98oI4dO+qOO+7Qnj17iu3TokULde/eXa1bt76qq749WIwrO9O7uMzMTAUGBiojI6PYgHsAAKoD9yHb4vsEUJYLFy4oISFBkZGR8vb2NrscOAjDMNSiRQs98sgjmjJlSpn7lvV3qLz3ILqXAwAAAABqhNOnT2vNmjVKTU0tddy3rRG6AQAAAAA1QnBwsOrXr69XXnmlxDHt9kDoBgAAAADUCGaMrmYiNQAAAAAA7ITQDQAAAACAnRC6AQAAALi0GrZgE2zIFn93TA3d27dv18CBAxUWFiaLxaKNGzeW+9ivv/5aHh4e6tixo93qAwAAAOC8itaFzsnJMbkSOKuivztFf5cqw9SJ1LKzs9WhQwdNmDBBQ4cOLfdx6enpGjt2rHr37q1Tp07ZsUIAAAAAzsrd3V1BQUFKS0uTJPn6+spisZhcFZyBYRjKyclRWlqagoKC5O7uXulzmRq6o6OjFR0dXeHj/vjHP+oPf/iD3N3dK9Q6DgAAAKBmCQkJkSRr8AYqIigoyPp3qLKcbsmw119/XUePHtVbb72lOXPmXHP/3Nxc5ebmWl9nZmbaszwAAAAADsRisSg0NFTBwcHKy8szuxw4EU9Pzyq1cBdxqtB96NAhTZs2TV999ZU8PMpXemxsrGbNmmXnygAAAAA4Mnd3d5sEKKCinGb28vz8fP3hD3/QrFmz1LJly3IfFxMTo4yMDOsjKSnJjlUCAAAAAPA/TtPSfe7cOe3bt0/fffedJk2aJEkqKCiQYRjy8PDQZ599pjvuuOOq47y8vOTl5VXd5QIAAAAA4DyhOyAgQD/88EOxbf/85z+1detWvfPOO4qMjDSpMgAAAAAASmZq6M7KytLhw4etrxMSEhQfH6+6deuqSZMmiomJUXJyst544w25ubnp+uuvL3Z8cHCwvL29r9pelqLFzZlQDQBghqL7T9H9CFXDfR0AYJby3tNNDd379u1Tr169rK+nTJkiSRo3bpxWrFihlJQUJSYm2vQzz507J0lq3LixTc8LAEBFnDt3ToGBgWaX4fS4rwMAzHate7rFqGG/ai8oKNDJkyfl7+8vi8VidjnVJjMzU40bN1ZSUpICAgLMLsfp8X3aFt+n7fGd2pYtv0/DMHTu3DmFhYXJzc1p5jN1WDXxvs5/37bF92lbfJ+2x3dqW2bc051mTLetuLm5qVGjRmaXYZqAgAD+Y7Uhvk/b4vu0Pb5T27LV90kLt+3U5Ps6/33bFt+nbfF92h7fqW1V5z2dX7EDAAAAAGAnhG4AAAAAAOyE0F1DeHl56ZlnnmHNchvh+7Qtvk/b4zu1Lb5POBL+PtoW36dt8X3aHt+pbZnxfda4idQAAAAAAKgutHQDAAAAAGAnhG4AAAAAAOyE0A0AAAAAgJ0Qul1YbGysbrzxRvn7+ys4OFiDBw/WwYMHzS7LZfztb3+TxWLR5MmTzS7FqSUnJ+v//u//VK9ePfn4+Khdu3bat2+f2WU5pfz8fE2fPl2RkZHy8fFRs2bNNHv2bDF1R/lt375dAwcOVFhYmCwWizZu3FjsfcMwNGPGDIWGhsrHx0d9+vTRoUOHzCkWNQr3dPvinm4b3NNth3t61TnSPZ3Q7cK2bdumiRMn6ptvvtGWLVuUl5envn37Kjs72+zSnN7evXv1r3/9S+3btze7FKd29uxZ9ejRQ56envrkk0/0448/6oUXXlCdOnXMLs0pzZs3T0uWLNHixYv1008/ad68eZo/f75eeukls0tzGtnZ2erQoYNefvnlEt+fP3++Fi1apKVLl2r37t3y8/NTv379dOHChWquFDUN93T74Z5uG9zTbYt7etU51D3dQI2RlpZmSDK2bdtmdilO7dy5c0aLFi2MLVu2GLfffrvx2GOPmV2S03r66aeNW265xewyXMaAAQOMCRMmFNs2dOhQY8yYMSZV5NwkGRs2bLC+LigoMEJCQoznn3/eui09Pd3w8vIy3n77bRMqRE3GPd02uKfbDvd02+Kebltm39Np6a5BMjIyJEl169Y1uRLnNnHiRA0YMEB9+vQxuxSn98EHH6hLly66++67FRwcrE6dOunVV181uyyn1b17d8XFxemXX36RJH3//ffasWOHoqOjTa7MNSQkJCg1NbXYf/uBgYHq2rWrdu3aZWJlqIm4p9sG93Tb4Z5uW9zT7au67+keNj8jHFJBQYEmT56sHj166Prrrze7HKe1Zs0affvtt9q7d6/ZpbiEo0ePasmSJZoyZYr+/Oc/a+/evXr00UdVq1YtjRs3zuzynM60adOUmZmp1q1by93dXfn5+Zo7d67GjBljdmkuITU1VZLUsGHDYtsbNmxofQ+oDtzTbYN7um1xT7ct7un2Vd33dEJ3DTFx4kQdOHBAO3bsMLsUp5WUlKTHHntMW7Zskbe3t9nluISCggJ16dJFzz33nCSpU6dOOnDggJYuXcoNuhLWrVunVatWafXq1Wrbtq3i4+M1efJkhYWF8X0CLoR7etVxT7c97um2xT3dtdC9vAaYNGmSPvroI33xxRdq1KiR2eU4rf379ystLU033HCDPDw85OHhoW3btmnRokXy8PBQfn6+2SU6ndDQUF133XXFtrVp00aJiYkmVeTcnnzySU2bNk2jRo1Su3btdM899+jxxx9XbGys2aW5hJCQEEnSqVOnim0/deqU9T3A3rin2wb3dNvjnm5b3NPtq7rv6YRuF2YYhiZNmqQNGzZo69atioyMNLskp9a7d2/98MMPio+Ptz66dOmiMWPGKD4+Xu7u7maX6HR69Ohx1ZI3v/zyi5o2bWpSRc4tJydHbm7F/7fu7u6ugoICkypyLZGRkQoJCVFcXJx1W2Zmpnbv3q1u3bqZWBlqAu7ptsU93fa4p9sW93T7qu57Ot3LXdjEiRO1evVqvf/++/L397eOTwgMDJSPj4/J1Tkff3//q8bO+fn5qV69eoypq6THH39c3bt313PPPacRI0Zoz549euWVV/TKK6+YXZpTGjhwoObOnasmTZqobdu2+u6777RgwQJNmDDB7NKcRlZWlg4fPmx9nZCQoPj4eNWtW1dNmjTR5MmTNWfOHLVo0UKRkZGaPn26wsLCNHjwYPOKRo3APd22uKfbHvd02+KeXnUOdU+3+XzocBiSSny8/vrrZpfmMlhepOo+/PBD4/rrrze8vLyM1q1bG6+88orZJTmtzMxM47HHHjOaNGlieHt7G1FRUcZf/vIXIzc31+zSnMYXX3xR4v83x40bZxhG4RIj06dPNxo2bGh4eXkZvXv3Ng4ePGhu0agRuKfbH/f0quOebjvc06vOke7pFsMwDNtHeQAAAAAAwJhuAAAAAADshNANAAAAAICdELoBAAAAALATQjcAAAAAAHZC6AYAAAAAwE4I3QAAAAAA2AmhGwAAAAAAOyF0AwAAAABgJ4RuANXCYrFo48aNZpcBAACqiHs6UDGEbqAGuPfee2WxWK569O/f3+zSAABABXBPB5yPh9kFAKge/fv31+uvv15sm5eXl0nVAACAyuKeDjgXWrqBGsLLy0shISHFHnXq1JFU2E1syZIlio6Olo+Pj6KiovTOO+8UO/6HH37QHXfcIR8fH9WrV08PPvigsrKyiu2zfPlytW3bVl5eXgoNDdWkSZOKvX/mzBkNGTJEvr6+atGihT744AP7XjQAAC6IezrgXAjdACRJ06dP17Bhw/T9999rzJgxGjVqlH766SdJUnZ2tvr166c6depo7969Wr9+vT7//PNiN+AlS5Zo4sSJevDBB/XDDz/ogw8+UPPmzYt9xqxZszRixAj9+9//1p133qkxY8bot99+q9brBADA1XFPBxyMAcDljRs3znB3dzf8/PyKPebOnWsYhmFIMv74xz8WO6Zr167Gww8/bBiGYbzyyitGnTp1jKysLOv7mzZtMtzc3IzU1FTDMAwjLCzM+Mtf/lJqDZKMv/71r9bXWVlZhiTjk08+sdl1AgDg6rinA86HMd1ADdGrVy8tWbKk2La6detan3fr1q3Ye926dVN8fLwk6aefflKHDh3k5+dnfb9Hjx4qKCjQwYMHZbFYdPLkSfXu3bvMGtq3b2997ufnp4CAAKWlpVX2kgAAqJG4pwPOhdAN1BB+fn5XdQ2zFR8fn3Lt5+npWey1xWJRQUGBPUoCAMBlcU8HnAtjugFIkr755purXrdp00aS1KZNG33//ffKzs62vv/111/Lzc1NrVq1kr+/vyIiIhQXF1etNQMAgKtxTwccCy3dQA2Rm5ur1NTUYts8PDxUv359SdL69evVpUsX3XLLLVq1apX27NmjZcuWSZLGjBmjZ555RuPGjdPMmTN1+vRp/elPf9I999yjhg0bSpJmzpypP/7xjwoODlZ0dLTOnTunr7/+Wn/605+q90IBAHBx3NMB50LoBmqIzZs3KzQ0tNi2Vq1a6eeff5ZUOAvpmjVr9Mgjjyg0NFRvv/22rrvuOkmSr6+vPv30Uz322GO68cYb5evrq2HDhmnBggXWc40bN04XLlzQiy++qKlTp6p+/foaPnx49V0gAAA1BPd0wLlYDMMwzC4CgLksFos2bNigwYMHm10KAACoAu7pgONhTDcAAAAAAHZC6AYAAAAAwE7oXg4AAAAAgJ3Q0g0AAAAAgJ0QugEAAAAAsBNCNwAAAAAAdkLoBgAAAADATgjdAAAAAADYCaEbAAAAAAA7IXQDAAAAAGAnhG4AAAAAAOyE0A0AAAAAgJ38P3OYb1lVI9UJAAAAAElFTkSuQmCC",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_1().to(device)\n",
|
||
"criterion = nn.BCELoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" \n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" total_epoch_acc += (1 - torch.abs(y_pred - targets) / torch.abs(targets)).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_regression_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建二分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 16,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_2(nn.Module):\n",
|
||
" def __init__(self):\n",
|
||
" super().__init__()\n",
|
||
" self.fc = nn.Linear(in_features=200, out_features=1)\n",
|
||
" self.sigmoid = nn.Sigmoid()\n",
|
||
"\n",
|
||
" def forward(self, x):\n",
|
||
" x = self.fc(x)\n",
|
||
" x = self.sigmoid(x)\n",
|
||
" return x"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述二分类模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 17,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 21.56280481815338, Used Time: 248.327ms, Test Acc: 18.617%, Used Time: 191.476ms\n",
|
||
"Epoch [2/10], Train Loss: 20.48189949989319, Used Time: 225.974ms, Test Acc: 39.233%, Used Time: 197.265ms\n",
|
||
"Epoch [3/10], Train Loss: 19.458877623081207, Used Time: 229.453ms, Test Acc: 62.983%, Used Time: 182.790ms\n",
|
||
"Epoch [4/10], Train Loss: 18.516239285469055, Used Time: 229.176ms, Test Acc: 81.850%, Used Time: 199.854ms\n",
|
||
"Epoch [5/10], Train Loss: 17.630264461040497, Used Time: 221.416ms, Test Acc: 93.067%, Used Time: 205.765ms\n",
|
||
"Epoch [6/10], Train Loss: 16.80879431962967, Used Time: 230.655ms, Test Acc: 97.967%, Used Time: 193.758ms\n",
|
||
"Epoch [7/10], Train Loss: 16.03673541545868, Used Time: 241.642ms, Test Acc: 99.467%, Used Time: 192.214ms\n",
|
||
"Epoch [8/10], Train Loss: 15.317354381084442, Used Time: 202.092ms, Test Acc: 99.800%, Used Time: 187.985ms\n",
|
||
"Epoch [9/10], Train Loss: 14.644242405891418, Used Time: 222.552ms, Test Acc: 100.000%, Used Time: 205.953ms\n",
|
||
"Epoch [10/10], Train Loss: 14.018830060958862, Used Time: 234.462ms, Test Acc: 100.000%, Used Time: 214.763ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 1e-4\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_2().to(device)\n",
|
||
"criterion = nn.BCELoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device).to(dtype=torch.float32)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" output = model(x)\n",
|
||
" pred = (output > 0.5).to(dtype=torch.long)\n",
|
||
" total_epoch_acc += (pred == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
"\n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_binarycls_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建MNIST多分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 18,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_3(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.linear = nn.Linear(in_features=28 * 28, out_features=num_classes)\n",
|
||
"\n",
|
||
" def forward(self, x: torch.Tensor):\n",
|
||
" x = self.flatten(x)\n",
|
||
" x = self.linear(x)\n",
|
||
" return x"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"训练并测试上述MNIST多分类模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 22,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/10], Train Loss: 90.53274163603783, Used Time: 781.786ms, Test Acc: 87.310%, Used Time: 266.083ms\n",
|
||
"Epoch [2/10], Train Loss: 50.167335361242294, Used Time: 752.594ms, Test Acc: 88.780%, Used Time: 296.608ms\n",
|
||
"Epoch [3/10], Train Loss: 44.92860543727875, Used Time: 795.665ms, Test Acc: 90.020%, Used Time: 272.585ms\n",
|
||
"Epoch [4/10], Train Loss: 42.10635221004486, Used Time: 777.619ms, Test Acc: 90.360%, Used Time: 280.241ms\n",
|
||
"Epoch [5/10], Train Loss: 40.80511271953583, Used Time: 753.084ms, Test Acc: 90.780%, Used Time: 264.655ms\n",
|
||
"Epoch [6/10], Train Loss: 39.463319301605225, Used Time: 774.873ms, Test Acc: 90.720%, Used Time: 273.553ms\n",
|
||
"Epoch [7/10], Train Loss: 38.5654878616333, Used Time: 757.741ms, Test Acc: 91.230%, Used Time: 261.461ms\n",
|
||
"Epoch [8/10], Train Loss: 38.006617456674576, Used Time: 746.465ms, Test Acc: 89.940%, Used Time: 276.766ms\n",
|
||
"Epoch [9/10], Train Loss: 37.3043093085289, Used Time: 759.912ms, Test Acc: 90.930%, Used Time: 288.009ms\n",
|
||
"Epoch [10/10], Train Loss: 36.95236110687256, Used Time: 797.856ms, Test Acc: 91.370%, Used Time: 261.851ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACb6UlEQVR4nOzdd3hUddrG8e+kh5CEnkIJEAKhBEVESEBQQKo0QYpIFXUXWUQEV1ZBafKCiC6IWBbpXbogiKAoEqogvZeEEoqQhBAIKfP+MZtZIy1lkjOT3J/rmovJzJkz9wSGyZPnV0xms9mMiIiIiIiIiNick9EBRERERERERPIrFd0iIiIiIiIiuURFt4iIiIiIiEguUdEtIiIiIiIikktUdIuIiIiIiIjkEhXdIiIiIiIiIrlERbeIiIiIiIhILlHRLSIiIiIiIpJLXIwOkNvS0tK4cOEC3t7emEwmo+OIiIgAYDabuXHjBoGBgTg56XfgD6LPchERsUeZ/SzP90X3hQsXKFu2rNExRERE7ik6OpoyZcoYHcOu6bNcRETs2cM+y/N90e3t7Q1YvhE+Pj4GpxEREbGIj4+nbNmy1s8puT99louIiD3K7Gd5vi+604eh+fj46INaRETsjj0Nl75x4wbDhw9n+fLlXL58mVq1avHvf/+bOnXqALBs2TI+//xzdu/ezbVr19izZw+PPvroA885c+ZM+vTpk+E2d3d3bt++nelc+iwXERF79rDPck0iExEREQD69evHhg0bmDNnDvv376dZs2Y0bdqU8+fPA3Dz5k0aNGjA+PHjs3ReHx8fLl68aL2cPXs2N+KLiIjYpXzf6RYREZGHu3XrFkuXLmXlypU0bNgQgPfff5/Vq1czbdo0xowZQ48ePQA4c+ZMls5tMpnw9/e3dWQRERGHoE63iIiIkJKSQmpqKh4eHhlu9/T0ZMuWLTk6d0JCAkFBQZQtW5Z27dpx8ODBHJ1PRETEkajTLSJiZ1JTU0lOTjY6huSQq6srzs7ORsfING9vb8LDwxk9ejRVq1bFz8+PBQsWEBkZSaVKlbJ93ipVqvD1119Ts2ZN4uLimDhxIhERERw8ePC+K70mJSWRlJRk/To+Pj5Tz6X3jmSVo71PRcQxqegWEbETZrOZmJgYYmNjjY4iNlKkSBH8/f3tarG0B5kzZw59+/aldOnSODs789hjj9GtWzd2796d7XOGh4cTHh5u/ToiIoKqVavyxRdfMHr06Hs+Zty4cYwcOTLTz6H3juSEo71PRcTxqOgWEbET6UVDqVKlKFSokH4AdGBms5nExEQuX74MQEBAgMGJMic4OJjNmzdz8+ZN4uPjCQgIoEuXLlSsWNFmz+Hq6kqtWrU4ceLEfY8ZNmwYgwcPtn6dviXL/ei9I9nhqO9TEXE8KrpFROxAamqqtWgoXry40XHEBjw9PQG4fPkypUqVcqghrF5eXnh5eXH9+nXWr1/PhAkTbHbu1NRU9u/fT6tWre57jLu7O+7u7pk+n947kl2O/D4VEceholtExA6kz0MtVKiQwUnEltL/PpOTkx3ih/n169djNpupUqUKJ06cYOjQoYSGhlr32b527RpRUVFcuHABgKNHjwLg7+9vXZ28Z8+elC5dmnHjxgEwatQo6tWrR6VKlYiNjeXDDz/k7Nmz9OvXzyaZ9d6RnHK096mIOB6tXi4iYkc0LDZ/cbS/z7i4OF577TVCQ0Pp2bMnDRo0YP369bi6ugKwatUqatWqRevWrQHo2rUrtWrV4vPPP7eeIyoqiosXL1q/vn79Oi+//DJVq1alVatWxMfHs3XrVqpVq2bT7I72vRb7oX87IpLbTGaz2Wx0iNwUHx+Pr68vcXFx+Pj4GB1HROSebt++zenTp6lQocJdWzaJ43rQ36s+nzLvQd8rvXckp/RvSESyK7Of5ep0i4iIXSlfvjyffPKJ0TFEREREbEJFt4iIZIvJZHrg5f3338/WeXfu3Mkrr7ySo2xPPfUUgwYNytE5RHJLbr130s+9YsWKTB//6quv4uzszJIlS7L9nCIi8mBaSE1ERLLlz/N2Fy1axIgRI6wLawEULlzYet1sNpOamoqLy8M/dkqWLGnboCJ2JivvndyUmJjIwoULeeutt/j66695/vnn8+R57+fOnTu4ubkZmkFEJDeo0y0iItmSvmK1v78/vr6+mEwm69dHjhzB29ub7777jtq1a+Pu7s6WLVs4efIk7dq1w8/Pj8KFC1OnTh1++OGHDOf96/Byk8nEf/7zHzp06EChQoUICQlh1apVOcq+dOlSqlevjru7O+XLl+ejjz7KcP9nn31GSEgIHh4e+Pn50alTJ+t933zzDWFhYXh6elK8eHGaNm3KzZs3c5RHCpYHvXf8/f1ZuHAhVatWxcPDg9DQUD777DPrY+/cucOAAQMICAjAw8ODoKAg60rx5cuXB6BDhw6YTCbr1/ezZMkSqlWrxttvv83PP/9MdHR0hvuTkpL45z//SdmyZXF3d6dSpUpMnz7dev/Bgwd59tln8fHxwdvbmyeffJKTJ08C9x5t0r59e3r37m39unz58owePZqePXvi4+NjHeHyz3/+k8qVK1OoUCEqVqzI8OHDravUp1u9ejV16tTBw8ODEiVK0KFDB8CyWn6NGjXueq2PPvoow4cPf+D3Q0Qkt6jTLSJih8xmSEw05rkLFQJbLeb79ttvM3HiRCpWrEjRokWJjo6mVatWjB07Fnd3d2bPnk2bNm04evQo5cqVu+95Ro4cyYQJE/jwww+ZMmUK3bt35+zZsxQrVizLmXbv3k3nzp15//336dKlC1u3bqV///4UL16c3r17s2vXLgYOHMicOXOIiIjg2rVr/PLLL4ClQ9mtWzcmTJhAhw4duHHjBr/88gv5fE1Sh2M2m0lMzvs3UCHXQjleCXvevHmMGDGCTz/9lFq1arFnzx5efvllvLy86NWrF5MnT2bVqlUsXryYcuXKER0dbS2Wd+7cSalSpZgxYwYtWrR46PZX06dP58UXX8TX15eWLVsyc+bMDIVpz549iYyMZPLkyTzyyCOcPn2aq1evAnD+/HkaNmzIU089xaZNm/Dx8eHXX38lJSUlS6934sSJjBgxgvfee896m7e3NzNnziQwMJD9+/fz8ssv4+3tzVtvvQXAmjVr6NChA++88w6zZ8/mzp07rF27FoC+ffsycuRIdu7cSZ06dQDYs2cP+/btY9myZVnKJiL5U5o5DSdT3vaeVXRnktkMQ4bAkSPw9dfg52d0IhHJzxITIY9GmN4lIQG8vGxzrlGjRvHMM89Yvy5WrBiPPPKI9evRo0ezfPlyVq1axYABA+57nt69e9OtWzcAPvjgAyZPnsyOHTto0aJFljNNmjSJJk2aWIuLypUrc+jQIT788EN69+5NVFQUXl5ePPvss3h7exMUFEStWrUAS9GdkpLCc889R1BQEABhYWFZziC5KzE5kcLj8v4NlDAsAS+3nL153nvvPT766COee+45ACpUqMChQ4f44osv6NWrF1FRUYSEhNCgQQNMJpP13yH8b2pGkSJFrPum38/x48fZtm2btRB98cUXGTx4MO+++y4mk4ljx46xePFiNmzYQNOmTQGoWLGi9fFTp07F19eXhQsXWreUq1y5cpZfb+PGjXnzzTcz3Pbuu+9ar5cvX54hQ4ZYh8EDjB07lq5duzJy5Ejrcen/r5QpU4bmzZszY8YMa9E9Y8YMGjVqlCG/iBRM129dp/X81gwOH0ynap0e/gAbMXR4+Y0bNxg0aBBBQUF4enoSERHBzp07rfebzWZGjBhBQEAAnp6eNG3alOPHjxuS1WSC5cth7Vr407QrERF5gMcffzzD1wkJCQwZMoSqVatSpEgRChcuzOHDh4mKinrgeWrWrGm97uXlhY+PD5cvX85WpsOHD1O/fv0Mt9WvX5/jx4+TmprKM888Q1BQEBUrVqRHjx7MmzePxP8OO3jkkUdo0qQJYWFhPP/883z11Vdcv349WzlE/urmzZucPHmSl156icKFC1svY8aMsQ7b7t27N3v37qVKlSoMHDiQ77//PlvP9fXXX9O8eXNKlCgBQKtWrYiLi2PTpk0A7N27F2dnZxo1anTPx+/du5cnn3zSWnBn11//jwDLPPf69evj7+9P4cKFeffddzP8H7F3716aNGly33O+/PLLLFiwgNu3b3Pnzh3mz59P3759c5RTRBzftVvXaDqnKZHnIvnHd//g5p28mxpmaKe7X79+HDhwgDlz5hAYGMjcuXNp2rQphw4donTp0kyYMIHJkycza9YsKlSowPDhw2nevDmHDh0yZB/FypXh9Gk4fhwaNszzpxeRAqRQIUvH2ajnthWvv7TMhwwZwoYNG5g4cSKVKlXC09OTTp06cefOnQee568/2JtMJtLS0mwX9E+8vb357bff+Omnn/j+++8ZMWIE77//Pjt37qRIkSJs2LCBrVu38v333zNlyhTeeecdtm/fToUKFXIlj2RdIddCJAzL+zdQIdecvXkS/vum/+qrr6hbt26G+9KHij/22GOcPn2a7777jh9++IHOnTvTtGlTvvnmm0w/T2pqKrNmzSImJibD4oapqal8/fXXNGnSBE9Pzwee42H3Ozk53TXt4q/zsuHu/yMiIyPp3r07I0eOpHnz5tZu+p/XXXjYc7dp0wZ3d3eWL1+Om5sbycnJGdZlEJGC52riVZrObsrvl36nRKESrH9xfY5HJmWFYUX3rVu3WLp0KStXrqThfyvY999/n9WrVzNt2jRGjx7NJ598wrvvvku7du0AmD17Nn5+fqxYsYKuXbvmeeaQEFi/Ho4dy/OnFpECxmSy3RBve/Lrr7/Su3dv66JHCQkJnDlzJk8zVK1alV9//fWuXJUrV7YWNi4uLjRt2pSmTZvy3nvvUaRIETZt2sRzzz2HyWSifv361K9fnxEjRhAUFMTy5csZPHhwnr4OuT+TyZSnP0zZip+fH4GBgZw6dYru3bvf9zgfHx+6dOlCly5d6NSpEy1atODatWsUK1YMV1dXUlNTH/g8a9eu5caNG+zZsyfDvO8DBw7Qp08fYmNjCQsLIy0tjc2bN1uHl/9ZzZo1mTVrFsnJyffsdpcsWTLDKu2pqakcOHCAp59++oHZtm7dSlBQEO+88471trNnz9713Bs3bqRPnz73PIeLiwu9evVixowZuLm50bVr14cW6iKSf12+eZmms5uy//J+/Lz82NhzI9VLVc/TDIYV3SkpKaSmpt7Vsfb09GTLli2cPn2amJiYDP/R+/r6UrduXSIjI+9bdCclJZGUlGT9Oj4+3maZ06cqGTTCXUTE4YWEhLBs2TLatGmDyWRi+PDhudaxvnLlCnv37s1wW0BAAG+++SZ16tRh9OjRdOnShcjISD799FPrCtHffvstp06domHDhhQtWpS1a9eSlpZGlSpV2L59Oxs3bqRZs2aUKlWK7du3c+XKFapWrZorr0EKnpEjRzJw4EB8fX1p0aIFSUlJ7Nq1i+vXrzN48GAmTZpEQEAAtWrVwsnJiSVLluDv70+RIkUAyxzojRs3Ur9+fdzd3SlatOhdzzF9+nRat26dYX0FgGrVqvHGG28wb948XnvtNXr16kXfvn2tC6mdPXuWy5cv07lzZwYMGMCUKVPo2rUrw4YNw9fXl23btvHEE09QpUoVGjduzODBg1mzZg3BwcFMmjSJ2NjYh77+kJAQoqKiWLhwIXXq1GHNmjUsX748wzHvvfceTZo0ITg4mK5du5KSksLatWv55z//aT2mX79+1vflX3/JJiIFR0xCDE1mN+HQlUMEFA5gU69NhJYIzfMchs3p9vb2Jjw8nNGjR3PhwgVSU1OZO3cukZGRXLx4kZiYGMDyW98/8/Pzs953L+PGjcPX19d6KVu2rM0yh4RY/lSnW0QkeyZNmkTRokWJiIigTZs2NG/enMceeyxXnmv+/PnUqlUrw+Wrr77iscceY/HixSxcuJAaNWowYsQIRo0aZd3KqEiRIixbtozGjRtTtWpVPv/8cxYsWED16tXx8fHh559/plWrVlSuXJl3332Xjz76iJYtW+bKa5CCp1+/fvznP/9hxowZhIWF0ahRI2bOnGmdvuDt7c2ECRN4/PHHqVOnDmfOnGHt2rU4OVl+pPvoo4/YsGEDZcuWtS4A+GeXLl1izZo1dOzY8a77nJyc6NChg3VbsGnTptGpUyf69+9PaGgoL7/8snV7vOLFi7Np0yYSEhJo1KgRtWvX5quvvrJ2vfv27UuvXr3o2bOndRGzh3W5Adq2bcsbb7zBgAEDePTRR9m6detdW3099dRTLFmyhFWrVvHoo4/SuHFjduzYkeGYkJAQIiIiCA0NvWuovogUDBduXOCpmU9x6MohSnuXZnPvzYYU3AAms4H7nJw8eZK+ffvy888/4+zszGOPPUblypXZvXs306dPp379+ly4cIGAgADrYzp37ozJZGLRokX3POe9Ot1ly5YlLi4OHx+fHOU9dQqCg8Hd3bKysJN2ORcRG7l9+zanT5+mQoUKhqxZIbnjQX+v8fHx+Pr62uTzKb970PdK7x25F7PZTEhICP3793/o1A/9GxLJf87Fn6PxrMYcv3acsj5l+bHXjwQXC7b582T2s9zQsjE4OJjNmzeTkJBAdHQ0O3bsIDk5mYoVK1q3urh06VKGx1y6dOmB22C4u7vj4+OT4WIr5cqBqyskJcF/t8QUERERETty5coVPv30U2JiYu4771tE8q+zsWdpNLMRx68dp3yR8mzuvTlXCu6ssIterZeXFwEBAVy/fp3169fTrl07KlSogL+/Pxs3brQeFx8fz/bt2wkPDzckp4uLpdMNGmIuIiIiYo9KlSrFqFGj+PLLL+85p11E8q/T10/TaGYjTl0/RcWiFdncezMVihq/u4ihW4atX78es9lMlSpVOHHiBEOHDiU0NJQ+ffpgMpkYNGgQY8aMISQkxLplWGBgIO3btzcsc0gIHDliWUztmWcMiyEiIiIi92DgzEkRMdCJaydoPKsx0fHRVCpWiR97/UgZnzJGxwIMLrrj4uIYNmwY586do1ixYnTs2JGxY8daF+F46623uHnzJq+88gqxsbE0aNCAdevWGTrfJn0Fc3W6RUREREREjHfsj2M0ntWY8zfOU6V4FTb12kSgd6DRsawMLbo7d+5M586d73u/yWRi1KhRjBo1Kg9TPVj6CubaNkxEcoM6NPmL/j7zjr7Xkl36tyPi2I5cPULjWY25mHCRaiWrsbHnRvwL338NMCPYxZxuR6JOt4jkhvQRPomJiQYnEVtK//tM//sV29N7R3JK71MRx3Xw8kEazWzExYSLhJUK48deP9pdwQ0Gd7odUXqn+/RpSE62rGYuIpJTzs7OFClShMuXLwNQqFAhTCaTwakku8xmM4mJiVy+fJkiRYrg7OxsdKR8S+8dyS69TwumxOREzsaepWrJqkZHkRzad2kfTWY34WriVR7xe4Qfev5AiUIljI51Tyq6sygwEAoVsuzTffr0/zrfIiI5lb4dYnrxII6vSJEiD9zmUmxD7x3JCb1PC47rt67TYEYDDl05xK99fyWibITRkSSb9lzcQ9M5Tbl26xqPBTzGhh4bKOZZzOhY96WiO4ucnKBSJdi3zzKvW0W3iNiKyWQiICCAUqVKkZycbHQcySFXV1d1zvKI3juSXXqfFhxJKUl0WNSBQ1cOATBjzwwV3Q5q94XdPDPnGa7fvk6dwDqsf3E9RT3te3tAFd3ZULmypeg+dgxatzY6jYjkN87OzvohUCQb9N4RkXtJM6fRe2VvNp/djIuTCylpKSw9vJSprafi5uxmdDzJgu3nttN8bnPikuIILxPOd92/w9fD1+hYD6WF1LJBK5iLiIiIiDiGYT8MY+GBhbg4ufBtt28JKBzA9dvXWX9ivdHRJAu2Rm/lmTnPEJcUR4NyDVj/4nqHKLhBRXe2aAVzERERERH7N3XHVCZsnQDAf9r8h+aVmtOlehcAFhxYYGQ0yYJfzv5C87nNuXHnBo2CGvFd9+/wdvc2OlamqejOBnW6RURERETs26qjqxi4biAAo54aRa9HewHQLawbACuPruTmnZuG5ZPM+enMT7SY14KEOwk0rtCYNS+sobBbYaNjZYmK7mxI73RHRcGtW8ZmERERERGRjLaf207Xb7qSZk6jX61+vNvwXet9dQLrEFw0mMTkRFYfW21gSnmYH079QKt5rUhMTqRZcDO+7fYtXm5eRsfKMhXd2VCiBPj+d/rAyZPGZhERERERkf85ee0kbRa04VbKLVpUasFnrT/DZDJZ7zeZTHSt0RXQEHN7tv7EeuvfY6uQVqzsuhJPV0+jY2WLiu5sMJk0r1tERERExN5cTbxKy3ktuZJ4hVr+tVjcaTGuzq53HdethmWI+XfHv+P6ret5HVMeYs2xNbRd2JbbKbdpU7kNyzovw8PFw+hY2aaiO5s0r1tERERExH7cSr5F2wVtOX7tOEG+Qax5Yc19F9uqXqo6YaXCSE5LZtnhZXmcVB5k1dFVdFjUgTupd+gQ2oFvOn+Du4u70bFyREV3NqnTLSIiIiJiH1LTUum+rDuR5yIp4lGE77p/R4B3wAMfoyHm9mfZ4WV0XNyR5LRknq/2PIs6LcoXe6mr6M6m9KJbnW4REREREeOYzWYGrx/M8iPLcXN2Y2XXlVQtWfWhj0svun888yMxCTG5HVMeYvHBxXRe0pmUtBS61ejG/I7z7zk1wBGp6M6m9OHl6nSLiIiIiBjn420fM3nHZABmtZ9Fw6CGmXpcxaIVqVu6LmnmNBYfXJybEeUh5u+fT7el3Ug1p9KjZg/mdJiDi5OL0bFsRkV3NqUX3ZcuQXy8sVlERERERAqiJQeX8Ob3bwIwoekEa/c6s9IXVNMQc+PM/n02PZb3IM2cRu9HezOj3QycnZyNjmVTKrqzydcXSpWyXNcQcxERERGRvLUlags9lvcA4LU6rzEkYkiWz9G5emecTE5sO7eN09dP2zqiPMTXe76m94repJnTePmxl5nednq+K7hBRXeOaF63iIiIiEjeO3L1CG0XtCUpNYl2Vdrx7xb/zrAXd2YFeAfwVPmnAFh0cJGNU8qDfLn7S15a9RJmzPz98b/z+bOf42TKn+Vp/nxVeUTzukVERERE8lZMQgwt57Xk+u3r1C1dl/kd5+eoO6oh5nlv6o6pvPrtqwAMfGIgU1tNzbcFN6jozhF1ukVERERE8k7CnQSenf8sZ2LPEFw0mNXdVlPItVCOztmxakdcnVzZd2kfh64cslFSuZ9/b/s3A74bAMDgeoP5pMUn2Rql4EhUdOeAOt0iIpKf3Lhxg0GDBhEUFISnpycRERHs3LnTev+yZcto1qwZxYsXx2QysXfv3kydd8mSJYSGhuLh4UFYWBhr167NpVcgIvlZSloKXb7pwu6LuylRqATfdf+Okl4lc3zeop5FaVGpBQAL9qvbnZs+2voRg9YPAuCf9f/JxGYT833BDSq6cyS9033sGJjNxmYRERHJqX79+rFhwwbmzJnD/v37adasGU2bNuX8+fMA3Lx5kwYNGjB+/PhMn3Pr1q1069aNl156iT179tC+fXvat2/PgQMHcutliEg+ZDabeW3Na6w9vhYPFw9Wd1tNSPEQm53/z0PMzfrBPlf835b/Y8gGy2J37z75LuOajCsQBTeAyZzP/1XFx8fj6+tLXFwcPj4+Nj13YiJ4eVmuX7kCJUrY9PQiIpKP5ebnU3bcunULb29vVq5cSevWra23165dm5YtWzJmzBjrbWfOnKFChQrs2bOHRx999IHn7dKlCzdv3uTbb7+13lavXj0effRRPv/880xls7fvlYjkvQ9++YB3Nr2DCRNLOy+lQ9UONj3/zTs3KTWxFInJiezot4M6pevY9PwF3ejNoxnx0wgA3m/0Pu899Z7BiWwjs59P6nTnQKFCULas5brmdYuIiCNLSUkhNTUVDw+PDLd7enqyZcuWbJ83MjKSpk2bZritefPmREZGZvucIlKwzN03l3c2vQPAv1v82+YFN4CXmxdtq7QFtKCaLZnNZt778T1rwT3m6TH5puDOChXdOaR53SIikh94e3sTHh7O6NGjuXDhAqmpqcydO5fIyEguXryY7fPGxMTg5+eX4TY/Pz9iYmLu+5ikpCTi4+MzXESkYNp0ehN9V/YF4M3wN/lH3X/k2nOlDzFfdHARqWmpufY8BYXZbObdTe8y6udRAIxvOp53Gr5jcCpjqOjOIa1gLiIi+cWcOXMwm82ULl0ad3d3Jk+eTLdu3XByytsfF8aNG4evr6/1UjZ9WJmIFCj7L+2nw6IOJKcl07l6ZyY8MyFXn695cHOKeBThwo0L/BL1S64+V35nNpv55w//5IMtHwAwqdkk3qr/lsGpjKOiO4fU6RYRkfwiODiYzZs3k5CQQHR0NDt27CA5OZmKFStm+5z+/v5cunQpw22XLl3C39//vo8ZNmwYcXFx1kt0dHS2n19EHNP5+PO0mt+K+KR4niz3JLPaz8r1fZzdXdzpWLUjoFXMc8JsNjN4/WA+3PohAJNbTOaN8DcMTmUsFd05pE63iIjkN15eXgQEBHD9+nXWr19Pu3btsn2u8PBwNm7cmOG2DRs2EB4eft/HuLu74+Pjk+EiIgVHfFI8rea34lz8OUJLhLKi6wo8XDwe/kAbSB9i/s3hb7iTeidPnjM/MZvNDPxuIJ9s/wSAz1p9lqtTAhyFi9EBHN2fO91mMxSQVe9FRCQfWr9+PWazmSpVqnDixAmGDh1KaGgoffr0AeDatWtERUVx4cIFAI4ePQpYutnpneuePXtSunRpxo0bB8Drr79Oo0aN+Oijj2jdujULFy5k165dfPnllwa8QhGxd8mpyXRa3Il9l/bh5+XHd92/o5hnsTx7/qfKP4V/YX9iEmLYcHIDrSu3fviDBIA0cxqvrXmNz3d/jgkTXzz7BS/XftnoWHZBne4cqlABnJ0t24f992cQERERhxQXF8drr71GaGgoPXv2pEGDBqxfvx5XV1cAVq1aRa1ataxbinXt2pVatWpl2PorKioqw8JrERERzJ8/ny+//JJHHnmEb775hhUrVlCjRo28fXEiYvfMZjMvr36ZDac24OXqxZoX1lC+SPk8zeDs5Eznap0BrWKeFWnmNF5d/aq14P663dcquP9E+3TbQKVKcPIk/PgjPPVUrjyFiIjkM9p7OvP0vRIpGN778T1G/TwKZ5Mzq7qtolVIK0NyREZHEvF1BF6uXlweeplCroUMyeEozGYzL616iRl7Z+BkcmJW+1m8WPNFo2PlCe3TnYfS53VrMTURERERkayb/tt069ZS01pPM6zgBqhXph7li5TnZvJNvj32rWE5HMWGUxuYsXcGziZn5j03r8AU3FmhotsG0ud1azE1EREREZGsWXdiHa9++yoA7zz5juHDkk0mE12rdwU0xDwzPor8CID+dfrTtUZXg9PYJxXdNqBOt4iIiIhI1u25uIfnlzxPqjmVHjV7MPrp0UZHAqBbmGUV87XH1xJ7O9bYMHZs36V9fH/ye5xMTrxRr2BvC/YgKrptQJ1uEREREZGsORt7llbzW5FwJ4EmFZrwn7b/wWQnWwGFlQqjWslq3Em9w4ojK4yOY7fSu9ydqnWiQtEKBqexXyq6bSC9033yJKSmGptFRERERMTeXb91nZbzWhKTEENYqTCWdl6Km7Ob0bGsTCaTdc9uDTG/t3Px55i/fz4AQ8KHGJzGvqnotoGyZcHNDe7cgagoo9OIiIiIiNivpJQkOizqwOGrhyntXZq13dfi6+FrdKy7pM9P3nhqI5dvXjY4jf2Zsn0KKWkpNAxqSJ3SdYyOY9dUdNuAs7Nl2zDQvG4RERERkftJM6fRe2VvNp/djI+7D2u7r6WMTxmjY91TpWKVqBNYh1RzKksOLjE6jl2JT4rn892fA/Bm+JsGp7F/KrptRPO6RUREREQebNgPw1h4YCEuTi4s67yMmn41jY70QBpifm/Tf5tOfFI8lYtX5tnKzxodx+6p6LYRrWAuIiIiInJ/U3dMZcLWCQBMbzudJhWbGJzo4brU6IIJE79G/0pUnOaRAiSnJvPJ9k8AS5fbyaSS8mH0HbIRdbpFRERERO5t1dFVDFw3EIDRT4+m5yM9DU6UOYHegTQq3wiAhQcWGpzGPnxz6Bui4qIoWagkPWr2MDqOQ1DRbSPqdIuIiIiI3G37ue10/aYraeY0+tXqxztPvmN0pCzREPP/MZvNTIycCMCAJwbg6eppcCLHoKLbRtI73WfOWFYxFxEREREp6E5eO0mbBW24lXKLlpVaMu3ZaXazF3dmdazaERcnF/bG7OXI1SNGxzHUT2d+4reLv+Hh4kH/Ov2NjuMwVHTbSEAAeHlBWhqcOmV0GhERERERY11NvErLeS25kniFxwIeY/Hzi3FxcjE6VpYVL1Sc5sHNAViwv2B3uz+K/AiAPo/2oUShEgancRwqum3EZNK8bhERERGxDbPZzIHLBzh05RC3km8ZHSfLbiXfou2Cthy/dpwg3yDWvLCGwm6FjY6VbX8eYm42mw1OY4xDVw6x5vgaTJh4o94bRsdxKI73qyY7Vrky7N2red0iIiIikn0paSm8vPplZu6dab0t0DuQikUrElw0mIpFK1ovwUWDKeVVyq6GbKempdJ9WXciz0VS1KMo33X/Dv/C/kbHypF2oe3wdPHk+LXj/HbxN2oH1jY6Up6bFDkJgPah7QkpHmJwGseiotuG1OkWERERkZxISkmi29JuLD+yHGeTM15uXsQnxXPhxgUu3LjAlqgtdz2mkGuh+xbk5YuUx93FPc/ym81mBq8fzPIjy3FzdmNl15VULVk1z54/txR2K0ybKm1YfHAxCw4sKHBFd0xCDHP2zQFgSMQQg9M4HhXdNqQVzEVEREQku27euUmHRR3YcGoDbs5uLO60mLZV2nLt1jVOXT/FqeunOHn9pPX6qeuniI6PJjE5kQOXD3Dg8oG7zmnCRGmf0ncV5enXSxQqYdMu+cfbPmbyjskAzG4/myeDnrTZuY3WrUY3Fh9czKKDi5jwzIQCtT/1pzs+5U7qHcLLhBNRNsLoOA5HRbcNqdMtIiIiItlx/dZ1Ws9vTeS5SLxcvVjZdSVNKjYBLAt5FS9UnDql69z1uDupdzgbe/aeRfnJ6ydJuJPAufhznIs/x89nf77r8YXdCt+3IA8qEoSbs1umX8OSg0t48/s3AfjwmQ/pUqNLNr8b9qlFpRb4uPtwLv4cW6K20DCoodGR8sTNOzf5bOdnALwZ/qbBaRyTim4bSu90nzsHiYlQqJCxeURERETE/l1KuESzuc3Yd2mfdQ503TJ1M/VYN2c3QoqH3HOOrdls5mri1ft2yc/FnyPhTgL7Lu1j36V9dz3eyeREGZ8y9xy2XrFoRYp5FrN2ybdEbaHH8h4ADKgzIF8WZx4uHjxX9Tlm7p3Jgv0LCkzRPWPvDK7fvk7FohVpH9re6DgOSUW3DRUvDsWKwbVrcOIE1KxpdCIRERERsWdnY8/yzJxnOH7tOP6F/fn+xe8J8wuzyblNJhMlvUpS0qvkPYv42ym3rV3yvxbkJ6+fJDE5kai4KKLiovjxzI93Pd7H3cdagG86vYmk1CTaVWnHJy0+sauF3WypW41uzNw7kyWHljC55WRcnV2NjpSrUtNSrQuoDa43GGcnZ4MTOSYV3TYWEgLbt1vmdavoFhEREZH7OXL1CM/MeYZz8ecoX6Q8P/T4geBiwXn2/B4uHlQpUYUqJarcdZ/ZbObyzcv3HbZ+4cYF4pPi2ROzhz0xewCoW7ou8zvOz9eFWeMKjSnlVYrLNy/zw6kfaBnS0uhIuWr5keWcjj1NMc9i9H60t9FxHJaKbhurXNlSdGtet4iIiIjcz56Le2g+tzlXEq9QtURVNvTYQGmf0kbHsjKZTPgV9sOvsB/hZcPvuv9W8i3OxJ6xFuGxt2N5rc5rFHLN3/MrXZxceL7a80zdOZUFBxbk66LbbDYzcetEAPo/3h8vNy+DEzkuFd02lr6YmlYwFxEREZF72RK1hdbzWxOfFE/tgNqse3EdJQqVMDpWlni6elK1ZNV8sR1YVnWr0Y2pO6ey4sgKbiXfwtPV0+hIuWJr9Fa2n9+Om7MbA54YYHQch1Zw1rnPI+mLqanTLSIiIiJ/te7EOprNaUZ8UjwNgxqyqdcmhyu4C7rwsuGU8y3HjTs3WHt8rdFxcs3ESEuXu2fNnvgV9jM4jWNT0W1j6nSLiIiIyL0sObiEtgvacivlFq1CWrGu+zp83H2MjiVZ5GRyomv1rgAsOLDA4DS549gfx1h5ZCUAg8MHG5zG8anotrH0ovvKFYiNNTSKiIiIiNiJ6b9Np+vSriSnJdO1RleWd1meb4clFwTdwroB8O2xb4lPijc4je19HPkxZsw8W/nZAjmFwNZUdNuYtzf4+1uua4i5iIiIiEyKnES/1f1IM6fxau1XmdthLm7ObkbHkhx4xO8RQkuEkpSaxIojK4yOY1NXbl5h5u8zARgSPsTYMPmEiu5coHndIiIiImI2mxnx4wje/P5NAN6KeItprafl6y21CgqTyUS3GpZud34bYv7Zzs+4nXKb2gG1aRjU0Og4+YKK7lyged0iIiIiBVuaOY3X173O6J9HAzCuyTjGPzMek8lkcDKxlfSie8PJDVy5ecXgNLZxK/kWn+78FIAhEUP079VGVHTnAnW6RURERAqulLQU+qzsw5QdUwCY2moqbzd42+BUYmshxUOoHVCbVHMq3xz6xug4NjH799lcTbxKOd9ydKrWyeg4+YahRXdqairDhw+nQoUKeHp6EhwczOjRozGbzdZjzGYzI0aMICAgAE9PT5o2bcpxO69m1ekWERERKZhup9zm+SXPM/v32TibnJnbYS796/Q3Opbkkvw0xDzNnMZHkR8B8Ea9N3BxcjE4Uf5haNE9fvx4pk2bxqeffsrhw4cZP348EyZMYMqUKdZjJkyYwOTJk/n888/Zvn07Xl5eNG/enNu3bxuY/MH+3On+0+8PRERERCQfS7iTwLPzn2XFkRW4O7uzvMtyutfsbnQsyUVdanTBhIlfon4hOi7a6Dg5svroao5fO46vuy8v1XrJ6Dj5iqFF99atW2nXrh2tW7emfPnydOrUiWbNmrFjxw7A0uX+5JNPePfdd2nXrh01a9Zk9uzZXLhwgRUrVhgZ/YGCg8Fkgrg4y9ZhIiIiIpK/Xbt1jWfmPMPG0xsp7FaY77p/R5sqbYyOJbmsjE8Zngx6EoBFBxcZnCZn0rvcf3v8b3i7exucJn8xtOiOiIhg48aNHPvvOOzff/+dLVu20LJlSwBOnz5NTEwMTZs2tT7G19eXunXrEhkZaUjmzPDwgHLlLNftfCS8iIiIiORQTEIMT818im3ntlHMsxgbe27k6QpPGx1L8kh+GGK+/dx2fon6BVcnV/7xxD+MjpPvGFp0v/3223Tt2pXQ0FBcXV2pVasWgwYNont3yzCcmJgYAPz8/DI8zs/Pz3rfXyUlJREfH5/hYgTN6xYRERHJ/87EnuHJGU+y//J+AgoHsLn3Zp4o/YTRsSQPdarWCWeTM79d/I1jfzjmD//pXe4Xwl6gtE9pg9PkP4YW3YsXL2bevHnMnz+f3377jVmzZjFx4kRmzZqV7XOOGzcOX19f66Vs2bI2TJx56fO6VXSLiIiI5E+HrxymwdcNOHHtBBWKVOCXPr9Qo1QNo2NJHitRqATPBD8DwIL9jtftPnX9FEsPLwXgzfA3DU6TPxladA8dOtTa7Q4LC6NHjx688cYbjBs3DgB/f38ALl26lOFxly5dst73V8OGDSMuLs56iY42ZkGD9E63hpeLiIiI5D+/XfyNhjMbcv7GeaqVrMaWvlsILhZsdCwxyJ+HmJsdbCXlT7Z9Qpo5jebBzQnzCzM6Tr5kaNGdmJiIk1PGCM7OzqSlpQFQoUIF/P392bhxo/X++Ph4tm/fTnh4+D3P6e7ujo+PT4aLEdTpFhERR3Pjxg0GDRpEUFAQnp6eREREsHPnTuv92dnG8/3338dkMmW4hIaG5vZLEclVv5z9hadnPc3VxKs8Hvg4P/f+mUDvQKNjiYHah7bHw8WDo38cZW/MXqPjZNq1W9eYvmc6AEMihhicJv8ytOhu06YNY8eOZc2aNZw5c4bly5czadIkOnToAIDJZGLQoEGMGTOGVatWsX//fnr27ElgYCDt27c3MvpDpXe6T5yA//4OQURExK7169ePDRs2MGfOHPbv30+zZs1o2rQp58+fB7K/jWf16tW5ePGi9bJly5a8eDkiuWLt8bU0m9uM+KR4GgU1YmPPjRQvVNzoWGIwH3cfWoe0BhxrQbXPd31OYnIiNf1q0qRCE6Pj5FuGFt1TpkyhU6dO9O/fn6pVqzJkyBBeffVVRo8ebT3mrbfe4h//+AevvPIKderUISEhgXXr1uHh4WFg8ocrXx5cXODWLfjvzyoiIiJ269atWyxdupQJEybQsGFDKlWqxPvvv0+lSpWYNm1ajrbxdHFxwd/f33opUaJE3rwoERtbdGAR7Ra243bKbZ6t/Czfdf8OH3djRlWK/UkfYr7wwELSzPbfdUtKSWLy9skADAkfgslkMjhR/mVo0e3t7c0nn3zC2bNnuXXrFidPnmTMmDG4ublZjzGZTIwaNYqYmBhu377NDz/8QOX0sdt2zNUVKlSwXNe8bhERsXcpKSmkpqbe9UttT09PtmzZkqNtPI8fP05gYCAVK1ake/fuREVF5cprEMlNX+3+im5Lu5GSlsILYS+wrPMyPF09jY4ldqRVSCu83byJjo8mMtp+tzdON2//PC7dvERp79J0qdHF6Dj5mqFFd36ned0iIuIovL29CQ8PZ/To0Vy4cIHU1FTmzp1LZGQkFy9ezNY2ngB169Zl5syZrFu3jmnTpnH69GmefPJJbty4cd/H2Mv2nyLpJm6dyCvfvoIZM3+r/TfmdJiDq7Or0bHEzni6etKhqmWarL0PMU8zpzFx60QAXq/7Om7Obg95hOSEiu5cpBXMRUTEkcyZMwez2Uzp0qVxd3dn8uTJdOvW7a5FT7OiZcuWPP/889SsWZPmzZuzdu1aYmNjWbx48X0fYy/bf4qYzWbe3fQuQzcMBeDt+m/zWevPcDLpR2i5t/Qh5ksOLSElLcXgNPe37sQ6Dl89jLebN6/UfsXoOPme/sfIRep0i4iIIwkODmbz5s0kJCQQHR3Njh07SE5OpmLFitnaxvNeihQpQuXKlTlx4sR9j7GX7T+lYEszp/GP7/7B2F/GAjCuyTjGNR2nea/yQE0qNKFEoRJcvnmZTac3GR3nvj6K/AiAlx97GV8PX4PT5H8qunOROt0iIuKIvLy8CAgI4Pr166xfv5527dplaxvPe0lISODkyZMEBATc9xh72f5TCq7k1GR6rejF1J1TMWFiWutpvN3gbaNjiQNwdXbl+WrPA/Y7xPy3i7+x6fQmnE3OvF7vdaPjFAgqunNReqf75ElIsd/RJSIiIgCsX7+edevWcfr0aTZs2MDTTz9NaGgoffr0yfQ2nk2aNOHTTz+1fj1kyBA2b97MmTNn2Lp1Kx06dMDZ2Zlu3boZ8ApFHu52ym06LenE3H1zcTY5M/e5ufzt8b8ZHUscSPoQ82WHl3E75cFbKhohvcvdpUYXyvmWMzhNweBidID8rEwZ8PCA27fh7FkIDjY6kYiIyP3FxcUxbNgwzp07R7FixejYsSNjx47F1dWyYNRbb73FzZs3eeWVV4iNjaVBgwZ3beN58uRJrl69av363LlzdOvWjT/++IOSJUvSoEEDtm3bRsmSJfP89Yk8zI2kG7Rf1J5Npzfh4eLBkueX8GzlZ42OJQ6mfrn6lPEpw7n4c3x3/Dvr4mr2ICouikUHFgHwZvibBqcpOExms9lsdIjcFB8fj6+vL3FxcYYMTwsLgwMHYO1aaNkyz59eRETslNGfT45E3yvJC9duXaPVvFZsP7+dwm6FWd1tNU+Vf8roWOKghn4/lImRE3m+2vMsfv7+C0fmtTfXv8mkbZNoXKExG3tufPgD5IEy+/mk4eW5TPO6RUREROzbxRsXaTSzEdvPb6eYZzE29dykgltypFuYZYj56mOruZF0/y0S81Ls7Vi+/O1LQF3uvKaiO5dpBXMRERER+3X6+mkazGjAgcsHCCgcwM+9f6ZO6TpGxxIHV8u/FpWLV+Z2ym1WHl1pdBwAvtr9FQl3EqhWshotKrUwOk6BoqI7l6nTLSIiImKfDl05RIMZDTh1/RQVi1ZkS98tVC9V3ehYkg+YTCbrgmr2sIr5ndQ7/Hv7vwFLl1t7zectfbdzmTrdIiIiIvZn14VdNJzRkAs3LlC9ZHV+6fMLFYtWNDqW5CPpRff3J7/nj8Q/DM2y6MAizt84j5+XH93DuhuapSBS0Z3L0jvdZ89CUpKxWUREREQENp/ZTONZjfnj1h88UfoJNvfeTKB3oNGxJJ+pUqIKtfxrkZKWwjeHvjEsh9lsZmLkRAAG1h2Iu4u7YVkKKhXduczPD7y9wWy27NctIiIiIsZZc2wNLea14MadGzxd/ml+6PEDxQsVNzqW5FNda3QFjB1ivvH0RvZd2kch10Lac94gKrpzmcmked0iIiIiRjObzXwc+THtF7Xndspt2lRuw9rua/F29zY6muRj6UX3z2d/5nz8eUMyTNxq6XK/VOslinkWMyRDQaeiOw9oXreIiIiIcWJvx9JxcUcGfz+YlLQUetTswdLOS/Fw8TA6muRz5XzLUb9sfcyYWXRwUZ4//75L+1h/cj1OJicG1RuU588vFiq680B60a1Ot4iIiEje2n1hN4998RjLjyzHzdmNqa2mMqv9LFydXY2OJgWEkauYT4qcBEDHqh21UKCBVHTngfTh5ep0i4iIiOQNs9nM57s+J+LrCE7HnqZ8kfL82vdX+tfpj8lkMjqeFCDPV38eZ5Mzuy7s4vgfedeFOx9/nvn75wOWbcLEOCq684A63SIiIiJ550bSDbov687f1/ydO6l3aFulLb+98huPBz5udDQpgEp5laJJxSYAeTrEfMqOKSSnJfNkuSepW6Zunj2v3E1Fdx5I73RfuAAJCcZmEREREcnP9l/aT52v6rDgwAKcTc5MfGYiK7qsoKhnUaOjSQH25yHmZrM515/vRtINPt/1OaAutz1Q0Z0HihaFEiUs10+cMDaLiIiISH41c+9M6v6nLkf/OEpp79Js7r2ZNyPe1HByMVyH0A64O7tz6Moh9l/en+vPN33PdOKS4ggpFkKbKm1y/fnkwVR05xHN6xYRERHJHYnJiby08iX6rOzDrZRbNA9uzp5X91C/XH2jo4kA4OvhS6uQVgAs2J+7C6qlpKXw8baPAUuX28mkks9o+hvII5rXLSIiImJ7R68epd5/6vH13q9xMjkx+unRrO2+lpJeJY2OJpJB+hDzhQcX5uoQ828OfUNUXBQlCpWg5yM9c+15JPNUdOcRdbpFREREbGvRgUU8/tXj7L+8Hz8vPzb02MC7Dd9VZ0/s0rOVn6WwW2HOxJ5h27ltufIcZrOZiVsnAjCgzgA8XT1z5Xkka/Q/Uh5Rp1tERETENpJSknhtzWt0XdqVhDsJNApqxJ5X99C4QmOjo4ncl6erJ+1D2wO5t2f3z2d/ZvfF3Xi4eNC/Tv9ceQ7JOhXdeUSdbhEREZGcO339NPW/rs9nuz4D4F8N/sUPPX8gwDvA4GQiD5c+xHzxwcWkpKXY/PwTIy1d7t6P9NYUCzuiojuPVKpk+fOPP+DaNWOziIiIiDiilUdWUuuLWuy+uJtinsVY+8JaxjYZi4uTi9HRRDLlmYrPUNyzOJduXuKnMz/Z9NyHrxzm22PfYsLEG+Fv2PTckjMquvNI4cIQGGi5riHmIiIiIpmXnJrMkO+H0H5Re+KS4qhXph57X91Ly5CWRkcTyRJXZ1c6VesE2H4V80mRkwBoF9qOysUr2/TckjMquvOQ5nWLiIiIZE10XDSNZjbio8iPABhcbzCbe2+mrG9Zg5OJZE/6EPOlh5eSlJJkk3PGJMQwe99sAIaED7HJOcV2VHTnIc3rFhEREcm89SfWU+uLWkSei8TX3ZdlnZfxUfOPcHN2MzqaSLY9GfQkpb1LE5cUx7oT62xyzqk7pnIn9Q51S9clomyETc4ptqOiOw+p0y0iIiLycKlpqQzfNJyW81ryx60/eCzgMXa/spsOVTsYHU0kx5xMTnSp3gWwzSrmN+/ctC4sOCRiCCaTKcfnFNtS0Z2H1OkWERERebCYhBiemfMMY34Zgxkzf3/87/za91eCiwUbHU3EZrrW6ArAqqOrSLiTkKNzzdw7k2u3rlGhSAU6hOoXU/ZIRXceSu90HzsGZrOxWURERETszU9nfqLWF7X48cyPeLl6Mf+5+XzW+jM8XDyMjiZiU48HPk5w0WBupdxi1dFV2T5Paloqk7ZZFlAbHD4YZydnW0UUG1LRnYcqVgQnJ0hIgEuXjE4jIiIiYh/SzGl88MsHNJndhJiEGGqUqsGuV3bRLayb0dFEcoXJZLIuqJaTIeYrjqzg1PVTFPUoSp9H+9gqntiYiu485O4OQUGW6xpiLiIiIgJXE6/Sen5r3tn0DmnmNHo/2pvt/bYTWiLU6GgiuSr9l0rrT6zn2q1r2TpH+qr+/ev0x8vNy2bZxLZUdOex9HndWkxNRERECrrI6EhqfVGLdSfW4eHiwddtv2ZGuxkUci1kdDSRXFetZDVq+tUkOS2ZpYeWZvnxW6O3EnkuEjdnNwY8MSAXEoqtqOjOY3+e1y0iIiJSEJnNZj6O/JiGMxtyLv4clYtXZnu/7fSppeGxUrDkZIj5xK0TAehRswf+hf1tmktsS0V3HlOnW0RERAqy2NuxPLf4OQZ/P5iUtBS6VO/Crpd3UdOvptHRRPJc+irmP535iYs3Lmb6ccf/OM6KIysAywJqYt9UdOcxdbpFRESkoNp9YTePffEYK46swM3ZjamtprKg4wK83b2NjiZiiPJFyhNeJhwzZhYfXJzpx3287WPMmGkd0ppqJavlYkKxBRXdeSy9033iBKSlGZtFREREJC+YzWam7ZxGxNcRnI49Tfki5fm176/0r9Mfk8lkdDwRQ2V1iPmVm1eYsXcGAEMihuRaLrEdFd15LCgIXF0hKQmio41OIyIiIpK7biTdoPuy7vRf2587qXdoV6Udv73yG48HPm50NBG70Ll6Z5xMTmw/v51T10899Phpu6ZxO+U2jwU8RqOgRnmQUHJKRXcec3Gx7NcNmtctIiIi+dv+S/up81UdFhxYgIuTCx81+4jlXZZT1LOo0dFE7IZfYT8aV2gMwMIDCx947K3kW3y641MAhoQP0UgRB6Gi2wCa1y0iIiL53cy9M6n7n7oc/eMoZXzKsLn3ZgaHD1aRIHIPmR1iPmffHK4kXqGcbzk6VeuUF9HEBlR0G0ArmIuIiEh+lZicSN+Vfemzsg+3Um7RPLg5e17dQ0TZCKOjidit56o+h5uzGwcuH+DA5QP3PCbNnMZHkR8BMKjuIFydXfMyouSAim4DqNMtIiIi+dHRq0ep9596zNg7AyeTE2OeHsPa7mspUaiE0dFE7FoRjyK0rNQSgAX7793tXnNsDcf+OIavuy/9HuuXl/Ekh1R0G0CdbhERsUc3btxg0KBBBAUF4enpSUREBDt37rTebzabGTFiBAEBAXh6etK0aVOOZ+LDbOrUqZQvXx4PDw/q1q3Ljh07cvNliEEWHVjE4189zv7L+/Hz8uOHHj/wTsN3cDLpx02RzEgfYr7w4ELMZvNd90+MnAjAq7Vf1TZ7Dkb/CxogvdN96hQkJxubRUREJF2/fv3YsGEDc+bMYf/+/TRr1oymTZty/vx5ACZMmMDkyZP5/PPP2b59O15eXjRv3pzbt2/f95yLFi1i8ODBvPfee/z222888sgjNG/enMuXL+fVy5JcZjabeXP9m3Rd2pWEOwk0CmrEnlf38HSFp42OJuJQ2lRpg5erF6eun2LH+Yy/nNxxfgc/n/0ZFycXBtYdaFBCyS4V3QYIDARPT0hNhTNnjE4jIiICt27dYunSpUyYMIGGDRtSqVIl3n//fSpVqsS0adMwm8188sknvPvuu7Rr146aNWsye/ZsLly4wIoVK+573kmTJvHyyy/Tp08fqlWrxueff06hQoX4+uuv8+7FSa7afXE3k7ZNAuCdJ9/hh54/EOAdYHAqEcdTyLUQ7ULbAXcvqJY+l/uFsBco7VM6z7NJzqjoNoCT0/+GmGtet4iI2IOUlBRSU1Px8PDIcLunpydbtmzh9OnTxMTE0LRpU+t9vr6+1K1bl8jIyHue886dO+zevTvDY5ycnGjatOl9HwOQlJREfHx8hovYr7n75gLQpXoXxjQeg4uTi8GJRBxX+hDzRQcXkZqWCsDp66f55tA3ALwZ/qZh2ST7VHQbRPO6RUTEnnh7exMeHs7o0aO5cOECqampzJ07l8jISC5evEhMTAwAfn5+GR7n5+dnve+vrl69SmpqapYeAzBu3Dh8fX2tl7Jly+bw1UluSUlLsXbketTsYXAaEcfXLLgZRT2KEpMQw+azmwH4ZNsnpJnTaBbcjJp+NQ1OKNmhotsgWsFcRETszZw5czCbzZQuXRp3d3cmT55Mt27dcHLK2x8Xhg0bRlxcnPUSHR2dp88vmbfh5AYu37xMyUIlaRbczOg4Ig7PzdmNjlU7ApZVzK/dusb0PdMBdbkdmYpug6jTLSIi9iY4OJjNmzeTkJBAdHQ0O3bsIDk5mYoVK+Lv7w/ApUuXMjzm0qVL1vv+qkSJEjg7O2fpMQDu7u74+PhkuIh9mrNvDgBda3TVnsEiNtItzDLEfOnhpUzZPoWbyTcJKxXGMxWfMTiZZJeKboOo0y0iIvbKy8uLgIAArl+/zvr162nXrh0VKlTA39+fjRs3Wo+Lj49n+/bthIeH3/M8bm5u1K5dO8Nj0tLS2Lhx430fI47jRtINVhxZAWhouYgtNQpqREDhAK7fvs6YX8YAMCRiCCaTyeBkkl0qug2SXnRHR8OtW8ZmERERAVi/fj3r1q3j9OnTbNiwgaeffprQ0FD69OmDyWRi0KBBjBkzhlWrVrF//3569uxJYGAg7du3t56jSZMmfPrpp9avBw8ezFdffcWsWbM4fPgwf//737l58yZ9+vQx4BWKLS07vIxbKbeoXLwyjwc+bnQckXzD2cmZztU7A5Z1EwK9A+lao6vBqSQntLykQUqUAF9fiIuDkyehRg2jE4mISEEXFxfHsGHDOHfuHMWKFaNjx46MHTsWV1fLsOG33nqLmzdv8sorrxAbG0uDBg1Yt25dhhXPT548ydWrV61fd+nShStXrjBixAhiYmJ49NFHWbdu3V2Lq4njmbvfsmp5j5o91IETsbFuNbrx7+3/BuD1uq/j5uxmcCLJCZPZbDYbHSI3xcfH4+vrS1xcnN3NCXviCdi5E5Ytgw4djE4jIiJ5yZ4/n+yNvlf253z8ecp+XBYzZk4NPEWFohWMjiSSr5jNZhrPbkx0XDS7XtlFEY8iRkeSe8js55M63QYKCbEU3ZrXLSIiIo5k/v75mDHToFwDFdwiucBkMvFjrx8xm80aSZIPaE63gdLndWsFcxEREXEk6UPLXwx70eAkIvmbCu78QUW3gdK3DVOnW0RERBzFvkv72HdpH27ObtbFnkRE5P5UdBtInW4RERFxNHP3WbrcrUNaU9SzqMFpRETsn4puA6V3umNiID7e2CwiIiIiD5Oalsq8/fMA7c0tIpJZKroN5OsLpUpZrp84YWwWERERkYf56cxPXLhxgaIeRWkV0sroOCIiDkFFt8E0r1tEREQcxZx9cwDoXL0z7i7uBqcREXEMhhbd5cuXx2Qy3XV57bXXALh9+zavvfYaxYsXp3DhwnTs2JFLly4ZGdnmNK9bREREHEFiciJLDy8FNLRcRCQrDC26d+7cycWLF62XDRs2APD8888D8MYbb7B69WqWLFnC5s2buXDhAs8995yRkW1OnW4RERFxBCuPrCThTgIVilQgomyE0XFERByGi5FPXrJkyQxf/9///R/BwcE0atSIuLg4pk+fzvz582ncuDEAM2bMoGrVqmzbto169eoZEdnm1OkWERERR2Ddm7vmi9o7WEQkC+xmTvedO3eYO3cuffv2xWQysXv3bpKTk2natKn1mNDQUMqVK0dkZOR9z5OUlER8fHyGiz1Tp1tERHLivffe4+zZs0bHkHzuUsIl1p9YD1iKbhERyTy7KbpXrFhBbGwsvXv3BiAmJgY3NzeKFCmS4Tg/Pz9iYmLue55x48bh6+trvZQtWzYXU+dcpUqWP69fhz/+MDaLiIg4npUrVxIcHEyTJk2YP38+SUlJRkeSfGjRwUWkmlN5ovQTVC5e2eg4IiIOxW6K7unTp9OyZUsCAwNzdJ5hw4YRFxdnvURHR9soYe4oVAjKlLFcV7dbRESyau/evezcuZPq1avz+uuv4+/vz9///nd27txpdDTJR9JXLX8xTF1uEZGssoui++zZs/zwww/069fPepu/vz937twhNjY2w7GXLl3C39//vudyd3fHx8cnw8Xepc/rVtEtIiLZUatWLSZPnsyFCxeYPn06586do379+tSsWZN///vfxMXFGR1RHNiRq0fYdWEXziZnutboanQcERGHYxdF94wZMyhVqhStW7e23la7dm1cXV3ZuHGj9bajR48SFRVFeHi4ETFzTfq8bi2mJiIiOWE2m0lOTubOnTuYzWaKFi3Kp59+StmyZVm0aJHR8cRBzd1nWUCtRaUWlPQq+ZCjRUTkrwxdvRwgLS2NGTNm0KtXL1xc/hfH19eXl156icGDB1OsWDF8fHz4xz/+QXh4eL5ZuTydOt0iIpITu3fvZsaMGSxYsAB3d3d69uzJ1KlTqfTfhUOmTJnCwIED6dKli8FJxdGkmdOYt38eoL25RUSyy/Ci+4cffiAqKoq+ffvedd/HH3+Mk5MTHTt2JCkpiebNm/PZZ58ZkDJ3qdMtIiLZFRYWxpEjR2jWrBnTp0+nTZs2ODs7ZzimW7duvP766wYlFEf2a9SvnIk9g7ebN22rtDU6joiIQzK86G7WrBlms/me93l4eDB16lSmTp2ax6ny1p/36jabQVtfiohIZnXu3Jm+fftSunTp+x5TokQJ0tLS8jCV5BfpC6h1qtYJT1dPg9OIiDgmw4tugQoVwMkJbt6Eixchhwu4i4hIATJ8+HCjI0g+dTvlNosPLga0N7eISE7YxUJqBZ2bm6XwBs3rFhGRrOnYsSPjx4+/6/YJEybw/PPPG5BI8os1x9YQlxRHGZ8yPFX+KaPjiIg4LBXddkLzukVEJDt+/vlnWrVqddftLVu25OeffzYgkeQXc/dbVi1/ocYLOJn0I6OISHbpf1A7oRXMRUQkOxISEnBzc7vrdldXV+Lj4w1IJPnBH4l/sObYGgB6PKJVy0VEckJFt51Qp1tERLIjLCzsnntwL1y4kGrVqhmQSPKDJYeWkJyWzCN+j1CjVA2j44iIOLQsL6R269YtzGYzhQoVAuDs2bMsX76catWq0axZM5sHLCjU6RYRkewYPnw4zz33HCdPnqRx48YAbNy4kQULFrBkyRKD04mjSl+1XHtzi4jkXJaL7nbt2vHcc8/xt7/9jdjYWOrWrYurqytXr15l0qRJ/P3vf8+NnPleeqf75ElITYW/bLEqIiJyT23atGHFihV88MEHfPPNN3h6elKzZk1++OEHGjVqZHQ8cUCnrp9ia/RWnExOdAvrZnQcERGHl+Xh5b/99htPPvkkAN988w1+fn6cPXuW2bNnM3nyZJsHLCjKlbOsYn7nDkRFGZ1GREQcSevWrfn111+5efMmV69eZdOmTSq4Jdvm7rMsoNakQhMCvbWPqYhITmW56E5MTMTb2xuA77//nueeew4nJyfq1avH2bNnbR6woHB2huBgy3XN6xYREREjmM1ma9GtoeUiIraR5aK7UqVKrFixgujoaNavX2+dx3358mV8fHxsHrAg0bxuERHJqtTUVCZOnMgTTzyBv78/xYoVy3ARyYod53dw/NpxCrkWokPVDkbHERHJF7JcdI8YMYIhQ4ZQvnx56tatS3h4OGDpeteqVcvmAQsSrWAuIiJZNXLkSCZNmkSXLl2Ii4tj8ODB1lFo77//vtHxxMGkd7k7hHagsFthg9OIiOQPWV5IrVOnTjRo0ICLFy/yyCOPWG9v0qQJHTroN6I5oU63iIhk1bx58/jqq69o3bo177//Pt26dSM4OJiaNWuybds2Bg4caHREcRDJqcksPLgQgBdrvmhwGhGR/CNb+3T7+/tTq1YtnJyciI+PZ8WKFXh7exMaGmrrfAWKOt0iIpJVMTExhIWFAVC4cGHi4uIAePbZZ1mzZo2R0cTBrD+5nquJV/Hz8qNpxaZGxxERyTeyXHR37tyZTz/9FLDs2f3444/TuXNnatasydKlS20esCBJ73SfPm1ZxVxERORhypQpw8WLFwEIDg7m+++/B2Dnzp24u7sbGU0cTPre3N1qdMPFKcuDIUVE5D6yXHT//PPP1i3Dli9fjtlsJjY2lsmTJzNmzBibByxIAgLAywvS0iyFt4iIyMN06NCBjRs3AvCPf/yD4cOHExISQs+ePenbt6/B6cRRxN2OY9XRVQD0eESrlouI2FKWf40ZFxdnXQ113bp1dOzYkUKFCtG6dWuGDh1q84AFiclkGWK+d69lXneVKkYnEhERe/d///d/1utdunQhKCiIrVu3EhISQps2bQxMJo5k6eGl3E65TdUSVanlr4VxRURsKcud7rJlyxIZGcnNmzdZt26ddcuw69ev4+HhYfOABU36EHPN6xYRkYdJTk6mb9++nP7T8Kh69eoxePBgFdySJelDy3vU7IHJZDI4jYhI/pLlonvQoEF0796dMmXKEBgYyFNPPQVYhp2nL+Qi2Ze+mJpWMBcRkYdxdXXVeiqSY1FxUfx05icAXgh7wdgwIiL5UJaL7v79+xMZGcnXX3/Nli1bcHKynKJixYqa020D6nSLiEhWtG/fnhUrVhgdQxzY/P3zAWgU1IigIkEGpxERyX+ytTTl448/zuOPP47ZbMZsNmMymWjdurWtsxVI6nSLiEhWhISEMGrUKH799Vdq166Nl5dXhvszu093amoq77//PnPnziUmJobAwEB69+7Nu+++ax1ufOnSJf75z3/y/fffExsbS8OGDZkyZQoh6R9e9zBz5kz69OmT4TZ3d3du376dxVcqucFsNluHlmtvbhGR3JGtonv27Nl8+OGHHP9vO7Zy5coMHTqUHj202mVOpXe6z52DxEQoVMjYPCIiYt+mT59OkSJF2L17N7t3785wn8lkynTRPX78eKZNm8asWbOoXr06u3btok+fPvj6+jJw4EDMZjPt27fH1dWVlStX4uPjw6RJk2jatCmHDh26q9j/Mx8fH44ePZohl9iHvTF7OXTlEO7O7nSq1snoOCIi+VKWi+5JkyYxfPhwBgwYQP369QHYsmULf/vb37h69SpvvPGGzUMWJMWLQ9GicP06nDgBNWsanUhEROzZaRvtMbl161batWtnHblWvnx5FixYwI4dOwA4fvw427Zt48CBA1SvXh2AadOm4e/vz4IFC+jXr999z20ymfD397dJTrGtufvmAtCmShuKeBQxNoyISD6V5TndU6ZMYdq0aYwfP562bdvStm1bJkyYwGeffcbkyZNzI2OBo3ndIiKS1yIiIti4cSPH/ju/6ffff2fLli20bNkSgKSkJIAMO5U4OTnh7u7Oli1bHnjuhIQEgoKCKFu2LO3atePgwYMPPD4pKYn4+PgMF7G9lLQU5h+wzOfuUVOjFUVEckuWO90XL14kIiLirtsjIiK4ePGiTUIVdCEhsH275nWLiMjD9e3b94H3f/3115k6z9tvv018fDyhoaE4OzuTmprK2LFj6d69OwChoaGUK1eOYcOG8cUXX+Dl5cXHH3/MuXPnHvj5X6VKFb7++mtq1qxJXFwcEydOJCIigoMHD1KmTJl7PmbcuHGMHDkyU7kl+zad3kRMQgzFPYvTolILo+OIiORbWe50V6pUicWLF991+6JFix64kIpknjrdIiKSWdevX89wuXz5Mps2bWLZsmXExsZm+jyLFy9m3rx5zJ8/n99++41Zs2YxceJEZs2aBVi2J1u2bBnHjh2jWLFiFCpUiB9//JGWLVtadzK5l/DwcHr27Mmjjz5Ko0aNWLZsGSVLluSLL76472OGDRtGXFyc9RIdHZ3p1yGZl76AWpfqXXBzdjM4jYhI/pXlTvfIkSPp0qULP//8s3VO96+//srGjRvvWYxL1mkFcxERyazly5ffdVtaWhp///vfCQ4OzvR5hg4dyttvv03Xrl0BCAsL4+zZs4wbN45evXoBULt2bfbu3UtcXBx37tyhZMmS1K1bl8cffzzTz+Pq6kqtWrU4ceLEfY9xd3fH3d090+eUrEu4k8Cyw8sA6PGIhpaLiOSmLHe6O3bsyPbt2ylRogQrVqxgxYoVlChRgh07dtChQ4fcyFjgqNMtIiI54eTkxODBg/n4448z/ZjExMS7OtbOzs6kpaXddayvry8lS5bk+PHj7Nq1i3bt2mX6eVJTU9m/fz8BAQGZfozY3oojK0hMTqRSsUrULV3X6DgiIvlatrYMq127NnPnzs1w2+XLl/nggw/417/+ZZNgBVl6p/vyZYiLA19fY/OIiIjjOXnyJCkpKZk+vk2bNowdO5Zy5cpRvXp19uzZw6RJkzLMGV+yZAklS5akXLly7N+/n9dff5327dvTrFkz6zE9e/akdOnSjBs3DoBRo0ZRr149KlWqRGxsLB9++CFnz5594GrnkvvSVy1/MexFbeEmIpLLslV038vFixcZPny4im4b8PYGf3+IibF0u7Mwak9ERAqYwYMHZ/jabDZz8eJF1qxZYx0WnhlTpkxh+PDh9O/fn8uXLxMYGMirr77KiBEjrMdcvHiRwYMHc+nSJQICAujZsyfDhw/PcJ6oqKgMHfPr16/z8ssvExMTQ9GiRalduzZbt26lWrVq2XzFklMXb1xkw6kNAHSv2d3gNCIi+Z/JbDabbXGi33//nccee4zU1FRbnM5m4uPj8fX1JS4uDh8fH6PjZFrDhvDLLzBvHrzwgtFpRETE1mz1+fT0009n+NrJyYmSJUvSuHFj+vbti4uLzX6/bhhH/Sy3Vx9Hfszg7wcTXiacrS9tNTqOiIjDyuznk+N/EudTlStbim4tpiYiIg/y448/Gh1BHEz6quUv1nzR4CQiIgVDlhdSk7yRPq9bi6mJiMiDnD59muP3+LA4fvw4Z86cyftAYtcOXj7Inpg9uDi50KV6F6PjiIgUCJnudP91zthfXblyJcdh5H/SVzBXp1tERB6kd+/e9O3bl5D039b+1/bt2/nPf/7DTz/9ZEwwsUvpC6i1CmlF8ULFDU4jIlIwZLro3rNnz0OPadiwYY7CyP/8udNtNoMWFhURkXvZs2cP9evXv+v2evXqMWDAAAMSib1KM6cxb/88AHrU1N7cIiJ5JdNFt+aM5a3gYEuhHRcHV65AqVJGJxIREXtkMpm4cePGXbfHxcXZ3eKmYqyfz/5MdHw0vu6+PFv5WaPjiIgUGJrTbac8PaFsWct1zesWEZH7adiwIePGjctQYKempjJu3DgaNGhgYDKxN3N+tyyg9ny15/Fw8TA4jYhIwaHVy+1Y5coQFWWZ132PkYMiIiKMHz+ehg0bUqVKFZ588kkAfvnlF+Lj49m0aZPB6cRe3Eq+xTeHvwG0armISF5Tp9uOaQVzERF5mGrVqrFv3z46d+7M5cuXuXHjBj179uTIkSPUqFHD6HhiJ1YfW018UjzlfMvxZNCTRscRESlQ1Om2Y1rBXEREMiMwMJAPPvjA6Bhix9JXLe8e1h0nk3ouIiJ5Sf/r2jF1ukVE5GFmzJjBkiVL7rp9yZIlzJo1y4BEYm+u3LzCdye+A7RquYiIEbLV6Y6NjWXHjh1cvnyZtLS0DPf17NnTJsHkf53u48chLQ2c9CsSERH5i3HjxvHFF1/cdXupUqV45ZVX6NWrlwGpxJ4sPriYlLQUagfUpmrJqkbHEREpcLJcdK9evZru3buTkJCAj48Ppj9tIG0ymVR021D58uDsDLduwYULUKaM0YlERMTeREVFUaFChbtuDwoKIioqyoBEYm/m7LOsWq4F1EREjJHl3umbb75J3759SUhIIDY2luvXr1sv165dy42MBZarK1SsaLmued0iInIvpUqVYt++fXfd/vvvv1O8eHEDEok9Of7Hcbaf346zyZluNboZHUdEpEDKctF9/vx5Bg4cSKFChXIjj/yF5nWLiMiDdOvWjYEDB/Ljjz+SmppKamoqmzZt4vXXX6dr165GxxODpS+g9kzwM/gV9jM4jYhIwZTlort58+bs2rUrN7LIPWgFcxEReZDRo0dTt25dmjRpgqenJ56enjRr1ozGjRszduxYo+OJgcxmM3P3W4puLaAmImKcLM/pbt26NUOHDuXQoUOEhYXh6uqa4f62bdvaLJyo0y0iIg/m5ubGokWLGDNmDHv37sXT05OwsDCCgoKMjiYGizwXyanrp/By9aJdlXZGxxERKbCyXHS//PLLAIwaNequ+0wmE6mpqTlPJVbqdIuISGaEhIQQ8t/f1MbHxzNt2jSmT5+u0WkFWPrQ8o7VOuLl5mVwGhGRgivLRfdftwiT3JXe6T51ClJSwCVbm7yJiEhB8OOPP/L111+zbNkyfH196dChg9GRxCB3Uu+w6OAiAF4M06rlIiJGUgln58qWBXd3SEqCs2chONjoRCIiYk/Onz/PzJkzmTFjhnVXkfnz59O5c+cM23pKwfLd8e+4dusaAYUDaFyhsdFxREQKtEwV3ZMnT+aVV17Bw8ODyZMnP/DYgQMH2iSYWDg5QaVKcPCgZV63im4REQFYunQp06dP5+eff6Zly5Z89NFHtGzZEi8vL8LCwlRwF3Dpe3O/EPYCzk7OBqcRESnYMlV0f/zxx3Tv3h0PDw8+/vjj+x5nMplUdOeCypUtRfexY9CihdFpRETEHnTp0oV//vOfLFq0CG9vb6PjiB2JvR3L6mOrAa1aLiJiDzJVdJ8+ffqe1yVvaAVzERH5q5deeompU6fy008/0aNHD7p06ULRokWNjiV2YMnBJdxJvUONUjWo6VfT6DgiIgVelvfplrynFcxFROSvvvjiCy5evMgrr7zCggULCAgIoF27dpjNZi16WsClDy3vUbOHphmIiNiBbC2kdu7cOVatWkVUVBR37tzJcN+kSZNsEkz+J73oVqdbRET+zNPTk169etGrVy+OHz/OjBkz2LVrF/Xr16d169Z06tSJ5557zuiYkofOxJ7hl6hfMGHihbAXjI4jIiJko+jeuHEjbdu2pWLFihw5coQaNWpw5swZzGYzjz32WG5kLPDSh5efPWtZxdzd3dg8IiJif0JCQvjggw8YM2YMa9asYfr06XTr1o2kpCSjo0kemrdvHgBPV3iaMj5lDE4jIiKQjeHlw4YNY8iQIezfvx8PDw+WLl1KdHQ0jRo14vnnn8+NjAWenx94e0NammW/bhERkftxcnKiTZs2rFixgujoaKPjSB4ym83M3T8X0N7cIiL2JMtF9+HDh+nZsycALi4u3Lp1i8KFCzNq1CjGjx9v84ACJtP/ut2a1y0iIplVqlQpoyNIHtp9cTdHrh7Bw8WDjtU6Gh1HRET+K8tFt5eXl3Ued0BAACdPnrTed/XqVdslkww0r1tEREQeZO4+S5e7fWh7fNx9DE4jIiLpsjynu169emzZsoWqVavSqlUr3nzzTfbv38+yZcuoV69ebmQU1OkWERGR+0tJS2HBgQWAhpaLiNibLBfdkyZNIiEhAYCRI0eSkJDAokWLCAkJ0crluUidbhEREbmfDSc3cPnmZUoWKkmz4GZGxxERkT/JUtGdmprKuXPnqFmzJmAZav7555/nSjDJSJ1uERG5l4oVK7Jz506KFy+e4fbY2Fgee+wxTmkFzgIhfW/urjW64ursanAaERH5syzN6XZ2dqZZs2Zcv37dZgHOnz/Piy++SPHixfH09CQsLIxdu3ZZ7zebzYwYMYKAgAA8PT1p2rQpxwtguze96L5wAf470EBERIQzZ86Qmpp61+1JSUmcP3/egESS124k3WDFkRUA9KjZw9gwIiJylywPL69RowanTp2iQoUKOX7y69evU79+fZ5++mm+++47SpYsyfHjxylatKj1mAkTJjB58mRmzZpFhQoVGD58OM2bN+fQoUN4eHjkOIOjKFYMiheHP/6AEyfg0UeNTiQiIkZatWqV9fr69evx9fW1fp2amsrGjRspX768Ackkry07vIxbKbeoXLwyjwc+bnQcERH5iywX3WPGjGHIkCGMHj2a2rVr4+XlleF+H5/Mr5Y5fvx4ypYty4wZM6y3/bmYN5vNfPLJJ7z77ru0a9cOgNmzZ+Pn58eKFSvo2rVrVuM7tMqVITLSMq9bRbeISMHWvn17AEwmE7169cpwn6urK+XLl+ejjz4yIJnktfS9uXvU7IHJZDI4jYiI/FWmh5ePGjWKmzdv0qpVK37//Xfatm1LmTJlKFq0KEWLFqVIkSIZOtSZsWrVKh5//HGef/55SpUqRa1atfjqq6+s958+fZqYmBiaNm1qvc3X15e6desSGRl5z3MmJSURHx+f4ZJfaF63iIikS0tLIy0tjXLlynH58mXr12lpaSQlJXH06FGeffZZo2NKLjsff56NpzYC0D2su8FpRETkXjLd6R45ciR/+9vf+PHHH2325KdOnWLatGkMHjyYf/3rX+zcuZOBAwfi5uZGr169iImJAcDPzy/D4/z8/Kz3/dW4ceMYOXKkzTLaE61gLiIif3X69Om7bouNjaVIkSJ5H0by3IIDCzBjpkG5BlQomvOpfyIiYnuZ7nSbzWYAGjVq9MBLVqSlpfHYY4/xwQcfUKtWLV555RVefvnlHK2IPmzYMOLi4qyX6OjobJ/L3qjTLSIifzV+/HgWLVpk/fr555+nWLFilC5dmt9//z3T50lNTWX48OFUqFABT09PgoODGT16tPXzH+DSpUv07t2bwMBAChUqRIsWLTK1uOmSJUsIDQ3Fw8ODsLAw1q5dm7UXKfeVvmq59uYWEbFfWVq93NbzhAICAqhWrVqG26pWrUpUVBQA/v7+gOVD/s8uXbpkve+v3N3d8fHxyXDJL9I73Sq6RUQk3eeff07ZsmUB2LBhAz/88APr1q2jZcuWDB06NNPnGT9+PNOmTePTTz/l8OHDjB8/ngkTJjBlyhTA8sv39u3bc+rUKVauXMmePXsICgqiadOm3Lx5877n3bp1K926deOll15iz549tG/fnvbt23PgwIGcvXBh36V97Lu0DzdnNzpX72x0HBERuY8sLaRWuXLlhxbe165dy/T56tevz9GjRzPcduzYMYKCggDLomr+/v5s3LiRR/+7clh8fDzbt2/n73//e1ai5wuVKln+/OMPuHbNsqK5iIgUbDExMdai+9tvv6Vz5840a9aM8uXLU7du3UyfZ+vWrbRr147WrVsDUL58eRYsWMCOHTsAOH78ONu2bePAgQNUr14dgGnTpuHv78+CBQvo16/fPc/773//mxYtWlh/ATB69Gg2bNjAp59+mqORbQJz91kWUGsd0pqinllbV0dERPJOlorukSNHZtiSJKfeeOMNIiIi+OCDD+jcuTM7duzgyy+/5MsvvwQsnfVBgwYxZswYQkJCrFuGBQYGWldtLUgKF4bAQMte3cePQxZ+lhIRkXyqaNGiREdHU7ZsWdatW8eYMWMAS2f6Xvt3309ERARffvklx44do3Llyvz+++9s2bKFSZMmAZaFSoEM23U6OTnh7u7Oli1b7lt0R0ZGMnjw4Ay3NW/enBUrVmTlZcpfpKalMm//PEB7c4uI2LssFd1du3alVKlSNnvyOnXqsHz5coYNG8aoUaOoUKECn3zyCd27/2/1zbfeeoubN2/yyiuvEBsbS4MGDVi3bl2B2qP7z0JCVHSLiMj/PPfcc7zwwguEhITwxx9/0LJlSwD27NlDpfQhUpnw9ttvEx8fT2hoKM7OzqSmpjJ27FjrZ3JoaCjlypVj2LBhfPHFF3h5efHxxx9z7tw5Ll68eN/zxsTEZGlBVLAU+OlFPpCvdiKxlZ/O/MSFGxco6lGUViGtjI4jIiIPkOmiO7f2fXz22WcfuKWJyWRi1KhRjBo1Klee39FUrgybN2tet4iIWHz88ceUL1+e6OhoJkyYQOHChQG4ePEi/fv3z/R5Fi9ezLx585g/fz7Vq1dn7969DBo0iMDAQHr16oWrqyvLli3jpZdeolixYjg7O9O0aVNatmyZYbE1W8jPO5HYSvoCap2rd8bdxd3gNCIi8iCZLrpt/YEq2ZO+grm2DRMREQBXV1eGDBly1+1vvPFGls4zdOhQ3n77bbp27QpAWFgYZ8+eZdy4cfTq1QuA2rVrs3fvXuLi4rhz5w4lS5akbt26PP744/c9r7+/f5YWRAXLTiR/HpIeHx9vnbcukJicyNLDSwF4saZWLRcRsXeZXr08LS3NpkPLJXu0grmIiPzVnDlzaNCgAYGBgZw9exaATz75hJUrV2b6HImJiTg5ZfyxwNnZmbS0tLuO9fX1pWTJkhw/fpxdu3bRrl27+543PDycjRs3Zrhtw4YNhIeH3/cx+XknEltYeWQlCXcSqFCkAvXL1jc6joiIPESWtgwT4/25063BByIiMm3aNAYPHkzLli2JjY21Lp5WpEgRPvnkk0yfp02bNowdO5Y1a9Zw5swZli9fzqRJk+jQoYP1mCVLlvDTTz9Ztw175plnaN++Pc2aNbMe07NnT4YNG2b9+vXXX2fdunV89NFHHDlyhPfff59du3YxYMCAnL/4Amrufsuq5S/WfDHXpv+JiIjtqOh2MMHBYDLBjRvwl9F6IiJSAE2ZMoWvvvqKd955B2dnZ+vtjz/+OPv378/SeTp16kT//v2pWrUqQ4YM4dVXX2X06NHWYy5evEiPHj0IDQ1l4MCB9OjRgwULFmQ4T1RUVIaF1SIiIpg/fz5ffvkljzzyCN988w0rVqygRo0aOXjVBdelhEusP7Ee0NByERFHYTLn88na8fHx+Pr6EhcXl2+Gp1WoAGfOwM8/w5NPGp1GRESyw1afT56enhw5coSgoCC8vb35/fffqVixIsePH6dmzZrcunXLhqmNkR8/y7Nr8vbJvL7udZ4o/QTb+203Oo6ISIGW2c8ndbodkOZ1i4hIugoVKrB37967bl+3bh1Vq1bN+0CSq9JXLX8xTF1uERFHoaLbAWkFcxERGTVqFImJiQwePJjXXnuNRYsWYTab2bFjB2PHjmXYsGG89dZbRscUGzpy9Qi7LuzC2eRM1xpdjY4jIiKZlOktw8R+qNMtIiIjR47kb3/7G/369cPT05N3332XxMREXnjhBQIDA/n3v/9t3f5L8oe5+ywLqLWo1IKSXiUNTiMiIpmlotsBqdMtIiJ/XpKle/fudO/encTERBISErTFZz6UZk5j3v55APSo2cPgNCIikhUquh1Qeqf7xAlISwMnTRIQESmQ/rpdVKFChShUqJBBaSQ3/Rr1K2diz+Dt5k3bKm2NjiMiIlmgotsBBQWBiwvcvg3nzkG5ckYnEhERI1SuXPmh+zRfu3Ytj9JIbkofWt6pWic8XT0NTiMiIlmhotsBubhY9us+etQyr1tFt4hIwTRy5Eh8fX2NjiG57HbKbRYfWgxob24REUekottBhYRYiu7jx6FpU6PTiIiIEbp27ar52wXA2uNrib0dSxmfMjxV/imj44iISBZpNrCD0grmIiIF28OGlUv+kb439ws1XsDJpB/dREQcjf7ndlBawVxEpGD78+rlkn/9kfgHa46tAaDHI1q1XETEEWl4uYNSp1tEpGBLS0szOoLkgSWHlpCclswjfo9Qo1QNo+OIiEg2qNPtoNI73adPQ3KysVlEREQkd6QPLdfe3CIijktFt4MqXRo8PSElBc6cMTqNiIiI2Nqp66fYGr0VJ5MT3cK6GR1HRESySUW3g3JygkqVLNc1r1tERCT/Sd+bu0mFJgR6BxqcRkREsktFtwPTvG4REZH8yWw2M2//PEBDy0VEHJ2KbgeWXnSr0y0iIpK/HLl6hGN/HMPN2Y32oe2NjiMiIjmgotuBpS+mpk63iIhI/rLq6CoAGldojLe7t8FpREQkJ1R0OzB1ukVERPKnVccsRXfbym0NTiIiIjmlotuBpXe6o6Lg9m1js4iIiIhtXL55mcjoSADaVGljcBoREckpFd0OrGRJ8PUFsxlOnjQ6jYiIiNjCmmNrMGPmsYDHKONTxug4IiKSQyq6HZjJpHndIiIi+Y2GlouI5C8quh2c5nWLiIjkH7eSb/H9ye8BaFtFRbeISH6gotvBqdMtIiKSf2w6vYnE5ETK+JThUf9HjY4jIiI2oKLbwanTLSIikn+kbxXWtnJbTCaTwWlERMQWVHQ7OHW6RURE8oc0cxqrj60GNLRcRCQ/UdHt4NKL7pgYuHHD2CwiIiKSfbsv7OZiwkW83bx5qvxTRscREREbUdHt4IoUsWwdBhpiLiIi4sjSh5a3qNQCdxd3g9OIiIitqOjOB9LndWuIuYiIiOOybhWmoeUiIvmKiu58IH2IuTrdIiIijulM7Bn2XdqHs8mZViGtjI4jIiI2pKI7H1CnW0RExLGtPmpZQK1BuQYU8yxmcBoREbElFd35gDrdIiIijk1Dy0VE8i8V3fmAOt0iIiKOK+52HD+d+QmANpXbGBtGRERsTkV3PlCpkuXP69fhjz+MzSIiIiJZs+7EOlLSUqhaoiohxUOMjiMiIjamojsfKFQIypSxXFe3W0RExLFoaLmISP6mojuf0LxuERERx5Ocmsza42sBFd0iIvmViu58QvO6RUREHM8vUb8QezuWkoVKUrd0XaPjiIhILlDRnU+o0y0iIuJ4Vh21DC1/tvKzODs5G5xGRERyg4rufEKdbhERyYnU1FSGDx9OhQoV8PT0JDg4mNGjR2M2m63HJCQkMGDAAMqUKYOnpyfVqlXj888/f+B5Z86ciclkynDx8PDI7ZfjEMxms7Xo1tByEZH8y8XoAGIbf+50m81gMhmbR0REHMv48eOZNm0as2bNonr16uzatYs+ffrg6+vLwIEDARg8eDCbNm1i7ty5lC9fnu+//57+/fsTGBhI27b3Lxp9fHw4evSo9WuTPqQAOHjlIKdjT+Pu7M4zFZ8xOo6IiOQSFd35RMWK4OQEN2/CxYsQGGh0IhERcSRbt26lXbt2tG7dGoDy5cuzYMECduzYkeGYXr168dRTTwHwyiuv8MUXX7Bjx44HFt0mkwl/f/9cze+I0rvcTSs2xcvNy+A0IiKSWzS8PJ9wc4Py5S3XNa9bRESyKiIigo0bN3Lsv/OUfv/9d7Zs2ULLli0zHLNq1SrOnz+P2Wzmxx9/5NixYzRr1uyB505ISCAoKIiyZcvSrl07Dh48mKuvxVFoaLmISMGgTnc+UrkynDplmdfdqJHRaURExJG8/fbbxMfHExoairOzM6mpqYwdO5bu3btbj5kyZQqvvPIKZcqUwcXFBScnJ7766isaNmx43/NWqVKFr7/+mpo1axIXF8fEiROJiIjg4MGDlClT5p6PSUpKIikpyfp1fHy87V6onYhJiGH7+e2AZRE1ERHJv1R05yMhIbBunTrdIiKSdYsXL2bevHnMnz+f6tWrs3fvXgYNGkRgYCC9evUCLEX3tm3bWLVqFUFBQfz888+89tprBAYG0rRp03ueNzw8nPDwcOvXERERVK1alS+++ILRo0ff8zHjxo1j5MiRtn+RduTbY98CUCewDoHemhMmIpKfqejOR7SCuYiIZNfQoUN5++236dq1KwBhYWGcPXuWcePG0atXL27dusW//vUvli9fbp33XbNmTfbu3cvEiRPvW3T/laurK7Vq1eLEiRP3PWbYsGEMHjzY+nV8fDxly5bNwauzPxpaLiJScGhOdz6ivbpFRCS7EhMTcXLK+GOBs7MzaWlpACQnJ5OcnPzAYzIjNTWV/fv3ExAQcN9j3N3d8fHxyXDJTxKTE9lwagMA7aq0MziNiIjkNnW685H0TveJE5CaCs7OxuYRERHH0aZNG8aOHUu5cuWoXr06e/bsYdKkSfTt2xewbPvVqFEjhg4diqenJ0FBQWzevJnZs2czadIk63l69uxJ6dKlGTduHACjRo2iXr16VKpUidjYWD788EPOnj1Lv379DHmd9uCHUz9wO+U25YuUp0apGkbHERGRXKaiOx8pV86yivmdOxAd/b/VzEVERB5mypQpDB8+nP79+3P58mUCAwN59dVXGTFihPWYhQsXMmzYMLp37861a9cICgpi7Nix/O1vf7MeExUVlaEbfv36dV5++WViYmIoWrQotWvXZuvWrVSrVi1PX589sQ4tr9xWe5aLiBQAJrPZbDY6RG6Kj4/H19eXuLi4fDc87V6qVYPDh2H9enjIDi4iImKggvb5lBP56XuVZk4j4KMALt+8zA89fqBJxSZGRxIRkWzK7OeT5nTnM5rXLSIiYr92nN/B5ZuX8XX3pWHQ/bdaExGR/ENFdz6jFcxFRETsV/rQ8pYhLXF1djU4jYiI5AUV3fmMOt0iIiL268/zuUVEpGBQ0Z3PqNMtIiJin05eO8nBKwdxcXKhRaUWRscREZE8oqI7n0kvus+csaxiLiIiIvZh9bHVADQMakhRz6IGpxERkbyiojufCQgALy/LPt2nTxudRkRERNKtPLoS0NByEZGCRkV3PmMyaV63iIiIvbl26xq/nP0FgDZV2hicRkRE8pKK7nwovejWvG4RERH78N3x70g1p1KjVA0qFq1odBwREclDhhbd77//PiaTKcMlNDTUev/t27d57bXXKF68OIULF6Zjx45cunTJwMSOIX1etzrdIiIi9mHVMa1aLiJSUBne6a5evToXL160XrZs2WK974033mD16tUsWbKEzZs3c+HCBZ577jkD0zoGdbpFRETsx53UO3x3/DsA2lZR0S0iUtC4GB7AxQV/f/+7bo+Li2P69OnMnz+fxo0bAzBjxgyqVq3Ktm3bqFevXl5HdRjqdIuIiNiPzWc2c+PODfy8/KhTuo7RcUREJI8Z3uk+fvw4gYGBVKxYke7duxMVFQXA7t27SU5OpmnTptZjQ0NDKVeuHJGRkUbFdQjpRXd0NEydamwWERGRgm7VUcvQ8jaV2+BkMvxHLxERyWOG/s9ft25dZs6cybp165g2bRqnT5/mySef5MaNG8TExODm5kaRIkUyPMbPz4+YmJj7njMpKYn4+PgMl4KmeHEYNMhyfcAAePttSEszNJKIiEiBZDab/zefW0PLRUQKJEOHl7ds2dJ6vWbNmtStW5egoCAWL16Mp6dnts45btw4Ro4caauIDmvSJChRAt59F8aPh3Pn4Ouvwc3N6GQiIiIFx75L+4iKi8LTxZMmFZsYHUdERAxgV2OcihQpQuXKlTlx4gT+/v7cuXOH2NjYDMdcunTpnnPA0w0bNoy4uDjrJTo6OpdT2yeTCd55B2bOBBcXmDcPWraEuDijk4mIiBQc6UPLmwU3o5BrIYPTiIiIEeyq6E5ISODkyZMEBARQu3ZtXF1d2bhxo/X+o0ePEhUVRXh4+H3P4e7ujo+PT4ZLQdarF6xZA4ULw6ZN0LAhnD9vdCoREZGCQUPLRUTE0KJ7yJAhbN68mTNnzrB161Y6dOiAs7Mz3bp1w9fXl5deeonBgwfz448/snv3bvr06UN4eLhWLs+iZs3g55/B3x/27YN69eDgQaNTiYiI5G/n48+z68IuTJhoHdLa6DgiImIQQ+d0nzt3jm7duvHHH39QsmRJGjRowLZt2yhZsiQAH3/8MU5OTnTs2JGkpCSaN2/OZ599ZmRkh1WrFkRGWoaYHzkC9evDypXQqJHRyURERPKnb499C0C9MvXwK+xncBoRETGKoUX3woULH3i/h4cHU6dOZar2vbKJ8uXh11+hbVvLn82awezZ0KWL0clERETyHw0tFxERsLM53ZL7ihWDDRvguefgzh3o2tWy0rmIiIjYTsKdBDaesqxLo6JbRKRgU9FdAHl6wuLFMHCg5es334Q33tBe3iIiIray4eQGklKTCC4aTNUSVY2OIyIiBlLRXUA5O8Mnn8CHH1q+/uQTyzDz27eNTCUiIpI//HlouclkMjiNiIgYSUV3AWYywZAhMH8+uLrCN99Y5nlfu2Z0MhEREceVmpZqXURNQ8tFRERFt9CtG6xfD76+8Msv0KABnD1rdCoRERHHFHkukquJVynqUZT6ZesbHUdERAymolsAePppS8FdujQcPgzh4bB3r9GpREREHM+qo5ah5a1CWuHq7GpwGhERMZqKbrEKC4Nt26BGDbh4ERo2tKx0LiIiIpmXXnRraLmIiICKbvmLMmUsHe+nnoIbN6BVK5gzx+hUIiIijuHo1aMc/eMork6uNA9ubnQcERGxAyq65S5FisC6dZY9vFNSoGdPGDcOzGajk4mIiNi31cdWA/BU+afw9fA1OI2IiNgDFd1yT+7uMG8eDB1q+fpf/4LXXoPUVGNziYiI2DMNLRcRkb9S0S335eQEEybA5MmW7cWmTYPnnoPERKOTiYiI2J+riVf5NfpXANpUbmNwGhERsRcquuWh/vEPWLLE0v1etQoaN4YrV4xOJSIiYl/WHl9LmjmNR/weIahIkNFxRETETqjolkzp2BE2boSiRWH7doiIgJMnjU4lIiJiPzS0XERE7kVFt2Ra/fqwdSsEBcGJE5a9vHfuNDqViIiI8W6n3GbdiXUAtKvSzuA0IiJiT1R0S5aEhkJkJNSqZRli/tRTsGaN0alERESM9dOZn7iZfJNA70AeC3jM6DgiImJHVHRLlgUEwObN0KyZZVG1du3gP/8xOpWIiIhxrEPLK7fFZDIZnEZEROyJim7JFm9v+PZb6NXLso3Yyy/De+9pL28RESl4zGaz5nOLiMh9qeiWbHN1hRkz4N13LV+PGgUvvQTJycbmEhERyUt7YvZw/sZ5vFy9eLrC00bHERERO6OiW3LEZILRo+Hzzy37es+YAW3bQkKC0clERCQrUlNTGT58OBUqVMDT05Pg4GBGjx6N+U9DmBISEhgwYABlypTB09OTatWq8fnnnz/03EuWLCE0NBQPDw/CwsJYu3Ztbr6UPJfe5W5eqTkeLh4GpxEREXujolts4tVXYcUK8PSEdeugUSOIiTE6lYiIZNb48eOZNm0an376KYcPH2b8+PFMmDCBKVOmWI8ZPHgw69atY+7cuRw+fJhBgwYxYMAAVq1add/zbt26lW7duvHSSy+xZ88e2rdvT/v27Tlw4EBevKw88ef53CIiIn9lMpvz9yzc+Ph4fH19iYuLw8fHx+g4+d6OHdC6NVy9CuXLWwrwKlWMTiUiYn/s7fPp2Wefxc/Pj+nTp1tv69ixI56ensydOxeAGjVq0KVLF4YPH249pnbt2rRs2ZIxY8bc87xdunTh5s2bfPvtt9bb6tWrx6OPPpqpLjnY3/fqz6Ljoin3STmcTE7EvBlDSa+SRkcSEZE8ktnPJ3W6xaaeeMKypVhwMJw5AxERlr29RUTEvkVERLBx40aOHTsGwO+//86WLVto2bJlhmNWrVrF+fPnMZvN/Pjjjxw7doxmzZrd97yRkZE0bdo0w23NmzcnMjLyvo9JSkoiPj4+w8VerT62GoCIshEquEVE5J5UdIvNVapkKbTr1IFr16BJE1i+3OhUIiLyIG+//TZdu3YlNDQUV1dXatWqxaBBg+jevbv1mClTplCtWjXKlCmDm5sbLVq0YOrUqTRs2PC+542JicHPzy/DbX5+fsQ8YA7SuHHj8PX1tV7Kli2b8xeYSzS0XEREHkZFt+SKUqXgxx/h2Wfh9m3o2BGmTjU6lYiI3M/ixYuZN28e8+fP57fffmPWrFlMnDiRWbNmWY+ZMmUK27ZtY9WqVezevZuPPvqI1157jR9++MGmWYYNG0ZcXJz1Eh0dbdPz20p8UjybTm8CtFWYiIjcn4vRAST/8vKydLgHDIAvvrD8GR0NH3xgWelcRETsx9ChQ63dboCwsDDOnj3LuHHj6NWrF7du3eJf//oXy5cvp3Xr1gDUrFmTvXv3MnHixLuGkKfz9/fn0qVLGW67dOkS/v7+983i7u6Ou7u7jV5Z7ll/Yj3JaclULl6ZKiW0gImIiNybSh/JVS4uMG0apK+vM3489OwJd+4Ym0tERDJKTEzE6S+/EXV2diYtLQ2A5ORkkpOTH3jMvYSHh7Nx48YMt23YsIHw8HAbJTfOqmMaWi4iIg+nTrfkOpMJ3nkHypSBfv1g3jy4eBGWLQNfX6PTiYgIQJs2bRg7dizlypWjevXq7Nmzh0mTJtG3b18AfHx8aNSoEUOHDsXT05OgoCA2b97M7NmzmTRpkvU8PXv2pHTp0owbNw6A119/nUaNGvHRRx/RunVrFi5cyK5du/jyyy8NeZ22kpKWwppjawANLRcRkQdT0S15plcvCAiwzO/etAkaNoS1a6F0aaOTiYjIlClTGD58OP379+fy5csEBgby6quvMmLECOsxCxcuZNiwYXTv3p1r164RFBTE2LFj+dvf/mY9JioqKkM3PCIigvnz5/Puu+/yr3/9i5CQEFasWEGNGjXy9PXZ2q9Rv3L99nWKexYnvKzjd+1FRCT3aJ9uyXN79kCrVhATY+l+r1sH1asbnUpEJG/p8ynz7PF79eb6N5m0bRI9H+nJrPazHv4AERHJd7RPt9itWrUse3mHhsK5c1C/PqxZA/n71z8iIpJfmM1mVh5dCWg+t4iIPJyKbjFE+fLw66+WgjsuzrK1WHg4rFoFD1iPR0RExHBHrh7h5PWTuDm70Sy4mdFxRETEzqnoFsMUKwYbNsDrr4OHB2zfDu3awaOPwoIFkJJidEIREZG7rTpqWbW8SYUmeLt7G5xGRETsnYpuMZSnJ3zyCZw5A2+/Dd7esH8/vPCCZfj5V19BUpLRKUVERP7HulWYVi0XEZFMUNEtdsHPD8aNg6goy57exYvDyZPwyitQsSJ8/DHcvGl0ShERKegu37xMZHQkAM9WftbgNCIi4ghUdItdKVLEsqf32bOWQrt0abhwAQYPhqAgS0F+/brRKUVEpKBac2wNZszUDqhNGZ8yRscREREHoKJb7JKXFwwaZOl2f/UVBAfDH3/A8OGW4vvtt+HSJaNTiohIQaOh5SIiklUqusWuubtDv35w5IhlcbWwMLhxA8aPt6yAPmCApSsuIiKS224l3+L7k98DKrpFRCTzVHSLQ3Bxga5dYe9ey7ZidevC7dswdSpUqgR9+lgKcxERkdyy6fQmEpMTKetTlkf8HjE6joiIOAgV3eJQnJygTRuIjIRNm6BpU8vWYjNnQrVq8Pzz8NtvRqcUEZH8KH2rsLZV2mIymQxOIyIijkJFtzgkkwmeftqyz/f27dC+PZjN8M03ULs2tGwJv/xidEoREckv0sxprD62GtDQchERyRoV3eLwnngCli+37O/dvbulG75uHTRsCE8+abluNhudUkREHNnuC7u5mHARbzdvGgU1MjqOiIg4EBXdkm/UqAFz58Lx4/Dqq+DmBlu2WLretWtbuuCpqUanFBERR5Q+tLxFpRa4u7gbnEZERByJim7JdypWhM8/h9On4c03LduP7dljme9dvbpl/ndystEpRUTEkaw8uhLQ0HIREck6Fd2SbwUGwsSJli3FRoyAIkXg6FHLSueVKllWPr91y+iUIiJi705fP83+y/txNjnTKqSV0XFERMTBqOiWfK94cRg5EqKiYMIE8POzXB8wwLLX9/jxEB9vdEoREbFX6QuoNSjXgGKexQxOIyIijkZFtxQY3t4wdCicOQOffQZBQXD5Mrz9tuX68OFw9arRKUVExN78easwERGRrFLRLQWOhwf8/e+WBddmz4aqVSE2FsaMsRTfgwfD+fNGpxQREXsQezuWzWc3A9CmchuD04iIiCNS0S0Flqsr9OgBBw7A0qWWFc4TE+Hjj6FCBXjlFThxwuiUIiJipHUn1pGSlkLVElUJKR5idBwREXFAKrqlwHNygueeg507Yf16aNTIsrr5V19BlSrwwguWPcBFRKTg0dByERHJKRXdIv9lMkGzZvDTT5b9vVu3hrQ0WLAAataEtm1h2zajU4qISF5JTk1m7fG1ALSr0s7gNCIi4qhUdIvcQ/368O23lv29O3e2FOSrV0N4uGXoebduMHky7NgBd+4YnVZERHLDL1G/EJcURymvUjxR+gmj44iIiINS0S3yAI8+CosWwZEj0LevZR74mTOwcCG8/jrUrQs+PpYi/c03YcmS/2/v/oOqqvf9j782bAREQET5paBoqIQ/boYpajUFN/N4vJme09Qlryf9Tr/Q/DGdb57TMe2mmTXZnepk2pg59/hjtDuW5ng65mksf6MGahr+yNRUwB8poIEG6/7xuYBb8Ee6F4u9eT5mPhN77cXmvdaEb1+uz/os6ehRp6sGAHhD9dTy36b8VoEBgQ5XAwDwVW6nCwB8QefO0rx5ZpG13Fxp0yYz1XzzZun0aWnjRjOqtW0r9e1rRkaG1KuXFBrqXP0AgF/Hsizu5wYAeAWhG/gVIiKkzEwzJMmyzArn1QF80yZp507zyLH/+R8zJMntNlfNMzJqw3hyspm2DgBofL49+a0OnT2kEHeIsjpmOV0OAMCHEbqBW+BySSkpZowYYbadPy9t3157NXzTJqmoSNq2zYx33jH7xcR4Xg1PT5datHDuWAAAtaqvcmd1zFJYszCHqwEA+DJCN+BlYWHSPfeYIZmr4YcP114N37xZ2rFDKi6WVqwwQzKPLuvevTaE9+1rprVzNRwAGl7N1PLOTC0HANwaQjdgM5dL6tDBjEcfNdvKy83K6NVXwjdvNguw5eebMWeO2S8qqvZqeN++ZuG2yEinjgQAmobCskJtObZFkvTbzr91uBoAgK8jdAMOCAkxV7MzMqQJE8y2Y8c8r4Zv2yb99JO0erUZkgnwqameV8NTU6VAFtUFAK/5bN9nkqS72t6l+PB4h6sBAPg6QjfQSLRtKw0fboZknv+9c6fn1fDvv5f27DHjww/NfuHh0l131YbwPn2k1q2dOw4A8HVMLQcAeBOhG2ikmjUzi6ulp0tjxphtxcWeV8O3bpVKS6W1a82olpJiAni/fmakpXE1HABuxIVLF7Tm+zWSeFQYAMA7CN2AD4mJkf7t38yQpF9+kb791vNqeEGBtH+/Gf/932a/8HDPEM694QBQvy++/0Llv5SrQ8sO6hbTzelyAAB+gNAN+DC3W+rZ04ynnjLbzpwxV8A3bqwN4qWl0po1Zkjm3vBu3UwA79/f/LdjR1ZKB4BPv/tUkpla7uIPRQCAFwQ4XUC11157TS6XS+PHj6/ZVl5erpycHEVHR6tFixYaPny4ioqKnCsS8AGtWkkPPij953+akH32rJSXJ733nvT441JysnmM2a5dZpX0//gP6bbbpLg46eGHpTfekDZsMCusA0BTUllVqZX7VkpiajkAwHsaxZXu3NxczZkzRz169PDYPmHCBK1atUrLli1TZGSkxowZo2HDhmnDhg0OVQr4nsDA2qvhzzxjtp04Ya6Cb9xoxvbt5n7xTz4xQ5KCgqQ776ydkt6vnxTPIr4A/NjWY1t18sJJRQZH6p729zhdDgDATzgeusvKypSdna0PPvhA06ZNq9l+7tw5zZs3T4sWLdL9998vSZo/f75SU1O1efNm9e3b16mSAZ8XHy8NG2aGZK5q79hRG8I3bPBctG3WLLNfhw6eIbx7dzPFHQD8QfWq5YNSBikoMMjhagAA/sLxvy7n5ORo8ODBysrK8gjd27dv16VLl5SVlVWzrWvXrkpKStKmTZuuGrorKipUUVFR87qkpMS+4gE/ERJSG6QlM/380CHPEL5rl/TDD2YsWmT2a9HCLMpW/b19+0otWzp0EABwi1bs41FhAADvc/Se7iVLlmjHjh2aMWNGnfcKCwvVrFkztbzib/CxsbEqLCy86mfOmDFDkZGRNSMxMdHbZQN+z+UyC6s9/ri5Fzw/39wb/o9/SFOnSg88IEVESGVl5lFlr7wiDRokRUWZBdqefFL66CNp3z4T4AH4hsrKSk2ePFnJyckKDQ1Vp06d9Morr8i67BfZ5XLVO954442rfu7UqVPr7N+1a9eGOKQbduDMAe05uUfuALcGpQxyuhwAgB9x7Er30aNHNW7cOK1Zs0YhISFe+9w//elPmjhxYs3rkpISgjfgBRER0r/+qxmSVFkp7dlTezV840bpwAHzCLNvv5U++MDsFx3tOSW9d28pNNS54wBwdTNnztTs2bO1YMECpaWladu2bXriiScUGRmp5557TpJ04sQJj+9ZvXq1Ro8ereHDh1/zs9PS0vTFF1/UvHY3sntTVhaYBdTubX+vWoa0dLYYAIBfcazjbd++XcXFxerVq1fNtsrKSn311Vd699139fnnn+vixYs6e/asx9XuoqIixcXFXfVzg4ODFRwcbGfpAGQWaOve3Yzqx5UVF3su0JabK50+La1caYZk7gHv1csziLdt69xxAKi1ceNGPfTQQxo8eLAkqUOHDlq8eLG2bt1as8+VPfjTTz/Vfffdp44dO17zs91u9zX7t9NqppazajkAwMscC92ZmZnatWuXx7YnnnhCXbt21QsvvKDExEQFBQVp7dq1Nf96XlBQoCNHjigjI8OJkgFcR0yM9NBDZkhSRYX0zTee94YXFprniG/dKv3Xf5n92raVUlOlLl08R2KiFNBoHmwI+L9+/fpp7ty52rdvnzp37qz8/HytX79es6pXU7xCUVGRVq1apQULFlz3s/fv36+EhASFhIQoIyNDM2bMUFJSUr37NvT6LGd+PqOvD38tSRrSeYitPwsA0PQ4FrrDw8PVrVs3j21hYWGKjo6u2T569GhNnDhRrVq1UkREhMaOHauMjAxWLgd8RHCwWVytb19p4kRzf/fhw55T0vPzpWPHzLhs5qkks8BbSkrdMN6lixQZ6cwxAf5s0qRJKikpUdeuXRUYGKjKykpNnz5d2dnZ9e6/YMEChYeHa1j1oxCuok+fPvroo4/UpUsXnThxQi+//LLuvvtu7d69W+Hh4XX2nzFjhl5++WWvHNONWL1/tSqtSnWP6a7kqOQG+7kAgKahcd1QdYW33npLAQEBGj58uCoqKjRw4EC99957TpcF4Ca5XOaxYx06SP/+72ZbWZkJ3gUFtWPfPnN/eHm5WTX9ikkxkqTYWBO+O3f2DOPJyeYZ4wB+vaVLl2rhwoVatGiR0tLSlJeXp/HjxyshIUEjR46ss/+HH36o7Ozs667NMmhQ7cJkPXr0UJ8+fdS+fXstXbpUo0ePrrN/Q6/PwtRyAICdXJbl32sLl5SUKDIyUufOnVNERITT5QC4Qb/8Yh5PdnkYrw7kV6zj5MHtljp1qj+Qt2ljgj/QGDTG/pSYmKhJkyYpJyenZtu0adP0t7/9Td99953Hvl9//bXuuece5eXlqWfPnr/6Z/Xu3VtZWVn1PsHkSnaeq4uVF9X69dYqvViqLf9vi+5qe5dXPx8A4L9utD816ivdAJout1u67TYz/m9NpxolJSZ81xfIf/659vWVWrb0DOHVoTwlxUxlB5q6CxcuKOCKhRQCAwNVVVVVZ9958+bpzjvvvKnAXVZWpoMHD2rEiBE3Xau3rPthnUovliquRZzSE9KdLgcA4IcI3QB8TkSElJ5uxuWqqsy94fWF8cOHzbPGt2wx43Iul9S+fd37xjt3ltq14+o4mo4hQ4Zo+vTpSkpKUlpamr755hvNmjVLo0aN8tivpKREy5Yt05tvvlnv52RmZurhhx/WmDFjJEnPP/+8hgwZovbt2+v48eOaMmWKAgMD9dhjj9l+TNezosBMLR/SeYgCXKzcCADwPkI3AL8REGBWPE9MlLKyPN/7+Wdzn/iVYbygwITxH34w4/PPPb+veXPPaeqdOknx8VJcnBnR0aywDv/xzjvvaPLkyXr22WdVXFyshIQEPfXUU3rppZc89luyZIksy7pqaD548KBOnTpV8/rHH3/UY489ptOnT6tNmzYaMGCANm/erDZt2th6PNdjWRb3cwMAbMc93QCaNMuSTp6sP4wfPGjuLb+WwECzqFtcnGcYrx6XbwsLa5hjgm+gP904u85VfmG+/mXOvyjUHarT//+0QoNCvfbZAAD/xz3dAHADXC7zfPGYGOnuuz3fu3RJOnTIM5AfPmyeNV5YaMJ6ZaV0/LgZ19OiRf1h/MqQ3qaNuacdgL2qp5Y/0OkBAjcAwDb8tQ4AriIoyEwt79xZGjKk7vuXLknFxbUhvHqcOFH39YUL5vFoBw6YcS0ulwneNxLQIyK45xy4WUwtBwA0BEI3ANykoCCpbVszrqe09PrhvLBQKioyC8IVF5uxc+e1Pzck5OpT2tu2lZKSzIiM9M4xA/7iWMkxbTu+TS65NDhl8PW/AQCAm0ToBoAGEB5uRkrKtferrJROnbp+OD9xwjw6rby8dhG4a4mMNOG7ffvaIF79dfv2JqQHBnrraIHGb+W+lZKkvu36KrZFrMPVAAD8GaEbABqR6oXZYmOl6z3++MIFc2W8vnB+4oT044/SkSPSmTPSuXPSrl1m1MftNo9HuzyIXx7OExNZCA7+pfp+bqaWAwDsRugGAB/VvLmUnGzGtZSVmfB95IhZCO7Kr3/80azSfr0r5tHRVw/lSUlmMTruL4cvKLtYprWH1koidAMA7EfoBgA/16KFdPvtZtTnl1/MlfHLg/iV4by0VDp92owdO+r/nODg+qeuV29LTDT7AE77x8F/6GLlRXWK6qTU1qlOlwMA8HOEbgBo4txuE4gTE6X+/eu+b1lmevq1QvmJE1JFhbR/vxlXExdX/1XyNm3MfefVo0ULrprDPpdPLXfxPxoAwGaEbgDANblcUsuWZvToUf8+Fy/W3kN+tXD+88+195xv2XLtnxkYaB6HVh3CW7b0DOXXex0ZKYWGEtxRV2VVpT7b95kkppYDABoGoRsAcMuaNZM6djSjPpZlVmW/WiivXuzt7FmzgntlpfTTT2bcrKCgXxfU6wvuTIf3P5t+3KTTP59WVEiUBiQNcLocAEATQOgGANjO5TJTyNu0ke688+r7WZZZlf3cudoQXv311bbVt49lSZcumaB/6tTN1x0SUjeUZ2ZKL7xw858JZ1VPLR/cebDcAfw1CABgP7oNAKDRcLnMo8nCwqSEhJv7jKoqs2L79YL5tbaVlprPKi83o6io9vNjeaSzT6u5n7szU8sBAA2D0A0A8CsBAeZ+8IgIszjczaisNMG7vmB+s5+JxuHjRz7WioIVGnjbQKdLAQA0EYRuAACuEBhYu3gc/Eu3mG7qFtPN6TIAAE1IgNMFAAAAAADgrwjdAAAAAADYhNANAAAAAIBNCN0AAAAAANiE0A0AAAAAgE0I3QAAAAAA2ITQDQAAAACATQjdAAAAAADYhNANAAAAAIBNCN0AAAAAANiE0A0AAAAAgE0I3QAAAAAA2ITQDQAAAACATQjdAAAAAADYhNANAAAAAIBNCN0AAAAAANjE7XQBdrMsS5JUUlLicCUAANSq7kvVfQpXRy8HADRGN9rL/T50l5aWSpISExMdrgQAgLpKS0sVGRnpdBmNGr0cANCYXa+Xuyw//yf2qqoqHT9+XOHh4XK5XE6X02BKSkqUmJioo0ePKiIiwuly/Abn1fs4p/bgvNrDm+fVsiyVlpYqISFBAQHc7XUt9HJ+j72J8+p9nFN7cF7t4UQv9/sr3QEBAWrXrp3TZTgmIiKCX1IbcF69j3NqD86rPbx1XrnCfWPo5fwe24Hz6n2cU3twXu3RkL2cf1oHAAAAAMAmhG4AAAAAAGxC6PZTwcHBmjJlioKDg50uxa9wXr2Pc2oPzqs9OK9oSPz/Zg/Oq/dxTu3BebWHE+fV7xdSAwAAAADAKVzpBgAAAADAJoRuAAAAAABsQugGAAAAAMAmhG4/M2PGDPXu3Vvh4eGKiYnR0KFDVVBQ4HRZfuW1116Ty+XS+PHjnS7F5x07dkyPP/64oqOjFRoaqu7du2vbtm1Ol+XTKisrNXnyZCUnJys0NFSdOnXSK6+8IpbvuHFfffWVhgwZooSEBLlcLn3yySce71uWpZdeeknx8fEKDQ1VVlaW9u/f70yx8Ev0cvvRy72HXu599PJb19h6OaHbz6xbt045OTnavHmz1qxZo0uXLumBBx7Q+fPnnS7NL+Tm5mrOnDnq0aOH06X4vJ9++kn9+/dXUFCQVq9erT179ujNN99UVFSU06X5tJkzZ2r27Nl69913tXfvXs2cOVOvv/663nnnHadL8xnnz59Xz5499de//rXe919//XW9/fbbev/997VlyxaFhYVp4MCBKi8vb+BK4a/o5fail3sPvdwe9PJb1+h6uQW/VlxcbEmy1q1b53QpPq+0tNRKSUmx1qxZY917773WuHHjnC7Jp73wwgvWgAEDnC7D7wwePNgaNWqUx7Zhw4ZZ2dnZDlXk2yRZy5cvr3ldVVVlxcXFWW+88UbNtrNnz1rBwcHW4sWLHagQTQG93Hvo5d5FL7cHvdy7GkMv50q3nzt37pwkqVWrVg5X4vtycnI0ePBgZWVlOV2KX1ixYoXS09P1+9//XjExMbrjjjv0wQcfOF2Wz+vXr5/Wrl2rffv2SZLy8/O1fv16DRo0yOHK/MOhQ4dUWFjo8edAZGSk+vTpo02bNjlYGfwZvdx76OXeRS+3B73cXk70crctn4pGoaqqSuPHj1f//v3VrVs3p8vxaUuWLNGOHTuUm5vrdCl+4/vvv9fs2bM1ceJE/fnPf1Zubq6ee+45NWvWTCNHjnS6PJ81adIklZSUqGvXrgoMDFRlZaWmT5+u7Oxsp0vzC4WFhZKk2NhYj+2xsbE17wHeRC/3Hnq599HL7UEvt5cTvZzQ7cdycnK0e/durV+/3ulSfNrRo0c1btw4rVmzRiEhIU6X4zeqqqqUnp6uV199VZJ0xx13aPfu3Xr//fdp1Ldg6dKlWrhwoRYtWqS0tDTl5eVp/PjxSkhI4LwCPohe7h30cnvQy+1BL/c/TC/3U2PGjNFnn32mL7/8Uu3atXO6HJ+2fft2FRcXq1evXnK73XK73Vq3bp3efvttud1uVVZWOl2iT4qPj9ftt9/usS01NVVHjhxxqCL/8Mc//lGTJk3So48+qu7du2vEiBGaMGGCZsyY4XRpfiEuLk6SVFRU5LG9qKio5j3AW+jl3kMvtwe93B70cns50csJ3X7GsiyNGTNGy5cv1z//+U8lJyc7XZLPy8zM1K5du5SXl1cz0tPTlZ2drby8PAUGBjpdok/q379/nUfg7Nu3T+3bt3eoIv9w4cIFBQR4/tEeGBioqqoqhyryL8nJyYqLi9PatWtrtpWUlGjLli3KyMhwsDL4E3q599HL7UEvtwe93F5O9HKml/uZnJwcLVq0SJ9++qnCw8Nr7kuIjIxUaGiow9X5pvDw8Dr30YWFhSk6Opr7627BhAkT1K9fP7366qt65JFHtHXrVs2dO1dz5851ujSfNmTIEE2fPl1JSUlKS0vTN998o1mzZmnUqFFOl+YzysrKdODAgZrXhw4dUl5enlq1aqWkpCSNHz9e06ZNU0pKipKTkzV58mQlJCRo6NChzhUNv0Iv9z56uT3o5fagl9+6RtfLbVkTHY6RVO+YP3++06X5FR4z4h0rV660unXrZgUHB1tdu3a15s6d63RJPq+kpMQaN26clZSUZIWEhFgdO3a0XnzxRauiosLp0nzGl19+We+foyNHjrQsyzxqZPLkyVZsbKwVHBxsZWZmWgUFBc4WDb9CL28Y9HLvoJd7H7381jW2Xu6yLMuyJ84DAAAAANC0cU83AAAAAAA2IXQDAAAAAGATQjcAAAAAADYhdAMAAAAAYBNCNwAAAAAANiF0AwAAAABgE0I3AAAAAAA2IXQDAAAAAGATQjcA27lcLn3yySdOlwEAAG4SvRy4eYRuwM/94Q9/kMvlqjMefPBBp0sDAAA3gF4O+Da30wUAsN+DDz6o+fPne2wLDg52qBoAAPBr0csB38WVbqAJCA4OVlxcnMeIioqSZKaLzZ49W4MGDVJoaKg6duyojz/+2OP7d+3apfvvv1+hoaGKjo7Wk08+qbKyMo99PvzwQ6WlpSk4OFjx8fEaM2aMx/unTp3Sww8/rObNmyslJUUrVqyw96ABAPAj9HLAdxG6AWjy5MkaPny48vPzlZ2drUcffVR79+6VJJ0/f14DBw5UVFSUcnNztWzZMn3xxRcejXj27NnKycnRk08+qV27dmnFihW67bbbPH7Gyy+/rEceeUQ7d+7Ub37zG2VnZ+vMmTMNepwAAPgrejnQiFkA/NrIkSOtwMBAKywszGNMnz7dsizLkmQ9/fTTHt/Tp08f65lnnrEsy7Lmzp1rRUVFWWVlZTXvr1q1ygoICLAKCwsty7KshIQE68UXX7xqDZKsv/zlLzWvy8rKLEnW6tWrvXacAAD4K3o54Nu4pxtoAu677z7Nnj3bY1urVq1qvs7IyPB4LyMjQ3l5eZKkvXv3qmfPngoLC6t5v3///qqqqlJBQYFcLpeOHz+uzMzMa9bQo0ePmq/DwsIUERGh4uLimz0kAACaFHo54LsI3UATEBYWVmeKmLeEhobe0H5BQUEer10ul6qqquwoCQAAv0MvB3wX93QD0ObNm+u8Tk1NlSSlpqYqPz9f58+fr3l/w4YNCggIUJcuXRQeHq4OHTpo7dq1DVozAACoRS8HGi+udANNQEVFhQoLCz22ud1utW7dWpK0bNkypaena8CAAVq4cKG2bt2qefPmSZKys7M1ZcoUjRw5UlOnTtXJkyc1duxYjRgxQrGxsZKkqVOn6umnn1ZMTIwGDRqk0tJSbdiwQWPHjm3YAwUAwE/RywHfRegGmoC///3vio+P99jWpUsXfffdd5LMaqRLlizRs88+q/j4eC1evFi33367JKl58+b6/PPPNW7cOPXu3VvNmzfX8OHDNWvWrJrPGjlypMrLy/XWW2/p+eefV+vWrfW73/2u4Q4QAAA/Ry8HfJfLsizL6SIAOMflcmn58uUaOnSo06UAAICbQC8HGjfu6QYAAAAAwCaEbgAAAAAAbML0cgAAAAAAbMKVbgAAAAAAbELoBgAAAADAJoRuAAAAAABsQugGAAAAAMAmhG4AAAAAAGxC6AYAAAAAwCaEbgAAAAAAbELoBgAAAADAJoRuAAAAAABs8r/o5qunnlKN4wAAAABJRU5ErkJggg==",
|
||
"text/plain": [
|
||
"<Figure size 1000x500 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5e-2\n",
|
||
"num_epochs = 10\n",
|
||
"batch_size = 512\n",
|
||
"num_classes = 10\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True,)\n",
|
||
"test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14,pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_3(num_classes).to(device)\n",
|
||
"criterion = nn.CrossEntropyLoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (images, targets) in enumerate(train_loader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" images = images.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" one_hot_targets = one_hot(targets, num_classes=num_classes).to(dtype=torch.float)\n",
|
||
"\n",
|
||
" outputs = model(images)\n",
|
||
" loss = criterion(outputs, one_hot_targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (image, targets) in enumerate(test_loader):\n",
|
||
" image = image.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" outputs = model(image)\n",
|
||
" pred = softmax(outputs, dim=1)\n",
|
||
" total_epoch_acc += (pred.argmax(1) == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Python 3 (ipykernel)",
|
||
"language": "python",
|
||
"name": "python3"
|
||
},
|
||
"language_info": {
|
||
"codemirror_mode": {
|
||
"name": "ipython",
|
||
"version": 3
|
||
},
|
||
"file_extension": ".py",
|
||
"mimetype": "text/x-python",
|
||
"name": "python",
|
||
"nbconvert_exporter": "python",
|
||
"pygments_lexer": "ipython3",
|
||
"version": "3.10.13"
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 4
|
||
}
|