10-advanced-convolutional-neural-network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "from torchvision import datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 卷积神经网络(进阶)\n",
    "\n",
    "### Inception Module\n",
    "\n",
    "在一个module中, 通过不同的branch, 实现不同尺度的特征提取.\n",
    "\n",
    "- What is 1x1 convolution?\n",
    "  - 起到\"信息融合\"的作用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionA(torch.nn.Module):\n",
    "    def __init__(self, in_channels):\n",
    "        super().__init__()\n",
    "\n",
    "        self.branch1x1 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "\n",
    "        self.branch5x5_1 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "        self.branch5x5_2 = torch.nn.Conv2d(16, 24, kernel_size=5, padding=2)\n",
    "\n",
    "        self.branch3x3_1 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)\n",
    "        self.branch3x3_2 = torch.nn.Conv2d(16, 24, kernel_size=3, padding=1)\n",
    "        self.branch3x3_3 = torch.nn.Conv2d(24, 24, kernel_size=3, padding=1)\n",
    "\n",
    "        self.branch_pool = torch.nn.Conv2d(in_channels, 24, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Branch: 1x1 conv\n",
    "        branch1x1 = self.branch1x1(x)\n",
    "\n",
    "        # Branch: 1x1 conv -> 5x5 conv\n",
    "        branch5x5 = self.branch5x5_1(x)\n",
    "        branch5x5 = self.branch5x5_2(branch5x5)\n",
    "\n",
    "        # Branch: 1x1 conv -> 3x3 conv -> 3x3 conv\n",
    "        branch3x3 = self.branch3x3_1(x)\n",
    "        branch3x3 = self.branch3x3_2(branch3x3)\n",
    "        branch3x3 = self.branch3x3_3(branch3x3)\n",
    "\n",
    "        # Branch: avg-pooling -> 1x1 conv\n",
    "        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)\n",
    "        branch_pool = self.branch_pool(branch_pool)\n",
    "\n",
    "        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]\n",
    "        return torch.cat(outputs, 1)\n",
    "    \n",
    "class Net(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = torch.nn.Conv2d(1, 10, 5)\n",
    "        self.conv2 = torch.nn.Conv2d(88, 20, 5)\n",
    "\n",
    "        self.incep1 = InceptionA(10)\n",
    "        self.incep2 = InceptionA(20)\n",
    "\n",
    "        self.mp = torch.nn.MaxPool2d(2)\n",
    "        self.fc = torch.nn.Linear(1408, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        in_size = x.size(0)\n",
    "        x = F.relu(self.mp(self.conv1(x)))\n",
    "        x = self.incep1(x)\n",
    "        x = F.relu(self.mp(self.conv2(x)))\n",
    "        x = self.incep2(x)\n",
    "        x = x.view(in_size, -1)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),                      # Convert PIL image to PyTorch Tensor.\n",
    "    transforms.Normalize((0.1307,), (0.3081,))  # Normalize using the mean value and std loss value\n",
    "])\n",
    "\n",
    "train_dataset = datasets.MNIST(root='./dataset/mnist', train=True, transform=transform, download=True)\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(root='./dataset/mnist', train=False, transform=transform, download=True)\n",
    "test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "model = Net()\n",
    "\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "\n",
    "def train(epoch: int):\n",
    "    running_loss = 0.0\n",
    "    for batch_idx, (inputs, target) in enumerate(train_loader):\n",
    "        inputs, target = inputs.to(device), target.to(device)\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        if batch_idx % 100 == 99:\n",
    "            print(f'[{epoch + 1}, {batch_idx + 1:5d}] loss: {running_loss / 100:.3f}')\n",
    "            running_loss = 0.0\n",
    "\n",
    "def test():\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for (images, labels) in test_loader:\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "            outputs = model(images)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "    print(f'Accuracy on test set: {100 * correct / total: .4f}%')\n",
    "    return 100 * correct / total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,   100] loss: 1.557\n",
      "[1,   200] loss: 0.452\n",
      "[1,   300] loss: 0.300\n",
      "[1,   400] loss: 0.235\n",
      "[1,   500] loss: 0.182\n",
      "[1,   600] loss: 0.165\n",
      "[1,   700] loss: 0.163\n",
      "[1,   800] loss: 0.115\n",
      "[1,   900] loss: 0.126\n",
      "Accuracy on test set:  96.8700%\n",
      "[2,   100] loss: 0.117\n",
      "[2,   200] loss: 0.112\n",
      "[2,   300] loss: 0.106\n",
      "[2,   400] loss: 0.105\n",
      "[2,   500] loss: 0.096\n",
      "[2,   600] loss: 0.104\n",
      "[2,   700] loss: 0.084\n",
      "[2,   800] loss: 0.097\n",
      "[2,   900] loss: 0.092\n",
      "Accuracy on test set:  97.6900%\n",
      "[3,   100] loss: 0.074\n",
      "[3,   200] loss: 0.071\n",
      "[3,   300] loss: 0.083\n",
      "[3,   400] loss: 0.085\n",
      "[3,   500] loss: 0.084\n",
      "[3,   600] loss: 0.074\n",
      "[3,   700] loss: 0.070\n",
      "[3,   800] loss: 0.080\n",
      "[3,   900] loss: 0.074\n",
      "Accuracy on test set:  98.1600%\n",
      "[4,   100] loss: 0.073\n",
      "[4,   200] loss: 0.069\n",
      "[4,   300] loss: 0.061\n",
      "[4,   400] loss: 0.067\n",
      "[4,   500] loss: 0.061\n",
      "[4,   600] loss: 0.059\n",
      "[4,   700] loss: 0.070\n",
      "[4,   800] loss: 0.059\n",
      "[4,   900] loss: 0.066\n",
      "Accuracy on test set:  98.4500%\n",
      "[5,   100] loss: 0.052\n",
      "[5,   200] loss: 0.052\n",
      "[5,   300] loss: 0.060\n",
      "[5,   400] loss: 0.055\n",
      "[5,   500] loss: 0.059\n",
      "[5,   600] loss: 0.054\n",
      "[5,   700] loss: 0.062\n",
      "[5,   800] loss: 0.056\n",
      "[5,   900] loss: 0.059\n",
      "Accuracy on test set:  98.5100%\n",
      "[6,   100] loss: 0.052\n",
      "[6,   200] loss: 0.051\n",
      "[6,   300] loss: 0.049\n",
      "[6,   400] loss: 0.057\n",
      "[6,   500] loss: 0.049\n",
      "[6,   600] loss: 0.049\n",
      "[6,   700] loss: 0.043\n",
      "[6,   800] loss: 0.046\n",
      "[6,   900] loss: 0.051\n",
      "Accuracy on test set:  98.4600%\n",
      "[7,   100] loss: 0.054\n",
      "[7,   200] loss: 0.038\n",
      "[7,   300] loss: 0.051\n",
      "[7,   400] loss: 0.047\n",
      "[7,   500] loss: 0.042\n",
      "[7,   600] loss: 0.045\n",
      "[7,   700] loss: 0.042\n",
      "[7,   800] loss: 0.045\n",
      "[7,   900] loss: 0.046\n",
      "Accuracy on test set:  98.6600%\n",
      "[8,   100] loss: 0.040\n",
      "[8,   200] loss: 0.050\n",
      "[8,   300] loss: 0.038\n",
      "[8,   400] loss: 0.047\n",
      "[8,   500] loss: 0.045\n",
      "[8,   600] loss: 0.036\n",
      "[8,   700] loss: 0.032\n",
      "[8,   800] loss: 0.040\n",
      "[8,   900] loss: 0.043\n",
      "Accuracy on test set:  98.6300%\n",
      "[9,   100] loss: 0.032\n",
      "[9,   200] loss: 0.037\n",
      "[9,   300] loss: 0.037\n",
      "[9,   400] loss: 0.038\n",
      "[9,   500] loss: 0.045\n",
      "[9,   600] loss: 0.036\n",
      "[9,   700] loss: 0.035\n",
      "[9,   800] loss: 0.037\n",
      "[9,   900] loss: 0.043\n",
      "Accuracy on test set:  98.7700%\n",
      "[10,   100] loss: 0.027\n",
      "[10,   200] loss: 0.037\n",
      "[10,   300] loss: 0.034\n",
      "[10,   400] loss: 0.044\n",
      "[10,   500] loss: 0.030\n",
      "[10,   600] loss: 0.034\n",
      "[10,   700] loss: 0.036\n",
      "[10,   800] loss: 0.033\n",
      "[10,   900] loss: 0.038\n",
      "Accuracy on test set:  98.7000%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epochs = []\n",
    "accuracies = []\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    for epoch in range(10):\n",
    "        train(epoch)\n",
    "        epochs.append(epoch + 1)\n",
    "        accuracies.append(test())\n",
    "    plt.plot(epochs, accuracies)\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Residual Network\n",
    "\n",
    "### 实现 ResBlock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(torch.nn.Module):\n",
    "    def __init__(self, channels):\n",
    "        super().__init__()\n",
    "        self.channels = channels\n",
    "        self.conv1 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "        self.conv2 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        y = F.relu(self.conv1(x))\n",
    "        y = self.conv2(y)\n",
    "        return F.relu(x + y)\n",
    "    \n",
    "class Net(torch.nn.Module):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=5)\n",
    "        self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=5)\n",
    "        self.mp = torch.nn.MaxPool2d(2)\n",
    "\n",
    "        self.rblock1 = ResidualBlock(16)\n",
    "        self.rblock2 = ResidualBlock(32)\n",
    "\n",
    "        self.fc = torch.nn.Linear(512, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        in_size = x.size(0)\n",
    "        x = self.mp(F.relu(self.conv1(x)))\n",
    "        x = self.rblock1(x)\n",
    "        x = self.mp(F.relu(self.conv2(x)))\n",
    "        x = self.rblock2(x)\n",
    "        x = x.view(in_size, -1)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),                      # Convert PIL image to PyTorch Tensor.\n",
    "    transforms.Normalize((0.1307,), (0.3081,))  # Normalize using the mean value and std loss value\n",
    "])\n",
    "\n",
    "train_dataset = datasets.MNIST(root='./dataset/mnist', train=True, transform=transform, download=True)\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(root='./dataset/mnist', train=False, transform=transform, download=True)\n",
    "test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "model = Net()\n",
    "\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "\n",
    "def train(epoch: int):\n",
    "    running_loss = 0.0\n",
    "    for batch_idx, (inputs, target) in enumerate(train_loader):\n",
    "        inputs, target = inputs.to(device), target.to(device)\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        if batch_idx % 100 == 99:\n",
    "            print(f'[{epoch + 1}, {batch_idx + 1:5d}] loss: {running_loss / 100:.3f}')\n",
    "            running_loss = 0.0\n",
    "\n",
    "def test():\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for (images, labels) in test_loader:\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "            outputs = model(images)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "    print(f'Accuracy on test set: {100 * correct / total: .4f}%')\n",
    "    return 100 * correct / total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,   100] loss: 1.052\n",
      "[1,   200] loss: 0.305\n",
      "[1,   300] loss: 0.232\n",
      "[1,   400] loss: 0.188\n",
      "[1,   500] loss: 0.149\n",
      "[1,   600] loss: 0.140\n",
      "[1,   700] loss: 0.139\n",
      "[1,   800] loss: 0.114\n",
      "[1,   900] loss: 0.106\n",
      "Accuracy on test set:  97.2000%\n",
      "[2,   100] loss: 0.101\n",
      "[2,   200] loss: 0.098\n",
      "[2,   300] loss: 0.081\n",
      "[2,   400] loss: 0.077\n",
      "[2,   500] loss: 0.090\n",
      "[2,   600] loss: 0.078\n",
      "[2,   700] loss: 0.073\n",
      "[2,   800] loss: 0.079\n",
      "[2,   900] loss: 0.076\n",
      "Accuracy on test set:  98.0900%\n",
      "[3,   100] loss: 0.069\n",
      "[3,   200] loss: 0.065\n",
      "[3,   300] loss: 0.059\n",
      "[3,   400] loss: 0.062\n",
      "[3,   500] loss: 0.059\n",
      "[3,   600] loss: 0.062\n",
      "[3,   700] loss: 0.064\n",
      "[3,   800] loss: 0.052\n",
      "[3,   900] loss: 0.056\n",
      "Accuracy on test set:  98.1400%\n",
      "[4,   100] loss: 0.045\n",
      "[4,   200] loss: 0.045\n",
      "[4,   300] loss: 0.053\n",
      "[4,   400] loss: 0.059\n",
      "[4,   500] loss: 0.049\n",
      "[4,   600] loss: 0.049\n",
      "[4,   700] loss: 0.047\n",
      "[4,   800] loss: 0.046\n",
      "[4,   900] loss: 0.044\n",
      "Accuracy on test set:  98.7000%\n",
      "[5,   100] loss: 0.049\n",
      "[5,   200] loss: 0.041\n",
      "[5,   300] loss: 0.038\n",
      "[5,   400] loss: 0.040\n",
      "[5,   500] loss: 0.043\n",
      "[5,   600] loss: 0.036\n",
      "[5,   700] loss: 0.042\n",
      "[5,   800] loss: 0.036\n",
      "[5,   900] loss: 0.043\n",
      "Accuracy on test set:  98.6300%\n",
      "[6,   100] loss: 0.034\n",
      "[6,   200] loss: 0.040\n",
      "[6,   300] loss: 0.036\n",
      "[6,   400] loss: 0.033\n",
      "[6,   500] loss: 0.041\n",
      "[6,   600] loss: 0.029\n",
      "[6,   700] loss: 0.035\n",
      "[6,   800] loss: 0.036\n",
      "[6,   900] loss: 0.028\n",
      "Accuracy on test set:  98.7400%\n",
      "[7,   100] loss: 0.027\n",
      "[7,   200] loss: 0.033\n",
      "[7,   300] loss: 0.028\n",
      "[7,   400] loss: 0.029\n",
      "[7,   500] loss: 0.030\n",
      "[7,   600] loss: 0.034\n",
      "[7,   700] loss: 0.034\n",
      "[7,   800] loss: 0.032\n",
      "[7,   900] loss: 0.032\n",
      "Accuracy on test set:  98.8100%\n",
      "[8,   100] loss: 0.028\n",
      "[8,   200] loss: 0.023\n",
      "[8,   300] loss: 0.023\n",
      "[8,   400] loss: 0.029\n",
      "[8,   500] loss: 0.026\n",
      "[8,   600] loss: 0.027\n",
      "[8,   700] loss: 0.028\n",
      "[8,   800] loss: 0.027\n",
      "[8,   900] loss: 0.025\n",
      "Accuracy on test set:  98.9900%\n",
      "[9,   100] loss: 0.024\n",
      "[9,   200] loss: 0.028\n",
      "[9,   300] loss: 0.018\n",
      "[9,   400] loss: 0.023\n",
      "[9,   500] loss: 0.027\n",
      "[9,   600] loss: 0.021\n",
      "[9,   700] loss: 0.027\n",
      "[9,   800] loss: 0.029\n",
      "[9,   900] loss: 0.024\n",
      "Accuracy on test set:  98.8800%\n",
      "[10,   100] loss: 0.023\n",
      "[10,   200] loss: 0.019\n",
      "[10,   300] loss: 0.018\n",
      "[10,   400] loss: 0.021\n",
      "[10,   500] loss: 0.021\n",
      "[10,   600] loss: 0.026\n",
      "[10,   700] loss: 0.022\n",
      "[10,   800] loss: 0.025\n",
      "[10,   900] loss: 0.019\n",
      "Accuracy on test set:  98.8600%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGwCAYAAABSN5pGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUM0lEQVR4nO3deVxU9f4/8NewDQMCsu+OLAruewiWK7nkLTEq89rVXPJaeG/cyrpYlqVmmS0/rbT6qhWodK3cWiRERVFAU3FJQsEFkEVFmGFnmDm/P5DJAVFAhsMwr+fjMY/inMNn3kfUefk5n/M+EkEQBBARERGRlonYBRARERF1NAxIRERERA0wIBERERE1wIBERERE1AADEhEREVEDDEhEREREDTAgERERETVgJnYBhkqj0SAvLw82NjaQSCRil0NERETNIAgCSktL4eHhAROTpueJGJBaKS8vD97e3mKXQURERK2Qk5MDLy+vJvczILWSjY0NgLpfYFtbW5GrISIiouZQKpXw9vbWfo43hQGpleovq9na2jIgERERGZh7LY/hIm0iIiKiBhiQiIiIiBpgQCIiIiJqgAGJiIiIqAEGJCIiIqIGGJCIiIiIGmBAIiIiImqAAYmIiIioAVEDUmlpKSIjIyGXyyGTyRASEoJjx45p9xcWFuLZZ5+Fh4cHrKysMHHiRFy4cOGe427btg2BgYGwtLREv3798Msvv+jsFwQBb775Jtzd3SGTyRAaGtqscYmIiMg4iBqQ5s2bh/j4eERHR+PMmTMYP348QkNDcfXqVQiCgLCwMFy8eBE7d+7EyZMnIZfLERoaivLy8ibHPHLkCKZPn465c+fi5MmTCAsLQ1hYGM6ePas9ZtWqVVizZg3Wr1+P1NRUWFtbY8KECaiqqmqP0yYiIqIOTiIIgiDGG1dWVsLGxgY7d+7E5MmTtduHDBmCSZMmYebMmQgICMDZs2fRp08fAIBGo4GbmxveffddzJs3747jTps2DeXl5fjpp5+024YPH46BAwdi/fr1EAQBHh4eePnll/HKK68AABQKBVxdXfH111/j6aefblb9SqUSdnZ2UCgUfNQIERGRgWju57doM0i1tbVQq9WwtLTU2S6TyZCUlITq6moA0NlvYmICqVSKpKSkJsdNTk5GaGiozrYJEyYgOTkZAHDp0iUUFBToHGNnZ4egoCDtMXdSXV0NpVKp8yIiIqLOSbSAZGNjg+DgYCxbtgx5eXlQq9WIiYlBcnIy8vPzERgYiG7duiEqKgrFxcWoqanB+++/j9zcXOTn5zc5bkFBAVxdXXW2ubq6oqCgQLu/fltTx9zJypUrYWdnp315e3u39tSJiKiDqVVrUF5dK3YZ1IGIugYpOjoagiDA09MTUqkUa9aswfTp02FiYgJzc3P8+OOPOH/+PBwcHGBlZYX9+/dj0qRJMDFp/7KjoqKgUCi0r5ycnHavgYiI2t7vl28i9KNEDHznN/x760kcvXQTIq0+oQ7ETMw39/PzQ2JiIsrLy6FUKuHu7o5p06bB19cXQN16pLS0NCgUCtTU1MDZ2RlBQUEYOnRok2O6ubmhsLBQZ1thYSHc3Ny0++u3ubu76xwzcODAJseVSqWQSqWtPVUiIupgqlRqfPhbBv4v6RLq89CuU3nYdSoPAa42eGZ4N4QN8oSNpbm4hZIoOkQfJGtra7i7u6O4uBhxcXGYMmWKzn47Ozs4OzvjwoUL+P333xvtv11wcDASEhJ0tsXHxyM4OBgA4OPjAzc3N51jlEolUlNTtccQEVHndjK7GJPXHMJXh+rC0ZNDvLBtQTCmP+ANmbkpMgpLsWTnHxj+bgJe334G6flcd2psRLuLDQDi4uIgCAICAgKQmZmJRYsWwdLSEocOHYK5uTm2bdsGZ2dndOvWDWfOnMGLL76IIUOG4IcfftCOMXPmTHh6emLlypUA6m7zHzVqFN577z1MnjwZsbGxePfdd3HixAn07dsXAPD+++/jvffewzfffAMfHx8sWbIEp0+fxrlz5xotGm8K72IjIjI81bVq/L+9F7A+MQsaAXCxkWLl4/0wrtdf61IVlSpsP5GL6JQryLr+V1uZoXJ7PDNcjkn93CA1MxWjfGoDzf38FvUSm0KhQFRUFHJzc+Hg4IDw8HCsWLEC5uZ105n5+fl46aWXtJfDZs6ciSVLluiMkZ2drbMmKSQkBFu2bMEbb7yBxYsXo0ePHtixY4c2HAHAq6++ivLycsyfPx8lJSV48MEHsWfPnmaHIyIiMjxnryrw8v9OIaOwFAAQNtADSx/rg65WFjrH2cnM8ewIH8wK6Y6UizcRk3IFcX8U4Pcrxfj9SjGW/WSBJ4d6Y0ZQN3g7WIlxKtQORJ1BMmScQSIiMgw1tRp8tj8Tn+3PRK1GgKO1BVZM7YeJfd2aPcY1ZRVij+VgS2o2CpR1TYUlEmBMgAueGd4No3q6wNREoq9ToDbU3M9vBqRWYkAiIur40vOVePl/p3Du1hqiyf3c8c6UPnDs0rqbbmrVGiT8eQ0xKVdw6MIN7XYvexn+HtQNTw31hlMrx6b2wYCkZwxIREQdV61ag/WJWfh/CRegUgvoamWOZVP64tEBHm32HpdulGNzyhVsO54LRaUKAGBuKsEj/dzxzHA5hsrtIZFwVqmjYUDSMwYkIqKOKfNaKV7+3ymcylUAAB7u7YoVU/vCxUY/60yrVGr8dDof0SlXcCqnRLs90M0GM4bLMXWQJ7pIRV3yS7dhQNIzBiQioo5FrRHwf4cu4sP486ip1cDW0gxLH+uDqYM8220m50yuAjEpV7Dz1FVUqTQAAGsLU0wd7IlnhssR6MbPC7ExIOkZAxIRUcdx6UY5Xtl2CsevFAMARgc4473H+8PNTpy7kxUVKvxwIhcxqVdw8bZWAcO617UKmNiXrQLEwoCkZwxIRETi02gEfH3kMlbF/YkqlQZdpGZY8rdeeGqod4dY/yMIApKzihCdcgW/nSuEWlP3ketobYFpw7wx/QG2CmhvDEh6xoBERCSu7KIKvPL9KRy9dBMA8KC/E95/oj88u8pEruzOChRViD2Wja1Hs1GorAZQ1ypgbIALnhkux8iezmwV0A4YkPSMAYmISByCICAmNRsrf0lHRY0aVhamiHqkF54J6tYhZo3uRaXWICG9EDEp2UjK/KtVgLeDDH9/QI6nhnq1ug0B3RsDkp4xIBERtb+rJZV47fvT2mAR5OOAD54YgG6OhnmZ6uL1MmxOzca233OgrKoFAFiYmuCRfm74R7Acg7uxVUBbY0DSMwYkIqL2IwgC/vd7Dpb9lI6y6lpYmpvgtYmBmBXcHSad4LJUZY0au0/nISblCk7fak8A1LUK+EewHGEDPWHNVgFtggFJzxiQiIjaR4GiClE/nsb+jOsAgMHdumL1kwPg69xF5Mr041ROCWJSrmDXqTxU19a1CugiNcPjt1oF9HS1EblCw8aApGcMSERE+iUIArafvIqlu/6AsqoWFmYmeGV8T8x90NcoFjOXVNTg++O52JyajUs3/moV8ICPQ12rgD5usDAzucsIdCcMSHrGgEREpD/XSqvw+vaziD9XCAAY4GWH1U8OQA8jnD3RaAQcySpCTMoVxKf/1SrAqctfrQK87A1zDZYYGJD0jAGJiEg/dp/Kw5s7z6K4QgVzUwkiQ3vinyN9YWbK2ZICRRW2Hq1rFXCttK5VgIkEGBt4q1VAD+dOsSZLnxiQ9IwBiYiobRWVVePNnX/g5zP5AIDe7rb48KkB6OXOv2MbUqk12HuuENEpV3Akq0i7vZuDFaYO8oRHV0t0tbKAg7UF7K3M0dXKAl1l5gyZYEDSOwYkIqK2s+dsAV7ffgZF5TUwM5EgYow/Isb4c41NM2ReK8Pm1Cv4/nguSm+1CmiKjaUZHKwt0NWqLjjZW1mgq5U5HKws0NW6wTZrC9hbWcDSvHM9EoUBSc8YkIiI7l9JRQ2W7voDO9LyAAABrjb48KkB6OtpJ3Jlhqeipha7T+Uh9eJNFFfUoLhCVfff8hptj6XWsDQ3uRWabgUonSB1+7a/ZqtsLc06bP8mBiQ9Y0AiIro/CemF+O+PZ3C9tBomEmDBKD+8GNqDD3HVg1q1BopKlU5oKqn//woVSipqcPMO22o1rYsIpiYSdJX9FaZun7HS3fZXwGqvS4DN/fxm1ykiImpXyioV3tl9Dt8fzwUA+Dpb48MnB2BQN3uRK+u8zExN4NhF2qJHmAiCgNLqWpSU14emugBVF6T+mqEquS10FVeoUKlSQ60RUFReg6LymhbVaWNppjMTNTNYjnG9XFt6um2CAYmIiNrNwfPX8doPp5GvqIJEAsx70Acvjw/odOtcOgOJRAJbS3PYWpq36FEuVSp1o9BUF6R0L/vVz1IVV6igqFQBAEqralFaVYvsuucP45F+bvo4tWZhQCIiIr0rq67Fip/TsfVoNgBA7miF1U8OwLDuDiJXRm3N0twUbnamcLOzbPb33H4J8PYgJebvDwYkIiLSqyNZN/Dq96eRW1wJAJgVLMdrkwJhZcGPIKrTmkuA+sbfnUREpBcVNbV4/9c/8U3yFQCAl70Mq57ojxA/J5ErI7o3BiQiImpzxy7fxCvbTuFKUQUA4O9B3bD4kV7owifSk4Hg71QiImozVSo1VsdlYMPhSxAEwN3OEu+H98fIns5il0bUIgxIRETUJk5mF+Plbadw8Xrdk+efHOKFN/7WG3Yyc5ErI2o5BiQiIrov1bVqfLL3Ar5IzIJGAJxtpHjv8X6i9a8hagsMSERE1CoqtQbHLt3E0t1/4HxhGQAgbKAHlj7WB12tLESujuj+MCAREVGzCIKAPwtKcTjzBo5kFSH1YhHKa9QAAEdrC6yY2g8T+4rX2I+oLTEgERFRk3JuVuBw5g0czipCctYN3CjTfXREVytzjO/titcmBnaoHjZE94sBiYiItIrKqnEkq+hWKLqBnJuVOvtl5qYY5uOAEX6OGOHvhN7utjAx6ZhPbSe6HwxIRERGrKy6FkcvFeFwZl0o+rOgVGe/qYkEA727YoSfI0L8nTCoW1dIzfjcNOr8GJCIiIxITa0GJ7OLcfjWLNGpnBLUagSdYwLdbDDC3wkj/B3xgI8jmzuSUeLveiKiTkyjEXAuX6ldR3Ts0k1UqtQ6x3g7yDDCzwkh/k4I8XOEE9cSETEgERF1JoIg4HJRxa07zeruNiupUOkc42htgRB/J+06Im8HK5GqJeq4GJCIiAzcNWUVjmQVISnzBo5k3kCeokpnv7WFKYJ8HRFyKxAFuNpwYTXRPZiI+ealpaWIjIyEXC6HTCZDSEgIjh07pt1fVlaGhQsXwsvLCzKZDL1798b69evvOubo0aMhkUgavSZPnqw95tlnn220f+LEiXo7TyKitqSsUuG3PwqwdNcfePijRDzwbgIiv0vD98dzkaeogrmpBEE+Dnjp4Z744flgpL01HhufHYZ5D/miF+86I2oWUWeQ5s2bh7NnzyI6OhoeHh6IiYlBaGgozp07B09PT7z00kvYt28fYmJi0L17d/z222944YUX4OHhgccee+yOY/7444+oqfmrT0dRUREGDBiAJ598Uue4iRMnYtOmTdqvpVJecyeijqlKpcaJK8U4nHUDSZlFOJNbgtvXVUskQB8PW4zwc8IIfycM6+4AmQXvNCO6H6IFpMrKSvzwww/YuXMnRo4cCQBYunQpdu/ejXXr1mH58uU4cuQIZs2ahdGjRwMA5s+fjy+++AJHjx5tMiA5ODjofB0bGwsrK6tGAUkqlcLNjR1fiajjUWsEnLmq0K4j+v1yMaprNTrH+DpZI8TfESP8nDDc1xH21ny0B1FbEi0g1dbWQq1Ww9LSUme7TCZDUlISACAkJAS7du3CnDlz4OHhgQMHDuD8+fP4+OOPm/0+GzZswNNPPw1ra2ud7QcOHICLiwvs7e0xduxYLF++HI6Ojk2OU11djerqau3XSqWy2TUQEd2NIAjIul6m7UWUcrEIyqpanWNcbKQYcesusxH+TvDoKhOpWiLjIBEEQbj3YfoREhICCwsLbNmyBa6urti6dStmzZoFf39/ZGRkoLq6GvPnz8e3334LMzMzmJiY4KuvvsLMmTObNf7Ro0cRFBSE1NRUPPDAA9rt9bNKPj4+yMrKwuLFi9GlSxckJyfD1PTO09JLly7F22+/3Wi7QqGAra1t634BiMhoXVNW4eCFG9pZokJltc5+G0szBPs6avsR+Tl3gUTCtUNE90upVMLOzu6en9+iBqSsrCzMmTMHBw8ehKmpKQYPHoyePXvi+PHjSE9Px+rVq/HVV19h9erVkMvlOHjwIKKiorB9+3aEhobec/x//vOfSE5OxunTp+963MWLF+Hn54e9e/di3LhxdzzmTjNI3t7eDEhE1GwajYDDWTcQnXwFCX9eg/q2hURSMxMM7W6PkFvriPp62MLMVNT7aIg6peYGJFEXafv5+SExMRHl5eVQKpVwd3fHtGnT4Ovri8rKSixevBjbt2/X3oHWv39/pKWlYfXq1fcMSOXl5YiNjcU777xzzzp8fX3h5OSEzMzMJgOSVCrlQm4iapWSihp8fzwXMSlXcLmoQrt9gJcdHuzhhBF+Thgst4elORdWE3UUHaIPkrW1NaytrVFcXIy4uDisWrUKKpUKKpUKJia6/4IyNTWFRqNpYqS/bNu2DdXV1XjmmWfueWxubi6Kiorg7u7e6nMgImroVE4JolOuYPepPO0iaxupGR4f7IkZw+Xo6WojcoVE1BRRA1JcXBwEQUBAQAAyMzOxaNEiBAYGYvbs2TA3N8eoUaOwaNEiyGQyyOVyJCYm4ttvv8VHH32kHWPmzJnw9PTEypUrdcbesGEDwsLCGi28Lisrw9tvv43w8HC4ubkhKysLr776Kvz9/TFhwoR2OW8i6rwqa9TYfSoP0SlXcOaqQru9l7st/jFcjikDPWDNZ5sRdXii/ilVKBSIiopCbm4uHBwcEB4ejhUrVsDc3BxA3WLqqKgozJgxAzdv3oRcLseKFSuwYMEC7RjZ2dmNZpkyMjKQlJSE3377rdF7mpqa4vTp0/jmm29QUlICDw8PjB8/HsuWLeMlNCJqtazrZYhJuYIfjudq70CzMDXB5P7ueGa4HIO7deUiayIDIuoibUPW3EVeRNR5qdQa7D1XiOiUKziSVaTd7u0gw4wgOZ4c4gVHPviVqEMxiEXaRESGqEBRha1Hs7H1aDauldbd3WoiAcYGuuCZ4XKM7OHMx3kQGTgGJCIjUFmjxqq4PyEzN8UIfycM4R1TLSYIAg5nFiEm5Qri0wu1t+g7dbHAtGHemP5AN3jZW4lcJRG1FQYkIiOw6cglbDp8GQDw+YEsWJiZYKjcXtuZuZ+nHXvuNEFRocL3J3KxOeUKLt4o125/wMcBzwyXY2IfN1iY8deOqLNhQCLq5Cpr1Nhw6BIAIMTPEVnXy1CorMaRrCLtuhkbSzMM93XEiFuPsfB3Ydfm07kliEm5gl2n8lClqrtFv4vUDFMHeeKZ4XIEuPEWfaLOjAGJqJP77lg2ispr4GUvw7dzHoCpiQRZ18txJOsGki789dyv+HOFiD9XCKDuuV8hfo4I8a/r6uxpJM/9qqxRY/fpPGxOuYJTuX/doh/oZoNnhssRNsgTXXiLPpFR4J90ok6splaDLw9eBAAsGOWnvYzm79IF/i5dMDO4O9QaAWevKnA46waOZBbh2OWbuFZajR1pediRlgcA8HGy1j4kNbgTPjn+4vUybE7NxvfHc6GoVAGou0X/kX5ueGa4HEPk9kY/o0ZkbHibfyvxNn8yBP/7PQevfn8azjZSHHp1TLMWZlep1DiRXYwjmUVIyryB07kluO2RYZBIgN7utrceouqEYd3tYWVheP/WqlVrsDf9GmJSriAp84Z2u5d93S36Tw3lLfpEnZFBPKzWkDEgUUen1gh4+KNEXLxRjsWPBGL+SL9WjaOsUiH14k3tU+fPF5bp7Dc3lWBQN3uM8Kt76vwA764w78ALvguVVYg9moOtR7NRoKwCUBf6xgbcukW/pzNMeYs+UafFgKRnDEjU0f18Oh8RW07ATmaOw/8d22ZrZ66VViE5qwiHM2/gcGYRrpZU6uy3tjDFAz4O2hmmAFcb0XsCCYKA5KwixKReQdwff92i72htgaeGeePvD3SDtwNv0ScyBmwUSWTEBEHAZ/szAQDPhnRv04XFLjaWmDLQE1MGekIQBFwpqtCuXzqSdQPFFSrsz7iO/RnXAdSFkOBb65dG+Dmhm2P7BRFFpQo/HM/F5tQryLr+1y36w7rb192i39cNUjP2gyKixjiD1EqcQaKObH/GNczedAxWFqY4/NrYdltUrdEISC9Q4khmEQ5n3cDRSzdRUaPWOcbLXoYH/Z0QcqsHk5Me1vmcvapAdPIV7Dx1VXuLvrWFKaYOrrtFP9CNf2aJjBUvsekZAxJ1ZE+uP4Jjl4vx3EM+eH1yb9HqqKnVIC2nRLt+6WR2CWo1un/lBLrZIOTW+qUgX8dWz3ZVqdT46XQ+olOu4FROiXZ7gKsNngmWYypv0SciMCDpHQMSdVRHL93EU18kw8LUBIdeGwNXW0uxS9Iqr67F0cs3ceTW+qVz+Uqd/aYmEgzwstPOMA3q1vWel8Au3yjH5tQr2HY8FyUVdbfom5tK8Eg/dzwzXI6hvEWfiG7DNUhERqp+7dETQ706VDgCAGupGcYEuGBMgAsAoKisGskXi3D41vqlK0UVOJFdghPZJVizLxOW5iYY1t1Bu36pt4ctTE0kqFVrkPBn3S36hy78dYu+Z1cZ/h7UDdOGeevl0h0RGQ8GJKJO5OxVBRLPX4eJBFjQytv625NjFyn+1t8Df+vvAQDILa7Qrl86nFmEG2XVOHThhjYE2cnMMay7A/7IUyBf8dct+qN7OuOZ4XKMDnDhLfpE1CYYkIg6kc8P1M0ePTbAo13vFmsrXvZWeGqYFZ4a5g1BEHDhWhmSLtStX0q5eBOKShX2ptc9DsXB2gJPDfXGjCDeok9EbY8BiaiTyLxWhl/PFgAAnh/tL3I1908ikaCnqw16utpgzoM+qFVrcPqqAr9fvglXW0veok9EesWARNRJrE/MgiAAD/d27ZRPmjczNcHgbvYY3M1e7FKIyAh03OcBEFGz5RZXYMfJqwCAF0Z3/LVHREQdHQMSUSfw1cGLqNUIGOHviEGcYSEium8MSEQG7nppNWKP5QAAIjrB2iMioo6AAYnIwG08fAnVtRoM9O6KYD9HscshIuoUGJCIDJiiUoXo5CsAgIgx/uwYTUTURhiQiAxYdPJllFXXIsDVBuMCXcQuh4io02BAIjJQFTW12Hj4MgDghTF+MGEHaSKiNsOARGSgYo/m4GZ5Dbo5WGFyP3exyyEi6lQYkIgMUE2tBl8evAgAWDDKD2am/KNMRNSW+LcqkQHafjIXBcoquNhIET7EU+xyiIg6HQYkIgOj1ghYdyALADB/pC+fR0ZEpAcMSEQG5pcz+bhcVAF7K3NMf6Cb2OUQEXVKDEhEBkQQBHy2PxMAMHuED6ylfN40EZE+MCARGZD9GdfwZ0EprC1MMSu4u9jlEBF1WgxIRAZCEAR8uq9u9uiZYDnsrMxFroiIqPNiQCIyEKmXbuJEdgkszEww90EfscshIurUGJCIDET92qNpQ73hYmMpcjVERJ0bAxKRATidW4JDF27A1ESC+SN9xS6HiKjTEzUglZaWIjIyEnK5HDKZDCEhITh27Jh2f1lZGRYuXAgvLy/IZDL07t0b69evv+uYX3/9NSQSic7L0lL3X9uCIODNN9+Eu7s7ZDIZQkNDceHCBb2cI1Fb+Hx/Xd+jKQM94O1gJXI1RESdn6gBad68eYiPj0d0dDTOnDmD8ePHIzQ0FFevXgUAvPTSS9izZw9iYmKQnp6OyMhILFy4ELt27brruLa2tsjPz9e+rly5orN/1apVWLNmDdavX4/U1FRYW1tjwoQJqKqq0tu5ErXWhcJS7PmjABIJ8MJoP7HLISIyCqIFpMrKSvzwww9YtWoVRo4cCX9/fyxduhT+/v5Yt24dAODIkSOYNWsWRo8eje7du2P+/PkYMGAAjh49etexJRIJ3NzctC9XV1ftPkEQ8Mknn+CNN97AlClT0L9/f3z77bfIy8vDjh079HnKRK2yLrFu9mhCbzf4u9iIXA0RkXEQLSDV1tZCrVY3uvwlk8mQlJQEAAgJCcGuXbtw9epVCIKA/fv34/z58xg/fvxdxy4rK4NcLoe3tzemTJmCP/74Q7vv0qVLKCgoQGhoqHabnZ0dgoKCkJyc3OSY1dXVUCqVOi8ifcu5WYGdaXkAgBfGcPaIiKi9iBaQbGxsEBwcjGXLliEvLw9qtRoxMTFITk5Gfn4+AGDt2rXo3bs3vLy8YGFhgYkTJ+Kzzz7DyJEjmxw3ICAAGzduxM6dOxETEwONRoOQkBDk5uYCAAoKCgBAZ1ap/uv6fXeycuVK2NnZaV/e3t73+0tAdE9fHrwItUbAQz2c0N+rq9jlEBEZDVHXIEVHR0MQBHh6ekIqlWLNmjWYPn06TEzqylq7di1SUlKwa9cuHD9+HB9++CEiIiKwd+/eJscMDg7GzJkzMXDgQIwaNQo//vgjnJ2d8cUXX9xXrVFRUVAoFNpXTk7OfY1HdC/XSqvw3e91v88ixviLXA0RkXER9UFOfn5+SExMRHl5OZRKJdzd3TFt2jT4+vqisrISixcvxvbt2zF58mQAQP/+/ZGWlobVq1frXCK7G3NzcwwaNAiZmXU9ZNzc3AAAhYWFcHd31x5XWFiIgQMHNjmOVCqFVCpt5ZkStdyGpEuoqdVgiNweQT4OYpdDRGRUOkQfJGtra7i7u6O4uBhxcXGYMmUKVCoVVCqVdjapnqmpKTQaTbPHVqvVOHPmjDYM+fj4wM3NDQkJCdpjlEolUlNTERwc3DYnRHSfFBUqxCTX3X0ZMcYPEolE5IqIiIyLqDNIcXFxEAQBAQEByMzMxKJFixAYGIjZs2fD3Nwco0aNwqJFiyCTySCXy5GYmIhvv/0WH330kXaMmTNnwtPTEytXrgQAvPPOOxg+fDj8/f1RUlKCDz74AFeuXMG8efMA1N3hFhkZieXLl6NHjx7w8fHBkiVL4OHhgbCwMDF+GYga+Sb5Mspr1Ah0s8GYABexyyEiMjqiBiSFQoGoqCjk5ubCwcEB4eHhWLFiBczN6x7CGRsbi6ioKMyYMQM3b96EXC7HihUrsGDBAu0Y2dnZOrNMxcXFeO6551BQUAB7e3sMGTIER44cQe/evbXHvPrqqygvL8f8+fNRUlKCBx98EHv27Gl0Rx2RGMqra7Hx8CUAdWuPOHtERNT+JIIgCGIXYYiUSiXs7OygUChga2srdjnUifzfoYtY/nM6ujtaIeHl0TA1YUAiImorzf387hBrkIioTnWtGl8duggAeH60H8MREZFIGJCIOpAfT1xFobIa7naWmDrIS+xyiIiMFgMSUQdRq9Zg/a3Hijz3kC8szPjHk4hILPwbmKiD+PlMPq4UVcDB2gJPP8BO7UREYmJAIuoANBoBn++vmz2aM6I7rCxEvcGUiMjoMSARdQD7/ryGjMJSdJGa4R/B3cUuh4jI6DEgEYlMEAR8ur/uUTj/CJbDTmYuckVERMSARCSy5ItFSMspgdTMBHNG+IhdDhERgQGJSHT1a4+eHuYNZxs+EJmIqCNgQCISUVpOCZIyb8DMRILnRvqKXQ4REd3CgEQkos9vrT0KG+QJL3srkashIqJ6DEhEIjlfWIrfzhVCIgEWjPITuxwiIroNAxKRSNYdqFt7NKmvG/xduohcDRER3Y4BiUgE2UUV2HUqDwDwwmh/kashIqKGGJCIRLD+YBbUGgGjejqjr6ed2OUQEVEDDEhE7axQWYXvf88FAESM4ewREVFHxIBE1M7+79BF1Kg1GNbdHg/4OIhdDhER3QEDElE7Ki6vwebUbADAC5w9IiLqsBiQiNrR10cuo6JGjd7uthjd01nscoiIqAkMSETtpKy6Fl8fuQygbu2RRCIRtyAiImoSAxJRO9mSegWKShV8nawxsa+b2OUQEdFdMCARtYMqlRpfHboEAFgw2g+mJpw9IiLqyBiQiNrB98dzcb20Gh52lggb6Cl2OUREdA8MSER6VqvWYH1i3WNF5o/0hYUZ/9gREXV0/JuaSM92n85DbnElHK0tMG1YN7HLISKiZmBAItIjjUbA5/vrZo/mPOgDmYWpyBUREVFzMCAR6VF8eiEuXCuDjdQM/wiWi10OERE1EwMSkZ4IgoDP92cCAGaGyGFraS5yRURE1FwMSER6cjizCKdyFbA0N8HsET5il0NERC3AgESkJ5/dmj16elg3OHWRilwNERG1BAMSkR4cv1KM5ItFMDORYP5IX7HLISKiFmJAItKDdQfqZo8eH+wJj64ykashIqKWYkAiamPp+UrsTb8GiQRYMMpP7HKIiKgVGJCI2ti6A3V9jx7p5w5f5y4iV0NERK3BgETUhi7fKMdPp/MAABGj/UWuhoiIWosBiagNfXEwCxoBGBvogt4etmKXQ0RErSRqQCotLUVkZCTkcjlkMhlCQkJw7Ngx7f6ysjIsXLgQXl5ekMlk6N27N9avX3/XMb/66is89NBDsLe3h729PUJDQ3H06FGdY5599llIJBKd18SJE/VyjmQ8ChRV+P54LgAgYgzXHhERGTJRA9K8efMQHx+P6OhonDlzBuPHj0doaCiuXr0KAHjppZewZ88exMTEID09HZGRkVi4cCF27drV5JgHDhzA9OnTsX//fiQnJ8Pb2xvjx4/Xjllv4sSJyM/P1762bt2q13Olzu+rQxehUgsI8nHAELmD2OUQEdF9kAiCIIjxxpWVlbCxscHOnTsxefJk7fYhQ4Zg0qRJWL58Ofr27Ytp06ZhyZIld9zfHGq1Gvb29vj0008xc+ZMAHUzSCUlJdixY0er61cqlbCzs4NCoYCtLS+lGLub5TUY8d4+VKrU+HbOAxjZ01nskoiI6A6a+/kt2gxSbW0t1Go1LC0tdbbLZDIkJSUBAEJCQrBr1y5cvXoVgiBg//79OH/+PMaPH9/s96moqIBKpYKDg+6/6A8cOAAXFxcEBATg+eefR1FR0V3Hqa6uhlKp1HkR1fv68CVUqtTo52mHh3o4iV0OERHdJ9ECko2NDYKDg7Fs2TLk5eVBrVYjJiYGycnJyM/PBwCsXbsWvXv3hpeXFywsLDBx4kR89tlnGDlyZLPf57XXXoOHhwdCQ0O12yZOnIhvv/0WCQkJeP/995GYmIhJkyZBrVY3Oc7KlSthZ2enfXl7e7f+5KlTKa1S4esjlwHUrT2SSCTiFkRERPetxQGpe/fueOedd5CdnX3fbx4dHQ1BEODp6QmpVIo1a9Zg+vTpMDGpK2vt2rVISUnBrl27cPz4cXz44YeIiIjA3r17mzX+e++9h9jYWGzfvl1npurpp5/GY489hn79+iEsLAw//fQTjh07hgMHDjQ5VlRUFBQKhfaVk5NzX+dOncfm1Gwoq2rh52yN8b3dxC6HiIjaQIsDUmRkJH788Uf4+vri4YcfRmxsLKqrq1v15n5+fkhMTERZWRlycnJw9OhRqFQq+Pr6orKyEosXL8ZHH32ERx99FP3798fChQsxbdo0rF69+p5jr169Gu+99x5+++039O/f/67H+vr6wsnJCZmZmU0eI5VKYWtrq/MiqlKp8X+HLgEAXhjtDxMTzh4REXUGrQpIaWlpOHr0KHr16oV//etfcHd3x8KFC3HixIlWFWFtbQ13d3cUFxcjLi4OU6ZMgUqlgkql0s4m1TM1NYVGo7nreKtWrcKyZcuwZ88eDB069J7vn5ubi6KiIri7u7eqfjJe237PwY2yanh2leGxgR5il0NERG2k1WuQBg8ejDVr1iAvLw9vvfUW/u///g/Dhg3DwIEDsXHjRjTn5ri4uDjs2bMHly5dQnx8PMaMGYPAwEDMnj0btra2GDVqFBYtWoQDBw7g0qVL+Prrr/Htt99i6tSp2jFmzpyJqKgo7dfvv/8+lixZgo0bN6J79+4oKChAQUEBysrKANT1Vlq0aBFSUlJw+fJlJCQkYMqUKfD398eECRNa+8tBRkil1mB94kUAwIJRvjA3Zd9VIqLOwqy136hSqbB9+3Zs2rQJ8fHxGD58OObOnYvc3FwsXrwYe/fuxZYtW+46hkKhQFRUFHJzc+Hg4IDw8HCsWLEC5ubmAIDY2FhERUVhxowZuHnzJuRyOVasWIEFCxZox8jOztaZZVq3bh1qamrwxBNP6LzXW2+9haVLl8LU1BSnT5/GN998g5KSEnh4eGD8+PFYtmwZpFJpa385yAjtSsvD1ZJKOHWR4smhXLRPRNSZtLgP0okTJ7Bp0yZs3boVJiYmmDlzJubNm4fAwEDtMWfPnsWwYcNQWVnZ5gV3FOyDZNw0GgEPf5yIrOvl+O+kQCwYxc7ZRESGoLmf3y2eQRo2bBgefvhhrFu3DmFhYdrZntv5+Pjg6aefbunQRAbjt3MFyLpeDltLM8wI6iZ2OURE1MZaHJAuXrwIuVx+12Osra2xadOmVhdF1JEJgoDP9mcBAJ4N6Q4by8b/SCAiIsPW4lWl165dQ2pqaqPtqamp+P3339ukKKKO7NCFGzhzVQGZuSmeHeEjdjlERKQHLQ5IERERd2ySePXqVURERLRJUUQd2Wf76/pl/T2oGxysLUSuhoiI9KHFAencuXMYPHhwo+2DBg3CuXPn2qQooo7q98s3kXrpJsxNJXjuIV+xyyEiIj1pcUCSSqUoLCxstD0/Px9mZq3uGkBkED4/ULf26IkhXnCzs7zH0UREZKhaHJDGjx+vfS5ZvZKSEixevBgPP/xwmxZH1JH8kafAvj+vwUQC/HMkb+snIurMWjzls3r1aowcORJyuRyDBg0CAKSlpcHV1RXR0dFtXiBRR7Hu1uzR3/p7oLuTtcjVEBGRPrU4IHl6euL06dPYvHkzTp06BZlMhtmzZ2P69Ol37IlE1BlcvF6Gn8/kAwCeH83ZIyKizq5Vi4asra0xf/78tq6FqMP6IvEiBAEI7eWCXu7snE5E1Nm1elX1uXPnkJ2djZqaGp3tjz322H0XRdSR5JVU4seTuQCAF8b4i1wNERG1h1Z10p46dSrOnDkDiUSC+ke5SSQSAIBarW7bColE9tWhi1CpBQT7OmJwN3uxyyEionbQ4rvYXnzxRfj4+ODatWuwsrLCH3/8gYMHD2Lo0KE4cOCAHkokan81tRqcy1Ni2+852Ho0GwAQwdkjIiKj0eIZpOTkZOzbtw9OTk4wMTGBiYkJHnzwQaxcuRL//ve/cfLkSX3USaQ3ikoV0vOVOJenxLlb/71wrRQqtaA9ZoCXHUb4O4pYJRERtacWByS1Wg0bGxsAgJOTE/Ly8hAQEAC5XI6MjIw2L5CorQiCgKsllTpB6Fy+ErnFlXc83sbSDL3dbdHbwxazgrtrLyMTEVHn1+KA1LdvX5w6dQo+Pj4ICgrCqlWrYGFhgS+//BK+vnz0AnUMNbUaXLhWivT80ltBSIFzeUooq2rveLxnVxl6e9hqA1Fvd1t42csYioiIjFSLA9Ibb7yB8vJyAMA777yDv/3tb3jooYfg6OiI7777rs0LJLoXRYWqbkbotlmhzAaXyOqZm0rQw8UGvT1s0cv9ViByt4WdFXt4ERHRXyRC/W1o9+HmzZuwt7c3qn9tK5VK2NnZQaFQwNaWfXHagyAIyC2u1AlC5/KUuFpy50tktpZmt2aD7LSzQv4uXWBh1uJ7E4iIqJNo7ud3i2aQVCoVZDIZ0tLS0LdvX+12BweH1ldKdAf1l8garhcqbeISmZe9TOfyWG8PW3h25SUyIiJqnRYFJHNzc3Tr1o29jqhNlVTUNJoVyrxWhlrN3S+R1QehXu62sJPxEhkREbWdFq9Bev3117F48WJER0dz5ohapP4S2R+3BaH0fF4iIyKijqfFAenTTz9FZmYmPDw8IJfLYW2t+1TzEydOtFlxZNgyCkpxKrdEOzOUnqdEafWdL5F5O9y6RFYfhjxs4WFnyUtkREQkihYHpLCwMD2UQZ3Ntt9zsOj70422m5tK0NPVRme9UCAvkRERUQfT4oD01ltv6aMO6mR2pF0FAPR2t0Wwn6M2EPk58xIZERF1fC0OSET3oqxSIfXiTQDAZzMGw8fJ+h7fQURE1LG0OCCZmJjcdV0I73CjQ+dvoFYjwNfZmuGIiIgMUosD0vbt23W+VqlUOHnyJL755hu8/fbbbVYYGa6E9EIAQGgvV5ErISIiap0WB6QpU6Y02vbEE0+gT58++O677zB37tw2KYwMk1ojYH/GNQDAuEAXkashIiJqnTZbLTt8+HAkJCS01XBkoE5kF6O4QgU7mTmGyO3FLoeIiKhV2iQgVVZWYs2aNfD09GyL4ciAJaTXzR6NDnCGmSnvViMiIsPU4ktsDR9KKwgCSktLYWVlhZiYmDYtjgxP/fqjcVx/REREBqzFAenjjz/WCUgmJiZwdnZGUFAQ7O15ScWYZRdV4MK1MpiaSDCqp7PY5RAREbVaiwPSs88+q4cyqDPYe2v2aFh3e3bGJiIig9biRSKbNm3Ctm3bGm3ftm0bvvnmmzYpigxTwp+8vZ+IiDqHFgeklStXwsnJqdF2FxcXvPvuu21SFBme0tu6Z3P9ERERGboWB6Ts7Gz4+Pg02i6Xy5Gdnd0mRZHhOcju2URE1Im0OCC5uLjg9OnGT2k/deoUHB0dWzRWaWkpIiMjIZfLIZPJEBISgmPHjmn3l5WVYeHChfDy8oJMJkPv3r2xfv36e467bds2BAYGwtLSEv369cMvv/yis18QBLz55ptwd3eHTCZDaGgoLly40KLaSZf27jU2hyQiok6gxQFp+vTp+Pe//439+/dDrVZDrVZj3759ePHFF/H000+3aKx58+YhPj4e0dHROHPmDMaPH4/Q0FBcvVr3JPiXXnoJe/bsQUxMDNLT0xEZGYmFCxdi165dTY555MgRTJ8+HXPnzsXJkycRFhaGsLAwnD17VnvMqlWrsGbNGqxfvx6pqamwtrbGhAkTUFVV1dJfDkKD7tm8vEZERJ2B0ELV1dXCU089JUgkEsHc3FwwNzcXTE1NhdmzZwvV1dXNHqeiokIwNTUVfvrpJ53tgwcPFl5//XVBEAShT58+wjvvvNPk/jt56qmnhMmTJ+tsCwoKEv75z38KgiAIGo1GcHNzEz744APt/pKSEkEqlQpbt25tdv0KhUIAICgUimZ/T2d17FKRIH/tJ6H/0jhBVasWuxwiIqImNffzu8UzSBYWFvjuu++QkZGBzZs348cff0RWVhY2btwICwuLZo9TW1sLtVoNS0tLne0ymQxJSUkAgJCQEOzatQtXr16FIAjYv38/zp8/j/Hjxzc5bnJyMkJDQ3W2TZgwAcnJyQCAS5cuoaCgQOcYOzs7BAUFaY+5k+rqaiiVSp0X1dnL7tlERNTJtLgPUr0ePXqgR48erX5jGxsbBAcHY9myZejVqxdcXV2xdetWJCcnw9/fHwCwdu1azJ8/H15eXjAzM4OJiQm++uorjBw5sslxCwoK4Oqqe5nH1dUVBQUF2v3125o65k5WrlyJt99+u1Xn2tmxezYREXU2Lf7nfnh4ON5///1G21etWoUnn3yyRWNFR0dDEAR4enpCKpVizZo1mD59OkxM6spau3YtUlJSsGvXLhw/fhwffvghIiIisHfv3paWfd+ioqKgUCi0r5ycnHavoSPS6Z7dg92ziYioc2hxQDp48CAeeeSRRtsnTZqEgwcPtmgsPz8/JCYmoqysDDk5OTh69ChUKhV8fX1RWVmJxYsX46OPPsKjjz6K/v37Y+HChZg2bRpWr17d5Jhubm4oLCzU2VZYWAg3Nzft/vptTR1zJ1KpFLa2tjovatA924rds4mIqHNocUAqKyu741ojc3PzVq/Lsba2hru7O4qLixEXF4cpU6ZApVJBpVJpZ5PqmZqaQqPRNDlWcHAwEhISdLbFx8cjODgYAODj4wM3NzedY5RKJVJTU7XHUPPt+7Nu/RG7ZxMRUWfS4jVI/fr1w3fffYc333xTZ3tsbCx69+7dorHi4uIgCAICAgKQmZmJRYsWITAwELNnz4a5uTlGjRqFRYsWQSaTQS6XIzExEd9++y0++ugj7RgzZ86Ep6cnVq5cCQB48cUXMWrUKHz44YeYPHkyYmNj8fvvv+PLL78EAEgkEkRGRmL58uXo0aMHfHx8sGTJEnh4eCAsLKylvxxGrbRKhdRLRQC4/oiIiDqXFgekJUuW4PHHH0dWVhbGjh0LAEhISMCWLVvw/ffft2gshUKBqKgo5ObmwsHBAeHh4VixYgXMzesu1cTGxiIqKgozZszAzZs3IZfLsWLFCixYsEA7RnZ2ts4sU0hICLZs2YI33ngDixcvRo8ePbBjxw707dtXe8yrr76K8vJyzJ8/HyUlJXjwwQexZ8+eRnfU0d0dPH8DKrUAXyd2zyYios5FIgiC0NJv+vnnn/Huu+8iLS0NMpkMAwYMwFtvvQUHBwedINKZKZVK2NnZQaFQGO16pJe+S8OPJ6/iuYd88Prkls0eEhERiaG5n9+tus1/8uTJmDx5svaNtm7dildeeQXHjx+HWq1uXcVkUNg9m4iIOrNWd/U7ePAgZs2aBQ8PD3z44YcYO3YsUlJS2rI26sBOZhejuEIFW0szDJXbi10OERFRm2rRDFJBQQG+/vprbNiwAUqlEk899RSqq6uxY8eOFi/QJsP2V/dsF3bPJiKiTqfZn2yPPvooAgICcPr0aXzyySfIy8vD2rVr9VkbdWB/dc92EbkSIiKittfsGaRff/0V//73v/H888/f1yNGyPDd3j17dE8GJCIi6nyaPYOUlJSE0tJSDBkyBEFBQfj0009x48YNfdZGHVTCn+yeTUREnVuzA9Lw4cPx1VdfIT8/H//85z8RGxsLDw8PaDQaxMfHo7S0VJ91UgeSkM7u2URE1Lm1eHWttbU15syZg6SkJJw5cwYvv/wy3nvvPbi4uOCxxx7TR43UgdzePXtsIC+vERFR53Rftx8FBARg1apVyM3NxdatW9uqJurAbu+e7evcRexyiIiI9KJN7s82NTVFWFgYdu3a1RbDUQdWv/6Id68REVFnxgY21GxqjYADGdcBsHs2ERF1bgxI1Gwns4txs7wGtpZmGMLu2URE1IkxIFGz3d4925zds4mIqBPjpxw12z6uPyIiIiPBgETNknOzAucL2T2biIiMAwMSNcveW89eGypn92wiIur8GJCoWdg9m4iIjAkDEt3T7d2zuf6IiIiMAQMS3dOhC+yeTURExoUBie6pfv0RZ4+IiMhYMCDRXd3ePXtsINcfERGRcWBAoru6vXv20O7snk1ERMaBAYnuKuFPds8mIiLjw088uqsErj8iIiIjxIBETWL3bCIiMlYMSNQkds8mIiJjxYBETdr3J7tnExGRcWJAojsqrVIh5SK7ZxMRkXFiQKI7qu+e7cPu2UREZIQYkOiOtN2zAzl7RERExocBiRq5vXv2OK4/IiIiI8SARI2k5bB7NhERGTcGJGpkbzq7ZxMRkXHjpx81wu7ZRERk7BiQSAe7ZxMRETEgUQMJ7J5NREQkfkAqLS1FZGQk5HI5ZDIZQkJCcOzYMe1+iURyx9cHH3zQ5Jjdu3e/4/dERERojxk9enSj/QsWLNDruRqCBHbPJiIigpnYBcybNw9nz55FdHQ0PDw8EBMTg9DQUJw7dw6enp7Iz8/XOf7XX3/F3LlzER4e3uSYx44dg1qt1n599uxZPPzww3jyySd1jnvuuefwzjvvaL+2srJqo7MyTLd3zx7L9UdERGTERA1IlZWV+OGHH7Bz506MHDkSALB06VLs3r0b69atw/Lly+Hm5qbzPTt37sSYMWPg6+vb5LjOzs46X7/33nvw8/PDqFGjdLZbWVk1Gt+Y3d4924/ds4mIyIiJeomttrYWarUalpaWOttlMhmSkpIaHV9YWIiff/4Zc+fObfZ71NTUICYmBnPmzIFEItHZt3nzZjg5OaFv376IiopCRUVFk+NUV1dDqVTqvDqbhFu397N7NhERGTtRZ5BsbGwQHByMZcuWoVevXnB1dcXWrVuRnJwMf3//Rsd/8803sLGxweOPP97s99ixYwdKSkrw7LPP6mz/+9//DrlcDg8PD5w+fRqvvfYaMjIy8OOPP95xnJUrV+Ltt99u0fkZErVGwP6MWwGJ64+IiMjISQRBEMQsICsrC3PmzMHBgwdhamqKwYMHo2fPnjh+/DjS09N1jg0MDMTDDz+MtWvXNnv8CRMmwMLCArt3777rcfv27cO4ceOQmZkJPz+/Rvurq6tRXV2t/VqpVMLb2xsKhQK2trbNrqejOn7lJsLXJcPG0gwnljzMBpFERNQpKZVK2NnZ3fPzW/RF2n5+fkhMTER5eTmUSiXc3d0xbdq0RmuMDh06hIyMDHz33XfNHvvKlSvYu3dvk7NCtwsKCgKAJgOSVCqFVCpt9nsbGnbPJiIi+kuH+SS0traGu7s7iouLERcXhylTpujs37BhA4YMGYIBAwY0e8xNmzbBxcUFkydPvuexaWlpAAB3d/cW1d1Z1Pc/CuXda0REROIHpLi4OOzZsweXLl1CfHw8xowZg8DAQMyePVt7jFKpxLZt2zBv3rw7jjFu3Dh8+umnOts0Gg02bdqEWbNmwcxMd6IsKysLy5Ytw/Hjx3H58mXs2rULM2fOxMiRI9G/f/+2P8kOjt2ziYiIdIl+iU2hUCAqKgq5ublwcHBAeHg4VqxYAXPzv7o4x8bGQhAETJ8+/Y5jZGVl4caNGzrb9u7di+zsbMyZM6fR8RYWFti7dy8++eQTlJeXw9vbG+Hh4XjjjTfa9uQMBLtnExER6RJ9kbahau4iL0Pwjw2pOHThBhY/Eoj5IxuvvyIiIuosmvv5LfolNhLX7d2zeXs/ERFRHQYkI5fE7tlERESNMCAZub3snk1ERNQIA5IRu717Nh9OS0RE9BcGJCOWllOMm+U1sLE0w7DuDmKXQ0RE1GEwIBmxBHbPJiIiuiN+Khqx+oDE7tlERES6GJCMVM7NCmQUlsLURIJRPZ3FLoeIiKhDYUAyUvXds4fI7dHVykLkaoiIiDoWBiQjlfAnL68RERE1hQHJCJVV17J7NhER0V0wIBmhQ+evs3s2ERHRXTAgGaH67tlj2T2biIjojhiQjMzt3bPHcf0RERHRHTEgGZm0nBJ2zyYiIroHBiQjU397P7tnExERNY2fkEamvnv2OK4/IiIiahIDkhG5vXv26AB2zyYiImoKA5IR2XerOSS7ZxMREd0dA5IR2Xtr/RG7ZxMREd0dA5KRKKuuRerFmwCAsYHsnk1ERHQ3DEhG4tD566hRa9Dd0Qp+ztZil0NERNShMSAZifru2eN6uUIikYhcDRERUcfGgGQE1BoBB9g9m4iIqNkYkIxAWk4Jitg9m4iIqNkYkIxAfffsUT2d2T2biIioGfhpaQTqu2eH9uLda0RERM3BgNTJsXs2ERFRyzEgdXLsnk1ERNRyDEidXH33bD6cloiIqPkYkDqx27tnj+P6IyIiomZjQOrEki6wezYREVFrMCB1YuyeTURE1DoMSJ2UWiNg/60F2lx/RERE1DIMSJ2UTvdsH3bPJiIiagkGpE6K3bOJiIhaT/RPztLSUkRGRkIul0MmkyEkJATHjh3T7pdIJHd8ffDBB02OuXTp0kbHBwYG6hxTVVWFiIgIODo6okuXLggPD0dhYaHezrO91fc/YvdsIiKilhM9IM2bNw/x8fGIjo7GmTNnMH78eISGhuLq1asAgPz8fJ3Xxo0bIZFIEB4eftdx+/Tpo/N9SUlJOvv/85//YPfu3di2bRsSExORl5eHxx9/XG/n2Z5yiyvwZ0EpTCRg92wiIqJWMBPzzSsrK/HDDz9g586dGDlyJIC62Z/du3dj3bp1WL58Odzc3HS+Z+fOnRgzZgx8fX3vOraZmVmj762nUCiwYcMGbNmyBWPHjgUAbNq0Cb169UJKSgqGDx/eBmcnnvpnrw2VO7B7NhERUSuIOoNUW1sLtVoNS0tLne0ymazRjA8AFBYW4ueff8bcuXPvOfaFCxfg4eEBX19fzJgxA9nZ2dp9x48fh0qlQmhoqHZbYGAgunXrhuTk5DuOV11dDaVSqfPqqLTds3vx7jUiIqLWEDUg2djYIDg4GMuWLUNeXh7UajViYmKQnJyM/Pz8Rsd/8803sLGxueelsKCgIHz99dfYs2cP1q1bh0uXLuGhhx5CaWkpAKCgoAAWFhbo2rWrzve5urqioKDgjmOuXLkSdnZ22pe3t3frTlrP2D2biIjo/om+Bik6OhqCIMDT0xNSqRRr1qzB9OnTYWLSuLSNGzdixowZjWacGpo0aRKefPJJ9O/fHxMmTMAvv/yCkpIS/O9//2t1nVFRUVAoFNpXTk5Oq8fSJ3bPJiIiun+irkECAD8/PyQmJqK8vBxKpRLu7u6YNm1aozVGhw4dQkZGBr777rsWv0fXrl3Rs2dPZGZmAgDc3NxQU1ODkpISnVmkwsLCJtctSaVSSKXSFr93e6vvnj02kN2ziYiIWkv0GaR61tbWcHd3R3FxMeLi4jBlyhSd/Rs2bMCQIUMwYMCAFo9dVlaGrKwsuLu7AwCGDBkCc3NzJCQkaI/JyMhAdnY2goOD7+9ERHR79+xQrj8iIiJqNdEDUlxcHPbs2YNLly4hPj4eY8aMQWBgIGbPnq09RqlUYtu2bZg3b94dxxg3bhw+/fRT7devvPIKEhMTcfnyZRw5cgRTp06Fqakppk+fDgCws7PD3Llz8dJLL2H//v04fvw4Zs+ejeDgYIO+g43ds4mIiNqG6JfYFAoFoqKikJubCwcHB4SHh2PFihUwNzfXHhMbGwtBELQBp6GsrCzcuHFD+3Vubi6mT5+OoqIiODs748EHH0RKSgqcnf/qCfTxxx/DxMQE4eHhqK6uxoQJE/D555/r70Tbwb4/2T2biIioLUgEQRDELsIQKZVK2NnZQaFQwNbWVuxyAAATPzmIPwtK8fG0AZg6yEvscoiIiDqc5n5+c5qhk9Dpnt2T64+IiIjuBwNSJ3F792x7a3bPJiIiuh8MSJ1Ewq2719g9m4iI6P4xIHUCZdW1SMkqAsDu2URERG2BAakTqO+eLWf3bCIiojbBgNQJ1HfPHsfu2URERG2CAcnAadg9m4iIqM0xIBm4tNxb3bOl7J5NRETUVhiQDFxCel337JEB7J5NRETUVviJauDq+x/x8hoREVHbYUAyYOyeTUREpB8MSAZs35/snk1ERKQPDEgGrP72/rG8vEZERNSmGJAM1O3ds7n+iIiIqG0xIBko3e7ZXcQuh4iIqFNhQDJQCeyeTUREpDcMSAZIoxGwP4O39xMREekLA5IBSsstwY2yuu7ZQ7uzezYREVFbY0AyQLd3z7Yw44+QiIiorfHT1QCxezYREZF+MSAZGHbPJiIi0j8GJANT3z17iNye3bOJiIj0hAHJwNR3zx7Xy1XkSoiIiDovBiQDwu7ZRERE7YMByYAkXbjB7tlERETtgAHJgNTf3j820IXds4mIiPSIAclA6HbP5vojIiIifWJAMhC3d88exu7ZREREesWAZCD23bp7jd2ziYiI9I+ftAZi7631R7x7jYiISP8YkAwAu2cTERG1LwYkA8Du2URERO2LAckAJLB7NhERUbtiQOrgyqtrkczu2URERO2KAamDO3Sre3Y3B3bPJiIiai8MSB1cfffscb3YPZuIiKi9iB6QSktLERkZCblcDplMhpCQEBw7dky7XyKR3PH1wQcfNDnmypUrMWzYMNjY2MDFxQVhYWHIyMjQOWb06NGNxlywYIHezrM12D2biIhIHKIHpHnz5iE+Ph7R0dE4c+YMxo8fj9DQUFy9ehUAkJ+fr/PauHEjJBIJwsPDmxwzMTERERERSElJQXx8PFQqFcaPH4/y8nKd45577jmdsVetWqXXc22pU+yeTUREJAozMd+8srISP/zwA3bu3ImRI0cCAJYuXYrdu3dj3bp1WL58Odzc3HS+Z+fOnRgzZgx8fX2bHHfPnj06X3/99ddwcXHB8ePHte8DAFZWVo3G70jq714b2ZPds4mIiNqTqJ+6tbW1UKvVsLS01Nkuk8mQlJTU6PjCwkL8/PPPmDt3boveR6FQAAAcHHRnYTZv3gwnJyf07dsXUVFRqKioaHKM6upqKJVKnZe+7b1t/RERERG1H1FnkGxsbBAcHIxly5ahV69ecHV1xdatW5GcnAx/f/9Gx3/zzTewsbHB448/3uz30Gg0iIyMxIgRI9C3b1/t9r///e+Qy+Xw8PDA6dOn8dprryEjIwM//vjjHcdZuXIl3n777ZafZCvd3j17TAADEhERUXuSCIIgiFlAVlYW5syZg4MHD8LU1BSDBw9Gz549cfz4caSnp+scGxgYiIcffhhr165t9vjPP/88fv31VyQlJcHLy6vJ4/bt24dx48YhMzMTfn5+jfZXV1ejurpa+7VSqYS3tzcUCgVsbW2bXU9zRSdfxpKdf2BYd3tsWxDS5uMTEREZI6VSCTs7u3t+fou+sMXPzw+JiYkoKytDTk4Ojh49CpVK1WiN0aFDh5CRkYF58+Y1e+yFCxfip59+wv79++8ajgAgKCgIAJCZmXnH/VKpFLa2tjovfdrL7tlERESiET0g1bO2toa7uzuKi4sRFxeHKVOm6OzfsGEDhgwZggEDBtxzLEEQsHDhQmzfvh379u2Dj4/PPb8nLS0NAODu7t6q+tvS7d2zxwXy8hoREVF7E3UNEgDExcVBEAQEBAQgMzMTixYtQmBgIGbPnq09RqlUYtu2bfjwww/vOMa4ceMwdepULFy4EAAQERGBLVu2YOfOnbCxsUFBQQEAwM7ODjKZDFlZWdiyZQseeeQRODo64vTp0/jPf/6DkSNHon///vo/6Xu4vXu2vwu7ZxMREbU30QOSQqFAVFQUcnNz4eDggPDwcKxYsQLm5ubaY2JjYyEIAqZPn37HMbKysnDjxg3t1+vWrQNQ1wzydps2bcKzzz4LCwsL7N27F5988gnKy8vh7e2N8PBwvPHGG21/gq3A7tlERETiEn2RtqFq7iKvltJoBDzw7l7cKKvB5nlBGOHv1GZjExERGTuDWaRNutg9m4iISHwMSB0Mu2cTERGJj5/AHYyySgVzUwm7ZxMREYmIa5BaSV9rkACgrLoWphIJZBambTouERGRsWvu57fod7FRY12k/LEQERGJiZfYiIiIiBpgQCIiIiJqgAGJiIiIqAEGJCIiIqIGGJCIiIiIGmBAIiIiImqAAYmIiIioAQYkIiIiogYYkIiIiIgaYEAiIiIiaoABiYiIiKgBBiQiIiKiBhiQiIiIiBrgY+NbSRAEAIBSqRS5EiIiImqu+s/t+s/xpjAgtVJpaSkAwNvbW+RKiIiIqKVKS0thZ2fX5H6JcK8IRXek0WiQl5cHGxsbSCQSscvpkJRKJby9vZGTkwNbW1uxyzF6/Hl0LPx5dCz8eXQs+vx5CIKA0tJSeHh4wMSk6ZVGnEFqJRMTE3h5eYldhkGwtbXlXzgdCH8eHQt/Hh0Lfx4di75+HnebOarHRdpEREREDTAgERERETXAgER6I5VK8dZbb0EqlYpdCoE/j46GP4+OhT+PjqUj/Dy4SJuIiIioAc4gERERETXAgERERETUAAMSERERUQMMSEREREQNMCBRm1q5ciWGDRsGGxsbuLi4ICwsDBkZGWKXRbe89957kEgkiIyMFLsUo3b16lU888wzcHR0hEwmQ79+/fD777+LXZZRUqvVWLJkCXx8fCCTyeDn54dly5bd8zld1DYOHjyIRx99FB4eHpBIJNixY4fOfkEQ8Oabb8Ld3R0ymQyhoaG4cOFCu9TGgERtKjExEREREUhJSUF8fDxUKhXGjx+P8vJysUszeseOHcMXX3yB/v37i12KUSsuLsaIESNgbm6OX3/9FefOncOHH34Ie3t7sUszSu+//z7WrVuHTz/9FOnp6Xj//fexatUqrF27VuzSjEJ5eTkGDBiAzz777I77V61ahTVr1mD9+vVITU2FtbU1JkyYgKqqKr3Xxtv8Sa+uX78OFxcXJCYmYuTIkWKXY7TKysowePBgfP7551i+fDkGDhyITz75ROyyjNJ///tfHD58GIcOHRK7FALwt7/9Da6urtiwYYN2W3h4OGQyGWJiYkSszPhIJBJs374dYWFhAOpmjzw8PPDyyy/jlVdeAQAoFAq4urri66+/xtNPP63XejiDRHqlUCgAAA4ODiJXYtwiIiIwefJkhIaGil2K0du1axeGDh2KJ598Ei4uLhg0aBC++uorscsyWiEhIUhISMD58+cBAKdOnUJSUhImTZokcmV06dIlFBQU6Py9ZWdnh6CgICQnJ+v9/fmwWtIbjUaDyMhIjBgxAn379hW7HKMVGxuLEydO4NixY2KXQgAuXryIdevW4aWXXsLixYtx7Ngx/Pvf/4aFhQVmzZoldnlG57///S+USiUCAwNhamoKtVqNFStWYMaMGWKXZvQKCgoAAK6urjrbXV1dtfv0iQGJ9CYiIgJnz55FUlKS2KUYrZycHLz44ouIj4+HpaWl2OUQ6v7hMHToULz77rsAgEGDBuHs2bNYv349A5II/ve//2Hz5s3YsmUL+vTpg7S0NERGRsLDw4M/DyPHS2ykFwsXLsRPP/2E/fv3w8vLS+xyjNbx48dx7do1DB48GGZmZjAzM0NiYiLWrFkDMzMzqNVqsUs0Ou7u7ujdu7fOtl69eiE7O1ukiozbokWL8N///hdPP/00+vXrh3/84x/4z3/+g5UrV4pdmtFzc3MDABQWFupsLyws1O7TJwYkalOCIGDhwoXYvn079u3bBx8fH7FLMmrjxo3DmTNnkJaWpn0NHToUM2bMQFpaGkxNTcUu0eiMGDGiUeuL8+fPQy6Xi1SRcauoqICJie5HoampKTQajUgVUT0fHx+4ubkhISFBu02pVCI1NRXBwcF6f39eYqM2FRERgS1btmDnzp2wsbHRXie2s7ODTCYTuTrjY2Nj02j9l7W1NRwdHbkuTCT/+c9/EBISgnfffRdPPfUUjh49ii+//BJffvml2KUZpUcffRQrVqxAt27d0KdPH5w8eRIfffQR5syZI3ZpRqGsrAyZmZnary9duoS0tDQ4ODigW7duiIyMxPLly9GjRw/4+PhgyZIl8PDw0N7pplcCURsCcMfXpk2bxC6Nbhk1apTw4osvil2GUdu9e7fQt29fQSqVCoGBgcKXX34pdklGS6lUCi+++KLQrVs3wdLSUvD19RVef/11obq6WuzSjML+/fvv+Jkxa9YsQRAEQaPRCEuWLBFcXV0FqVQqjBs3TsjIyGiX2tgHiYiIiKgBrkEiIiIiaoABiYiIiKgBBiQiIiKiBhiQiIiIiBpgQCIiIiJqgAGJiIiIqAEGJCIiIqIGGJCIiIiIGmBAIiJqJYlEgh07dohdBhHpAQMSERmkZ599FhKJpNFr4sSJYpdGRJ0AH1ZLRAZr4sSJ2LRpk842qVQqUjVE1JlwBomIDJZUKoWbm5vOy97eHkDd5a9169Zh0qRJkMlk8PX1xffff6/z/WfOnMHYsWMhk8ng6OiI+fPno6ysTOeYjRs3ok+fPpBKpXB3d8fChQt19t+4cQNTp06FlZUVevTogV27dmn3FRcXY8aMGXB2doZMJkOPHj0aBToi6pgYkIio01qyZAnCw8Nx6tQpzJgxA08//TTS09MBAOXl5ZgwYQLs7e1x7NgxbNu2DXv37tUJQOvWrUNERATmz5+PM2fOYNeuXfD399d5j7fffhtPPfUUTp8+jUceeQQzZszAzZs3te9/7tw5/Prrr0hPT8e6devg5OTUfr8ARNR6AhGRAZo1a5ZgamoqWFtb67xWrFghCIIgABAWLFig8z1BQUHC888/LwiCIHz55ZeCvb29UFZWpt3/888/CyYmJkJBQYEgCILg4eEhvP76603WAEB44403tF+XlZUJAIRff/1VEARBePTRR4XZs2e3zQkTUbviGiQiMlhjxozBunXrdLY5ODho/z84OFhnX3BwMNLS0gAA6enpGDBgAKytrbX7R4wYAY1Gg4yMDEgkEuTl5WHcuHF3raF///7a/7e2toatrS2uXbsGAHj++ecRHh6OEydOYPz48QgLC0NISEirzpWI2hcDEhEZLGtr60aXvNqKTCZr1nHm5uY6X0skEmg0GgDApEmTcOXKFfzyyy+Ij4/HuHHjEBERgdWrV7d5vUTUtrgGiYg6rZSUlEZf9+rVCwDQq1cvnDp1CuXl5dr9hw8fhomJCQICAmBjY4Pu3bsjISHhvmpwdnbGrFmzEBMTg08++QRffvnlfY1HRO2DM0hEZLCqq6tRUFCgs83MzEy7EHrbtm0YOnQoHnzwQWzevBlHjx7Fhg0bAAAzZszAW2+9hVmzZmHp0qW4fv06/vWvf+Ef//gHXF1dAQBLly7FggUL4OLigkmTJqG0tBSHDx/Gv/71r2bV9+abb2LIkCHo06cPqqur8dNPP2kDGhF1bAxIRGSw9uzZA3d3d51tAQEB+PPPPwHU3WEWGxuLF154Ae7u7ti6dSt69+4NALCyskJcXBxefPFFDBs2DFZWVggPD8dHH32kHWvWrFmoqqrCxx9/jFdeeQVOTk544oknml2fhYUFoqKicPnyZchkMjz00EOIjY1tgzMnIn2TCIIgiF0EEVFbk0gk2L59O8LCwsQuhYgMENcgERERETXAgERERETUANcgEVGnxNUDRHQ/OINERERE1AADEhEREVEDDEhEREREDTAgERERETXAgERERETUAAMSERERUQMMSEREREQNMCARERERNfD/Aczq6t4+DjVCAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epochs = []\n",
    "accuracies = []\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    for epoch in range(10):\n",
    "        train(epoch)\n",
    "        epochs.append(epoch + 1)\n",
    "        accuracies.append(test())\n",
    "    plt.plot(epochs, accuracies)\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作业\n",
    "\n",
    "- 阅读论文并实现: \n",
    "  - [He K, Zhang X, Ren S, et al. Identity Mappings in Deep Residual Networks[C].](https://link.springer.com/chapter/10.1007/978-3-319-46493-0_38)   [PDF ver.](https://arxiv.org/pdf/1603.05027.pdf)\n",
    "- 阅读并实现 DenseNet: \n",
    "  - [Huang G, Liu Z, Van Der Maaten L, et al. Densely Connected Convolutional Networks[J].](https://arxiv.org/pdf/1608.06993v5.pdf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 深入学习题外话\n",
    "\n",
    "1. 理论 <深度学习> 花书\n",
    "2. 阅读 Pytorch 文档\n",
    "3. 复现经典工作\n",
    "    - 跑代码 (会配环境)\n",
    "    - 读代码 (理解别人思路)\n",
    "    - 写代码 (复现)\n",
    "4. 扩充视野"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "vpteam",
   "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}