{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "import cv2\n", "from torch.utils.data import DataLoader, Dataset\n", "from torch.utils.data import random_split\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import torch.optim as optim\n", "import torchvision\n", "from torch.utils.tensorboard import SummaryWriter\n", "\n", "writer = SummaryWriter()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class TreesDataset(Dataset):\n", " def __init__(self, data_links) -> None:\n", " self.X, self.Y = readData(data_links)\n", "\n", " def __len__(self):\n", " return len(self.X)\n", "\n", " def __getitem__(self, index):\n", " return (self.X[index], self.Y[index])\n", "\n", "\n", "class Net(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", " self.conv1 = nn.Conv2d(3, 6, 5)\n", " self.pool = nn.MaxPool2d(2, 2)\n", " self.conv2 = nn.Conv2d(6, 16, 5)\n", " self.fc1 = nn.Linear(3264, 120)\n", " self.fc2 = nn.Linear(120, 84)\n", " self.fc3 = nn.Linear(84, 2)\n", "\n", " def forward(self, x):\n", " x = self.pool(F.relu(self.conv1(x)))\n", " x = self.pool(F.relu(self.conv2(x)))\n", " x = torch.flatten(x, 1)\n", " x = F.relu(self.fc1(x))\n", " x = F.relu(self.fc2(x))\n", " x = self.fc3(x)\n", " return x" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def create_datalinks(root_dir):\n", " data_links = os.listdir(root_dir)\n", " data_links = [root_dir + \"/\" + x for x in data_links]\n", " return data_links\n", "\n", "def preprocess(img):\n", " scale_percent = 10\n", " width = int(img.shape[1] * scale_percent / 100)\n", " height = int(img.shape[0] * scale_percent / 100)\n", " dim = (width, height)\n", " resized = cv2.resize(img, dim, interpolation = cv2.INTER_AREA)\n", " resized = torchvision.transforms.functional.to_tensor(resized)\n", " return resized\n", "\n", "def readData(data_links):\n", " x, y = [], []\n", " for link in data_links:\n", " img = cv2.imread(link, cv2.IMREAD_COLOR)\n", " img = preprocess(img)\n", " if(\"ground\" in link):\n", " label = 1\n", " elif(\"AS12\" in link):\n", " label = 0\n", " else:\n", " label = 0\n", " x.append(img)\n", " y.append(label)\n", "\n", " return x, y" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "links_3_plus_ground = create_datalinks(\"new_data/AS12_3\") + create_datalinks(\"new_data/ground\")\n", "\n", "dataset = TreesDataset(links_3_plus_ground)\n", "\n", "train_set, test_set = random_split(dataset, [300, 50], generator=torch.Generator().manual_seed(42))\n", "\n", "trainloader = DataLoader(train_set, batch_size=10, shuffle=True, num_workers=2)\n", "testloader = DataLoader(test_set, batch_size=10, shuffle=True, num_workers=2)\n", "\n", "classes = ('tree', 'ground')\n", "epochs_num = 15\n", "\n", "net = Net()\n", "criterion = nn.CrossEntropyLoss()\n", "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 1] loss: 0.074\n", "[1, 11] loss: 0.725\n", "[1, 21] loss: 0.695\n", "[2, 1] loss: 0.063\n", "[2, 11] loss: 0.606\n", "[2, 21] loss: 0.594\n", "[3, 1] loss: 0.071\n", "[3, 11] loss: 0.405\n", "[3, 21] loss: 0.477\n", "[4, 1] loss: 0.015\n", "[4, 11] loss: 0.327\n", "[4, 21] loss: 0.484\n", "[5, 1] loss: 0.052\n", "[5, 11] loss: 0.486\n", "[5, 21] loss: 0.370\n", "[6, 1] loss: 0.014\n", "[6, 11] loss: 0.454\n", "[6, 21] loss: 0.317\n", "[7, 1] loss: 0.052\n", "[7, 11] loss: 0.434\n", "[7, 21] loss: 0.467\n", "[8, 1] loss: 0.051\n", "[8, 11] loss: 0.438\n", "[8, 21] loss: 0.457\n", "[9, 1] loss: 0.071\n", "[9, 11] loss: 0.422\n", "[9, 21] loss: 0.358\n", "[10, 1] loss: 0.013\n", "[10, 11] loss: 0.447\n", "[10, 21] loss: 0.373\n", "[11, 1] loss: 0.052\n", "[11, 11] loss: 0.314\n", "[11, 21] loss: 0.387\n", "[12, 1] loss: 0.037\n", "[12, 11] loss: 0.437\n", "[12, 21] loss: 0.395\n", "[13, 1] loss: 0.013\n", "[13, 11] loss: 0.431\n", "[13, 21] loss: 0.423\n", "[14, 1] loss: 0.017\n", "[14, 11] loss: 0.466\n", "[14, 21] loss: 0.371\n", "[15, 1] loss: 0.032\n", "[15, 11] loss: 0.441\n", "[15, 21] loss: 0.324\n", "Finished Training\n" ] } ], "source": [ "\n", "\n", "for epoch in range(epochs_num):\n", " correct = 0\n", " total = 0\n", " running_loss = 0.0\n", " for i, data in enumerate(trainloader, 0):\n", " inputs, labels = data\n", " optimizer.zero_grad()\n", " outputs = net(inputs)\n", " loss = criterion(outputs, labels)\n", " loss.backward()\n", " optimizer.step()\n", " running_loss += loss.item()\n", "\n", " _, predicted = torch.max(outputs.data, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", "\n", " if i % 10 == 0: \n", " print('[%d, %5d] loss: %.3f' %\n", " (epoch + 1, i + 1, running_loss / 10))\n", " running_loss = 0.0\n", "\n", " writer.add_scalar(\"Loss/train\", loss.item(), i + epoch)\n", " writer.add_scalar(\"Accuracy/train\", correct/total, i + epoch)\n", "\n", "print('Finished Training')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy : 84 %\n" ] } ], "source": [ "correct = 0\n", "total = 0\n", "i=0\n", "with torch.no_grad():\n", " for data in testloader:\n", " images, labels = data\n", " outputs = net(images)\n", " loss = criterion(outputs, labels)\n", " _, predicted = torch.max(outputs.data, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", " writer.add_scalar(\"Accuracy/test\", correct/total, i + epoch)\n", " writer.add_scalar(\"Loss/test\", loss.item(), i + epoch)\n", " i += 1\n", "\n", "print('Accuracy : %d %%' % (100 * correct / total))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "\n", "images, labels = next(iter(trainloader))\n", "grid = torchvision.utils.make_grid(images)\n", "writer.add_image('images', grid, 0)\n", "writer.add_graph(net, images)\n", "writer.close()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "multi = create_datalinks(\"new_data/multi\")\n", "multiset = TreesDataset(multi)\n", "multiloader = DataLoader(multiset, batch_size=10, shuffle=True, num_workers=2)\n", "criterion2 = nn.Softmax(dim=1)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[0.8594, 0.1406],\n", " [0.8276, 0.1724],\n", " [0.8850, 0.1150],\n", " [0.8887, 0.1113],\n", " [0.8737, 0.1263],\n", " [0.8814, 0.1186],\n", " [0.8911, 0.1089],\n", " [0.8364, 0.1636],\n", " [0.8846, 0.1154],\n", " [0.8726, 0.1274]])\n", "tensor([[0.8452, 0.1548],\n", " [0.8533, 0.1467],\n", " [0.8536, 0.1464],\n", " [0.8593, 0.1407],\n", " [0.8557, 0.1443],\n", " [0.8811, 0.1189],\n", " [0.8727, 0.1273],\n", " [0.8529, 0.1471],\n", " [0.9053, 0.0947],\n", " [0.8824, 0.1176]])\n", "tensor([[0.8593, 0.1407],\n", " [0.8952, 0.1048],\n", " [0.8780, 0.1220],\n", " [0.8724, 0.1276],\n", " [0.8451, 0.1549],\n", " [0.8424, 0.1576],\n", " [0.8332, 0.1668],\n", " [0.8567, 0.1433],\n", " [0.8487, 0.1513],\n", " [0.8839, 0.1161]])\n", "tensor([[0.8759, 0.1241],\n", " [0.8340, 0.1660],\n", " [0.9141, 0.0859],\n", " [0.9075, 0.0925],\n", " [0.8674, 0.1326],\n", " [0.8431, 0.1569],\n", " [0.8933, 0.1067],\n", " [0.8475, 0.1525],\n", " [0.8363, 0.1637],\n", " [0.8789, 0.1211]])\n", "tensor([[0.8495, 0.1505],\n", " [0.8402, 0.1598],\n", " [0.8482, 0.1518],\n", " [0.8470, 0.1530],\n", " [0.8733, 0.1267],\n", " [0.8362, 0.1638],\n", " [0.8909, 0.1091],\n", " [0.8568, 0.1432],\n", " [0.8577, 0.1423],\n", " [0.8678, 0.1322]])\n", "1.0\n" ] } ], "source": [ "correct = 0\n", "total = 0\n", "i=0\n", "with torch.no_grad():\n", " for data in multiloader:\n", " images, labels = data\n", " outputs = net(images)\n", " loss = criterion2(outputs)\n", " loss2 = criterion(outputs, labels)\n", " print(loss)\n", " _, predicted = torch.max(outputs, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", " writer.add_scalar(\"Multi/Accuracy\", correct/total, i)\n", " writer.add_scalar(\"Multi/Loss\", loss2.item(), i + epoch)\n", "\n", " i += 1\n", "\n", "print(correct/total)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "from IPython.display import Image\n", "from torchvision import models\n", "from torchsummary import summary\n", "from matplotlib import pyplot" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "----------------------------------------------------------------\n", " Layer (type) Output Shape Param #\n", "================================================================\n", " Conv2d-1 [-1, 6, 76, 56] 456\n", " MaxPool2d-2 [-1, 6, 38, 28] 0\n", " Conv2d-3 [-1, 16, 34, 24] 2,416\n", " MaxPool2d-4 [-1, 16, 17, 12] 0\n", " Linear-5 [-1, 120] 391,800\n", " Linear-6 [-1, 84] 10,164\n", " Linear-7 [-1, 2] 170\n", "================================================================\n", "Total params: 405,006\n", "Trainable params: 405,006\n", "Non-trainable params: 0\n", "----------------------------------------------------------------\n", "Input size (MB): 0.05\n", "Forward/backward pass size (MB): 0.37\n", "Params size (MB): 1.54\n", "Estimated Total Size (MB): 1.97\n", "----------------------------------------------------------------\n" ] } ], "source": [ "summary(net, (3, 80, 60))\n", "link = \"new_data/AS12_3/AS12_3_1.png\"" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([1, 6, 28, 38])\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA44AAAMXCAYAAAB1ngsfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA6gklEQVR4nO3dy69tSZ4f9F+svfc5574yb2ZWVVe/qtxuv7EA2RIg8AQhTxDIMgMmCCHBAGSJAWbsCUJCAvEPMGAAAySEGIChBzBAiJfcArWETdPdsruruqorqyof93Xueey9VzBICSZ1g2/kPbtO38zPZ5j61S9ixYpYa33PLum23nsBAADAmyz3PQEAAAD+eBMcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGNrOFG8ePuq7px9GtS38Vz56m5nBu+OreP3pNVXNXddMX+Cr5frjH3zSe//mfc/jXTbzbq77fuec4nl/39f0Lvm6v29n9srXfa34Wrv50c9+N08Fx93TD+tP/Gt/M6o9SXB6hw684Hiavtwj94nQzJn+7X/vb37vdDP5etg9/bC++69n7+Z7D1mC4/36uj/H36HvyHsf/wRO9R15ivFP4h0a/3f+3Z/9bvZ/VQUAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBoO1XdqtazO57BPf9rnKf4B0Zn3Pc/Rnrf1191/2tw39J7MLVOMzc2bXyKnrN973H4ufWfqJ2RLtV6ovH542mpWs/ejQfpSc7bO+S+/1HzUz3Gv9bepXV6l+Yamtr/p5rEPX9M/zzPql8cAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGNpOVbeq9bxHpVnVCbX7nsA7wjrdv5MclhM07ac61Xff99639buzVNVOMdd7fwF8vfSqWjdh8SkOx0zPcG+cbAvd88Oh3/P4M+c9LX2Xrukk7nv8Uwmv677ft388Pk1O8B1zgrN6F/ziCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2prgvVcfzfrczaHfb7v+VTnNi/D4z1xZOYKZp2nPGzDWdYPipOcyMf6p9lZr5k8yalfVdvgDt9lQbO53AxM0Kxz/F9v9i/Hek54R3aq14e61qPXtH3s33/Wy+Z6d43J7KKT5j7tvMs7Eds7qpszc1/j0v7Ck+OWd6vkvvmxN8x0xd/s9xrfziCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2qrr1Wh+sJ5rKHWv9BD0natPhv6rR/RTrP6PP3KzQNt/7m/NjXHt8cZYVnuXj92Xi+k+wVPH+P1XLU2y/U+ypU5m5/ona9i6twddJq+q78Eae4haeoGc/1TsknevM8O/Ims7q9/waT9egHScWa5/X9vD7rD29jXsum3xRj5+fx7UnkU51Yp+cZEutM987M5PN+7bwsNz/d8zbt/iqxhYAAADuiOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADA0HaqeqlqDw5ZbQt79nz4tuTFvWcTmOl5Ci1dp6qqls91pm3cc2L8r6Lzi31c+/jiJq599eA8q/vkUdyzna1x7fY8O9PpmaqaOta5mfFPMYETbf++nuC0TqzVVNt0DU40Pm/QevVdeHNO8Ryfeo+ldSc6cO/K1pyZ58xSvSvXP2Hm8jeXu7j2+DB7jz54eBv3/OaTy7j2e1ffyApP8Q6pyhf2vj8NZ943U3OdyRxZXTvZXH9+Pf3iCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2prgtvc4f7rPa1r/UhO6qZ2t333NG2jec5rTNsp6oc+YU67qcarFC/9yv/t249jc//25c+1//xf8kqvtrf+9fjnt+/H9/K6598usvo7reT3MD0r7rxPinONUz17+ueW36rJrpOzP+jHQN+onG5w2WqjoLn/npu+lUtzB9N5xo/JO8808w15Ot/1fQ8WYT1z74OF/Yq29nv638G3/uf4p7/vbrX4xrf/DTD6K69TixWU6w/U/2vE/fuX3iomauf+abJ+zbZ+Y640TfZz+LXxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2s4Ub5a1njy8jmqX1uOeqRZX5uOndVVVbaL2FOMvldemZtZ/xtR1TdSeQrquf3Tzftzzb/+Z34hr/4nf+leiuh//OB+/Lfma/vJ7L6K6w3qavzMdT9Q3dbtu7rxn7/nTamZd07u6Tow/M9f0Xq33e6S/flqvZXcMa08w/EzP8Hk/1XLmHZKOf4J1+qLvuzH+jJlnyCnGv7rMP2U/+N1DXPvgp9m74Zt/LXuHVlX9Ix99L6598WsXUd3f+f534p51gnfDzB3t6wk29sQEpsafWqu77zm3sGHxzPhv4BdHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhrYzxbvNsX7p8Yus8XIM69Z4/KV6XJuOv2kTPdvEXMPamfFnrj/uOXVN+fibyvueYvxT+NMPfnySvv/qr/0vUd1/+bf+6bjn7/yNB3Htn378k6huZv33fRPXptbeJmrzv4ntw9rDml/TWvlc9xN9b8PambWaua5DvFb+Jvnztmyy89lO8Ryd6NnyrRlblvt9N8ysaVp7inU6lTbxHXES4d6vqnr095/FtZd/5RtR3X/wu3817vm//+X/PK79j8K6uf2f1/aJ90jcc+bVEI4/M88+sVfS8Wf0iaMytf7pZd3BNXm7AwAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMLSdKV57q8vDWVS7VI/qWsvqqqqWE9RO9Qyv6Yu+a1yb98zHP4WZ8dfe4trtcvdrNSO9r3/1vb8b9/zfro9x7W+9+k5U93v/0pO45+ZZXFo/un4/qlsrv6czZvbKKXqmtTP7/3bNH62nmOtxzf8meOh57SnuFXdjXbN7007w5+KZlj08Rm3Jz1vac0a7560+823UJ87lcoL37cz4M9I1aJebvOmS79ZHP8re46/y0ev1ehvX/vKDZ1Hd/7H8StwzfU7M6CfoWTXxvpnYf31i+59kX8+s1cwz4ET34GfxiyMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABD25nim/22/uDHH0W169qiurb0mSnElmUN6/LxD/t8udLxq01cf8/WdKZvX/O/HSyb8Jpqbl33+01Ut5kYf0YPp/o7n/31uOff+FP/Y1z7P/xXfymqe+/TuGWdvczX/zd/8btR3cz97+H5r6q5MxBPIB8/fQatx/ysbHfHuPYQ7v+qqnaCteoTa5U+1/k52y/VfnSR1YZ7qE3c6+PZxL5MHyMTW61vZ96j4fAT1983E+Onj5GZoz5Te4KfC2auvx0nbmy4Vy5+nD9D14dnce35pzdR3Q9/98O45z97/i/GtZ+8ehTV3Xz/cdxz5qy0Q/gdP/Fp1mf2X7hVWv66rSW8ponhqyo/gjNrNXNd8afBTI54A784AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMLSdKn6x1Ie/8eBOJ9BnomvLS9f0ynrec3Ob1/ZNVtfWiZ4T178csgs7XORNl2M+/sx1xSbu1fHs7offP34c1/6Hf+dfiGvPP8/q3v/ePu65e57Xtv/mIiyMW9a6yYvTs7rJL6mWfb5Z0rN6PJs4K4e4tNoxn2ubOAOpmevaXmcTOO7ynn8QV/Imm5uq9/5BVtuX7KW7uc0323F393+Dbn3iDIfXVFXV1qzv3Dts4uF43yaeIekazDxD0vWvqlrCZ/6H/9dl3PP2/bv/OPj2/5pf00+e/VJc28JvrqefTrxD1om9Grad+o4N37dVeT5oE+/bmZ/L0vWfMXP9M9K59jv4iPCLIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEOCIwAAAEPbmeK2Vu2u1qy4Z2XrtsXjL8ewaVX1Je+bun2U99xdZXNd9vk1TQmn2iaG39zmxbeP8r9JnL0K99TELd3e5MVtza7r7DLveXiW156/zK7/4R+8iHu+/s57ce1mn9Udz+KWU3avs/Wf2X+nsLmZGL/l93/dTMwhXIOZZ+VyyM/qcgj73u+t+trZ3PR6//cPWXHPbs7Mu6FPPJv7JiueeYdvro9xbXpd6Tyr5q4/7jlx/ek7bFa6VutuYq75rYqva7kO935VPfj4WVy7//bTqO7wOH+If/O38rmm1z+zpjPaIfw2mzGxr9N9NfMdPXNW28R7tKXRaOLnuplnULoGM2f1jWO9dQcAAAC+0gRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhrZT1b3Xsu9R6XKb1VXLh1/P8uLlZs0bhzY3+fj7h1km317n87x9solrNzfZ+p+9yMdfDuE9rarjLl+rFk5hM7FWh3D9q6q2V1nfq4/y47J/kl//4x8eorrjo7O4Z8tvVW3Cs7K5yXu2Y147c65TM3tluc1qb5/m978d8xuwe5nPtW+ytVonzt/Zi/xm9fBYtePd31PerK29tpfZc+S+/1zcl3APh3t9fgJZWfpcqKpat/lcN/usb28T3zthzy/6xqVV4Rw2rye+DR7mz9HNTfhsmtgr66MHee159s21fZU/Q2e+o9Ln/YyZnpvr7LraOnNNEw+g9e4fVrvX4XOyKt7/VVXrWTbXzeuZ9+3M+OFenRj/TfziCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2prj1qmXfs9o1rMvKqqpquV3j2qtv7bLxjxPjH/LJbtJ1mhj/7HlefP3RJqq7+DRf0561rKqqhz/ex7XH8+zvF8sxX/+Lz/LxDw+yC3vyg5u456t+Fteuu+z6D0/ynun5q8r31f5x/rhoE/dq+zo8K4d8r7a8NLa5nrimq/ysHs/yv9+l67q0uOXUXtlcZwvbZybA21urNteHqLSHt6Zv8325nk28HEKbm4l30zbfb8tNeDYnvk1av/u/wbeeT2DmvM08R9fw3bx9eRv3XKbGz/bV8VH2vVdVtUzs6+3L7J1/eO887pme06r8vvbwG6KqavMsv1exlu+/Nb9VtWyyvul9qqrqu/xZlT4rqyYyz8x3TD58LbfZc20mc71xrLdvAQAAwFeZ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMDQdqa4t6p117LisO78s308flt7XLu73ER110+zuqqqp793Fddef+s8qttcH+Oey36Na9O12j/Jr//i0/xe7R/nW2tzk13X5ipfq+r5Xjm/OkR16y5fq/d+/zquvX1vF9Uth4n7f51f//Eiu66zZ7dxz2rhc6Kqlpts/Y+PsnWqqtqE97Qqv6/b13HLKWfP83XtS7iuE+vfNxP3auIZxM/RUnW8yJ65m6vsOZ4/QSb25YT1PO+5e5W/m9Lzvvv0Mu55+ODhxPjZ3+u3z2/ynuG9r6qqiVu1fZU9m9ox3y3tMPHNl77zJp53M9pN9s2xfZk/w+Nrqqpas9q+yb9N2nHiOyqd6sQ7pE/s1e1ltlfS+1Q1t/7HR2dx7RJ+c7SZ7/iJ79i4537i/r+BXxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2s4UL/teFz+5iWr37+2ius3VPh7/xa8/jmsPD1pUd/HsGPdsa49rdy+yvsttPv5M7WaX/U2gb7N1qqravsrv1eYyrz08OYvq9k/y7bp9na/VGtYt+4l7dX2Ia3fhPZhZ03W3iWuP59le2VxPXP/VbT7+w+z+b1/mPfuS7+t2yHZAf5Cv6dln13c+flVV32TXla5pVdV2Yl9VOtetv0n+XK29Nq+z87G8yt7ht999+hYTerOLH7yI6tZH53HPdjPxbrrJn83x+Mf8DG/C98hymT9Dltf5864/yJ8NPTzH7XZiTSfWql2H93Xied/Ps2/Tqqq2D69r4nE3Nf5t9s3ZJr5N2jGvrfSbd+IVspl4N7RjeP3X2TOtqqrO8vXfPs/PYOyQr3/f5d+8rYf36nbiZr2BtzsAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABD26nqpdV6volKz57fRnXHR7t4+PPnx7h2OWSZ+OEPXsc9Z5z/6EVUt//W47hne3UT1+4+OUR1y815Pv7VPq7tj8/i2rNPr7LxX2V1VVUv/+FvxbWP/8HLqK5vJ/7Ocljj0u3z7L4eH+RnpR3z8S9+eh3V3Xx0kY//IHtOVFVtL7O9OqPt8+tva4/qLn6YrVPV3F5pt/n194vsXG0/z8/K8b38GbAJ59p7i3vy9lqvaukzZ5PtzWXiDK27fL+vD7M9vDyfeDf37Ax/0Tic65pf//Iq+96pqmph33bIv3dm5lrHvO/Nn/woqtue55+Sy03+vNt8mr2bp+5/+LyvqurhdcVnr6raPn+PxGflNt9/a/gOqapaXoZnsOXP+2XiOzbeqxPj18S30cxZqU34zbPkc02fFTPa/u2/t/ziCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2qnrttbk+RKWblzdR3fKqxcMff+lxXHv+eTbP9WwT99x+/jqu7ee7rOez67jnjP4gG385rHHPts/WtKpq8/wY1/Zddg/2334/H/8qv66+yfbg8jK/V8cPHsa1m09fZXW9xz1rovbm29m52j2/jXsut/leaeEebPt8T81cf7Xs/vftxN/ZTjB+Vb4G7Tp7/lZVLeGzoqqqXWV74Pgwf1ZzB45rLc8vo9L1aXZvjmf5ft9eTrwbPsued+vDi7jn8uxlXNsfnGeFu/zzqN3kz8b42XCceYdOfMpNPG+2r/ZZ3fP83dgur+LaSp9jF+E9nZQ+b/sm/46c2SvL8/Cbc+YdMrGv2jH/jkr1ma26pu/RifftzDXNnMG0cM3vVW3zfZV+R7eJvfImfnEEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgaDtTfHyw1Gd/4VFU+63f+ElUd/MXfjke/+b9TVx78dkhqtu8uol71trj0r7NMvnmkxd5zwfnee0uW6t2zK9pyj5b/6qq5fo2qjt7fhn33L6f7dOqqr7J1qpf7OKeMw7feBLVLYc17rlc5vv64g8+j+oOHz3Ox7/ax7WxwzEuba+v49r0XLVDi3vOWB9dxLVtH65By+e6vLiKaw/fyPbA5jI709yR9Vj95aus9FvvR3Xb6/y87X6cv8fqmPVdnr3Me05ot9mzqU+coer5e7Sl78Zj/rxvt/kZnrELn7n9LH839vOzuLbdhM+RiXdDf5x/9i7he6StE9+RS/57Td9lc23X+fjt1eu4ttJ7NTP+Rf4dm65V3+Rrmp7/qqo+c13peZ04K+uDmbOSPVduf/mDuGf9g5/9n/3iCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2prgvVftHLapdv/VB2DQf//z5Ma69+P1Ps8Jj3nN9/1Fcu/np86iuX5zHPeuQz7Xts9p2zG9Au93HtX03sbXWiU0Qatf5XOtBtqePj87ilruPs/tfVbU+vojqlk9fxD3rbBeXpvdq96PP457r08dxbbs9ZIV9Yp9MXH8t2d/PXv5DH8UtLz69jWt3n7yOa+sm7BteU1VVu76Ja7e/l+3r1//Yn4h71m/lpbzBdlv1jQ+j0s3L66iu7fPnXTuucW1/dZn1PMvHr/O8tm832fgT77sp6ftuM/F3/Za9w6ry9a+qatvwPT7zvp/xIHs3znzHLZdXcW1/8TKqaw8exD1nvrpb+rzfZHv6i9qJs3qVPSvqEL7Dq+be4+8/icrWJ+E+qarN5/n1t5nv8/AZ2C/z9327yJ9r68Nsru0OPrf94ggAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMDQdqZ42Vc9+viYFR97VHb+h5/H46/vPYhr+9Kyws0u7rn8JJ9r7Pwsr23hNVVV32yiuuX5i3z8sGdVVXt9Hdf2i3ANlny7tkO4T6uq9mFttqW/KN1NzPX1TVY4s1dubvPa11dZ3ZL/nWk9y/fK8YOLbPib/J7uvvfTuLYuX0dl55+9F7d8+Svnce17t2tcu/v+y6iuP8qflesHT+LaCmsf/GE2T+7I8VjtxauodP3m06hu89Nn+fgT76a0tu/3ecuL/Ly1Y3be+szz9tnEe/SYfkPlz4XaTnzKneXfPNWzl167Ct9hNfG+r6r1vYfZ+D+ceN7PWMOXfnpPq+I1raqpd25q/51vxLXbT7JnSn32LJ/AbX6ur/7kh1Hd8Tx//jz5eOI7fmb902++6/zbuCa+YzcvLrO6wyEf/w384ggAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMDQdqZ4c32s9377eVR7+evvRXVPfutH+fifHePaVN9u7rxnVVW1ltVtJrL7cc2HX8PazcT1X13HpX2/j2tbugaHifu/5Ovaeo/qtmFdVVW7za+/9oewabinqqrOdnFp2009BiKbVzdx7fI6W6ur7zyJe+7+KL+mZ3/lO1Hdoz/Kr6kv+b3avJzoe3kZ1c3c0/Y6P9ep/vDiznsysGyqP3mU1f7+D6Oyfn4WD992E8+b8/Ns/HCvV9XcuyF950+c4fboYT5++LzvL1/m40/cq5l3c7+5zcaf+I6Zqv30RVY48R3Xb7NrqqqqY7ivJr4N+iF831dVf5WdgeXp+3HP5Sof//hh9kzZTHybtOf5vt49z+7V9mziOzr9Nq6qPvEd18I92LYT31sz35Hpvpp4Vr+JXxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2s4U9+1S+288jGp3L49Z00NYV1XHT34S1y7vvRfVtYvzuGdtJ5brcMjGv76NW/btJq5dPnme9Xx4EfesdY1L28Ra9V1Ye/n6JONX71ndxPpPaS2r2+/znumaVlU/22WFn2V7qqqqf/p5XHv4S38qqnv0f/4o7jnjg9/8OKqbOX/f+GF+/XV1HZf2TTiHffb8qarqNzdxbXquDh89jntyF3r8HGvpeT/mz/ve8/dYe+9JVrc+yMd/PfFuuMjeeS19L1RVf3WZj5++m2beoRPvxlrC901V1RI+b9LnUlXVzcQ3T/rNseb3aqo2NXP9l/leSc90f30Vt2z9aVy7+fhZNv5lPn6dn8Wlux98mo1/nb/D+j7ffzN65deVmnoGPc6yWfy9OeAXRwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIa2M8XtsNbu86uodnl+mTU9P4vH33z7W3Ft7OY2r334IK89HrO63uOW7Xafj5969jIf//HDuLZvN3nfV6+junXiXrVH+VzrkN2rdnWT95y4/v443Vf5/js+uYhr236N6pZPwj1dVcuHT+Pa3d/7flTXj9k8q6raxHOl9uG5+vD9vGe4p6qq+qP8vrazXVY486w4HOLSHt7X7bPsTHNH1rXay+yd29N3U8v/rtwn9ltrLStc8vHbLjwXX0wgKutX13nPmTM0sa5xz5v83dT3+VzT5017/I2459Q3TzrXib3Sb8P9V1V1k71z+sP8fVuvs2/oKZuJs/LDn8a1fcnWaup9O/NtlJ7BcJ5Vk98RE+vaX4fvvIm9Wn1iruEz8Pjtj/Lx38AvjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAwJjgAAAAxtp6r3h2off5rVnp1FZf2zZ/Hw7cOnce36k0+yng8f5OPHlVW12WR1x3Wma+54jMr69XXe84P38tp14rp6j8raxUXe85Bdf1VVv7nJCtN7WlVtlx+tfpbVHh9mZ6qqark+5OOfZ9fVHj7Me16+jmvTdW2P8vGrTZzWsLY9f3WS8Vt4Vquq6jzcA+GZ+mIC+d8P+w9+lLV88jgfn7d3XGtNz9x+H5W1B/m7MX3ffDF++Gza5s/bmdr42TRzhmYcsuuf+TbpN7d57XX4vquqdsyeDf1V/rxvD/P3eA9r28T7vlX+Hl2fv8h6zuyVb34Yly4vsnfO1HfcLr/+dK+ury7jlsuHH8S1bQnfTdv8e6tdnMe1U98xt9lzdepZObOvwm+DzU8+z3u+gV8cAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGNpOVS9LtYcPstp1jcp67/n4L1/Fpe38PKvbTizB/hCXrh8+yca/3ufjt5bXfnaTtUzvZ1XVxz+NS9uTx3Ht+q0Psp4//Encs9pZXnsI7+ttfq8mdnUt4X1dnuX7//ALT+PazScvo7p+exv3XCfO6uaDp9n4l6/jnrXZ5LVP38vqXk2Mv+Rnte12ed/Q1HN14hnYevZcnzkrvL3ee/Xr7Jnfj8eobvMgfzcs4Rn+YgLh3ryZeN4+eRTXtuNF1nPiedMnvg1a+GxaX2TP5aq59/j20cO4Nn6O32R7r6qq7/P3SHucfUf06+u4Z32UfW9UVS3f/EZWeAyfi1XVP30W1x4+/zyqWx7l+3+ZONd9Db9NnuTvsP4wO39VVfXZ86xu4tukPng/r534jkifq8vj/F5V2LOqql+FZ2Cd+Tr92fziCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwJDgCAAAwNB2+n/Re1Z2fpb1W9d86KvruLad7eLa2H6fj38d1m43ec+rm7i20us/HuOW60Rtf/Y8rl3Cvv0bH8Y96/IqLj2Gc93+6q/EPQ9/+IO4dvuL347q+nV+/7etxbV1DM/gNn9ctIna/jq7V+2jD+KeM7InWlW/nnj+zKz/xFrVITyDa3pVVbXm57rOz6Oy/uoy78lba5ullvefRLXry1dZ04nnfc3s9/QbIqyrqvx9V1X18u73ZntwEdeuz19Gdf2Qf29sNvlvAL3ltUv4zl0/e5aPP/Edk35HbL7xUdyzJtYq1T/9PC+e2Cubp+9nhRP3tF++jmvbe9kzpU98G9ezF3nt/javTT0Pn381+c7fhN/yM99GE5mnh9+8S7qnRj3eugMAAABfaYIjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ633nhe39tOq+t7ppgPA18x3e+/fvO9JvMu8mwG4Yz/z3TwVHAEAAPj68X9VBQAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYGg7U3zWzvtFPTrVXAD4mnlZn3/Se//mfc/jXbZ59KjvPvjwvqcBf/z1idp2gp7wjrj5ox/8zHfzVHC8qEf1j7d/5u5mBcDX2n/f/4vv3fcc3nW7Dz6sX/k3/637nsbduueP8SYMfDXdd3C0r2LpGezpffpj4F16rvze3/q3f+a72f9VFQAAgCHBEQAAgCHBEQAAgCHBEQAAgCHBEQAAgCHBEQAAgCHBEQAAgCHBEQAAgKHtfU8AAPjy+lJ1fHC3/7K0f1T7K8pa3a+v+frf+1m99/FP82D9ea6rXxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2t73BACAt7D0Wh8c77Znu9t2pxy/z/RNi+/7+nl3TG3Ar+L479BhmVmre17Xdop1vYNr8osjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ9v7ngAA8BaWXpvHh7vt2frd9juhdoqe79D1cyLhHmgTG3A95r/XnGQH9rs/Lf1UR+UEffvM9Z/iuk6w/lPD38E1+cURAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAoe19TwAA+PI2m15PHl/d2/it9XeiZ1XV0k7S9s6d6vq/ino/zU29PWyiuu3mGPfcbda49rhmv+2sE1vlFGt1qvVfTzHXmdqJ8dPafs/H+i7ulV8cAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGNre9wQAgC9vuxzrF568jGqX1u98/Jmeae1Sdz/PL8Zfw7rTjJ+67/G/qr7/4oO49lefZmfq6rCLex7X/PeaDy8u49rU2vPx12phz6xuVtp3Zvw+UZte/8wcTjXX1Mz4v/OG/+4XRwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIa29z0BAODLu9gc6s+895Oodmk9qtvUGo+f9pyxa8c771k1cf1t4vrr7q9/ZvxTOcV1ncK+b+Laz28exrWfXuW1qV998iyu/fNPPr7z8Y89/71o7S3rOfEbVNrzj8f4ed99WDvTc2quldXu1/ys/M9v+O9+cQQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBoe98TAAC+vAfLbf3FRz+Mas/aIapbao3H37Qe1+7C8TeV99y0fK7pdc30nJlram7989oZp7iuU/j7t9+Ka28Ofzau/fh7H0V1T3/xRdzzzz/5OK79px79blS3TvwGdKyW1/as79T4Yc+qqn3fZD2nxs+vf9/ziJTOIb2m2do1XNeZnv/ZG/67XxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2t73BACAL+/hclt/+eIPotpN9ahuaVndTM+qql1b77znzF/AN22iOLS7+5a1aSeYaJ3m14JNnWauqafLVVz7H/d/8s7Hv77Nd8AfXT+Na//RD59Fdceen5VjXFmVndSqYz583LOq6hjuq2PP999+4gSsE33Tue775s57ftE3i3MzPd/EL44AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMbe97AgDAl7ertb65uY1q078Wb2bGby2u3VRWu7T879ppzxnLxN/VNxPXP9M37zmx/hPr+u54HVf+uac/iWt/8uwXorqbm0dxzwe/lp3TqqqPlgdR3Vo97rnWGtcee9Z3pueMfc/6Hqeu/xjX3obX/0XfzDFvObWq1z17Yh/v4Fn5VXyCAAAAcIcERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIYERwAAAIa29z0BAODLe75e1H/76s9GtUvrdz7+RbuNa/c9++y4WPYTPTdx7a4d49rUpta49hj+vX7XDnHPtee/AaTjV1VdtPwepGbuVeqnh+/Gtd+//CCu3V63qG49y8/Ubz//dlz7nz7Oa1PLxF59vZ5nPSeeKTP3Pz1X6TOlqupY2T39om8+1/QMHifO6jox19P4wc/8r35xBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYGh73xMAAL68j188rX//v/vns+KlZ3VhWVVVtRPVnkI6/nrSWfz/m/mz/qnmmu6Bmbme4P5vX+QT2L3MJ7C9zerOP83H/971r8S1/87jX8oKZ9Z0zYtbev9P9axI9/XE/usT47djXhv3nFirublmxTPjV/3tn/lf/eIIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADA0Pa+JwAAfHnLvurBj9+NvwP3dr/jL8es7r7nWScaf+a62hrW9dOMn96r7eu858Mfh00nxr/6KD9755/nC7B7uYnq0nlWVfWJx0R6r2bu/ymc6qxOresp5nCCs3oX3o03DQAAAPdGcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBIcAQAAGBoe98TAAC+vHasOnt2x00n/qzcDj2u7dv2JSZzd3p4Xe2Q92x94vpbdv3LcaZnXFp9yYvT65rpuU58dbZwCTY3+VrdPs439jbsu9zGLWv3Kp9rhaVTZ2rNSytsu0yc/1NIz3RVfv6q5s51O6Y945ZT15U+r/odpD6/OAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADAkOAIAADC0ve8JAABfXlurzl72qHYN3/rLMR+/t4naJZznLu+5bvMJbG+y8Tc3+fjHs7y2Khu/Tax/WydqezZ+VVUPf1pY9vkE+jKxWcLS48Reafnln6Tn7tXdj5+eqarTXP9yyJsed3d//+fOysxhyUt7Syc7Mfzx7m/W1Pl7A784AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMLS97wkAAF9eW6s2tz2qXY5Zz2Wf9auq2j/M/wa9HLK6PvFn7YfP1rz4BJZ9Xru9ydb1eNbinm3i8mfWtcItsBzzvdLWvLaHS7DLl6rW7cS6hteV7umqqs1NfrPW8MKWw8yaTizWRGncMnz+VOXPtHUiyWwmnmszjum9mrj+KfFlvf31+8URAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAoe19TwAAeAu9arPvUWm7yer2D/O/K5+/WOPa/cMW1T34LJtnVVVb89rlkNfG40/07Nvs+pd9VvdF07y0HWeK89LYzPDhfe1LPtF297d/av+tu3yum+vwXLWZG3X356pPDL+bWP/jefYM2oTPtKqq5TZ/VtXEvlrCc32K/T/jLva/XxwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAYEhwBAAAY2t73BACAL6+tvTZXa1S7HHvW8/g2M3qz7U1Wd/biEPfsLR8/vf7eJprO2Gfjz1j22b2vqlrP8t8L1m22Bj2sq6pabvO5bsLraod8TWf2Sm3C65/YK8s+H/4Y3quZNT2F9D5V1dTPVZub7CE0df+X05zrTXhdM3Ndd/litfS5Fu7pEb84AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMCQ4AgAAMLS97wkAAF9eW3vtXh3utuna89Kz/G/Qu1dZ3+Wwxj2Xm2Ncm2rHievfTvwNvqV1aWFVO06s1T5fq3W3ieqO5/n1b27yubZwD8xcf4XXVFXVwz2wrPn461k+/vYyO9Nt4qz2TX6v0r3SJ/bqjNbD65q4/pq5/olnUA+XoE1M9RSmzsob+MURAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAoe19TwAA+PL60urwKHudnz27ieqWm0M8/u0H53Ht7lXWt+2Pcc92XPPasG8/yz+PlkM+fm9ZXVt73LN6XjuzrsuS/baweR1e1Im0Y379E0tV6y67/jZx/7e3+fr3JVvXts/Hn/m5KF7Xmf03sVZreganrmlirWaWdeJcxT1nNmvL9srh8e5Lzub/4xdHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhgRHAAAAhrb3PQEA4Mvrm1Y372+i2vNP1qjueJF/Hmyvj3Ht5vl1VNd6j3v21uLatmbXX0tYV1WV9qyqeKYz13SYmOv+kNeGc2ib/DeIfjbx2TlzXamJdd2+uMoKJ+7/zPj9bJcVbid+A7qZ2KvH8Fwf8vNfy8RcH2TX3/YT40+s/9S5TmuPE3tlM7FXwnXdXO7z8d/AL44AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMbe97AgDAl7e5Ptb7v/0squ1n2Wt/c7WPx2/7Y157c5sV9p73jCurahd+9syMf1hnZpA5TvTcbvLaNe/bwjn0dE2rqj/Y5eP38M5O3KvlZmZfH+58/Clp333+G9D63oO4dvn0Oqo7vv8o7rl59iquXc8fZ4W7fP8fH+Z79fyPXsS1dQifgTPPldv8ydaWcA/cvP1e9YsjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ9v7ngAA8POxvL698559ufu/Qbf9IR//bJc3Phyz8WeuqbW8tves5cT1183EPQ2vv6qqP7wIC7NrqqpaXt3EtbWuee0J9CW7r+2YX//MNbV0C+zzNV02+b4+fvg4ro1NXP/uB59GdcdvPY17Ls+u49r2Oq/tYW178ijuWTf7fPzdzy/O+cURAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAIcERAACAoe19TwAAeAu9VzusWe0xq2s3t/Hwrfe4tp/tssLNJh8/vKaqqjoew7q8Z19aPn7Lavt24vqvDvn4E9rVTVa4Tqz/jF34iTpz/2ek+3oz8RvMzL56fZ3VXWd1VVXt/cdx7fL8ddbzEJ6pqqlzne6rzacv857p+a+aulft/CwrvN3n44fPiqqqusjG79u3/73QL44AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMCY4AAAAMbe97AgDAW+o9Kms3t1m/w/HOx66qasc1LGz5+IdDXnu2y+qO+fW3m4m1Sq9rYvxT6Zevs8Lz87hnS9e/qirdK9tN3nMNe1ZVHbN93R9exC3bi8u89vHDrO4iX//69Flc2sNz3Z88ysefONctvVf7ifM/8azoM3tlDZ+/m4nf6zYT+/qnn0dlS7inhj3eugMAAABfaYIjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ4IjAAAAQ9v7ngAA8BaOa7WXr++0Zd/v8+Kr6zsdu6qqffB+Xryd+JS5Da9rmfi7+naT17Z29z17z0tfXeZ9d+G67m/zno8e5LXHNa9NbSbW9XC827qqfE2rqm+yPdiub/LxT+H5q7y2T9zT9FynZ6qq+pqP3yb61lk213445D1fX8Wl7eI8K5y4/jfxiyMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABDgiMAAABD2/ueAADwNnrV4ZBVXl9ndfusX1VVOzuLa2tzgr9X7yY+ZdLxe897Ho55bWrmmtZ8ru3iIq7t4Z6aGX9mXfvtbVTX+i4ff0J6/W3m/s/UvnwVla23+7hlay0fP9yDM3tqZl/37SYrfHkZ92zbiXN1nLhX65rVpWeqqmpmrkv4XDuG8xwN9dYdAAAA+EoTHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABja3vcEAIC30Kv6cc1qN5uorIV1VVXt4iKu7YdDVng4xj2nnKLvMe+5Xr6O6tpm4u/6M/dqt8v7pvdqaXHL/vnzuPb44kVUt/ngg3z829u4tj0I9/XtPu5Zy8R9XcKzepa3rG3+2d9adl/jM11VbTuxV2+ydZ0Zv0+c1eo9r02Fa1pV1a+v77w2vacjfnEEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgSHAEAABgqPXe8+LWflpV3zvddAD4mvlu7/2b9z2Jd5l3MwB37Ge+m6eCIwAAAF8//q+qAAAADAmOAAAADAmOAAAADAmOAAAADAmOAAAADAmOAAAADAmOAAAADAmOAAAADAmOAAAADP0/JAK9NjbmQ1MAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "img = cv2.imread(link, cv2.IMREAD_COLOR)\n", "img = preprocess(img)\n", "img = img.view(1, 3, 60, 80)\n", "\n", "output = net.pool(F.relu(net.conv1(img)))\n", "print(output.size())\n", "\n", "square = 2\n", "ix = 1\n", "pyplot.figure(figsize=(16, 16))\n", "with torch.no_grad():\n", " for _ in range(square):\n", " for _ in range(square):\n", " ax = pyplot.subplot(square, square, ix)\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " pyplot.imshow(output[0, ix-1, :, :])\n", " ix += 1\n", "\n", "pyplot.show()" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "img = cv2.imread(link, cv2.IMREAD_COLOR)\n", "img = preprocess(img)\n", "img = img.view(1, 3, 60, 80)\n", "\n", "output = net.pool(F.relu(net.conv1(img)))\n", "output = net.pool(F.relu(net.conv2(output)))\n", "output.size()\n", "\n", "square = 4\n", "ix = 1\n", "pyplot.figure(figsize=(16, 16))\n", "with torch.no_grad():\n", " for _ in range(square):\n", " for _ in range(square):\n", " ax = pyplot.subplot(square, square, ix)\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " pyplot.imshow(output[0, ix-1, :, :])\n", " ix += 1\n", "\n", "pyplot.show()" ] } ], "metadata": { "interpreter": { "hash": "3c791669b07b322e46c2c9e5f9e8a4c39f8cc206c386431b147b2f78281d9ccb" }, "kernelspec": { "display_name": "Python 3.8.10 64-bit ('venv': venv)", "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.10" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }